开源软件构建与测试

_service:tar_scm:Imath.spec Changed

_service Changed

_service:tar_scm:Imath-3.1.4.tar.gz/INSTALL.md Deleted

@@ -1,319 +0,0 @@
-# Building and Installation
-
-## Download
-
-To build the latest release of Imath, download the source (.zip or
-.tar.gz) from the releases page
-https://github.com/AcademySoftwareFoundation/Imath/releases.
-
-To build from the latest development version, clone the GitHub repo directly via:
-
-    % git clone https://github.com/AcademySoftwareFoundation/Imath.git
-
-The ``master`` branch is the most recent development version, which
-may be unstable, but the ``release`` branch always points to the most
-recent and most modern, stable, released version.
-
-**Note:** The GitHub repository identifies a "latest" release, which
-GitHub defines as the release containing the most recent commit, which
-may correspond to a patch for an earlier minor release. Therefore, the
-release labled "latest" is not always the most modern or preferable
-version. If you want the most modern release, use the ``releases``
-branch.
-
-In the instructions that follow, we will refer to the top-level
-directory of the source code tree as ``$source_directory``.
-
-## Prerequisites
-
-Make sure these are installed on your system before building Imath:
-
-* Imath requires CMake version 3.12 or newer 
-* C++ compiler that supports C++11
-
-## Linux/macOS Quick Start
-
-To build via CMake, first choose a location for the build directory,
-which we will refer to as ``$build_directory``.
-
-    % mkdir $build_directory
-    % cd $build_directory
-    % cmake $source_directory
-    % make
-    % make install
-
-Note that the CMake configuration prefers to apply an out-of-tree
-build process, since there may be multiple build configurations
-(i.e. debug and release), one per folder, all pointing at once source
-tree, hence the ``$build_directory`` noted above, referred to in CMake
-parlance as the *build directory*. You can place this directory
-wherever you like.
-
-See the CMake Configuration Options(#CMake-Configuration-Options)
-section below for the most common configuration options especially the
-install directory. Note that with no arguments, as above, ``make
-install`` installs the header files in ``/usr/local/include``, the
-object libraries in ``/usr/local/lib``, and the executable programs in
-``/usr/local/bin``.
-
-## Windows Quick Start
-
-Under Windows, if you are using a command line-based setup, such as
-cygwin, you can of course follow the above. For Visual Studio, CMake
-generators are "multiple configuration", so you don't even have to set
-the build type, although you will most likely need to specify the
-install location.  Install Directory By default, ``make install``
-installs the headers, libraries, and programs into ``/usr/local``, but you
-can specify a local install directory to CMake via the
-``CMAKE_INSTALL_PREFIX`` variable:
-
-    % cmake .. -DCMAKE_INSTALL_PREFIX=$install_directory
-
-
-## Documentation
-
-The Imath documentation at
-imath.readthedocs.io(https://imath.readthedocs.io) is generated via
-Sphinx(https://www.sphinx-doc.org) with the
-Breathe(https://breathe.readthedocs.io) extension using information
-extracted from header comments by Doxgen(https://www.doxygen.nl).
-
-To build the documentation locally from the source headers and
-``.rst`` files, set the CMake option ``DOCS=ON``. This adds
-``Doxygen`` and ``Sphinx`` CMake targets. Local documentation
-generation is off by default.
-
-Building the documentation requires that sphinx, breathe, and doxygen
-are installed.
-
-## Python Bindings
-
-To build and install the optional Python bindings for Imath, set the
-CMake option ``PYTHON=ON``.
-
-The Python bindings require that ``boost_python`` is installed. By
-default, the bindings build for Python 3. To build with python 2, set
-the CMake option ``USE_PYTHON2=ON``.
-
-## Library Names
-
-By default the installed libraries follow a pattern for how they are
-named. This is done to enable multiple versions of the library to be
-installed and targeted by different builds depending on the needs of
-the project. A simple example of this would be to have different
-versions of the library installed to allow for applications targeting
-different VFX Platform years to co-exist.
-
-If you are building dynamic libraries, once you have configured,
-built, and installed the libraries, you should see something like the
-following pattern of symlinks and files in the install lib folder:
-
-    libImath.so -> libImath-3_1.so
-    libImath-3_1.so -> libImath-3_1.so.29
-    libImath-3_1.so.29 -> libImath-3_1.29.0.1
-
-The actual shared object file is appended with the library interface
-version name, formed according to the libtool versioning
-scheme(https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html):
-``current.revision.age``.
-
-Note that the ``libImath.so`` symlink is ommitted if the
-``IMATH_INSTALL_SYM_LINK`` option is disabled.
-
-You can configure the ``IMATH_LIB_SUFFIX``, although it defaults to
-the library major and minor version, so in the case of a ``3.1`` release,
-it would default to ``-3_1``. You would then link your programs against
-this versioned library to have maximum safety (i.e. `-lImath-3_1`),
-and the pkg-config and CMake configuration files included with
-find_package should set this up.
-
-The versioned libraries will have the ``-d`` suffix when the
-``CMAKE_BUILD_TYPE`` is ``Debug``.
-
-## Custom Namespaces
-
-Normally, all Imath symbols are in the ``Imath`` namespace, but you
-can control this at CMake time via the ``IMATH_NAMESPACE`` and
-``IMATH_INTERNAL_NAMESPACE`` CMake settings.
-
-These settings specify an ``IMATH_INTERNAL_NAMESPACE`` preprocessor
-definition that places all of the Imath symbols within the given
-namespace rather than the standard ``Imath`` namespace.  Those symbols
-are made available to client code through the ``IMATH_NAMESPACE`` in
-addition to the ``IMATH_INTERNAL_NAMESPACE``. See
-``Imath/ImathConfig.h`` for details.
-
-To ensure source code compatibility, the ``IMATH_NAMESPACE`` defaults
-to ``Imath`` and then ``using namespace IMATH_INTERNAL_NAMESPACE;``
-brings all of the declarations from the ``IMATH_INTERNAL_NAMESPACE``
-into the ``IMATH_NAMESPACE``.  This means that client code can
-continue to use syntax like ``Imath::V3f``, but at link time it will
-resolve to a mangled symbol based on the ``IMATH_INTERNAL_NAMESPACE``.
-
-As an example, if one needed to build against a newer version of Imath
-and have it run alongside an older version in the same application, it
-is possible to use an internal namespace to prevent collisions between
-the older versions of Imath symbols and the newer ones.  To do this,
-the following could be defined at build time:
-
-    % cmake -DIMATH_INTERNAL_NAMESPACE=Imath_v2 $source_directory
-
-This means that declarations inside Imath headers look like this (after
-the preprocessor has done its work):
-
-    namespace Imath_v2 {
-        ...
-        class declarations
-        ...
-    }
-
-    namespace Imath {
-        using namespace Imath_v2;
-    }
-
-## Cross Compiling / Specifying Specific Compilers
-
-When either cross-compiling for a different platform, or when
-specifying a compiler set to match the VFX reference platform
-(https://vfxplatform.com/), CMake provides the idea of a *toolchain*,
-which may be useful instead of having to remember a chain of
-configuration options. This also means that platform-specific compiler
-names and options are kept out of the main ``CMakeList.txt`` file,
-which provides better isolation.
-
-A toolchain file is simply a CMake script that sets compiler and
-related flags and is run early in the configuration step, prior to
-CMake's automatic discovery step. These options can still be set on
-the command line if that is clearer, but a theoretical toolchain file
-for compiling for VFX Platform 2021 is provided in the source tree at
-``cmake/Toolchain-Linux-VFX_Platform21.cmake`` which will hopefully
-provide a guide how this might work.
-
-For cross-compiling for additional platforms, there is also an
-included sample script in ``cmake/Toolchain-mingw.cmake`` which shows how
-cross compiling from Linux for Windows may work. The compiler names
-and paths may need to be changed for your environment.
-
-More documentation:
-
-* Toolchains: https://cmake.org/cmake/help/v3.12/manual/cmake-toolchains.7.html

_service:tar_scm:Imath-3.1.4.tar.gz/docs/float.rst Deleted

@@ -1,179 +0,0 @@
-Floating Point Representation
-#############################
-
-The half type is a 16-bit floating number, compatible with the
-IEEE 754-2008 binary16 type.
-
-Representation of a 32-bit float
---------------------------------
-
-We assume that a float, ``f``, is an IEEE 754 single-precision
-floating point number, whose bits are arranged as follows:
-
-.. code-block::
-
-    31 (msb)
-    |
-    | 30     23
-    | |      |
-    | |      | 22                    0 (lsb)
-    | |      | |                     |
-    X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
-
-    s e        m
-
-``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand.
-
-If ``e`` is between 1 and 254, ``f`` is a normalized number:
-
-    f = (-1)\ :sup:`s`  * 2\ :sup:`e-127` * 1.m
-
-If ``e`` is 0, and ``m`` is not zero, ``f`` is a denormalized number:
-
-    f = (-1)\ :sup:`s`  * 2\ :sup:`-126` * 0.m
-
-If ``e`` and ``m`` are both zero, ``f`` is zero:
-
-    f = 0.0
-
-If ``e`` is 255, ``f`` is an "infinity" or "not a number" (NAN),
-depending on whether ``m`` is zero or not.
-
-Examples:
-
-.. code-block::
-
-    0 00000000 00000000000000000000000 = 0.0
-    0 01111110 00000000000000000000000 = 0.5
-    0 01111111 00000000000000000000000 = 1.0
-    0 10000000 00000000000000000000000 = 2.0
-    0 10000000 10000000000000000000000 = 3.0
-    1 10000101 11110000010000000000000 = -124.0625
-    0 11111111 00000000000000000000000 = +infinity
-    1 11111111 00000000000000000000000 = -infinity
-    0 11111111 10000000000000000000000 = NAN
-    1 11111111 11111111111111111111111 = NAN
-
-Representation of a 16-bit half
--------------------------------
-
-Here is the bit-layout for a half number, ``h``:
-
-.. code-block::
-
-    15 (msb)
-    |
-    | 14  10
-    | |   |
-    | |   | 9        0 (lsb)
-    | |   | |        |
-    X XXXXX XXXXXXXXXX
-
-    s e     m
-
-``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand.
-
-If ``e`` is between 1 and 30, ``h`` is a normalized number:
-
-    h = (-1)\ :sup:`s`  * 2\ :sup:`e-15` * 1.m
-
-If ``e`` is 0, and ``m`` is not zero, ``h`` is a denormalized number:
-
-    h = (-1) :sup:`s`  * 2\ :sup:`-14` * 0.m
-
-If ``e`` and ``m`` are both zero, ``h`` is zero:
-
-    h = 0.0
-
-If ``e`` is 31, ``h`` is an "infinity" or "not a number" (NAN),
-depending on whether ``m`` is zero or not.
-
-Examples:
-
-.. code-block::
-
-    0 00000 0000000000 = 0.0
-    0 01110 0000000000 = 0.5
-    0 01111 0000000000 = 1.0
-    0 10000 0000000000 = 2.0
-    0 10000 1000000000 = 3.0
-    1 10101 1111000001 = -124.0625
-    0 11111 0000000000 = +infinity
-    1 11111 0000000000 = -infinity
-    0 11111 1000000000 = NAN
-    1 11111 1111111111 = NAN
-
-Conversion via Lookup Table
----------------------------
-
-Converting from half to float is performed by default using a
-lookup table. There are only 65,536 different half numbers; each
-of these numbers has been converted and stored in a table pointed
-to by the ``imath_half_to_float_table`` pointer.
-
-Prior to Imath v3.1, conversion from float to half was
-accomplished with the help of an exponent look table, but this is
-now replaced with explicit bit shifting.
-
-Conversion via Hardware
------------------------
-
-For Imath v3.1, the conversion routines have been extended to use
-F16C SSE instructions whenever present and enabled by compiler
-flags.
-
-Conversion via Bit-Shifting
----------------------------
-
-If F16C SSE instructions are not available, conversion can be
-accomplished by a bit-shifting algorithm. For half-to-float
-conversion, this is generally slower than the lookup table, but it
-may be preferable when memory limits preclude storing of the
-65,536-entry lookup table.
-
-The lookup table symbol is included in the compilation even if
-``IMATH_HALF_USE_LOOKUP_TABLE`` is false, because application code
-using the exported ``half.h`` may choose to enable the use of the table.
-
-An implementation can eliminate the table from compilation by
-defining the ``IMATH_HALF_NO_LOOKUP_TABLE`` preprocessor symbol.
-Simply add:
-
-.. code-block::
-
-    #define IMATH_HALF_NO_LOOKUP_TABLE
-
-before including ``half.h``, or define the symbol on the compile
-command line.
-
-Furthermore, an implementation wishing to receive ``FE_OVERFLOW``
-and ``FE_UNDERFLOW`` floating point exceptions when converting
-float to half by the bit-shift algorithm can define the
-preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to
-including ``half.h``:
-
-.. code-block::
-
-    #define IMATH_HALF_ENABLE_FP_EXCEPTIONS
-
-Conversion Performance Comparison
----------------------------------
-
-Testing on a Core i9, the timings are approximately:
-
-- half to float:
-
-  * table: 0.71 ns / call
-  * no table: 1.06 ns / call
-  * f16c: 0.45 ns / call
-
-- float-to-half:
-
-  * original: 5.2 ns / call
-  * no exp table + opt: 1.27 ns / call
-  * f16c: 0.45 ns / call
-
-**Note:** the timing above depends on the distribution of the
-floats in question.
-
-

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/half_c.rst Deleted

_service:tar_scm:Imath-3.1.4.tar.gz/docs/half_conversion.rst Deleted

@@ -1,71 +0,0 @@
-.. _half-float-conversion-configuration-options:
-
-half-float Conversion Configuration Options
-###########################################
-
-The Imath library supports three options for conversion between 16-bit
-half and 32-bit float:
-
-1. Conversion from half to float via a 16-bit lookup table. Prior to
-   Imath v3.1, this was the only method supported.
-
-2. F16C SSE instructions: single-instruction conversion for machine
-   architectures that support it. When available, this is the fastest
-   option, by far.
-
-3. Bit-shift conversion algorithm.
-
-To use the F16C SSE instruction set on an architecture that supports
-it, simply provide the appropriate compiler flags when building an
-application that includes ``half.h``. For g++ and clang,
-for example:
-::
-
-    % cmake -DCMAKE_CXX_FLAGS="-m16fc" <source directory> 
-    
-When code including ``half.h`` is compiled with F16C enabled, it will
-automatically perform conversions using the instruction set. F16C
-compiler flags take precedence over other lookup-table-related Imath
-CMake settings.
-
-On architectures that do not support F16C, you may choose at
-compile-time between the bit-shift conversion and lookup table
-conversion via the ``IMATH_HALF_USE_LOOKUP_TABLE`` CMake option:
-::
-
-    % cmake -DIMATH_HALF_USE_LOOKUP_TABLE=OFF <source directory>
-
-Note that when building and installing the Imath library itself, the
-65,536-entry lookup table symbol will be compiled into the library
-even if the ``IMATH_HALF_USE_LOOKUP_TABLE`` setting is false. This
-allows applications using that installed Imath library downstream to
-choose at compile time which conversion method to use.
-
-Applications with memory limitations that cannot accomodate the
-conversion lookup table can eliminate it from the library by building
-Imath with the C preprocessor define ``IMATH_HALF_NO_LOOKUP_TABLE``
-defined. Note that this is a compile-time option, not a CMake setting
-(making it possible for application code to choose the desired
-behavior). Simply add:
-::
-
-    #define IMATH_HALF_NO_LOOKUP_TABLE
-
-before including ``half.h``, or define the symbol on the compile
-command line.
-
-Furthermore, an implementation wishing to receive ``FE_OVERFLOW`` and
-``FE_UNDERFLOW`` floating point exceptions when converting float to
-half by the bit-shift algorithm can define the preprocessor symbol
-``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to including ``half.h``:
-::
-   
-    #define IMATH_HALF_ENABLE_FP_EXCEPTIONS
-
-By default, no exceptions are raised on overflow and underflow.
-
-
-
-
-
-

_service:tar_scm:Imath-3.1.4.tar.gz/docs/half_limits.rst Deleted

@@ -1,50 +0,0 @@
-half Limits
-###########
-
-``HALF_DENORM_MIN``
-  Smallest positive denormalized half.
-
-``HALF_NRM_MIN``
-  Smallest positive normalized half.
-
-``HALF_MIN``
-  Smallest positive normalized half.
-
-``HALF_MAX``
-  Largest positive half.
-
-``HALF_EPSILON``
-  Smallest positive e for which half(1.0 + e) != half(1.0)
-
-``HALF_MANT_DIG``
-  Number of digits in mantissa (significand + hidden leading 1)
-
-``HALF_DIG``
-  Number of base 10 digits that can be represented without change:
-
-    floor( (``HALF_MANT_DIG`` - 1) * log10(2) ) => 3.01... -> 3
-
-``HALF_DECIMAL_DIG``
-  Number of base-10 digits that are necessary to uniquely represent
-  all distinct values:
-
-    ceil(``HALF_MANT_DIG`` * log10(2) + 1) => 4.31... -> 5
-
-``HALF_RADIX``
-  Base of the exponent.
-
-``HALF_DENORM_MIN_EXP``
-  Minimum negative integer such that ``HALF_RADIX`` raised to the
-  power of one less than that integer is a normalized half.
-
-``HALF_MAX_EXP``
-  Maximum positive integer such that ``HALF_RADIX`` raised to the
-  power of one less than that integer is a normalized half.
-
-``HALF_DENORM_MIN_10_EXP``
-  Minimum positive integer such that 10 raised to that power is a
-  normalized half.
-
-``HALF_MAX_10_EXP``
-  Maximum positive integer such that 10 raised to that power is a
-  normalized half.

_service:tar_scm:Imath-3.1.4.tar.gz/docs/intro.rst Deleted

@@ -1,176 +0,0 @@
-Overview
-########
-
-Imath is a basic, light-weight, and efficient C++ representation of 2D
-and 3D vectors and matrices and other simple but useful mathematical
-objects, functions, and data types common in computer graphics
-applications, including the ``half`` 16-bit floating-point type.
-
-Imath also includes optional python bindings for all types and
-functions, including optimized implementations of vector and matrix
-arrays.
-
-The Imath library emphasizes simplicity, ease of use, correctness and
-verifiability, performance, and breadth of adoption. Imath is not
-intended to be a comprehensive linear algebra or numerical analysis
-package.
-
-Imath is not `Eigen <https://eigen.tuxfamily.org>`_! It's not a
-full-featured linear algebra package, and it doesn't represent vectors
-and matrices of arbitrary dimension. Its greatest utility is as a
-geometric data representation, primarily for 2D images and 3D scenes
-and coordinate transformations, along with an accompanying set of
-utility methods and functions.
-
-Example
--------
-
-A basic program:
-
-.. code-block::
-
-   #include <Imath/ImathVec.h>
-   #include <iostream>
-   
-   int
-   main()
-   {
-       Imath::V3f v (3.0, 4.0, 5.0);
-   
-       v.normalize();
-
-       Imath::M33f M;
-       M.translate (1.0, 2.0, 3.0);
-       Imath::V3f p = v * M;
-
-       std::cout << "What's your vector, Victor? " << p << std::endl;
-
-       return 0;
-   }
-
-Matrices Are Row-Major
-----------------------
-
-Imath stores matrices in row-major layout, originally inspired by
-compatibility with OpenGL matrices. 
-
-A matrix described as:
-
-.. math::
-  \begin{bmatrix}
-  m_{00} & m_{01} & m_{02} & m_{03} \\
-  m_{10} & m_{11} & m_{12} & m_{13} \\
-  m_{20} & m_{21} & m_{22} & m_{23} \\
-  m_{30} & m_{31} & m_{32} & m_{33} \\
-  \end{bmatrix}
-
-is laid out in memory as:
-
-.. list-table::
-   :widths: 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
-   :header-rows: 1
-
-   * - 0
-     - 1
-     - 2
-     - 3
-     - 4
-     - 5
-     - 6
-     - 7
-     - 8
-     - 9
-     - 10
-     - 11
-     - 12
-     - 13
-     - 14
-     - 15
-   * - :math:`m_{00}`
-     - :math:`m_{01}`
-     - :math:`m_{02}`
-     - :math:`m_{03}`
-     - :math:`m_{10}`
-     - :math:`m_{11}`
-     - :math:`m_{12}`
-     - :math:`m_{13}`
-     - :math:`m_{20}`
-     - :math:`m_{21}`
-     - :math:`m_{22}`
-     - :math:`m_{23}`
-     - :math:`m_{30}`
-     - :math:`m_{31}`
-     - :math:`m_{32}`
-     - :math:`m_{33}`
-
-A matrix representing a homogeneous transform has a right-hand column
-of :math:`\begin{bmatrix} 0 & 0 & 0 & 1\end{bmatrix}` and the
-translation component across the bottom row.
-
-As a result, it is best to think of Imath vectors as row-vectors, and
-vector-matrix multiplication with the vector on the left and matrix on
-the right:
-
-.. math::
-  \begin{bmatrix} v_{0}' & v_{1}' & v_{2}' & 1' \end{bmatrix}
-  =
-  \begin{bmatrix} v_{0} & v_{1} & v_{2} & 1 \end{bmatrix}
-  \begin{bmatrix} m_{00} & m_{01} & m_{02} & 0 \\
-  m_{10} & m_{11} & m_{12} & 0 \\
-  m_{20} & m_{21} & m_{22} & 0 \\
-  m_{30} & m_{31} & m_{32} & 1
-  \end{bmatrix}
-
-This further implies that you should interpret local transformations
-as pre-multiplication:
-
-.. code-block::
-
-   M44f M;
-   M.translate (tx, ty, tz);
-   m.rotate (r, 0, 0);
-   m.scale (s);
-
-.. math::
-  \begin{bmatrix}
-  m_{00} & m_{01} & m_{02} & m_{03} \\
-  m_{10} & m_{11} & m_{12} & m_{13} \\
-  m_{20} & m_{21} & m_{22} & m_{23} \\
-  m_{30} & m_{31} & m_{32} & m_{33} \\
-  \end{bmatrix}
-  = 
-  \begin{bmatrix}
-  s & 0 & 0 & 0 \\
-  0 & s & 0 & 0 \\
-  0 & 0 & s & 0 \\
-  0 & 0 & 0 & 1 \\
-  \end{bmatrix}
-  \begin{bmatrix}
-  1 & 0 & 0 & 0 \\
-  0 & \cos(r) & \sin(r) & 0 \\
-  0 & -\sin(r) & \cos(r) & 0 \\
-  0 & 0 & 0 & 1 \\
-  \end{bmatrix}
-  \begin{bmatrix}
-  1 & 0 & 0 & 0 \\
-  0 & 1 & 0 & 0 \\
-  0 & 0 & 1 & 0 \\
-  tx & ty & tz & 1 \\
-  \end{bmatrix}
-
-
-About
------
-
-Imath originated at Industrial Light & Magic in the late 1990's and
-early 2000's, and it was originally distributed publicly as a
-component of `OpenEXR
-<https:://github.com/AcademySoftwareFoundation/openexr>`_.  Imath is
-now a project of the `Academy Software Foundation
-<https://www.aswf.io>`_ and is still maintained by the OpenEXR
-project.
-
-Imath is Version 3 because it was previously distributed as a
-component of OpenEXR v1 and v2.
-
-

_service:tar_scm:Imath-3.1.4.tar.gz/.github/workflows/analysis_workflow.yml -> _service:tar_scm:Imath-3.1.9.tar.gz/.github/workflows/analysis_workflow.yml Changed

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: BSD-3-Clause
-# Copyright Contributors to the OpenEXR Project.
+# Copyright (c) Contributors to the OpenEXR Project.
 #
 # GitHub Actions workflow file
 # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
@@ -19,13 +19,13 @@
   # ---------------------------------------------------------------------------
 
   linux_sonarcloud:
-    name: 'SonarCloud Linux CentOS 7 VFX CY2021 <GCC 6.3.1>'
+    name: 'SonarCloud Linux CentOS 7 VFX CY2022 <GCC 9.3.1>'
     # GH-hosted VM. The build runs in CentOS 7 'container' defined below.
     runs-on: ubuntu-latest
     container:
       # DockerHub: https://hub.docker.com/u/aswf
       # Source: https://github.com/AcademySoftwareFoundation/aswf-docker
-      image: aswf/ci-openexr:2021
+      image: aswf/ci-openexr:2022
     env:
       CXX: g++
       CC: gcc
@@ -35,14 +35,13 @@
       - name: Setup container
         run: sudo rm -rf /usr/local/lib64/cmake/glew
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: Create build directories
         run: |
           mkdir _install
           mkdir _build
-        shell: bash
       - name: Configure
         run: |
           cmake .. \
@@ -51,6 +50,8 @@
                 -DCMAKE_CXX_STANDARD=14 \
                 -DCMAKE_CXX_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage" \
                 -DCMAKE_CXX_OUTPUT_EXTENSION_REPLACE=ON \
+                -DCMAKE_C_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage" \
+                -DCMAKE_C_OUTPUT_EXTENSION_REPLACE=ON \
                 -DCMAKE_EXE_LINKER_FLAGS="-lgcov" \
                 -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \
                 -DBUILD_SHARED_LIBS='OFF' \
@@ -82,13 +83,13 @@
   #  Valgrind memcheck test
   # ------------------------------------------------------------------------------
   linux_valgrind:
-    name: 'Valgrind Linux CentOS 7 VFX CY2021 <GCC 6.3.1>'
+    name: 'Valgrind Linux CentOS 7 VFX CY2022 <GCC 9.3.1>'
     # GH-hosted VM. The build runs in CentOS 7 'container' defined below.
     runs-on: ubuntu-latest
     container:
       # DockerHub: https://hub.docker.com/u/aswf
       # Source: https://github.com/AcademySoftwareFoundation/aswf-docker
-      image: aswf/ci-openexr:2021
+      image: aswf/ci-openexr:2022
     env:
       CXX: g++
       CC: gcc
@@ -98,7 +99,7 @@
       - name: Setup container
         run: sudo rm -rf /usr/local/lib64/cmake/glew
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: Create build directories
@@ -118,8 +119,6 @@
                 -DCMAKE_CXX_STANDARD=14 \
                 -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \
                 -DBUILD_SHARED_LIBS='OFF' \
-                -DOPENEXR_BUILD_UTILS='ON' \
-                -DOPENEXR_RUN_FUZZ_TESTS='OFF' \
                 -DPYTHON='ON'
         working-directory: _build
       - name: Build

_service:tar_scm:Imath-3.1.4.tar.gz/.github/workflows/ci_workflow.yml -> _service:tar_scm:Imath-3.1.9.tar.gz/.github/workflows/ci_workflow.yml Changed

@@ -32,7 +32,8 @@
 
   linux:
     name: 'Linux CentOS 7 VFX CY${{ matrix.vfx-cy }} 
-      <${{ matrix.compiler-desc }} 
+      <${{ matrix.compiler-desc }} ,
+       ${{ matrix.python-desc }},
        config=${{ matrix.build-type }}, 
        shared=${{ matrix.build-shared }}, 
        cxx=${{ matrix.cxx-standard }}>'
@@ -44,190 +45,214 @@
       image: aswf/ci-openexr:${{ matrix.vfx-cy }}
     strategy:
       matrix:
-        build: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
+        build: 1, 2, 3, 4, 9, 10, 11, 12, 13, 14, 15, 20, 21, 22
         include:
           # -------------------------------------------------------------------
-          # GCC, VFX CY2021
+          # GCC, VFX CY2022
           # -------------------------------------------------------------------
-          # C++11, Python 3.7
-          - build: 11
+          # C++17, Python 3.9
+          - build: 1
             build-type: Release
             build-shared: 'ON'
-            cxx-standard: 11
+            cxx-standard: 17
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2021
-          # Debug
-          - build: 12
+            compiler-desc: gcc9.3.1
+            python: 'ON'
+            python-desc: python3.9.7
+            vfx-cy: 2022
+
+          # C++17, Python 3.9.7, Debug
+          - build: 2
             build-type: Debug
             build-shared: 'ON'
-            cxx-standard: 11
+            cxx-standard: 17
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2021
-          # C++14
-          - build: 13
+            compiler-desc: gcc9.3.1
+            python: 'ON'
+            python-desc: python3.9.7
+            vfx-cy: 2022
+
+          # C++17, Python 3.9.7, Static
+          - build: 3
             build-type: Release
-            build-shared: 'ON'
-            cxx-standard: 14
+            build-shared: 'OFF'
+            cxx-standard: 17
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2021
-          # Static
-          - build: 14
+            compiler-desc: gcc9.3.1
+            python: 'ON'
+            python-desc: python3.9.7
+            vfx-cy: 2022
+
+          # C++14, Python 3.9.7, Static
+          - build: 4
             build-type: Release
-            build-shared: 'OFF'
-            cxx-standard: 11
+            build-shared: 'ON'
+            cxx-standard: 14
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2021
+            compiler-desc: gcc9.3.1
+            python: 'ON'
+            python-desc: python3.9.7
+            vfx-cy: 2022
+
+          # C++17, no Python
+            # - build: 5
+            # build-type: Release
+            # build-shared: 'ON'
+            # cxx-standard: 17
+            # cxx-compiler: g++
+            # cc-compiler: gcc
+            # compiler-desc: gcc9.3.1
+            # python: 'OFF'
+            # python-desc: no python
+            # vfx-cy: 2022
+
           # -------------------------------------------------------------------
-          # GCC, VFX CY2020
+          # GCC, VFX CY2021
           # -------------------------------------------------------------------
-          # C++11, Python 3.7
-          - build: 1
+          # C++17, Python 3.7.9
+          - build: 9
             build-type: Release
             build-shared: 'ON'
-            cxx-standard: 11
+            cxx-standard: 17
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2020
-          # Debug
-          - build: 2
-            build-type: Debug
-            build-shared: 'ON'
-            cxx-standard: 11
-            cxx-compiler: g++
-            cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2020
-          # C++14
-          - build: 3
+            compiler-desc: gcc9.3.1
+            python: 'ON'
+            python-desc: python3.7.9
+            vfx-cy: 2021
+
+          # -------------------------------------------------------------------
+          # GCC, VFX CY2020
+          # -------------------------------------------------------------------
+          # C++14, Python 3.7
+          - build: 10
             build-type: Release
             build-shared: 'ON'
             cxx-standard: 14
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
-            vfx-cy: 2020
-          # Static
-          - build: 4
-            build-type: Release
-            build-shared: 'OFF'
-            cxx-standard: 11
-            cxx-compiler: g++
-            cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
+            compiler-desc: gcc6.3.1
+            python: 'ON'
+            python-desc: python3.7.3
             vfx-cy: 2020
+
           # -------------------------------------------------------------------
           # GCC, VFX CY2019
           # -------------------------------------------------------------------
-          # Python 2.7
-          - build: 5
+          # C++11, Python 2.7
+          - build: 11
             build-type: Release
             build-shared: 'ON'
             use-python2: 'ON'
             cxx-standard: 11
             cxx-compiler: g++
             cc-compiler: gcc
-            compiler-desc: GCC 6.3.1
+            compiler-desc: gcc6.3.1
+            python: 'ON'
+            python-desc: python2.7.15
             vfx-cy: 2019
+
           # -------------------------------------------------------------------
-          # Clang, VFX CY2021
+          # Clang, VFX CY2022
           # -------------------------------------------------------------------
-          # C++11, Python 3.7
-          - build: 15
+          # C++17, Python 3.9
+          - build: 12
             build-type: Release
             build-shared: 'ON'
-            cxx-standard: 11
+            cxx-standard: 17
             cxx-compiler: clang++
             cc-compiler: clang
-            compiler-desc: Clang 7
-            vfx-cy: 2021
-          # Debug
-          - build: 16
+            compiler-desc: clang10.4
+            python: 'ON'
+            python-desc: python3.9.7

_service:tar_scm:Imath-3.1.4.tar.gz/CHANGES.md -> _service:tar_scm:Imath-3.1.9.tar.gz/CHANGES.md Changed

@@ -1,5 +1,10 @@
 # Imath Release Notes
 
+* Version 3.1.9(#version-319-May-31-2023) May 31, 2023
+* Version 3.1.8(#version-318-May-22-2023) May 22, 2023
+* Version 3.1.7(#version-317-March-1-2023) March 1, 2023
+* Version 3.1.6(#version-316-november-7-2022) November 7, 2022
+* Version 3.1.5(#version-315-march-28-2022) March 28, 2022
 * Version 3.1.4(#version-314-january-21-2022) January 21, 2022
 * Version 3.1.3(#version-313-september-2-2021) September 2, 2021
 * Version 3.1.2(#version-312-july-31-2021) July 31, 2021
@@ -13,6 +18,103 @@
 * Version 3.0.0-beta(#version-300-beta-march-15-2021) March 15, 2021
 * Inherited History from OpenEXR(#inherited-history-from-openexr)
 
+## Version 3.1.9 (May 31, 2023)
+
+Patch release that fixes an correct .so version number introduced in
+v3.1.8. All Imath library functionality is compatible with v3.1.8.
+
+This release also reverts
+#305(https://github.com/AcademySoftwareFoundation/Imath/pull/305),
+which inadvertently introduced additional python bindings in v3.1.8
+that altered the ABI of ``libPyImath``. ``libPyImath`` is now
+ABI-compatible with v3.1.7 and previous releases.
+
+## Version 3.1.8 (May 22, 2023)
+
+**NOTE: this version has an incorrect .so number and should not be used. Use v3.1.9 instead.**
+
+Patch release that addresses miscellaneous minor compiler/build/doc
+issues and extends test coverage.
+
+### Merged Pull Requests
+
+* \#318(https://github.com/AcademySoftwareFoundation/Imath/pull/318)\ Separate CI job for docs 
+* \#317(https://github.com/AcademySoftwareFoundation/Imath/pull/317)\ fix the macro switching half-precision floating-point format implementation.
+* \#315(https://github.com/AcademySoftwareFoundation/Imath/pull/315)\ Updated Mac and Windows jobs for VFX platform 2023. 
+* \#314(https://github.com/AcademySoftwareFoundation/Imath/pull/314)\ Remove duplicate IMATH_HOSTDEVICE 
+* \#313(https://github.com/AcademySoftwareFoundation/Imath/pull/313)\ IMATH_EXPORT for Rand32::nextf() 
+* \#310(https://github.com/AcademySoftwareFoundation/Imath/pull/310)\ Extend test coverage 
+* \#309(https://github.com/AcademySoftwareFoundation/Imath/pull/309)\ Undo #307, restore array-based Matrix constructors 
+* \#308(https://github.com/AcademySoftwareFoundation/Imath/pull/308)\ Fix run_gcov.sh to use proper _build/_coverage dirs 
+* \#307(https://github.com/AcademySoftwareFoundation/Imath/pull/307)\ Conditionally include Matrix constructors duplicated by interop declarations 
+* \#306(https://github.com/AcademySoftwareFoundation/Imath/pull/306)\ Fix coverage analysis for .c files 
+* \#305(https://github.com/AcademySoftwareFoundation/Imath/pull/305)\ Extend test code coverage and add missing python bindings 
+* \#303(https://github.com/AcademySoftwareFoundation/Imath/pull/303)\ Remove unused variables 
+* \#302(https://github.com/AcademySoftwareFoundation/Imath/pull/302)\ In testMatrix(), call fabs() instead of fabsf() for double values 
+* \#300(https://github.com/AcademySoftwareFoundation/Imath/pull/300)\ Check return status of extractSHRT in computeRSMatrix 
+
+
+## Version 3.1.7 (March 1, 2023)
+
+**NOTE: this version has an incorrect .so number and should not be used. Use v3.1.9 instead.**
+
+Patch release with miscellaneous bug/doc/build fixes. In particular:
+
+- Support for relative prefix in pkg-config
+- Reorganization of documentation at https://imath.readthedocs.io
+- Add a ``trace()`` method on Matrix types
+
+### Merged Pull Requests
+
+* \#296(https://github.com/AcademySoftwareFoundation/Imath/pull/296)\ Move index to bottom of main page; remove top-level link
+* \#295(https://github.com/AcademySoftwareFoundation/Imath/pull/295)\ Fix doc typo
+* \#294(https://github.com/AcademySoftwareFoundation/Imath/pull/294)\ Fix documentation glitches and symbol visibility table
+* \#293(https://github.com/AcademySoftwareFoundation/Imath/pull/293)\ Reorganize repo/readthedocs documentation
+* \#292(https://github.com/AcademySoftwareFoundation/Imath/pull/292)\ Add missing licenses/copyrights
+* \#291(https://github.com/AcademySoftwareFoundation/Imath/pull/291)\ Support relative prefix in pkg-config
+* \#282(https://github.com/AcademySoftwareFoundation/Imath/pull/282)\ Remove MACOSX_RPATH forcing
+* \#280(https://github.com/AcademySoftwareFoundation/Imath/pull/280)\ Add trace function for matrix types
+* \#279(https://github.com/AcademySoftwareFoundation/Imath/pull/279)\ Define BOOST_BIND_GLOBAL_PLACEHOLDERS to suppress pragma message
+* \#278(https://github.com/AcademySoftwareFoundation/Imath/pull/278)\ Use Py_ssize_t in place of size_t where appropriate to avoid warnings
+* \#277(https://github.com/AcademySoftwareFoundation/Imath/pull/277)\ Update CONTRIBUTING.md to be consistent with OpenEXR 
+* \#275(https://github.com/AcademySoftwareFoundation/Imath/pull/275)\ Remove export attribute from inline half functions
+
+## Version 3.1.6 (November 7, 2022)
+
+Patch release with miscellaneous bug/doc/build fixes.
+
+* \#269(https://github.com/AcademySoftwareFoundation/Imath/pull/269)\ fix memory leak in V3fArrayFromBuffer
+* \#268(https://github.com/AcademySoftwareFoundation/Imath/pull/268)\ Add <cstdint> for int64_t
+* \#263(https://github.com/AcademySoftwareFoundation/Imath/pull/263)\ Initialize x in testRoots.cpp:solve() to suppress compiler warning
+* \#262(https://github.com/AcademySoftwareFoundation/Imath/pull/262)\ Fix gcc compiler warning in testFun.cpp
+* \#261(https://github.com/AcademySoftwareFoundation/Imath/pull/261)\ Test return value of extractSHRT to avoid uninitialized reference
+* \#260(https://github.com/AcademySoftwareFoundation/Imath/pull/260)\ Fix example code so it compiles as is 
+* \#259(https://github.com/AcademySoftwareFoundation/Imath/pull/259)\ Cuda safety in several headers
+* \#256(https://github.com/AcademySoftwareFoundation/Imath/pull/256)\ Fix markdown and typos in README.md
+* \#255(https://github.com/AcademySoftwareFoundation/Imath/pull/255)\ Do not warn if half.h has already being included
+* \#250(https://github.com/AcademySoftwareFoundation/Imath/pull/250)\ Fix compiler warnings on windows
+* \#249(https://github.com/AcademySoftwareFoundation/Imath/pull/249)\ Remove irrelevant cvs ignore files
+* \#248(https://github.com/AcademySoftwareFoundation/Imath/pull/248)\ Update sphinx version
+
+## Version 3.1.5 (March 28, 2022)
+
+Patch release with miscellaneous bug/doc/build fixes.
+
+In particular, this fixes an issue that could lead to incorrect values
+for `numeric_limits<half>`. This also updates the CI workflow matrix
+to VFX-CY2022.
+
+* \#246(https://github.com/AcademySoftwareFoundation/Imath/pull/246)\ 
+Update CI workflow matrix for VFX-CY2022
+* \#245(https://github.com/AcademySoftwareFoundation/Imath/pull/245)\ 
+Use `_WIN32` instead of `_MSC_VER` to fix mingw build
+* \#244(https://github.com/AcademySoftwareFoundation/Imath/pull/244)\ 
+Fix 32-bit x86 build failure with 16c instructions
+* \#241(https://github.com/AcademySoftwareFoundation/Imath/pull/241)\ 
+Move `numeric_limits<half>` specializations into half.h
+* \#236(https://github.com/AcademySoftwareFoundation/Imath/pull/236)\ 
+Change references to "master" branch to "main"
+
 ## Version 3.1.4 (January 21, 2022)
 
 Patch release with miscellaneous bug/doc/build fixes.

_service:tar_scm:Imath-3.1.4.tar.gz/CMakeLists.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/CMakeLists.txt Changed

_service:tar_scm:Imath-3.1.4.tar.gz/CONTRIBUTING.md -> _service:tar_scm:Imath-3.1.9.tar.gz/CONTRIBUTING.md Changed

@@ -1,3 +1,6 @@
+
+
+
 # Contributing to Imath
 
 Thank you for your interest in contributing to Imath. This document
@@ -15,13 +18,12 @@
 follows OpenEXR's governance and contribution policies.
 
 For a description of the roles and responsibilities of the various
-members of the OpeneEXR community, see GOVERNANCE.md(https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md),
-and for further details, see the OpenEXR project's Technical
-Charter(https://github.com/AcademySoftwareFoundation/openexr/blob/master/ASWF/charter/OpenEXR-Technical-Charter.md).
-Briefly, a "contributor" is anyone who submits content to the project,
-a "committer" is someone who reviews and approves such submissions,
-and the Technical Steering Committee provides general project
-oversight.
+members of the OpenEXR community, see GOVERNANCE(GOVERNANCE.md), and
+for further details, see the OpenEXR project's Technical
+Charter(ASWF/charter/OpenEXR-Technical-Charter.md). Briefly,
+a "contributor" is anyone who submits content to the project, a
+"committer" reviews and approves such submissions, and the "Technical
+Steering Committee" provides general project oversight and governance.
 
 ## Getting Information
 
@@ -73,9 +75,7 @@
 
 ### How to Contribute a Bug Fix or Change
 
-To contribute code to the project, first read over the
-GOVERNANCE.md(https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md)
-page to understand the roles involved. You'll need:
+To contribute code to the project, first read over the GOVERNANCE(GOVERNANCE.md) page to understand the roles involved. You'll need:
 
 * A good knowledge of git.
 
@@ -100,25 +100,39 @@
 ### Contributor License Agreements
 
 Developers who wish to contribute code to be considered for inclusion
-in the Imath distribution must first complete a **Contributor License
-Agreement** for the OpenEXR project.
+in the OpenEXR distribution must first complete a **Contributor
+License Agreement**.
+
+To contribute to Imath or OpenEXR, you must sign a CLA through the
+EasyCLA(https://contributor.easycla.lfx.linuxfoundation.org/#/cla/project/2e8710cb-e379-4116-a9ba-964f83618cc5/user/564e571e-12d7-4857-abd4-898939accdd7?redirect=https:%2F%2Fgithub.com%2FAcademySoftwareFoundation%2Fopenexr%2Fpull%2F1154)
+system, which is integrated with GitHub as a pull request check.
 
-Imath uses EasyCLA for managing CLAs, which automatically
-checks to ensure CLAs are signed by a contributor before a commit
-can be merged. 
+Sign the form through this
+link(https://contributor.easycla.lfx.linuxfoundation.org/#/cla/project/2e8710cb-e379-4116-a9ba-964f83618cc5/user/564e571e-12d7-4857-abd4-898939accdd7?redirect=https:%2F%2Fgithub.com%2FAcademySoftwareFoundation%2Fopenexr%2Fpull%2F1154)
+prior to submitting a pull request. If you submit a pull request
+before the form is signed, the "linux-foundation-easycla" check will
+fail and a red "NOT COVERED" button will appear in the PR
+comments. Click that link to sign the form.
 
 * If you are an individual writing the code on your own time and
-  you're SURE you are the sole owner of any intellectual property you
-  contribute, you can sign the CLA as an individual contributor(https://github.com/communitybridge/easycla/blob/master/contributors/sign-a-cla-as-an-individual-contributor-to-github.md).
+  you're **sure** you are the sole owner of any intellectual property you
+  contribute, you can sign the CLA as an **Individual Contributor**.
+
+* If you are writing the code as part of your job, or if your employer
+  retains ownership to intellectual property you create, no matter how
+  small, then your company's legal affairs representatives should sign
+  a **Corporate Contributor Licence Agreement**. If your company already
+  has a signed CCLA on file, ask your local CLA manager to add you
+  (via your GitHub account name/email address) to your company's
+  "approved" list.
 
-* If you are writing the code as part of your job, or if there is any
-  possibility that your employers might think they own any
-  intellectual property you create, then you should use the Corporate
-  Contributor Licence
-  Agreement(https://github.com/communitybridge/easycla/blob/master/contributors/contribute-to-a-github-company-project.md).
+The downloadable PDF's on the EasyCLA page are provided for reference
+only. To execute the signature, sign the form online through the
+relevant links.
 
-The Imath CLAs are the standard forms used by Linux Foundation
-projects and recommended by the ASWF TAC(https://github.com/AcademySoftwareFoundation/tac/blob/master/process/contributing.md#contributor-license-agreement-cla).
+The OpenEXR CLAs are the standard forms used by Linux Foundation
+projects and recommended by the ASWF
+TAC(https://github.com/AcademySoftwareFoundation/tac/blob/main/process/contributing.md#contributor-license-agreement-cla).
 
 ### Commit Sign-Off
 
@@ -126,7 +140,7 @@
 must include a “`Signed-off-by`” line (generated, for example, with
 “`git commit --signoff`”), indicating that the committer wrote the
 code and has the right to release it under the BSD-3-Clause(LICENSE.md)
-license. See https://github.com/AcademySoftwareFoundation/tac/blob/master/process/contributing.md#contribution-sign-off for more information on this requirement.
+license. See https://github.com/AcademySoftwareFoundation/tac/blob/main/process/contributing.md#contribution-sign-off for more information on this requirement.
 
 ## Development Workflow
 
@@ -149,21 +163,21 @@
 
 The Imath repository uses a simple branching and merging strategy.
 
-All development work is done directly on the master branch. The master
+All development work is done directly on the ``main`` branch. The ``main``
 branch represents the bleeding-edge of the project and most
 contributions should be done on top of it.
 
-After sufficient work is done on the master branch and the Imath
+After sufficient work is done on the ``main`` branch and the Imath
 leadership determines that a release is due, we will bump the relevant
 internal versioning and tag a commit with the corresponding version
 number, e.g. v2.0.1. Each minor version also has its own “Release
 Branch”, e.g. RB-1.1. This marks a branch of code dedicated to that
 ``major.minor version``, which allows upstream bug fixes to be
-cherry-picked to a given version while still allowing the master
+cherry-picked to a given version while still allowing the ``main``
 branch to continue forward onto higher versions. This basic repository
 structure keeps maintenance low, while remaining simple to understand.
 
-To reiterate, the master branch represents the latest development
+To reiterate, the ``main`` branch represents the latest development
 version, so beware that it may include untested features and is not
 generally stable enough for release.  To retrieve a stable version of
 the source code, use one of the release branches.
@@ -224,7 +238,7 @@
 
 6. Upon receiving the required number of committer approvals (as
 outlined in Required Approvals(#required-approvals)), a committer
-other than the PR contributor may merge changes into the master
+other than the PR contributor may merge changes into the ``main``
 branch.
 
 ### Code Review and Required Approvals
@@ -243,13 +257,14 @@
 
 * Core design decisions, large new features, or anything that might be
 perceived as changing the overall direction of the project should be
-discussed at length in the mail list before any PR is submitted, in
-order to: solicit feedback, try to get as much consensus as possible,
-and alert all the stakeholders to be on the lookout for the eventual
-PR when it appears.
+discussed at length in the mail list or TSC meetings before any PR is
+submitted, in order to solicit feedback, try to get as much consensus
+as possible, and alert all the stakeholders to be on the lookout for
+the eventual PR when it appears.
 
-* Small changes (bug fixes, docs, tests, cleanups) can be approved and
-merged by a single committer.
+* Trivial changes that don't affect functionality (typos, docs, tests)
+can be approved by the committer without review, after waiting at
+least 48 hours.
 
 * Big changes that can alter behavior, add major features, or present
 a high degree of risk should be signed off by TWO committers, ideally
@@ -289,26 +304,31 @@
 
 All functionality in the library must be covered by an automated
 test. Each library has a companion ``Test`` project,
-i.e. ``ImathTest`` and ``HalfTest``.  This test suite is collectively
-expected to validate the behavior of very part of the library.
+e.g. ``ImathTest``, ``HalfTest``, ``PyImathTest``.  This test suite is
+collectively expected to validate the behavior of very part of the
+library.
 
-* Any new functionality should be accompanied by a test that validates
+* All new functionality should be accompanied by a test that validates
   its behavior.
 
 * Any change to existing functionality should have tests added if they
   don't already exist.
 
-The test should should be run, via ``make test``, before submitting a
-pull request.
+The test should should be run, via:
+
+    make test
+
+before submitting a pull request.
 
 ## Coding Style
 
 #### Formatting
 
-Code formattting is controlled by ``clang-format``, with the style
-specified via the project
-.clang-format(https://github.com/AcademySoftwareFoundation/Imath/blob/master/.clang-format)
-file.
+The coding style of the library source code is enforced via Clang format, with the configuration defined in .clang-format(.clang-format).
+
+When modifying existing code, follow the surrounding formatting
+conventions so that new or modified code blends in with the current
+code.
 
 * Indent with spaces, never tabs. Each indent level should be 4 spaces.
 
@@ -348,12 +368,6 @@

_service:tar_scm:Imath-3.1.4.tar.gz/CONTRIBUTORS.md -> _service:tar_scm:Imath-3.1.9.tar.gz/CONTRIBUTORS.md Changed

_service:tar_scm:Imath-3.1.9.tar.gz/GOVERNANCE.md Added

@@ -0,0 +1,156 @@
+
+
+
+# OpenEXR Project Roles and Responsibilities
+
+Imath is a subproject of OpenEXR and follows OpenEXR's governance and
+contribution policies. OpeneEXR is a project of the Academy Software
+Foundation and in turn relies on the ASWF governance policies,
+supported by the Linux Foundation.
+
+There are three primary project roles: a "contributor" submits code to the
+project; a "committer" approves code to be included into the project; and
+the "Technical Steering Committee" (TSC) provides overall high-level
+project guidance.
+
+* Contributors(#Contributors)
+* Committers(#Committers)
+* Technical Steering Committee(#Technical-Steering-Committee)
+
+## Contributors
+
+The OpenEXR project grows and thrives from assistance from
+contributors.  A contributor is anyone in the community who submits
+code, bug fixes, documentation, or other technical artifacts to the
+project. However, such contributions must be approved by a project
+committer before they become a part of the project.
+
+Anyone can be a contributor. You need no formal approval from the
+project, beyond the legal forms.
+
+### How to Become a Contributor
+
+* Review the coding standards to ensure your contribution is in line
+  with the project's coding and styling guidelines.
+
+* Sign the Individual CLA, or have your organization sign the Corporate CLA.
+
+* Submit your code as a PR with the appropriate DCO sign-off.
+
+## Committers
+
+Project committers have merge access on the Imath GitHub repository
+and are responsible for approving submissions by contributors.
+
+### Committer Responsibilities
+
+Typical activities of a committer include:
+
+* Helping users and novice contributors.
+
+* Ensuring a response to questions posted to the
+  openexr-dev@lists.aswf.io mailing list.
+
+* Contributing code and documentation changes that improve the
+  project.
+
+* Reviewing and commenting on issues and pull requests.
+
+* Ensuring that changes and new code meet acceptable standards and are
+  in the long-term interest of the project.
+
+* Participating in working groups.
+
+* Merging pull requests.
+
+### How to Become a Committer
+
+Any existing committer can nominate an individual making significant
+and valuable contributions to the OpenEXR project to become a new
+committer.  New committers are approved by vote of the TSC.
+
+If you are interested in becoming a committer, contact the TSC at
+info@openexr.com.
+
+## Technical Steering Committee
+
+The Technical Steering Committee (TSC) oversees the overall technical
+direction of OpenEXR, as defined in the project
+charter(ASWF/charter/OpenEXR-Technical-Charter.md).  This
+charter defines the TSC member terms and succession policies.
+
+The responsibilities of the TSC include:
+
+* Coordinating technical direction of the project.
+
+* Project governance and contribution policy.
+
+* GitHub repository administration.
+
+* Maintaining the list of additional committers.
+
+* Appointing representatives to work with other open source or open
+  standards communities.
+
+* Discussions, seeking consensus, and where necessary, voting on
+  technical matters relating to the code base that affect multiple
+  projects.
+
+* Coordinating any marketing, events, or communications regarding the
+  project.
+
+The TSC elects a Chair person, who acts as the project manager,
+organizing meetings and providing oversight to project
+administration. The Chair is elected by the TSC.  The Chair also
+serves as the OpenEXR representative on the Academy Software
+Foundation (ASWF) Technical Advisory Council (TAC). The chair
+represents the project at ASWF TAC meetings.
+
+### Current TSC Members
+
+* Cary Phillips (chair) - Industrial Light & Magic
+* Rod Bogart - Epic Games
+* Larry Gritz - Sony Pictures ImageWorks
+* Peter Hillman - Weta Digital, Ltd.
+* Kimball Thurston - Weta Digital, Ltd.
+* Nick Porcino - Pixar Animation Studios
+* Christina Tempelaar-Lietz - Industrial Light & Magic
+* Joseph Goldstone - ARRI
+* John Mertic - The Linux Foundation
+
+### TSC Meetings
+
+All meetings of the TSC are open to participation by any member of the
+OpenEXR community. Meeting times are listed in the ASWF technical
+community calendar(https://lists.aswf.io/g/tac/calendar), currently
+each Thursday at 1:30pm Pacific Time via Zoom video conference.  The
+TSC Chair moderates the meeting, or appoints another TSC member to
+moderate in his or her absence.
+
+Items are added to the TSC agenda which are considered contentious or
+are modifications of governance, contribution policy, TSC membership,
+or release process, in addition to topics involving the high-level
+technical direction of the project.
+
+The intention of the agenda is not to approve or review all
+patches. That should happen continuously on GitHub and be handled by
+the larger group of committers.
+
+Any community member or contributor can ask that something be reviewed
+by the TSC at the meeting by logging a GitHub issue. Any committer,
+TSC member, or the meeting chair can bring the issue to the TSC's
+attention by applying the `TSC` label.
+
+Prior to each TSC meeting, the meeting chair will share the agenda with members
+of the TSC. TSC members can also add items to the agenda at the beginning of
+each meeting. The meeting chair and the TSC cannot veto or remove items.
+
+The TSC may invite additional persons to participate in a non-voting capacity.
+
+The meeting chair is responsible for archiving the minutes, stored at 
+https://wiki.aswf.io/display/OEXR/TSC+Meetings.
+
+Due to the challenges of scheduling a global meeting with participants
+in several time zones, the TSC will seek to resolve as many agenda
+items as possible outside of meetings on the public mailing list.
+

_service:tar_scm:Imath-3.1.4.tar.gz/README.md -> _service:tar_scm:Imath-3.1.9.tar.gz/README.md Changed

@@ -1,3 +1,6 @@
+
+
+
 !License(https://img.shields.io/github/license/AcademySoftwareFoundation/Imath)(LICENSE.md)
 !CII Best Practices(https://bestpractices.coreinfrastructure.org/projects/2799/badge)(https://bestpractices.coreinfrastructure.org/projects/2799)
 !Build Status(https://dev.azure.com/academysoftwarefoundation/Academy%20Software%20Foundation/_apis/build/status/academysoftwarefoundation.Imath)(https://dev.azure.com/academysoftwarefoundation/Academy%20Software%20Foundation/_build?definitionId=4&_a=summary)
@@ -12,125 +15,96 @@
 
 Imath also includes optional python bindings for all types and
 functions, including optimized implementations of vector and matrix
-arrays. 
+arrays.
 
-### Project Mission
+## Project Mission
 
 The goals of the Imath project are simplicity, ease of use,
 correctness and verifiability, performance, and breadth of
 adoption. Imath is not intended to be a comprehensive linear algebra
 or numerical analysis package.
 
-### Features
-
-* half: 16-bit floating-point type
-* Vector: V2s, V2i, V2i64, V2f, V2d, V3s, V3i, V4i64, V3f, V3d, V4s, V4i, V4i64, V4f, V4d 
-* Matrix: M22f, M22d, M33f, M33d, M44f, M44d 
-* Bounding box: Box2s, Box2i, Box2i64, Box2f, Box2d, Box3s, Box3i, Box3i64, Box3f, Box3d
-* Color: C3h, C3f, C3c, C4f, C4h, C4c 
-* Euler angles: Eulerf, Eulerd
-* Quaternion: Quatf, Quatd
-* Viewing frustum: Frustrumf, Frustumd
-* Interval: Intervals, Intervali, Intervalf, Intervald
-* Line: Line3f, Line3d
-* Plane: Plane3f, Plane3d
-* Sphere: Sphere3f, Sphere3d
-* Shear: Shear3f, Shear3d, Shear6f, Shear6
-* Miscellaneous math functions
-  
-### New Features in 3.1
-
-The 3.1 release of Imath introduces optimized half-to-float and
-float-to-half conversion using the F16C SSE instruction set extension,
-if available. These single-instruction conversions offer a 5-10x
-speedup for float-to-half and 2x speedup for half-to-float over
-Imath/half's traditional table-based conversion (timings depend on the
-data).
-
-In the absence of the F16C instruction set, the lookup-table-based
-conversion from half to float is still the default, but Imath 3.1 also
-introduces an optimized bit-shift conversion algorithm as a
-compile-time option that does not require lookup tables, for
-architectures where memory is limited. The float-to-half conversion
-also no longer requires an exponent lookup table, further reducing
-memory requirements.
+## Project Governance
 
-These new conversions generate the same values as the tranditional
-methods, which ensures backwards compatibility.  See
-INSTALL.md(INSTALL.md#imath-configuration-settings) for more
-installation and configuation options.
+OpenEXR is a project of the Academy Software
+Foundation(https://www.aswf.io). See the project's governance
+policies(GOVERNANCE.md), contribution guidelines(CONTRIBzuTING.md), and code of conduct(CODE_OF_CONDUCT)
+for more information.
 
-Also, ``half.h`` can now be included in pure C code for a definition
-of the type and for conversions between half and float.
+The OpenEXR project is dedicated to promoting a harassment-free
+community. Read our code of conduct(CODE_OF_CONDUCT.md).
 
-### Supported Platforms
+## Supported Platforms
 
 Imath builds on Linux, macOS, Microsoft Windows, and is
 cross-compilable on other systems.
 
-### About Imath
-
-Imath was originally developed at Industrial Light & Magic in the
-early 2000's and was originally distributed as open source as a part
-of the OpenEXR(https://github.com/AcademySoftwareFoundation/openexr)
-project.
+## A Note about Versioning
 
-Imath continues to be maintained as a sub-project of OpenEXR, which is
-now a project of the Academy Software
-Foundation(https://www.aswf.io).  See
-the OpenEXR project's GOVERNANCE.md(https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md)
-for more information about how the project operates.
-
-The OpenEXR project is dedicated to promoting a harassment-free
-community. Read our code of conduct(CODE_OF_CONDUCT.md).
+Because Imath was originally distributed as a part of OpenEXR, it has
+already had two major release versions, as a part of OpenEXR v1 and
+v2. To avoid confusion with these original releases, the first
+version of Imath released independently of OpenEXR is Version v3.0. To
+be clear, the versioning and release of Imath is no longer tied to
+OpenEXR.
 
-### Developer Quick Start
+# Quick Start
 
 Technical documentation for the Imath classes and functions can be found at
-imath.readthedocs.io(https://imath.readthedocs.io).
+https://imath.readthedocs.io.
 
-See INSTALL.md(INSTALL.md) for instructions on downloading and building Imath
-from source.
+See the Install(https://imath.readthedocs.io) instructions for
+how to download, install, or build Imath from source.
 
 If you encounter problems compiling code or building projects written
 with an earlier release of Imath, the porting
-guide(https://github.com/AcademySoftwareFoundation/Imath/blob/master/docs/PortingGuide2-3.md)
+guide(https://openexr.readthedocs.io/en/latest/PortingGuide.html)
 explains some of the differences and how to address them.
 
-### A Note about Versioning
+# Community
 
-Because Imath was originally distributed as a part of OpenEXR, it has
-already had two major release versions, as a part of OpenEXR v1.* and
-v2.*. To avoid confusion with these original releases, the first
-version of Imath released independently of OpenEXR is Version v3.0. To
-be clear, the versioning and release of Imath is no longer tied to
-OpenEXR.
+* **Ask a question:**
+
+  - Email: openexr-dev@lists.aswf.io
+
+  - Slack: academysoftwarefdn#openexr(https://academysoftwarefdn.slack.com/archives/CMLRW4N73)
+
+* **Attend a meeting:**
+
+  - Technical Steering Committee meetings are open to the
+    public, fortnightly on Thursdays, 1:30pm Pacific Time.
+
+  - Calendar: https://lists.aswf.io/g/openexr-dev/calendar
+
+* **Report a bug:**
+
+  - Submit an Issue: https://github.com/AcademySoftwareFoundation/Imath/issues
+
+* **Report a security vulnerability:**
 
-### Getting Help
+  - Email to security@openexr.com
 
-Connect with the project through:
+* **Contribute a Fix, Feature, or Improvement:**
 
-* The openexr-dev@lists.aswf.io mail list: This is a development
-  focused mail list with a deep history of technical conversations and
-  decisions that have shaped the project. Subscribe at
-  openexr-dev@lists.aswf.io(https://lists.aswf.io/g/openexr-dev).
+  - Read the Contribution Guidelines(CONTRIBUTING.md) and Code of Conduct(CODE_OF_CONDUCT.md)
 
-* Slack: #openexr(https://academysoftwarefdn.slack.com/archives/CMLRW4N73)
+  - Sign the Contributor License
+    Agreement(https://contributor.easycla.lfx.linuxfoundation.org/#/cla/project/2e8710cb-e379-4116-a9ba-964f83618cc5/user/564e571e-12d7-4857-abd4-898939accdd7)
   
-* GitHub Issues: GitHub issues are used both to track bugs and to
-  discuss feature requests. Submit an issue here:
-  https://github.com/AcademySoftwareFoundation/imath/issues. 
+  - Submit a Pull Request: https://github.com/AcademySoftwareFoundation/Imath/pulls
 
-### Getting Involved
+# Resources
 
-The OpenEXR developer community welcomes contributions to the
-project. See CONTRIBUTING.md(CONTRIBUTING.md) for more information
-about contributing to Imath and OpenEXR.
+- Technical documentation: https://imath.readthedocs.io
+- Porting help: OpenEXR/Imath Version 2.x to 3.x Porting Guide(https://openexr.readthedocs.io/en/latest/PortingGuide.html)
+- Security policy: SECURITY.md(SECURITY.md)
+- Release notes: CHANGES.md(CHANGES.md)
+- Contributors: CONTRIBUTORS.md(CONTRIBUTORS.md)  
 
-## License
+# License
 
 Imath is released under OpenEXR's BSD-3-Clause(LICENSE.md) license.
 
 ---
 
-!aswf(https://github.com/AcademySoftwareFoundation/openexr/blob/master/ASWF/images/aswf.png)
+!aswf(https://github.com/AcademySoftwareFoundation/openexr/blob/main/ASWF/images/aswf.png)

_service:tar_scm:Imath-3.1.4.tar.gz/SECURITY.md -> _service:tar_scm:Imath-3.1.9.tar.gz/SECURITY.md Changed

_service:tar_scm:Imath-3.1.9.tar.gz/cmake/FindPythonPackage.cmake Added

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright Contributors to the OpenColorIO Project.
+#
+# Locate a Python package
+#
+# Variables defined by this module:
+#   <package>_FOUND
+#
+# Usage:
+#   find_python_package(Jinja2 2.10.1)
+#
+# If the package is not installed in a standard path, add it to the PYTHONPATH 
+# environment variable before running CMake.
+#
+
+find_package(Python QUIET COMPONENTS Interpreter)
+
+macro(find_python_package package)
+    # Some Python packages have "-" in the PyPi name, but are replaced with "_" 
+    # in the actual package name.
+    string(REPLACE "-" "_" _PKG_IMPORT ${package})
+
+    # Parse options
+    foreach(_ARG ${ARGN})
+        if(_ARG STREQUAL "REQUIRED")
+            set(_PKG_REQUIRED TRUE)
+        endif()
+        if(_PREV_ARG STREQUAL "REQUIRES")
+            set(_PKG_REQUIRES ${_ARG})
+        endif()
+        set(_PREV_ARG ${_ARG})
+    endforeach()
+    
+    if(NOT TARGET ${package})
+        add_custom_target(${package})
+        if(_PKG_REQUIRES)
+            add_dependencies(${package} ${_PKG_REQUIRES})
+            unset(_PKG_REQUIRES)
+        endif()
+        set(_${package}_TARGET_CREATE TRUE)
+    endif()
+
+    set(_PKG_INSTALL TRUE)
+
+    # Try importing Python package
+    execute_process(
+        COMMAND
+            "${Python_EXECUTABLE}" -c "import ${_PKG_IMPORT}"
+        RESULT_VARIABLE
+            _PKG_IMPORT_RESULT
+        OUTPUT_QUIET ERROR_QUIET
+    )
+
+    if(_PKG_IMPORT_RESULT EQUAL 0)
+        set(${package}_FOUND TRUE)
+
+        # Get the package's location
+        execute_process(
+            COMMAND
+                "${Python_EXECUTABLE}" -c 
+                "import ${_PKG_IMPORT}, os; print(os.path.dirname(${_PKG_IMPORT}.__file__))"
+            OUTPUT_VARIABLE
+                _PKG_DIR
+            ERROR_QUIET
+        )
+        string(STRIP "${_PKG_DIR}" _PKG_DIR)
+        message(STATUS "Found ${package}: ${_PKG_DIR}")
+
+    else()
+        set(${package}_FOUND FALSE)
+        set(_FIND_ERR "Could NOT find ${package} (import ${_PKG_IMPORT} failed)")
+
+        if(_PKG_REQUIRED)
+            message(FATAL_ERROR "${_FIND_ERR}")
+        endif()
+        message(STATUS "${_FIND_ERR}")
+    endif()
+
+endmacro()

_service:tar_scm:Imath-3.1.4.tar.gz/cmake/FindSphinx.cmake -> _service:tar_scm:Imath-3.1.9.tar.gz/cmake/FindSphinx.cmake Changed

_service:tar_scm:Imath-3.1.4.tar.gz/config/CMakeLists.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/config/CMakeLists.txt Changed

@@ -31,12 +31,23 @@
 add_library(Imath::Config ALIAS ImathConfig)
 
 if(IMATH_INSTALL_PKG_CONFIG)
+
+  # Prepend prefix for includedir only if CMAKE_INSTALL_INCLUDEDIR is relative
+  if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+      set(PKG_CONFIG_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
+  else()
+      set(PKG_CONFIG_INSTALL_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  endif()
+
+  # Prepend exec_prefix for libdir only if CMAKE_INSTALL_LIBDIR is relative
+  if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+      set(PKG_CONFIG_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+  else()
+      set(PKG_CONFIG_INSTALL_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+
   # use a helper function to avoid variable pollution, but pretty simple
   function(imath_pkg_config_help pcinfile)
-    set(prefix ${CMAKE_INSTALL_PREFIX})
-    set(exec_prefix "\${prefix}")
-    set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
-    set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
     string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
     set(LIB_SUFFIX_DASH ${IMATH_LIB_SUFFIX}${CMAKE_${uppercase_CMAKE_BUILD_TYPE}_POSTFIX})
     string(REPLACE ".in" "" pcout ${pcinfile})

_service:tar_scm:Imath-3.1.4.tar.gz/config/Imath.pc.in -> _service:tar_scm:Imath-3.1.9.tar.gz/config/Imath.pc.in Changed

_service:tar_scm:Imath-3.1.4.tar.gz/config/ImathConfig.cmake.in -> _service:tar_scm:Imath-3.1.9.tar.gz/config/ImathConfig.cmake.in Changed

_service:tar_scm:Imath-3.1.4.tar.gz/config/ImathSetup.cmake -> _service:tar_scm:Imath-3.1.9.tar.gz/config/ImathSetup.cmake Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/PortingGuide.rst Added

@@ -0,0 +1,607 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+:orphan:
+
+.. _porting:
+
+OpenEXR/Imath 2.x to 3.x Porting Guide
+######################################
+
+This porting guide outlines the several areas where switching from OpenEXR
+2.x to OpenEXR 3.x + Imath 3.x will require source code or build changes of
+downstream software.
+
+In each case, we will often explain both how to change if you are expecting
+3.x only hereafter, or usually a more complex accommodation if you want to
+keep compatibility with both 2.x and 3.x.
+
+OpenEXR and Imath Are Different Packages
+========================================
+
+If your use of OpenEXR was only for the sake of using the math classes and
+utilities, maybe you were unhappy that you needed to download and build the
+full OpenEXR dependency. You are in luck -- now Imath is a separate, very
+lightweight open source package. You can use Imath functionality without
+needing any of OpenEXR, which as of 3.x only includes the parts you need to
+read and write OpenEXR image files.
+
+The parts of "IlmBase" that were ``Imath`` and ``half`` are now repackaged
+as the ``Imath`` library. The ``IlmThread`` and ``Iex`` libraries have been
+folded into the OpenEXR package, since they were were not necessary to
+the rest of Imath.
+
+When building OpenEXR 3.x, note that if Imath 3.x library is not found
+already installed at build time, it will be automatically downloaded and
+built as part of the OpenEXR build.
+
+Background
+==========
+
+Why is this happening? Here is the relevant history.
+
+The OpenEXR project has historically consisted of four separate subprojects:
+
+* ``OpenEXR`` - the Imf image format
+* ``IlmBase`` - supporting utilities (Imath, Half, Iex, IlmThread)
+* ``PyIlmBase`` - python bindings for the IlmBase libraries
+* ``OpenEXR_Viewers`` - code for an example EXR image viewer 
+
+Prior to the 2.4 release in 2019, OpenEXR relied primarily on the Gnu
+autotools build system and was released as four separate tarballs
+(ilmbase, pyilmbase, openexr, openexr_viewers) that were constructed
+via the Gnu tools. This gave direct access to the "IlmBase" libraries
+independent of the OpenEXR format library. The project also included
+CMake files but CMake support was incomplete.
+
+With the adoption of OpenEXR by the Academy Software Foundation in
+2019, the technical steering committee made several key changes:
+
+1. Drop support for autotools in favor of CMake. A significant portion
+   of the OpenEXR user base uses Windows, which the Gnu autotools does
+   not support.  Supporting two build systems is a maintenance burden
+   that the TSC opted to avoid. We now assume that all modern users of
+   OpenEXR can reasonably be expected to rely on CMake.
+
+2. Rely on GitHub's automatic release packaging mechanism. This
+   packages the entire contents of package in a single
+   tarball. Separate tarballs are no longer generated by the Gnu
+   autotools setup.
+
+3. Deprecate the OpenEXR_Viewers code. It was impossibly out of date
+   and of little modern value.
+
+Thus, with the 2.4 release, the "IlmBase" libraries are no longer
+distributed in a form that is readily separable from the rest of
+OpenEXR. The build and installation process for the overall OpenEXR
+project is complicated by the fact it consists of four separate
+projects, which added significant complexity to the CMake setup.
+
+Because Imath is generally useful to the community, the TSC decided to
+simplify the configuration by separating Imath into its own independent
+project, maintained and released independently of OpenEXR, and
+introducing it as a new external dependency of OpenEXR.
+
+To further simplify matters, the new Imath library includes the half
+data type directly, rather than maintaining it in a separate
+library. Also, the community at large has a strong desire for simple
+vector/matrix utilities that are unencumbered by Iex, the IlmBase
+library that provides higher-level exception classes, and even
+further, a clear delineation between functionality that (1) relies on
+exception handlings and (2) is free from exceptions. As a result,
+support for Iex has been removed from Imath, and the Iex library is
+now packaged as a component of OpenEXR.
+
+The Imath python bindings are a part of Imath as a configuration
+option, although support is off by default to simplify the build process
+for most users.
+
+New Library Names and Repository Structures
+===========================================
+
+The new repositories place all source code under the ``src`` top-level
+subdirectory.
+
+Imath:
+------
+
+.. code-block::
+
+    src
+    ├── Imath
+    ├── ImathTest
+    └── python
+        ├── config
+        ├── PyImath
+        ├── PyImathNumpy
+        ├── PyImathTest
+        ├── PyImathNumpyTest
+        └── PyImathSpeedTest
+
+
+OpenEXR:
+--------
+
+The ``IlmImf`` library has been renamed ``OpenEXR``. No header files have
+changed names, only their locations in the repo have changes.
+
+.. code-block::
+
+    src
+    ├── bin
+    │   ├── exr2aces
+    │   ├── exrbuild
+    │   ├── exrcheck
+    │   ├── exrenvmap
+    │   ├── exrheader
+    │   ├── exrmakepreview
+    │   ├── exrmaketiled
+    │   ├── exrmultipart
+    │   ├── exrmultiview
+    │   └── exrstdattr
+    ├── lib
+    │   ├── Iex
+    │   ├── IexMath
+    │   ├── IlmThread
+    │   ├── OpenEXR
+    │   └── OpenEXRUtil
+    ├── examples
+    └── test
+        ├── IexTest
+        ├── OpenEXRTest
+        ├── OpenEXRUtilTest
+        └── OpenEXRFuzzTest
+
+
+Finding and Using OpenEXR and Imath CMake Configs
+=================================================
+
+OpenEXR/Imath 3.x Only
+----------------------
+
+If you are *only* concerned with OpenEXR/Imath 3.x going forward, this is
+the recommended way to find the libraries in a downstream project that uses
+the CMake build system:
+
+.. code-block::
+
+    find_package(Imath CONFIG)
+    find_package(OpenEXR CONFIG)
+
+Note that the second line may be omitted if you only need the Imath
+portions.
+
+And then your project can reference the imported targets like this:
+
+.. code-block::
+
+    target_link_libraries (my_target
+        PRIVATE
+            OpenEXR::OpenEXR
+            Imath::Imath
+            Imath::Half
+        )
+
+You only need the parts you use, so for example, if you only need Half and
+Imath, you can omit the OpenEXR target. Also note that in our example above,
+we have used the ``PRIVATE`` label, but you should specify them as ``PUBLIC`` if
+you are exposing those classes in your own package's public interface.
+
+
+Accommodating OpenEXR/Imath 3.x or OpenEXR 2.x
+----------------------------------------------
+
+On the other hand, to accommodate both 2.x and 3.x, it's admittedly
+inconvenient because the packages and the import targets have changed their
+names.  We have found the following idioms to work:
+
+Finding either/both packages:

_service:tar_scm:Imath-3.1.4.tar.gz/docs/PortingGuide2-3.md -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/PortingGuide2-3.md Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/SymbolVisibility.rst Added

@@ -0,0 +1,156 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+:orphan:
+
+.. _Symbol Visibility in Imath/OpenEXR:
+
+Symbol Visibility in Imath/OpenEXR
+##################################
+
+Managing symbol visibility in a C++ library can reduce library sizes,
+and with the extra information, the optimizer may produce faster
+code. To take advantage of this, OpenEXR 3.0 is switching to
+explicitly manage symbols on all platforms, with a hidden-by-default
+behavior on unix-based platforms. Managing symbols has always been
+required for Windows DLLs, where one must explicitly tag functions for
+import and export as appropriate.
+
+For C, this is trivial: just tag public functions or global variable
+as default visibility and leave everything else defaulting to
+hidden. However, in C++, this is not exactly the same story. Functions
+and globals are of course the same. And class member functions are
+largely the same, and other than the attribute specification
+mechanics, follow the same rules between gcc, clang, and
+msvc. However, types have richer information than they do in C. So,
+unless extra work is done, concepts for RTTI like the typeinfo and the
+vtable for virtual classes will be hidden, and not visible. These are
+referred to as "vague" linkage objects in some discussions. 
+
+It is with the "vague" linkage objects where different properties
+arise. For example, if you have a template, it is happily instantiated
+in multiple compile units. If the typeinfo is hidden for one library,
+then this may cause things like dynamic_cast to fail because then the
+same typeinfo is not used, and even though one might think that
+``ImfAttribute<Imath::Box2i>`` are the same in two places, because they
+are instantiated in separate places, they may be considered different
+types. To compound the issue, there are different rules for this in
+different implementations. For example, a default gcc under linux
+allows one to link against otherwise private "vague" linkage objects
+such that the typeinfo ends up as the same entity. clang, for MacOS
+anyway, follows a stricter approach and keeps those types separate,
+perhaps due to the two level namespace they maintain for symbols.
+
+Unfortunately, this is not clearly discussed as an overview of the
+differences between platforms, hence this document to add
+clarity. Each compiler / platform describes their own behavior, but
+not how that behaves relative to others. `libc++
+<https://libcxx.llvm.org/docs/DesignDocs/VisibilityMacros.html>`_ from
+the llvm project is the closest to providing comparative information,
+where by looking at how they define their macros and the comments
+surrounding, one can infer the behavior among at least windows DLL
+mode, then gcc vs. clang for unixen. Other compilers, for example,
+Intel's icc, tend to adopt the behavior of the predominant compiler
+for that platform (i.e. msvc under windows, gcc under linux), and so
+can generally adopt that behavior and are ignored here. If this is not
+true, the ifdef rules in the various library ``Export.h`` headers
+within OpenEXR may need to be adjusted, and this table updated.
+
+As a summary, below is a table of the attribute or declspec that needs
+to be used for a particular C++ entity to be properly exported. This
+does not address weak symbols, ABI versioning, and only focusing on
+visibility. Under Windows DLL rules, if one exports the entire class,
+it also exports the types for the member types as well, which is not
+desired, so these are marked as N/A even though the compiler does
+allow that to happen.
+
+.. list-table::
+   :header-rows: 1
+   :align: left
+
+   * - C++ vs Compiler
+     - MSVC
+     - mingw
+     - gcc
+     - clang
+   * - function
+     - ``dllexport/dllimport``
+     - ``dllexport/dllimport``
+     - ``visibility("default")``
+     - ``visibility("default")``
+   * - hide a function
+     - N/A
+     - N/A
+     - ``visibility("hidden")``
+     - ``visibility("hidden")``
+   * - ``class(typeinfo)``
+     - N/A
+     - N/A
+     - ``visibility("default")``
+     - ``visibility("default")``
+   * - template class
+     - N/A
+     - N/A
+     - ``visibility("default")``
+     - ``type_visibility("default")``
+   * - template data
+     - N/A
+     - N/A
+     - ``visibility("default")``
+     - ``visibility("default")``
+   * - class template instantiation
+     - ``dllexport/dllimport``
+     - N/A
+     - N/A
+     - ``visibility("default")``
+   * - enum
+     - N/A
+     - N/A
+     - auto unhides (N/A)
+     - ``type_visibility("default")``
+   * - extern template
+     - N/A
+     - ``dllexport/dllimport``
+     - ``visibility("default")``
+     - ``visibility("default")``
+
+With this matrix in mind, we can see the maximal set of macros we need to
+provide throughout the code. *NB*: This does not mean that we need to
+declare all of these, just that they might be needed.
+
+.. list-table::
+   :header-rows: 1
+   :align: left
+
+   * - macro name
+     - purpose
+   * - ``IMATH_EXPORT``
+     - one of export or import for windows, visibility for others
+   * - ``IMATH_EXPORT_TYPE``
+     - for declaring a class / struct as public (for typeinfo / vtable)
+   * - ``IMATH_HIDDEN``
+     - used to explicitly hide, especially members of types
+   * - ``IMATH_EXPORT_TEMPLATE_TYPE``
+     - stating the template type should be visible
+   * - ``IMATH_EXPORT_EXTERN_TEMPLATE``
+     - exporting template types (i.e. extern side of extern template)
+   * - ``IMATH_EXPORT_TEMPLATE_INSTANCE``
+     - exporting specific template instantiations (in cpp code)
+   * - ``IMATH_EXPORT_TEMPLATE_DATA``
+     - exporting templated data blocks
+   * - ``IMATH_EXPORT_ENUM``
+     - exporting enum types
+
+The preference might be to call ``IMATH_EXPORT`` something like
+``IMATH_FUNC``, and rename things such as ``IMATH_EXPORT_TYPE`` to
+``IMATH_TYPE`` for simplicity. However, historically, OpenEXR has used
+the ``_EXPORT`` tag, and so that is preserved for consistency.
+
+---------
+
+* LLVM libc++ visibility macros: https://libcxx.llvm.org/docs/DesignDocs/VisibilityMacros.html
+
+* GCC visibility wiki: https://gcc.gnu.org/wiki/Visibility
+
+* Apple library design docs: https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html

_service:tar_scm:Imath-3.1.9.tar.gz/docs/about.rst Added

@@ -0,0 +1,71 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _About Imath:
+
+About Imath
+===========
+
+.. toctree::
+   :caption: About
+             
+Imath is maintained by the OpenEXR project, a part of the `Academy
+Software Foundation <https://www.aswf.io>`_.  The library were
+originally developed at Industrial Light & Magic and first released as
+open source in 2003.
+
+Read the origin story of OpenEXR and Imath, and the ``half`` 16-bit
+float type, in particular, on the `ASWF Blog
+<https://www.aswf.io/news/aswf-deep-dive-openexr-origin-story-part-1>`_.
+
+Imath is Version 3 because it was previously distributed as a
+component of OpenEXR v1 and v2.
+
+OpenEXR and Imath is included in the `VFX Reference Platform <https://vfxplatform.com>`_.
+
+New Features in 3.1
+-------------------
+
+The 3.1 release of Imath introduces optimized half-to-float and
+float-to-half conversion using the F16C SSE instruction set extension,
+if available. These single-instruction conversions offer a 5-10x
+speedup for float-to-half and 2x speedup for half-to-float over
+Imath/half's traditional table-based conversion (timings depend on the
+data).
+
+In the absence of the F16C instruction set, the lookup-table-based
+conversion from half to float is still the default, but Imath 3.1 also
+introduces an optimized bit-shift conversion algorithm as a
+compile-time option that does not require lookup tables, for
+architectures where memory is limited. The float-to-half conversion
+also no longer requires an exponent lookup table, further reducing
+memory requirements.
+
+These new conversions generate the same values as the traditional
+methods, which ensures backwards compatibility.  See :doc:`install`
+for more installation and configuration options.
+
+Also, ``half.h`` can now be included in pure C code for a definition
+of the type and for conversions between half and float.
+
+OpenEXR/Imath 2.x to 3.x Porting Guide
+--------------------------------------
+
+See the :doc:`PortingGuide` for help in restructing old code to work
+with recent releases of OpenEXR and Imath.
+
+Credits
+-------
+
+The ILM Imath library and the ``half`` data type were originally
+designed and implemented at Industrial Light & Magic by Florian Kainz,
+Wojciech Jarosz, Rod Bogart, and others. Drew Hess packaged and
+adapted ILM's internal source code for public release.
+
+For a complete list of contributors see `CONTRIBUTORS.md
+<https://github.com/AcademySoftwareFoundation/Imath/blob/main/CONTRIBUTORS.md>`_.
+
+
+
+

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes.rst Added

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Box.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Box.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Color3.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Color3.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Color4.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Color4.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Euler.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Euler.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Frustum.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Frustum.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Interval.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Interval.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Line3.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Line3.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Matrix22.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Matrix22.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Matrix33.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Matrix33.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Matrix44.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Matrix44.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Plane3.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Plane3.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Quat.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Quat.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Rand32.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Rand32.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Rand48.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Rand48.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Shear6.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Shear6.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Sphere3.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Sphere3.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Vec2.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Vec2.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Vec3.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Vec3.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/Vec4.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/Vec4.rst Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/float.rst Added

@@ -0,0 +1,183 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+Floating Point Representation
+#############################
+
+The half type is a 16-bit floating number, compatible with the
+IEEE 754-2008 binary16 type.
+
+Representation of a 32-bit float
+--------------------------------
+
+We assume that a float, ``f``, is an IEEE 754 single-precision
+floating point number, whose bits are arranged as follows:
+
+.. code-block::
+
+    31 (msb)
+    |
+    | 30     23
+    | |      |
+    | |      | 22                    0 (lsb)
+    | |      | |                     |
+    X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
+
+    s e        m
+
+``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand.
+
+If ``e`` is between 1 and 254, ``f`` is a normalized number:
+
+.. math::    {\tt f} = (-1)^{\tt s} \times 2^{\tt e-127} \times {\tt 1.m}
+
+If ``e`` is 0, and ``m`` is not zero, ``f`` is a denormalized number:
+
+.. math::    {\tt f} = (-1)^{\tt s} \times 2^{\tt e-126} \times {\tt 0.m}
+    
+If ``e`` and ``m`` are both zero, ``f`` is zero:
+
+.. math::    {\tt f} = 0.0
+
+If ``e`` is 255, ``f`` is an "infinity" or "not a number" (NAN),
+depending on whether ``m`` is zero or not.
+
+Examples:
+
+.. code-block::
+
+    0 00000000 00000000000000000000000 = 0.0
+    0 01111110 00000000000000000000000 = 0.5
+    0 01111111 00000000000000000000000 = 1.0
+    0 10000000 00000000000000000000000 = 2.0
+    0 10000000 10000000000000000000000 = 3.0
+    1 10000101 11110000010000000000000 = -124.0625
+    0 11111111 00000000000000000000000 = +infinity
+    1 11111111 00000000000000000000000 = -infinity
+    0 11111111 10000000000000000000000 = NAN
+    1 11111111 11111111111111111111111 = NAN
+
+Representation of a 16-bit half
+-------------------------------
+
+Here is the bit-layout for a half number, ``h``:
+
+.. code-block::
+
+    15 (msb)
+    |
+    | 14  10
+    | |   |
+    | |   | 9        0 (lsb)
+    | |   | |        |
+    X XXXXX XXXXXXXXXX
+
+    s e     m
+
+``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand.
+
+If ``e`` is between 1 and 30, ``h`` is a normalized number:
+
+.. math::    {\tt h} = (-1)^{\tt s} \times 2^{\tt e-15} \times {\tt 1.m}
+    
+If ``e`` is 0, and ``m`` is not zero, ``h`` is a denormalized number:
+
+.. math::    {\tt h} = (-1)^{\tt s} \times 2^{\tt -14} \times {\tt 0.m}
+
+If ``e`` and ``m`` are both zero, ``h`` is zero:
+
+.. math::    {\tt h} = 0.0
+
+If ``e`` is 31, ``h`` is an "infinity" or "not a number" (NAN),
+depending on whether ``m`` is zero or not.
+
+Examples:
+
+.. code-block::
+
+    0 00000 0000000000 = 0.0
+    0 01110 0000000000 = 0.5
+    0 01111 0000000000 = 1.0
+    0 10000 0000000000 = 2.0
+    0 10000 1000000000 = 3.0
+    1 10101 1111000001 = -124.0625
+    0 11111 0000000000 = +infinity
+    1 11111 0000000000 = -infinity
+    0 11111 1000000000 = NAN
+    1 11111 1111111111 = NAN
+
+Conversion via Lookup Table
+---------------------------
+
+Converting from half to float is performed by default using a
+lookup table. There are only 65,536 different half numbers; each
+of these numbers has been converted and stored in a table pointed
+to by the ``imath_half_to_float_table`` pointer.
+
+Prior to Imath v3.1, conversion from float to half was
+accomplished with the help of an exponent look table, but this is
+now replaced with explicit bit shifting.
+
+Conversion via Hardware
+-----------------------
+
+For Imath v3.1, the conversion routines have been extended to use
+F16C SSE instructions whenever present and enabled by compiler
+flags.
+
+Conversion via Bit-Shifting
+---------------------------
+
+If F16C SSE instructions are not available, conversion can be
+accomplished by a bit-shifting algorithm. For half-to-float
+conversion, this is generally slower than the lookup table, but it
+may be preferable when memory limits preclude storing of the
+65,536-entry lookup table.
+
+The lookup table symbol is included in the compilation even if
+``IMATH_HALF_USE_LOOKUP_TABLE`` is false, because application code
+using the exported ``half.h`` may choose to enable the use of the table.
+
+An implementation can eliminate the table from compilation by
+defining the ``IMATH_HALF_NO_LOOKUP_TABLE`` preprocessor symbol.
+Simply add:
+
+.. code-block::
+
+    #define IMATH_HALF_NO_LOOKUP_TABLE
+
+before including ``half.h``, or define the symbol on the compile
+command line.
+
+Furthermore, an implementation wishing to receive ``FE_OVERFLOW``
+and ``FE_UNDERFLOW`` floating point exceptions when converting
+float to half by the bit-shift algorithm can define the
+preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to
+including ``half.h``:
+
+.. code-block::
+
+    #define IMATH_HALF_ENABLE_FP_EXCEPTIONS
+
+Conversion Performance Comparison
+---------------------------------
+
+Testing on a Core i9, the timings are approximately:
+
+- half to float:
+
+  * table: 0.71 ns / call
+  * no table: 1.06 ns / call
+  * f16c: 0.45 ns / call
+
+- float-to-half:
+
+  * original: 5.2 ns / call
+  * no exp table + opt: 1.27 ns / call
+  * f16c: 0.45 ns / call
+
+**Note:** the timing above depends on the distribution of the
+floats in question.
+
+

_service:tar_scm:Imath-3.1.4.tar.gz/docs/classes/half.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/half.rst Changed

@@ -1,15 +1,21 @@
-The half Class
-##############
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _half:
+
+half
+####
 
 .. code-block::
 
    #include <Imath/half.h>
 
-``half`` is a 16-bit floating point number. See :doc:`../float` for an
+``half`` is a 16-bit floating point number. See :doc:`float` for an
 explanation of the representation.
 
-See :doc:`../functions/half_c` for C-language functions for conversion
-between ``half`` and ``float``. Also, see :doc:`../half_conversion`
+See :doc:`half_c` for C-language functions for conversion
+between ``half`` and ``float``. Also, see :doc:`half_conversion`
 for information about building Imath with support for the F16C SSE
 instruction set.
 
@@ -18,12 +24,13 @@
 .. literalinclude:: ../examples/half.cpp
    :language: c++
               
-.. doxygenclass:: Imath::half
-   :undoc-members:
-   :members:
-
-.. doxygenfunction:: operator<<(std::ostream& os, Imath::half h)
-
-.. doxygenfunction:: operator>>(std::ostream& is, Imath::half& h)
-
-                     
+.. toctree::
+   :caption: half
+   :maxdepth: 1
+
+   half_class
+   half_limits
+   half_c
+   half_conversion
+   float
+

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/half_c.rst Added

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/half_class.rst Added

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/half_conversion.rst Added

@@ -0,0 +1,75 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _half-float-conversion-configuration-options:
+
+Build-time half-float Conversion Configuration Options
+######################################################
+
+The Imath library supports three options for conversion between 16-bit
+half and 32-bit float:
+
+1. Conversion from half to float via a 16-bit lookup table. Prior to
+   Imath v3.1, this was the only method supported.
+
+2. F16C SSE instructions: single-instruction conversion for machine
+   architectures that support it. When available, this is the fastest
+   option, by far.
+
+3. Bit-shift conversion algorithm.
+
+To use the F16C SSE instruction set on an architecture that supports
+it, simply provide the appropriate compiler flags when building an
+application that includes ``half.h``. For g++ and clang,
+for example:
+::
+
+    $ cmake -DCMAKE_CXX_FLAGS="-m16fc" <source directory> 
+    
+When code including ``half.h`` is compiled with F16C enabled, it will
+automatically perform conversions using the instruction set. F16C
+compiler flags take precedence over other lookup-table-related Imath
+CMake settings.
+
+On architectures that do not support F16C, you may choose at
+compile-time between the bit-shift conversion and lookup table
+conversion via the ``IMATH_HALF_USE_LOOKUP_TABLE`` CMake option:
+::
+
+    $ cmake -DIMATH_HALF_USE_LOOKUP_TABLE=OFF <source directory>
+
+Note that when building and installing the Imath library itself, the
+65,536-entry lookup table symbol will be compiled into the library
+even if the ``IMATH_HALF_USE_LOOKUP_TABLE`` setting is false. This
+allows applications using that installed Imath library downstream to
+choose at compile time which conversion method to use.
+
+Applications with memory limitations that cannot accomodate the
+conversion lookup table can eliminate it from the library by building
+Imath with the C preprocessor define ``IMATH_HALF_NO_LOOKUP_TABLE``
+defined. Note that this is a compile-time option, not a CMake setting
+(making it possible for application code to choose the desired
+behavior). Simply add:
+::
+
+    #define IMATH_HALF_NO_LOOKUP_TABLE
+
+before including ``half.h``, or define the symbol on the compile
+command line.
+
+Furthermore, an implementation wishing to receive ``FE_OVERFLOW`` and
+``FE_UNDERFLOW`` floating point exceptions when converting float to
+half by the bit-shift algorithm can define the preprocessor symbol
+``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to including ``half.h``:
+::
+   
+    #define IMATH_HALF_ENABLE_FP_EXCEPTIONS
+
+By default, no exceptions are raised on overflow and underflow.
+
+
+
+
+
+

_service:tar_scm:Imath-3.1.9.tar.gz/docs/classes/half_limits.rst Added

@@ -0,0 +1,117 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+half Limits
+###########
+
+Constants
+---------
+
+``HALF_DENORM_MIN``
+  Smallest positive denormalized half.
+
+``HALF_NRM_MIN``
+  Smallest positive normalized half.
+
+``HALF_MIN``
+  Smallest positive normalized half.
+
+``HALF_MAX``
+  Largest positive half.
+
+``HALF_EPSILON``
+  Smallest positive e for which half(1.0 + e) != half(1.0)
+
+``HALF_MANT_DIG``
+  Number of digits in mantissa (significand + hidden leading 1)
+
+``HALF_DIG``
+  Number of base 10 digits that can be represented without change:
+
+    floor( (``HALF_MANT_DIG`` - 1) * log10(2) ) => 3.01... -> 3
+
+``HALF_DECIMAL_DIG``
+  Number of base-10 digits that are necessary to uniquely represent
+  all distinct values:
+
+    ceil(``HALF_MANT_DIG`` * log10(2) + 1) => 4.31... -> 5
+
+``HALF_RADIX``
+  Base of the exponent.
+
+``HALF_DENORM_MIN_EXP``
+  Minimum negative integer such that ``HALF_RADIX`` raised to the
+  power of one less than that integer is a normalized half.
+
+``HALF_MAX_EXP``
+  Maximum positive integer such that ``HALF_RADIX`` raised to the
+  power of one less than that integer is a normalized half.
+
+``HALF_DENORM_MIN_10_EXP``
+  Minimum positive integer such that 10 raised to that power is a
+  normalized half.
+
+``HALF_MAX_10_EXP``
+  Maximum positive integer such that 10 raised to that power is a
+  normalized half.
+
+``std::numeric_limits<half>``
+-----------------------------
+
+The ``half`` type provides specializations for
+``std::numeric_limits<half>``:
+
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::min() <https://en.cppreference.com/w/cpp/types/numeric_limits/min>`_                           | ``HALF_MIN``               |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::max() <https://en.cppreference.com/w/cpp/types/numeric_limits/max>`_                           | ``HALF_MAX``               |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::lowest() <https://en.cppreference.com/w/cpp/types/numeric_limits/lowest>`_                     | ``-HALF_MAX``              |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::digits <https://en.cppreference.com/w/cpp/types/numeric_limits/digits>`_                       | ``HALF_MANT_DIG``          |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::digits10 <https://en.cppreference.com/w/cpp/types/numeric_limits/digits10>`_                   | ``HALF_DIG``               |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::max_digits10 <https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10>`_           | ``HALF_DECIMAL_DIG``       |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::is_signed <https://en.cppreference.com/w/cpp/types/numeric_limits/is_signed>`_                 | ``true``                   |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::is_integer <https://en.cppreference.com/w/cpp/types/numeric_limits/is_integer>`_               | ``false``                  |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::is_exact <https://en.cppreference.com/w/cpp/types/numeric_limits/is_exact>`_                   | ``false``                  |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::radix <https://en.cppreference.com/w/cpp/types/numeric_limits/radix>`_                         | ``HALF_RADIX``             |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::epsilon() <https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon>`_                   | ``HALF_EPSILON``           |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::round_error() <https://en.cppreference.com/w/cpp/types/numeric_limits/round_error()>`_         | ``0.5``                    |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::min_exponent <https://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent>`_           | ``HALF_DENORM_MIN_EXP``    |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::min_exponent10 <https://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent10>`_       | ``HALF_DENORM_MIN_10_EXP`` |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::max_exponent <https://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent>`_           | ``HALF_MAX_EXP``           |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::max_exponent10 <https://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent10>`_       | ``HALF_MAX_10_EXP``        |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::has_infinity <https://en.cppreference.com/w/cpp/types/numeric_limits/has_infinity>`_           | ``true``                   |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::has_quiet_NaN <https://en.cppreference.com/w/cpp/types/numeric_limits/has_quiet_NaN>`_         | ``true``                   |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::has_signaling_NaN <https://en.cppreference.com/w/cpp/types/numeric_limits/has_signaling_NaN>`_ | ``true``                   |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::has_denorm <https://en.cppreference.com/w/cpp/types/numeric_limits/denorm_style>`_             | ``std::denorm_present``    |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::has_denorm_loss <https://en.cppreference.com/w/cpp/types/numeric_limits/has_denorm_loss>`_     | ``false``                  |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::infinity() <https://en.cppreference.com/w/cpp/types/numeric_limits/infinity()>`_               | ``half::posInf()``         |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::quiet_NaN() <https://en.cppreference.com/w/cpp/types/numeric_limits/quiet_NaN()>`_             | ``half::qNan()``           |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::signaling_NaN() <https://en.cppreference.com/w/cpp/types/numeric_limits/signaling_NaN()>`_     | ``half::sNan()``           |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+| `std::numeric_limits<half>::denorm_min() <https://en.cppreference.com/w/cpp/types/numeric_limits/denorm_min()>`_           | ``HALF_DENORM_MIN``        |
++----------------------------------------------------------------------------------------------------------------------------+----------------------------+
+
+

_service:tar_scm:Imath-3.1.9.tar.gz/docs/concepts.rst Added

@@ -0,0 +1,143 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _Concepts:
+
+Concepts
+########
+
+.. toctree::
+   :caption: Concepts
+   :maxdepth: 0
+              
+The Imath library emphasizes simplicity, ease of use, correctness and
+verifiability, performance, and breadth of adoption. Imath is not
+intended to be a comprehensive linear algebra or numerical analysis
+package.
+
+Imath is not a substitute for `Eigen <https://eigen.tuxfamily.org>`_!
+It's not a full-featured linear algebra package, and it doesn't
+represent vectors and matrices of arbitrary dimension. Its greatest
+utility is as a geometric data representation, primarily for 2D images
+and 3D scenes and coordinate transformations, along with an
+accompanying set of utility methods and functions.
+
+Example
+=======
+
+A basic program:
+
+.. literalinclude:: examples/intro.cpp
+
+Matrices Are Row-Major
+======================
+
+Imath stores matrices in row-major layout, originally inspired by
+compatibility with OpenGL matrices. 
+
+A matrix described as:
+
+.. math::
+  \begin{bmatrix}
+  m_{00} & m_{01} & m_{02} & m_{03} \\
+  m_{10} & m_{11} & m_{12} & m_{13} \\
+  m_{20} & m_{21} & m_{22} & m_{23} \\
+  m_{30} & m_{31} & m_{32} & m_{33} \\
+  \end{bmatrix}
+
+is laid out in memory as:
+
+.. list-table::
+   :widths: 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
+   :header-rows: 1
+
+   * - 0
+     - 1
+     - 2
+     - 3
+     - 4
+     - 5
+     - 6
+     - 7
+     - 8
+     - 9
+     - 10
+     - 11
+     - 12
+     - 13
+     - 14
+     - 15
+   * - :math:`m_{00}`
+     - :math:`m_{01}`
+     - :math:`m_{02}`
+     - :math:`m_{03}`
+     - :math:`m_{10}`
+     - :math:`m_{11}`
+     - :math:`m_{12}`
+     - :math:`m_{13}`
+     - :math:`m_{20}`
+     - :math:`m_{21}`
+     - :math:`m_{22}`
+     - :math:`m_{23}`
+     - :math:`m_{30}`
+     - :math:`m_{31}`
+     - :math:`m_{32}`
+     - :math:`m_{33}`
+
+A matrix representing a homogeneous transform has a right-hand column
+of :math:`\begin{bmatrix} 0 & 0 & 0 & 1\end{bmatrix}` and the
+translation component across the bottom row.
+
+As a result, it is best to think of Imath vectors as row-vectors, and
+vector-matrix multiplication with the vector on the left and matrix on
+the right:
+
+.. math::
+  \begin{bmatrix} v_{0}' & v_{1}' & v_{2}' & 1' \end{bmatrix}
+  =
+  \begin{bmatrix} v_{0} & v_{1} & v_{2} & 1 \end{bmatrix}
+  \begin{bmatrix} m_{00} & m_{01} & m_{02} & 0 \\
+  m_{10} & m_{11} & m_{12} & 0 \\
+  m_{20} & m_{21} & m_{22} & 0 \\
+  m_{30} & m_{31} & m_{32} & 1
+  \end{bmatrix}
+
+This further implies that you should interpret local transformations
+as pre-multiplication:
+
+.. code-block::
+
+   M44f M;
+   M.translate (tx, ty, tz);
+   m.rotate (r, 0, 0);
+   m.scale (s);
+
+.. math::
+  \begin{bmatrix}
+  m_{00} & m_{01} & m_{02} & m_{03} \\
+  m_{10} & m_{11} & m_{12} & m_{13} \\
+  m_{20} & m_{21} & m_{22} & m_{23} \\
+  m_{30} & m_{31} & m_{32} & m_{33} \\
+  \end{bmatrix}
+  = 
+  \begin{bmatrix}
+  s & 0 & 0 & 0 \\
+  0 & s & 0 & 0 \\
+  0 & 0 & s & 0 \\
+  0 & 0 & 0 & 1 \\
+  \end{bmatrix}
+  \begin{bmatrix}
+  1 & 0 & 0 & 0 \\
+  0 & \cos(r) & \sin(r) & 0 \\
+  0 & -\sin(r) & \cos(r) & 0 \\
+  0 & 0 & 0 & 1 \\
+  \end{bmatrix}
+  \begin{bmatrix}
+  1 & 0 & 0 & 0 \\
+  0 & 1 & 0 & 0 \\
+  0 & 0 & 1 & 0 \\
+  tx & ty & tz & 1 \\
+  \end{bmatrix}
+
+

_service:tar_scm:Imath-3.1.4.tar.gz/docs/conf.py -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/conf.py Changed

@@ -1,4 +1,8 @@
 #!/usr/bin/env python3
+
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright Contributors to the OpenEXR Project.
+
 # -*- coding: utf-8 -*-
 #
 # ReadTheDocs-Breathe documentation build configuration file, created by
@@ -68,9 +72,6 @@
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
 
-# The master toctree document.
-master_doc = 'index'
-
 # General information about the project.
 project = 'Imath'
 copyright = '2021, Contributors to the OpenEXR Project'
@@ -139,9 +140,16 @@
 #html_theme = 'agogo'
 #html_theme = 'default' # good
 #html_theme = 'nature' # too green
-html_theme = 'bizstyle' # OK
+#html_theme = 'bizstyle' # OK
 #html_theme = 'sphinxdoc'
 
+html_theme = "press"
+html_theme_options = {
+  "external_links": 
+      ("Github", "https://github.com/AcademySoftwareFoundation/Imath"),
+  
+}
+
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
@@ -164,7 +172,7 @@
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+html_favicon = "images/imath-fav.ico"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
@@ -223,7 +231,7 @@
 
 # -- Options for LaTeX output ---------------------------------------------
 
-latex_elements = {
+#latex_elements = {
 # The paper size ('letterpaper' or 'a4paper').
 #'papersize': 'letterpaper',
 
@@ -232,15 +240,15 @@
 
 # Additional stuff for the LaTeX preamble.
 #'preamble': '',
-}
+#}
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass howto, manual, or own class).
-latex_documents = 
-  ('index', 'Imath.tex', 'Imath Documentation',
-   'Contributors to the OpenEXR Project', 'manual'),
-
+#latex_documents = 
+#  ('index', 'Imath.tex', 'Imath Documentation',
+#   'Contributors to the OpenEXR Project', 'manual'),
+#
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/CMakeLists.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/CMakeLists.txt Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Color3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Color3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Color4.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Color4.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Euler.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Euler.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Frustum.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Frustum.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Interval.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Interval.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Line3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Line3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Matrix22.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Matrix22.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Matrix33.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Matrix33.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Matrix44.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Matrix44.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Plane3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Plane3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Quat.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Quat.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Sphere3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Sphere3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Vec2.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Vec2.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Vec3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Vec3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/examples/Vec4.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/Vec4.cpp Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/examples/intro.cpp Added

_service:tar_scm:Imath-3.1.9.tar.gz/docs/functions.rst Added

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/box.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/box.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/color.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/color.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/frame.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/frame.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/gl.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/gl.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/glu.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/glu.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/line.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/line.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/matrix.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/matrix.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/random.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/random.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/roots.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/roots.rst Changed

_service:tar_scm:Imath-3.1.4.tar.gz/docs/functions/vec.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/functions/vec.rst Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/images/imath-fav.ico Added

_service:tar_scm:Imath-3.1.4.tar.gz/docs/index.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/index.rst Changed

@@ -1,80 +1,77 @@
-Imath |version| Technical Documentation
-=======================================
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _Overview:
+
+Imath
+#####
+
+.. toctree::
+   :caption: Imath
+   :maxdepth: 1
 
 Imath is a basic, light-weight, and efficient C++ representation of 2D
-and 3D vectors and matrices and other simple but useful mathematical
-objects, functions, and data types common in computer graphics
-applications, including the ``half`` 16-bit floating-point type.
+and 3D vectors, 2x2, 3x3, and 4x4 matrices, and other simple but useful
+mathematical objects, functions, and data types common in computer
+graphics applications, including the :doc:`classes/half` 16-bit floating-point
+type.
 
-- Download: https://github.com/AcademySoftwareFoundation/Imath
-- Install Help: `INSTALL.md <https://github.com/AcademySoftwareFoundation/Imath/blob/master/INSTALL>`_
-- Porting Help: `Imath/OpenEXR Version 2->3 Porting Guide <https://github.com/AcademySoftwareFoundation/Imath/blob/master/docs/PortingGuide2-3.md>`_
-- License: `BSD License <https://github.com/AcademySoftwareFoundation/Imath/blob/master/LICENSE.md>`_
+Imath also includes optional python bindings for all types and
+functions, including optimized implementations of vector and matrix
+arrays.
 
-Introduction
-############
+Imath is maintained by the `OpenEXR project <https://openexr.com>`_, a part of the `Academy
+Software Foundation <https://www.aswf.io>`_.
 
-.. toctree::
-   :maxdepth: 3
+Community
+=========
 
-   intro
-   
-   install
+* **Ask a question:**
 
-The half Type
-#############
+  - Email: `openexr-dev@lists.aswf.io <https://lists.aswf.io/g/openexr-dev>`_
 
-.. toctree::
-   :maxdepth: 1
+  - Slack: `academysoftwarefdn#openexr <https://academysoftwarefdn.slack.com/archives/CMLRW4N73>`_
 
-   classes/half
-   half_limits
-   functions/half_c
-   half_conversion
-   float
-              
-Imath Classes
-#############
+* **Attend a meeting:**
 
-.. toctree::
-   :maxdepth: 3
-
-   classes/Box
-   classes/Color3
-   classes/Color4
-   classes/Euler
-   classes/Frustum
-   classes/Interval
-   classes/Line3
-   classes/Matrix22
-   classes/Matrix33
-   classes/Matrix44
-   classes/Plane3
-   classes/Quat
-   classes/Rand32
-   classes/Rand48
-   classes/Shear6
-   classes/Sphere3
-   classes/Vec2
-   classes/Vec3
-   classes/Vec4
-
-Imath Functions
-###############
+  - Technical Steering Committee meetings are open to the
+    public, fortnightly on Thursdays, 1:30pm Pacific Time.
+
+  - Calendar: https://lists.aswf.io/g/openexr-dev/calendar
+
+* **Report a bug:**
+
+  - Submit an Issue: https://github.com/AcademySoftwareFoundation/Imath/issues
+
+* **Report a security vulnerability:**
+
+  - Email security@openexr.com
+
+* **Contribute a Fix, Feature, or Improvement:**
+
+  - Read the `Contribution Guidelines
+    <https://github.com/AcademySoftwareFoundation/openexr/blob/main/CONTRIBUTING.md>`_
+    and `Code of Conduct <https://github.com/AcademySoftwareFoundation/openexr/blob/main/CODE_OF_CONDUCT.md>`_
+
+  - Sign the `Contributor License Agreement
+    <https://contributor.easycla.lfx.linuxfoundation.org/#/cla/project/2e8710cb-e379-4116-a9ba-964f83618cc5/user/564e571e-12d7-4857-abd4-898939accdd7>`_
+  
+  - Submit a Pull Request: https://github.com/AcademySoftwareFoundation/Imath/pulls
+
+Resources
+=========
+
+- Security policy: `SECURITY.md <https://github.com/AcademySoftwareFoundation/Imath/blob/main/SECURITY.md>`_
+- Release notes: `CHANGES.md
+  <https://github.com/AcademySoftwareFoundation/Imath/blob/main/CHANGES.md>`_
+- Contributors: `CONTRIBUTORS.md <https://github.com/AcademySoftwareFoundation/Imath/blob/main/CONTRIBUTORS.md>`_
+- Porting Guide: :doc:`PortingGuide`
+
+Index
+=====
 
-.. toctree::
-   :maxdepth: 3
-
-   functions/box
-   functions/color
-   functions/frame
-   functions/gl
-   functions/glu
-   functions/line
-   functions/matrix
-   functions/random
-   functions/roots
-   functions/vec
-   
 :ref:`genindex`
 
+.. include:: toc_redirect.rst
+

_service:tar_scm:Imath-3.1.4.tar.gz/docs/install.rst -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/install.rst Changed

@@ -1,69 +1,310 @@
-Install Options
-###############
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
 
-When installing Imath from source, take note of the following CMake options:
+.. _Install:
 
-``IMATH_CXX_STANDARD``
-  C++ standard to compile against. Default is ``14``.
+Install
+========
 
-``IMATH_HALF_USE_LOOKUP_TABLE``
-  Use the half-to-float conversion lookup table. Default is ``ON`` for
-  backwards compatibility. With the value of ``OFF``, use a bit-shift
-  conversion algorithm. Note that this setting is overriden when
-  compiler flags enable the F16C SSE instruction set.
+.. toctree::
+   :caption: Install
+             
+The Imath library is available for download and installation in
+binary form via package managers on many Linux distributions. See
+`https://pkgs.org/download/Imath
+<https://pkgs.org/download/Imath>`_ for a complete list. The common
+ones that generally provide current releases include:
 
-``IMATH_USE_DEFAULT_VISIBILITY``
-  Use default visibility, which makes all symbols visible in compiled
-  objects.  Default is ``OFF``, in which case only designated
-  necessary symbols are marked for export.
+* `Fedora <https://packages.fedoraproject.org/pkgs/`download/Imath/>`_
+* `Gentoo <https://packages.gentoo.org/packages/media-libs/Imath>`_ 
+* `Ubuntu <https://packages.ubuntu.com/source/kinetic/Imath>`_
 
-``IMATH_USE_NOEXCEPT``
-  Use the ``noexcept`` specifier of appropriate methods. Default is
-  ``ON``.  With the value of ``OFF``, the ``noexcept`` specifier is
-  omitted, for situations in which it is not desireable.
+Beware that some distributions are out of date and only provide
+distributions of outdated releases OpenEXR. We recommend against using
+OpenEXR v2, and we *strongly* recommend against using OpenEXR v1.
 
-``IMATH_ENABLE_LARGE_STACK``
-  Enables the ``halfFunction`` object to place the lookup tables on
-  the stack rather than allocating heap memory. Default is ``OFF``.
+On macOS, we do not recommend installation via HomeBrew because the
+distribution is outdated.
 
-``IMATH_VERSION_RELEASE_TYPE``
-  A string to append to the version
-  number in the internal package name macro
-  IMATH_PACKAGE_STRING. Default is the empty string, but can be set
-  to, for example, "-dev" during development (e.g. "3.1.0-dev").
+Please note that ``pip install openexr`` installs the `openexrpython
+<https://github.com/jamesbowman/openexrpython>`_ module, which is not
+affiliated with the OpenEXR project or the ASWF. Please direct
+questions there.
 
-``IMATH_INSTALL_SYM_LINK``
-  Install an unversioned symbolic link (i.e. libImath.so) to the
-  versioned library.
+Build from Source
+-----------------
 
-``IMATH_INSTALL_PKG_CONFIG``
-  Install Imath.pc file. Default is ``ON``.
+Imath builds on Linux, macOS, Microsoft Windows via CMake, and is
+cross-compilable on other systems.
+
+Download the source from the `GitHub releases page
+<https://github.com/AcademySoftwareFoundation/Imath/releases>`_
+page, or clone the `repo <https://github.com/AcademySoftwareFoundation/Imath>`_.
+
+The ``release`` branch of the repo always points to the most advanced
+release.
+
+
+Prerequisites
+~~~~~~~~~~~~~
+
+Make sure these are installed on your system before building Imath:
+
+* Imath requires CMake version 3.12 or newer
+* C++ compiler that supports C++11
+
+The instructions that follow describe building Imath with CMake.
+
+Linux/macOS
+~~~~~~~~~~~
+
+To build via CMake, you need to first identify three directories:
+
+1. The source directory, i.e. the top-level directory of the
+   downloaded source archive or cloned repo, referred to below as ``$srcdir``
+2. A temporary directory to hold the build artifacts, referred to below as
+   ``$builddir``
+3. A destination directory into which to install the
+   libraries and headers, referred to below as ``$installdir``.  
+
+To build:
+.. code-block::
+
+    $ cd $builddir
+    $ cmake $srcdir --install-prefix $installdir
+    $ cmake --build $builddir --target install --config Release
+
+Note that the CMake configuration prefers to apply an out-of-tree
+build process, since there may be multiple build configurations
+(i.e. debug and release), one per folder, all pointing at once source
+tree, hence the ``$builddir`` noted above, referred to in CMake
+parlance as the *build directory*. You can place this directory
+wherever you like.
+
+See the CMake Configuration Options section below for the most common
+configuration options especially the install directory. Note that with
+no arguments, as above, ``make install`` installs the header files in
+``/usr/local/include``, the object libraries in ``/usr/local/lib``, and the
+executable programs in ``/usr/local/bin``.
+
+Windows
+~~~~~~~
+
+Under Windows, if you are using a command line-based setup, such as
+cygwin, you can of course follow the above. For Visual Studio, cmake
+generators are "multiple configuration", so you don't even have to set
+the build type, although you will most likely need to specify the
+install location.  Install Directory By default, ``make install``
+installs the headers, libraries, and programs into ``/usr/local``, but you
+can specify a local install directory to cmake via the
+``CMAKE_INSTALL_PREFIX`` variable:
+
+.. code-block::
+
+    $ cmake .. -DCMAKE_INSTALL_PREFIX=$Imath_install_directory
+
+Library Names
+-------------
+
+By default the installed libraries follow a pattern for how they are
+named. This is done to enable multiple versions of the library to be
+installed and targeted by different builds depending on the needs of
+the project. A simple example of this would be to have different
+versions of the library installed to allow for applications targeting
+different VFX Platform years to co-exist.
+
+If you are building dynamic libraries, once you have configured, built,
+and installed the libraries, you should see the following pattern of
+symlinks and files in the install lib folder:
+
+.. code-block::
+
+    libImath.so -> libImath-3_1.so
+    libImath-3_1.so -> libImath-3_1.so.30
+    libImath-3_1.so.30 -> libImath-3_1.so.30.3.0
+    libImath-3_1.so.30.3.0 (the shared object file)
+    
+The ``-3_1`` suffix encodes the major and minor version, which can be
+configured via the ``IMATH_LIB_SUFFIX`` CMake setting. The ``30``
+corresponds to the so version, or in ``libtool`` terminology the
+``current`` shared object version; the `3` denotes the ``libtool``
+``revision``, and the ``0`` denotes the ``libtool`` ``age``. See the
+`libtool
+<https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html#Updating-version-info>`_
+documentation for more details.
+
+Porting Applications from OpenEXR v2 to v3
+------------------------------------------
+
+See the :doc:`PortingGuide` for details about differences from previous
+releases and how to address them. Also refer to the porting guide for
+details about changes to Imath.
+
+Building the Documentation
+--------------------------
+
+The Imath technical documentation at `https://imath.readthedocs.io
+<https://imath.readthedocs.io>`_ is generated via `Sphinx
+<https://www.sphinx-doc.org>`_ with the `Breathe
+<https://breathe.readthedocs.io>`_ extension using information
+extracted from header comments by `Doxygen <https://www.doxygen.nl>`_.
+
+To build the documentation locally from the source headers and
+``.rst`` files, set the CMake option ``BUILD_DOCS=ON``. This adds
+``Doxygen`` and ``Sphinx`` CMake targets and enables building the docs
+by default.  generation is off by default.
+
+Building the documentation requires that ``sphinx``, ``breathe``, and
+``doxygen`` are installed. It further requires the `sphinx-press-theme
+<https://pypi.org/project/sphinx-press-theme>`_, as indicated in the
+`requirements.txt
+<https://github.com/AcademySoftwareFoundation/imath/blob/main/docs/requirements.txt>`_
+file.
+
+CMake Build-time Configuration Options
+--------------------------------------
+
+The default CMake configuration options are stored in

_service:tar_scm:Imath-3.1.9.tar.gz/docs/license.rst Added

@@ -0,0 +1,33 @@
+..
+  SPDX-License-Identifier: BSD-3-Clause
+  Copyright Contributors to the OpenEXR Project.
+
+.. _License:
+
+License
+=======
+
+.. toctree::
+   :caption: License
+
+Imath is licensed under the BSD-3-Clause license. Contributions to the 
+library should abide by that license unless otherwised approved by the OpenEXR
+TSC and ASWF Governing Board.
+
+See `LICENSE.md 
+<https://github.com/AcademySoftwareFoundation/Imath/blob/main/LICENSE.md>`__ 
+on GitHub.
+
+Copyright (c) Contributors to the OpenEXR Project. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

_service:tar_scm:Imath-3.1.4.tar.gz/docs/requirements.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/docs/requirements.txt Changed

_service:tar_scm:Imath-3.1.9.tar.gz/docs/toc_redirect.rst Added

_service:tar_scm:Imath-3.1.4.tar.gz/share/ci/scripts/linux/run_gcov.sh -> _service:tar_scm:Imath-3.1.9.tar.gz/share/ci/scripts/linux/run_gcov.sh Changed

@@ -1,17 +1,43 @@
-!/usr/bin/env bash
+#!/usr/bin/env bash
+
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) Contributors to the OpenEXR Project.
 
 set -ex
 
-mkdir _coverage
-cd _coverage
+if  $# -gt 0 
+then
+   build=$1  # use explicity-provided build directory
+   coverage="$build/_coverage"
+else
+   build='../_build'  # from with CI, use the _build subdirectory
+   coverage="_coverage"
+fi
+   
+mkdir -p $coverage
+cd $coverage
+
+for gcno in $(find $build -name "*.gcno" -type f); do
+
+    # Identify the original source file (.cpp or .c) from the .gcno
+    # file by examining the .o.d make dependency file. The source
+    # file should be the second line in the .o.d file.
+    
+    # gcno = $build/src/bin/exrheader/CMakeFiles/exrheader.dir/main.gcno
+    # object_directory = $build/src/bin/exrheader/CMakeFiles/exrheader.dir
+    # source_base = $build/src/bin/exrheader/CMakeFiles/exrheader.dir/main
+    # dependenty_file = $build/src/bin/exrheader/CMakeFiles/exrheader.dir/main.o.d
 
-# The sed command below converts from:
-#   ../_build/src/OpenEXR/CMakeFiles/OpenColorIO.dir/ops/Exponent.gcno
-# to:
-#   ../src/OpenEXR/ops/Exponent.cpp
+    object_directory=$(dirname "$gcno")
+    source_base=$(basename "$gcno" ".gcno")
+    dependency_file=$object_directory/$source_base.o.d
 
-for g in $(find ../_build -name "*.gcno" -type f); do
-    gcov -l -p -o $(dirname "$g") $(echo "$g" | sed -e 's/\/_build\//\//' -e 's/\.gcno/\.cpp/' -e 's/\/CMakeFiles.*\.dir\//\//')
+    if  -f "$dependency_file" ; then
+
+        source_file=$(head -2 $dependency_file | tail -1 | sed -e 's/ //' -e 's/ \\//') 
+        gcov -l -p -o $object_directory $source_file 
+    fi
 done
 
-cd ..
+
+

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathColor.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathColor.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathEuler.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathEuler.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathMatrix.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathMatrix.h Changed

@@ -83,7 +83,6 @@
     ///     a00 a01
     ///     a10 a11
     IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 (const T a22) IMATH_NOEXCEPT;
-
     /// Construct from given scalar values:
     ///
     ///     a b
@@ -260,6 +259,9 @@
     /// Determinant
     IMATH_HOSTDEVICE constexpr T determinant() const IMATH_NOEXCEPT;
 
+    /// Trace
+    IMATH_HOSTDEVICE constexpr T trace() const IMATH_NOEXCEPT;
+
     /// Set matrix to rotation by r (in radians)
     /// @return const referenced to this
     template <class S> IMATH_HOSTDEVICE const Matrix22& setRotation (S r) IMATH_NOEXCEPT;
@@ -356,7 +358,6 @@
     ///     a10 a11 a12
     ///     a20 a21 a22
     IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 (const T a33) IMATH_NOEXCEPT;
-
     /// Construct from given scalar values
     ///     a b c
     ///     d e f
@@ -573,6 +574,9 @@
     /// Determinant
     IMATH_HOSTDEVICE constexpr T determinant() const IMATH_NOEXCEPT;
 
+    /// Trace
+    IMATH_HOSTDEVICE constexpr T trace() const IMATH_NOEXCEPT;
+
     /// Set matrix to rotation by r (in radians)
     /// @return const referenced to this
     template <class S> IMATH_HOSTDEVICE const Matrix33& setRotation (S r) IMATH_NOEXCEPT;
@@ -703,7 +707,6 @@
     ///     a20 a21 a22 a23
     ///     a30 a31 a32 a33
     IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (const T a44) IMATH_NOEXCEPT;
-
     /// Construct from given scalar values
     ///     a b c d
     ///     e f g h
@@ -947,6 +950,9 @@
     /// Determinant
     IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T determinant() const IMATH_NOEXCEPT;
 
+    /// Trace
+    IMATH_HOSTDEVICE constexpr T trace() const IMATH_NOEXCEPT;
+
     /// Set matrix to rotation by XYZ euler angles (in radians)
     /// @return const referenced to this
     template <class S> IMATH_HOSTDEVICE const Matrix44& setEulerAngles (const Vec3<S>& r) IMATH_NOEXCEPT;
@@ -1144,7 +1150,7 @@
 //---------------------------
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
+IMATH_HOSTDEVICE inline T*
 Matrix22<T>::operator (int i) IMATH_NOEXCEPT
 {
     return xi;
@@ -1173,7 +1179,9 @@
     x11 = a;
 }
 
-template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22<T>::Matrix22 (const T a22) IMATH_NOEXCEPT
+template <class T>
+IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22<T>::Matrix22 (
+    const T a22) IMATH_NOEXCEPT
 {
     // Function calls and aliasing issues can inhibit vectorization versus
     // straight assignment of data members, so instead of this:
@@ -1185,7 +1193,9 @@
     x11 = a11;
 }
 
-template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22<T>::Matrix22 (T a, T b, T c, T d) IMATH_NOEXCEPT
+template <class T>
+IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22<T>::Matrix22 (
+    T a, T b, T c, T d) IMATH_NOEXCEPT
 {
     x00 = a;
     x01 = b;
@@ -1242,8 +1252,8 @@
 }
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
-Matrix22<T>::getValue() IMATH_NOEXCEPT
+IMATH_HOSTDEVICE inline T*
+Matrix22<T>::getValue () IMATH_NOEXCEPT
 {
     return (T*) &x00;
 }
@@ -1639,6 +1649,13 @@
 }
 
 template <class T>
+IMATH_HOSTDEVICE constexpr inline T
+Matrix22<T>::trace () const IMATH_NOEXCEPT
+{
+    return x00 + x11;
+}
+
+template <class T>
 template <class S>
 IMATH_HOSTDEVICE inline const Matrix22<T>&
 Matrix22<T>::setRotation (S r) IMATH_NOEXCEPT
@@ -1722,7 +1739,7 @@
 //---------------------------
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
+IMATH_HOSTDEVICE inline T*
 Matrix33<T>::operator (int i) IMATH_NOEXCEPT
 {
     return xi;
@@ -1763,7 +1780,9 @@
     x22 = a;
 }
 
-template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33<T>::Matrix33 (const T a33) IMATH_NOEXCEPT
+template <class T>
+IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33<T>::Matrix33 (
+    const T a33) IMATH_NOEXCEPT
 {
     // Function calls and aliasing issues can inhibit vectorization versus
     // straight assignment of data members, so instead of this:
@@ -1864,8 +1883,8 @@
 }
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
-Matrix33<T>::getValue() IMATH_NOEXCEPT
+IMATH_HOSTDEVICE inline T*
+Matrix33<T>::getValue () IMATH_NOEXCEPT
 {
     return (T*) &x00;
 }
@@ -2632,8 +2651,8 @@
 }
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33<T>
-Matrix33<T>::inverse() const IMATH_NOEXCEPT
+IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33<T>
+Matrix33<T>::inverse () const IMATH_NOEXCEPT
 {
     if (x02 != 0 || x12 != 0 || x22 != 1)
     {
@@ -2765,6 +2784,13 @@
 }
 
 template <class T>
+IMATH_HOSTDEVICE constexpr inline T
+Matrix33<T>::trace () const IMATH_NOEXCEPT
+{
+    return x00 + x11 + x22;
+}
+
+template <class T>
 template <class S>
 IMATH_HOSTDEVICE inline const Matrix33<T>&
 Matrix33<T>::setRotation (S r) IMATH_NOEXCEPT
@@ -2981,7 +3007,7 @@
 //---------------------------
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
+IMATH_HOSTDEVICE inline T*
 Matrix44<T>::operator (int i) IMATH_NOEXCEPT
 {
     return xi;
@@ -3034,7 +3060,9 @@
     x33 = a;
 }
 
-template <class T> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44<T>::Matrix44 (const T a44) IMATH_NOEXCEPT
+template <class T>
+IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44<T>::Matrix44 (
+    const T a44) IMATH_NOEXCEPT
 {
     x00 = a00;
     x01 = a01;
@@ -3185,8 +3213,8 @@
 }
 
 template <class T>
-IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T*
-Matrix44<T>::getValue() IMATH_NOEXCEPT
+IMATH_HOSTDEVICE inline T*
+Matrix44<T>::getValue () IMATH_NOEXCEPT
 {
     return (T*) &x00;
 }
@@ -3226,22 +3254,22 @@
 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44<T>&
 Matrix44<T>::setValue (const Matrix44<S>& v) IMATH_NOEXCEPT

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathMatrixAlgo.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathMatrixAlgo.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathQuat.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathQuat.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathRandom.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathRandom.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathShear.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathShear.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/ImathVec.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/ImathVec.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/half.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/half.h Changed

@@ -177,10 +177,14 @@
 /// floats in question.
 ///
 
-#ifdef _WIN32
-#        include <intrin.h>
+#ifdef __CUDA_ARCH__
+// do not include intrinsics headers on Cuda
+#elif defined(_WIN32)
+#    include <intrin.h>
 #elif defined(__x86_64__)
-#        include <x86intrin.h>
+#    include <x86intrin.h>
+#elif defined(__F16C__)
+#    include <immintrin.h>
 #endif
 
 #include <stdint.h>
@@ -443,7 +447,7 @@
 
 ///
 ///
-/// class half -- 16-bit floating point number
+/// class half represents a 16-bit floating point number
 ///
 /// Type half can represent positive and negative numbers whose
 /// magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative
@@ -616,10 +620,10 @@
     /// @name Access to the internal representation
 
     /// Return the bit pattern
-    IMATH_EXPORT constexpr uint16_t bits() const IMATH_NOEXCEPT;
+    constexpr uint16_t bits () const IMATH_NOEXCEPT;
 
     /// Set the bit pattern
-    IMATH_EXPORT IMATH_CONSTEXPR14 void setBits (uint16_t bits) IMATH_NOEXCEPT;
+    IMATH_CONSTEXPR14 void setBits (uint16_t bits) IMATH_NOEXCEPT;
 
     /// @}
 
@@ -889,6 +893,83 @@
 /// Input h from is
 IMATH_EXPORT std::istream& operator>> (std::istream& is, IMATH_INTERNAL_NAMESPACE::half& h);
 
+#include <limits>
+
+namespace std
+{
+
+template <> class numeric_limits<IMATH_INTERNAL_NAMESPACE::half>
+{
+public:
+    static const bool is_specialized = true;
+
+    static constexpr IMATH_INTERNAL_NAMESPACE::half min () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x0400); /*HALF_MIN*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half max () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7bff); /*HALF_MAX*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half lowest ()
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0xfbff); /* -HALF_MAX */
+    }
+
+    static constexpr int  digits       = HALF_MANT_DIG;
+    static constexpr int  digits10     = HALF_DIG;
+    static constexpr int  max_digits10 = HALF_DECIMAL_DIG;
+    static constexpr bool is_signed    = true;
+    static constexpr bool is_integer   = false;
+    static constexpr bool is_exact     = false;
+    static constexpr int  radix        = HALF_RADIX;
+    static constexpr IMATH_INTERNAL_NAMESPACE::half epsilon () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x1400); /*HALF_EPSILON*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half round_error () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x3800); /*0.5*/
+    }
+
+    static constexpr int min_exponent   = HALF_DENORM_MIN_EXP;
+    static constexpr int min_exponent10 = HALF_DENORM_MIN_10_EXP;
+    static constexpr int max_exponent   = HALF_MAX_EXP;
+    static constexpr int max_exponent10 = HALF_MAX_10_EXP;
+
+    static constexpr bool               has_infinity      = true;
+    static constexpr bool               has_quiet_NaN     = true;
+    static constexpr bool               has_signaling_NaN = true;
+    static constexpr float_denorm_style has_denorm        = denorm_present;
+    static constexpr bool               has_denorm_loss   = false;
+    static constexpr IMATH_INTERNAL_NAMESPACE::half               infinity () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7c00); /*half::posInf()*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half quiet_NaN () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7fff); /*half::qNan()*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half signaling_NaN () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7dff); /*half::sNan()*/
+    }
+    static constexpr IMATH_INTERNAL_NAMESPACE::half denorm_min () IMATH_NOEXCEPT
+    {
+        return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x0001); /*HALF_DENORM_MIN*/
+    }
+
+    static constexpr bool is_iec559  = false;
+    static constexpr bool is_bounded = false;
+    static constexpr bool is_modulo  = false;
+
+    static constexpr bool              traps           = true;
+    static constexpr bool              tinyness_before = false;
+    static constexpr float_round_style round_style     = round_to_nearest;
+};
+
+} // namespace std
+
 //----------
 // Debugging
 //----------
@@ -898,7 +979,7 @@
 IMATH_EXPORT void printBits (char c19, IMATH_INTERNAL_NAMESPACE::half h);
 IMATH_EXPORT void printBits (char c35, float f);
 
-#    ifndef __CUDACC__
+#    if !defined(__CUDACC__) && !defined(__CUDA_FP16_HPP__)
 using half = IMATH_INTERNAL_NAMESPACE::half;
 #    else
 #        include <cuda_fp16.h>

_service:tar_scm:Imath-3.1.4.tar.gz/src/Imath/halfLimits.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/Imath/halfLimits.h Changed

@@ -3,74 +3,24 @@
 // Copyright Contributors to the OpenEXR Project.
 //
 
-//
-// Primary origin authors:
-//     Florian Kainz <kainz@ilm.com>
-//     Rod Bogart <rgb@ilm.com>
-//
-
 #ifndef INCLUDED_HALF_LIMITS_H
 #define INCLUDED_HALF_LIMITS_H
 
-//------------------------------------------------------------------------
+// Warn if half.h hasn't being included
+#ifndef IMATH_HALF_H_
 //
-//	C++ standard library-style numeric_limits for class half
+// This file is now deprecated. It previously included the
+// specialization of std::numeric_limits<half>, but those now appear
+// directly in half.h, because they should be regarded as inseperable
+// from the half class.
 //
-//------------------------------------------------------------------------
-
-#include "half.h"
-#include <limits>
-
-/// @cond Doxygen_Suppress
-
-namespace std
-{
-
-template <> class numeric_limits<half>
-{
-  public:
-    static const bool is_specialized = true;
-
-    static constexpr half min() IMATH_NOEXCEPT { return half(half::FromBits, 0x0400); /*HALF_MIN*/ }
-    static constexpr half max() IMATH_NOEXCEPT { return half(half::FromBits, 0x7bff); /*HALF_MAX*/ }
-    static constexpr half lowest() { return half(half::FromBits, 0xfbff); /* -HALF_MAX */ }
 
-    static constexpr int digits       = HALF_MANT_DIG;
-    static constexpr int digits10     = HALF_DIG;
-    static constexpr int max_digits10 = HALF_DECIMAL_DIG;
-    static constexpr bool is_signed   = true;
-    static constexpr bool is_integer  = false;
-    static constexpr bool is_exact    = false;
-    static constexpr int radix        = HALF_RADIX;
-    static constexpr half epsilon() IMATH_NOEXCEPT { return half(half::FromBits, 0x1400); /*HALF_EPSILON*/ }
-    static constexpr half round_error() IMATH_NOEXCEPT { return half(half::FromBits, 0x3800); /*0.5*/ }
-
-    static constexpr int min_exponent   = HALF_DENORM_MIN_EXP;
-    static constexpr int min_exponent10 = HALF_DENORM_MIN_10_EXP;
-    static constexpr int max_exponent   = HALF_MAX_EXP;
-    static constexpr int max_exponent10 = HALF_MAX_10_EXP;
-
-    static constexpr bool has_infinity             = true;
-    static constexpr bool has_quiet_NaN            = true;
-    static constexpr bool has_signaling_NaN        = true;
-    static constexpr float_denorm_style has_denorm = denorm_present;
-    static constexpr bool has_denorm_loss          = false;
-    static constexpr half infinity() IMATH_NOEXCEPT { return half(half::FromBits, 0x7c00); /*half::posInf()*/ }
-    static constexpr half quiet_NaN() IMATH_NOEXCEPT { return half(half::FromBits, 0x7fff); /*half::qNan()*/ }
-    static constexpr half signaling_NaN() IMATH_NOEXCEPT { return half(half::FromBits, 0x7dff); /*half::sNan()*/ }
-    static constexpr half denorm_min() IMATH_NOEXCEPT { return half(half::FromBits, 0x0001); /*HALF_DENORM_MIN*/ }
-
-    static constexpr bool is_iec559  = false;
-    static constexpr bool is_bounded = false;
-    static constexpr bool is_modulo  = false;
-
-    static constexpr bool traps                    = true;
-    static constexpr bool tinyness_before          = false;
-    static constexpr float_round_style round_style = round_to_nearest;
-};
-
-/// @endcond
-
-} // namespace std
+#ifdef __GNUC__
+#warning "ImathLimits is deprecated; use #include <half.h>"
+#else
+#pragma message("ImathLimits is deprecated; use #include <half.h>")
+#endif
 
+#include "half.h"
+#endif
 #endif

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/CMakeLists.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/CMakeLists.txt Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/half_perf_test.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/half_perf_test.cpp Changed

@@ -3,18 +3,19 @@
 // Copyright Contributors to the OpenEXR Project.
 //
 
-#ifdef _MSC_VER
+#ifdef _WIN32
 #    define _CRT_RAND_S
 #endif
 
 #include <ImathConfig.h>
+#include <ImathRandom.h>
 #include <half.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
-#ifdef _MSC_VER
+#ifdef _WIN32
 #    include <windows.h>
 #else
 #    include <time.h>
@@ -267,7 +268,7 @@
 int64_t
 get_ticks (void)
 {
-#ifdef _MSC_VER
+#ifdef _WIN32
     static uint64_t scale = 0;
     if (scale == 0)
     {
@@ -372,26 +373,17 @@
 
         if (halfs && floats)
         {
-            srand (numentries);
+            Rand48 r(numentries);
             for (int i = 0; i < numentries; ++i)
             {
-                halfsi  = (uint16_t) (rand());
+                halfsi  = (uint16_t) r.nexti();
                 floatsi = imath_half_to_float (halfsi);
             }
             perf_test_half_to_float (floats, halfs, numentries);
 
             // test float -> half with real-world values
-#ifdef _MSC_VER
-            unsigned int rv;
             for (int i = 0; i < numentries; ++i)
-            {
-                rand_s( &rv );
-                floatsi = 65504.0 * (((double) rand() / (double) UINT_MAX) * 2.0 - 1.0);
-            }
-#else
-            for (int i = 0; i < numentries; ++i)
-                floatsi = 65504.0 * (drand48() * 2.0 - 1.0);
-#endif
+                floatsi = float(r.nextf(-65504, 65504));
             perf_test_float_to_half (halfs, floats, numentries);
         }

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/main.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/main.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testBox.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testBox.cpp Changed

@@ -39,7 +39,7 @@
     T p;
     for (unsigned int i = 0; i < value.size(); i++)
     {
-        pi = valuei;
+        pi = static_cast<typename T::BaseType>(valuei);
     }
     perms.push_back (p);
 }
@@ -92,8 +92,8 @@
     //
     {
         T p;
-        for (unsigned int i = 0; i < T::dimensions(); i++)
-            pi = i;
+        for (unsigned int i = 0; i < T::dimensions (); i++)
+            pi = static_cast<typename T::BaseType>(i);
 
         IMATH_INTERNAL_NAMESPACE::Box<T> b (p);
         assert (b.min == p && b.max == p);
@@ -107,8 +107,8 @@
         T p1;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            p0i = i;
-            p1i = 10 * T::dimensions() - i - 1;
+            p0i = static_cast<typename T::BaseType>(i);
+            p1i = static_cast<typename T::BaseType>(10 * T::dimensions () - i - 1);
         }
 
         IMATH_INTERNAL_NAMESPACE::Box<T> b (p0, p1);
@@ -169,8 +169,21 @@
     //
     {
         IMATH_INTERNAL_NAMESPACE::Box<T> b;
-        b.makeInfinite();
-        assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax()));
+        b.makeInfinite ();
+        assert (
+            b.min == T (T::baseTypeLowest ()) &&
+            b.max == T (T::baseTypeMax ()));
+
+        for (unsigned int i=0; i<b.min.dimensions(); i++)
+        {
+            IMATH_INTERNAL_NAMESPACE::Box<T> c = b;
+            c.maxi = 0;
+            assert (!c.isInfinite());
+
+            c = b;
+            c.mini = 0;
+            assert (!c.isInfinite());
+        }
     }
 
     //
@@ -610,7 +623,7 @@
         T p;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            pi = i;
+            pi = static_cast<typename T::BaseType>(i);
         }
         IMATH_INTERNAL_NAMESPACE::Box<T> b1 (-p, p);
         assert (b1.size() == p * T (2));
@@ -669,8 +682,10 @@
         T p1;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            p0i = -typename T::BaseType (1 << (i + 1));
-            p1i = typename T::BaseType (1 << (T::dimensions() - i));
+            int lo = 1 << (i + 1);
+            int hi = 1 << (T::dimensions () - i);
+            p0i = -static_cast<typename T::BaseType>(lo);
+            p1i = static_cast<typename T::BaseType>(hi);
         }
         IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
         assert (b1.center() == (p1 + p0) / 2);
@@ -722,8 +737,10 @@
         T p1;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            p0i = -typename T::BaseType (1 << (i + 1));
-            p1i = typename T::BaseType (1 << (T::dimensions() - i));
+            int lo = 1 << (i + 1);
+            int hi = 1 << (T::dimensions () - i);
+            p0i = -static_cast<typename T::BaseType>(lo);
+            p1i = static_cast<typename T::BaseType>(hi);
         }
         IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
         assert (!b1.isEmpty());
@@ -776,8 +793,10 @@
         T p1;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            p0i = -typename T::BaseType (1 << (i + 1));
-            p1i = typename T::BaseType (1 << (T::dimensions() - i));
+            int lo = 1 << (i + 1);
+            int hi = 1 << (T::dimensions () - i);
+            p0i = -static_cast<typename T::BaseType>(lo);
+            p1i = static_cast<typename T::BaseType>(hi);
         }
         IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
         assert (!b1.isInfinite());
@@ -838,8 +857,10 @@
         T p1;
         for (unsigned int i = 0; i < T::dimensions(); i++)
         {
-            p0i = -typename T::BaseType (1 << (i + 1));
-            p1i = typename T::BaseType (1 << (T::dimensions() - i));
+            int lo = 1 << (i + 1);
+            int hi = 1 << (T::dimensions () - i);
+            p0i = -static_cast<typename T::BaseType>(lo);
+            p1i = static_cast<typename T::BaseType>(hi);
         }
         IMATH_INTERNAL_NAMESPACE::Box<T> b1 (p0, p1);
         assert (b1.hasVolume());

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testBoxAlgo.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testBoxAlgo.cpp Changed

@@ -51,9 +51,10 @@
 
         for (int i = 0; i < 100000; ++i)
         {
-            V3f p1 (random.nextf (box.max.x, box.min.x),
-                    random.nextf (box.max.y, box.min.y),
-                    random.nextf (box.max.z, box.min.z));
+            V3f p1 (
+                float(random.nextf (box.max.x, box.min.x)),
+                float(random.nextf (box.max.y, box.min.y)),
+                float(random.nextf (box.max.z, box.min.z)));
 
             V3f p2 (p1 + hollowSphereRand<V3f> (random));
 
@@ -91,8 +92,8 @@
             // box, and it passes the box at a minimum distance of r1.
             //
 
-            const float r1 = 0.00001;
-            const float r2 = 1.0;
+            const float r1 = 0.00001f;
+            const float r2 = 1.0f;
 
             V3f p1 = box.min + r2 * hollowSphereRand<V3f> (random);
             V3f p2;
@@ -133,18 +134,20 @@
 
         do
         {
-            p1 = V3f (random.nextf (bigBox.min.x, bigBox.max.x),
-                      random.nextf (bigBox.min.y, bigBox.max.y),
-                      random.nextf (bigBox.min.z, bigBox.max.z));
+            p1 = V3f (
+                float(random.nextf (bigBox.min.x, bigBox.max.x)),
+                float(random.nextf (bigBox.min.y, bigBox.max.y)),
+                float(random.nextf (bigBox.min.z, bigBox.max.z)));
         } while (box.intersects (p1));
 
         V3f p2;
 
         do
         {
-            p2 = V3f (random.nextf (box.min.x, box.max.x),
-                      random.nextf (box.min.y, box.max.y),
-                      random.nextf (box.min.z, box.max.z));
+            p2 = V3f (
+                float(random.nextf (box.min.x, box.max.x)),
+                float(random.nextf (box.min.y, box.max.y)),
+                float(random.nextf (box.min.z, box.max.z)));
         } while (approximatelyEqual (p1, p2, e));
 
         Line3f ray (p1, p2);
@@ -422,9 +425,10 @@
 
         for (int i = 0; i < 100000; ++i)
         {
-            V3f p1 (random.nextf (box.max.x, box.min.x),
-                    random.nextf (box.max.y, box.min.y),
-                    random.nextf (box.max.z, box.min.z));
+            V3f p1 (
+                float(random.nextf (box.max.x, box.min.x)),
+                float(random.nextf (box.max.y, box.min.y)),
+                float(random.nextf (box.max.z, box.min.z)));
 
             V3f p2 (p1 + hollowSphereRand<V3f> (random));
 
@@ -462,8 +466,8 @@
             // box, and it passes the box at a minimum distance of r1.
             //
 
-            const float r1 = 0.00001;
-            const float r2 = 1.0;
+            const float r1 = 0.00001f;
+            const float r2 = 1.0f;
 
             V3f p1 = box.min + r2 * hollowSphereRand<V3f> (random);
             V3f p2;
@@ -494,9 +498,10 @@
 
     for (int i = 0; i < 1000; ++i)
     {
-        V3f p1 (random.nextf (box.min.x, box.max.x),
-                random.nextf (box.min.y, box.max.y),
-                random.nextf (box.min.z, box.max.z));
+        V3f p1 (
+            float(random.nextf (box.min.x, box.max.x)),
+            float(random.nextf (box.min.y, box.max.y)),
+            float(random.nextf (box.min.z, box.max.z)));
 
         V3f p2 (p1 + hollowSphereRand<V3f> (random));
 
@@ -520,18 +525,20 @@
 
         do
         {
-            p1 = V3f (random.nextf (bigBox.min.x, bigBox.max.x),
-                      random.nextf (bigBox.min.y, bigBox.max.y),
-                      random.nextf (bigBox.min.z, bigBox.max.z));
+            p1 = V3f (
+                float(random.nextf (bigBox.min.x, bigBox.max.x)),
+                float(random.nextf (bigBox.min.y, bigBox.max.y)),
+                float(random.nextf (bigBox.min.z, bigBox.max.z)));
         } while (box.intersects (p1));
 
         V3f p2;
 
         do
         {
-            p2 = V3f (random.nextf (box.min.x, box.max.x),
-                      random.nextf (box.min.y, box.max.y),
-                      random.nextf (box.min.z, box.max.z));
+            p2 = V3f (
+                float(random.nextf (box.min.x, box.max.x)),
+                float(random.nextf (box.min.y, box.max.y)),
+                float(random.nextf (box.min.z, box.max.z)));
         } while (approximatelyEqual (p1, p2, e));
 
         Line3f ray (p1, p2);
@@ -830,6 +837,19 @@
     assert (approximatelyEqual (b5.min, b6.min, e));
     assert (approximatelyEqual (b5.max, b6.max, e));
     assert (b51 == b5);
+
+    Box3f b7;
+    Box3f r;
+    b7.makeEmpty();
+    assert (b7.isEmpty() && !b7.isInfinite());
+    affineTransform (b7, M, r);
+    assert (r.isEmpty());
+
+    Box3f b8;
+    b8.makeInfinite();
+    assert (b8.isInfinite() && !b8.isEmpty());
+    affineTransform (b8, M, r);
+    assert (r.isInfinite());
 }
 
 void

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testColor.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testColor.cpp Changed

@@ -10,6 +10,7 @@
 #include <ImathColor.h>
 #include <ImathColorAlgo.h>
 #include <ImathMath.h>
+#include <ImathFun.h>
 #include <assert.h>
 #include <iostream>
 #include "testColor.h"
@@ -38,7 +39,7 @@
     assert (in3 == out3);
 
     IMATH_INTERNAL_NAMESPACE::C4c testConstructor1;
-    IMATH_INTERNAL_NAMESPACE::C4c testConstructor1i (0.f);
+    IMATH_INTERNAL_NAMESPACE::C4c testConstructor1i (0);
     IMATH_INTERNAL_NAMESPACE::C4c testConstructor2 (testConstructor1i);
 
     testConstructor1 = testConstructor2; // use these so the compiler doesn't emit a warning
@@ -162,5 +163,84 @@
             std::fabs ((X.b / Y.b) - tmp.b) <= 1e-5f &&
             std::fabs ((X.a / Y.a) - tmp.a) <= 1e-5f);
 
+    cout << "rgb2hsv and hsv2rgb" << endl;
+
+    // C4f
+    
+    IMATH_INTERNAL_NAMESPACE::C4f c4f, r4f, tmp4f;
+
+    for (float r=0.0f; r<=1.0; r += 1.0f)
+        for (float g=0.0f; g<=1.0; g += 1.0f)
+            for (float b=0.0f; b<=1.0; b += 1.0f)
+            {
+                c4f.r = r;
+                c4f.g = g;
+                c4f.b = b;
+                c4f.a = 1.0f;
+                tmp4f = rgb2hsv(c4f);
+                r4f = hsv2rgb(tmp4f);
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4f.r, c4f.r, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4f.g, c4f.g, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4f.b, c4f.b, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4f.a, c4f.a, 1e-5f));
+            }
+    
+    // C3f
+    
+    IMATH_INTERNAL_NAMESPACE::C3f c3f, r3f, tmp3f;
+
+    for (float r=0.0f; r<=1.0; r += 1.0f)
+        for (float g=0.0f; g<=1.0; g += 1.0f)
+            for (float b=0.0f; b<=1.0; b += 1.0f)
+            {
+                c3f.x = r;
+                c3f.y = g;
+                c3f.z = b;
+                tmp3f = rgb2hsv(c3f);
+                r3f = hsv2rgb(tmp3f);
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3f.x, c3f.x, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3f.y, c3f.y, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3f.z, c3f.z, 1e-5f));
+            }
+    
+    // C4d
+    
+    IMATH_INTERNAL_NAMESPACE::Color4<double> c4d, r4d, tmp4d;
+
+    for (double r=0.0; r<=1.0; r += 1.0)
+        for (double g=0.0; g<=1.0; g += 1.0)
+            for (double b=0.0; b<=1.0; b += 1.0)
+            {
+                c4d.r = r;
+                c4d.g = g;
+                c4d.b = b;
+                c4d.a = 1.0;
+                tmp4d = rgb2hsv(c4d);
+                r4d = hsv2rgb(tmp4d);
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4d.r, c4d.r, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4d.g, c4d.g, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4d.b, c4d.b, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r4d.a, c4d.a, 1e-5f));
+            }
+    
+
+    // C3d
+    
+    IMATH_INTERNAL_NAMESPACE::Color3<double> c3d, r3d, tmp3d;
+
+    for (double r=0.0; r<=1.0; r += 1.0)
+        for (double g=0.0; g<=1.0; g += 1.0)
+            for (double b=0.0; b<=1.0; b += 1.0)
+            {
+                c3d.x = r;
+                c3d.y = g;
+                c3d.z = b;
+                tmp3d = rgb2hsv(c3d);
+                r3d = hsv2rgb(tmp3d);
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3d.x, c3d.x, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3d.y, c3d.y, 1e-5f));
+                assert (IMATH_INTERNAL_NAMESPACE::equal (r3d.z, c3d.z, 1e-5f));
+            }
+    
     cout << "ok\n" << endl;
 }

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testExtractEuler.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testExtractEuler.cpp Changed

@@ -24,7 +24,7 @@
 float
 rad (float deg)
 {
-    return deg * (M_PI / 180);
+    return deg * float(M_PI / 180);
 }
 
 M44f
@@ -100,10 +100,11 @@
         // Create a rotation matrix, M
         //
 
-        Eulerf e (rad (r.nextf (-180, 180)),
-                  rad (r.nextf (-180, 180)),
-                  rad (r.nextf (-180, 180)),
-                  Eulerf::XYZ);
+        Eulerf e (
+            rad (float(r.nextf (-180, 180))),
+            rad (float(r.nextf (-180, 180))),
+            rad (float(r.nextf (-180, 180))),
+            Eulerf::XYZ);
 
         M44f M (e.toMatrix44());
 
@@ -113,7 +114,7 @@
 
         for (int j = 0; j < 3; ++j)
             for (int k = 0; k < 3; ++k)
-                Mjk += r.nextf (-1e-7, 1e-7);
+                Mjk += float(r.nextf (-1e-7, 1e-7));
 
         //
         // Extract Euler angles from M, convert the Euler angles
@@ -169,7 +170,7 @@
     for (int i = 0; i < 360; i += 90)
         for (int j = 0; j < 360; j += 90)
             for (int k = 0; k < 360; k += 90)
-                testAngles (V3f (i, j, k), matrixEulerMatrix, order);
+                testAngles (V3f (float(i), float(j), float(k)), matrixEulerMatrix, order);
 }
 
 void
@@ -177,11 +178,11 @@
 {
     Rand48 r (0);
 
-    float eps = 8.0 * std::numeric_limits<float>::epsilon();
+    float eps = 8.0f * std::numeric_limits<float>::epsilon ();
 
     for (int i = 0; i < 100000; ++i)
     {
-        float angle = rad (r.nextf (-180, 180));
+        float angle = rad (float(r.nextf (-180, 180)));
 
         M33f M;
         M.setRotation (angle);

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testExtractSHRT.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testExtractSHRT.cpp Changed

@@ -32,7 +32,7 @@
 float
 rad (float deg)
 {
-    return deg * (M_PI / 180);
+    return deg * float(M_PI / 180);
 }
 
 void
@@ -108,7 +108,8 @@
         // Scale M.
         //
 
-        V2f s (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0));
+        V2f s (float(random.nextf (0.000001, 2.0)), 
+               float(random.nextf (0.000001, 2.0)));
 
         for (int j = 0; j < 2; j++)
             if (random.nextf (0.0, 1.0) >= 0.5)
@@ -120,9 +121,8 @@
         // Shear M.
         //
 
-        float h = random.nextf (0.000001, 2.);
-        if (random.nextf (0.0, 1.0) >= 0.5)
-            h *= -1;
+        float h = float(random.nextf (0.000001, 2.));
+        if (random.nextf (0.0, 1.0) >= 0.5) h *= -1;
 
         M *= M33f().setShear (h);
 
@@ -130,7 +130,7 @@
         // Rotate M.
         //
 
-        float r = rad (random.nextf (-180, 180));
+        float r = rad (float(random.nextf (-180, 180)));
 
         M *= M33f().setRotation (r);
 
@@ -138,7 +138,8 @@
         // Translate M.
         //
 
-        V2f t (random.nextf (-10, 10), random.nextf (-10, 10));
+        V2f t (float(random.nextf (-10, 10)),
+               float(random.nextf (-10, 10)));
 
         M *= M33f().setTranslation (t);
 
@@ -148,7 +149,7 @@
 
         for (int j = 0; j < 3; ++j)
             for (int k = 0; k < 2; ++k)
-                Mjk += random.nextf (-1e-7, 1e-7);
+                Mjk += float(random.nextf (-1e-7, 1e-7));
 
         debug (("Scale   : %f %f\n", s0, s1));
         debug (("Shear   : %f\n", h));
@@ -206,7 +207,11 @@
 
     V3f s, h, r, t;
 
-    extractSHRT (M, s, h, r, t, true);
+    if (!extractSHRT (M, s, h, r, t, true))
+    {
+        cout << "Unable to extractSHRT" << std::endl;
+        assert (false);
+    }
 
     M44f N;
 
@@ -264,7 +269,10 @@
         // Translate M.
         //
 
-        V3f t (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10));
+        V3f t (
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)));
 
         M.translate (t);
 
@@ -272,9 +280,10 @@
         // Rotate M.
         //
 
-        V3f r (rad (random.nextf (-180, 180)),
-               rad (random.nextf (-180, 180)),
-               rad (random.nextf (-180, 180)));
+        V3f r (
+            rad (float(random.nextf (-180, 180))),
+            rad (float(random.nextf (-180, 180))),
+            rad (float(random.nextf (-180, 180))));
 
         M.rotate (r);
 
@@ -282,9 +291,10 @@
         // Shear M.
         //
 
-        V3f h (random.nextf (0.000001, 2.0),
-               random.nextf (0.000001, 2.0),
-               random.nextf (0.000001, 2.0));
+        V3f h (
+            float(random.nextf (0.000001, 2.0)),
+            float(random.nextf (0.000001, 2.0)),
+            float(random.nextf (0.000001, 2.0)));
 
         for (int j = 0; j < 3; j++)
             if (random.nextf (0.0, 1.0) >= 0.5)
@@ -296,9 +306,10 @@
         // Scale M.
         //
 
-        V3f s (random.nextf (0.000001, 2.0),
-               random.nextf (0.000001, 2.0),
-               random.nextf (0.000001, 2.0));
+        V3f s (
+            float(random.nextf (0.000001, 2.0)),
+            float(random.nextf (0.000001, 2.0)),
+            float(random.nextf (0.000001, 2.0)));
 
         for (int j = 0; j < 3; j++)
             if (random.nextf (0.0, 1.0) >= 0.5)
@@ -312,7 +323,7 @@
 
         for (int j = 0; j < 4; ++j)
             for (int k = 0; k < 3; ++k)
-                Mjk += random.nextf (-1e-7, 1e-7);
+                Mjk += float(random.nextf (-1e-7, 1e-7));
 
         debug (("Scale   : %f %f %f\n", s0, s1, s2));
         debug (("Shear   : %f %f %f\n", h0, h1, h2));
@@ -382,7 +393,7 @@
     for (int i = 0; i < 360; i += 90)
         for (int j = 0; j < 360; j += 90)
             for (int k = 0; k < 360; k += 90)
-                testAngles44 (V3f (i, j, k));
+                testAngles44 (V3f (float(i), float(j), float(k)));
 }
 
 } // namespace

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testFrustum.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testFrustum.cpp Changed

@@ -28,7 +28,7 @@
 {
     bool ortho = frustum.orthographic();
     IMATH_INTERNAL_NAMESPACE::V3f o (0.0f, 0.0f, 0.0f);
-    float eps = 5.0e-4;
+    float                         eps = 5.0e-4f;
 
     for (auto xRo : { 0.0f, 100.0f, 200.0f })
     {
@@ -159,12 +159,12 @@
 
     cout << "\nperspective ";
 
-    float n = 1.7;
-    float f = 567.0;
-    float l = -3.5;
-    float r = 2.0;
-    float b = -1.3;
-    float t = 0.9;
+    float n = 1.7f;
+    float f = 567.0f;
+    float l = -3.5f;
+    float r = 2.0f;
+    float b = -1.3f;
+    float t = 0.9f;
 
     IMATH_INTERNAL_NAMESPACE::Frustum<float> frustum (n, f, l, r, t, b, false);
 
@@ -178,40 +178,54 @@
             1e-6);
     cout << "2";
 
-    IMATH_INTERNAL_NAMESPACE::M44f m = frustum.projectionMatrixExc();
-    assert (IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - ((2 * n) / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - ((2 * n) / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m20 - ((r + l) / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m21 - ((t + b) / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-(f + n) / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m23 - -1.0) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m30) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m31) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m32 - ((-2 * f * n) / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m33) < 1e-6);
-    m = frustum.projectionMatrix();
-    assert (IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - ((2 * n) / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - ((2 * n) / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m20 - ((r + l) / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m21 - ((t + b) / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-(f + n) / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m23 - -1.0) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m30) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m31) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m32 - ((-2 * f * n) / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m33) < 1e-6);
+    IMATH_INTERNAL_NAMESPACE::M44f m = frustum.projectionMatrixExc ();
+    assert (
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - ((2 * n) / (r - l))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - ((2 * n) / (t - b))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m20 - ((r + l) / (r - l))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m21 - ((t + b) / (t - b))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-(f + n) / (f - n))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m23 - -1.0f) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m30) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m31) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (
+            m32 - ((-2 * f * n) / (f - n))) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m33) < 1e-6f);
+    m = frustum.projectionMatrix ();
+    assert (
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - ((2 * n) / (r - l))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - ((2 * n) / (t - b))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6 &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6 &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m20 - ((r + l) / (r - l))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m21 - ((t + b) / (t - b))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-(f + n) / (f - n))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m23 - -1.0f) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m30) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m31) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (
+            m32 - ((-2 * f * n) / (f - n))) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m33) < 1e-6f);
     cout << "3";
 
     cout << "\nplanes ";
@@ -268,23 +282,28 @@
 
     frustum.setOrthographic (true);
 
-    m = frustum.projectionMatrix();
-    assert (IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - (2 / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - (2 / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m20) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m21) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-2 / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m23) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m30 - (-(r + l) / (r - l))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m31 - (-(t + b) / (t - b))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m32 - (-(f + n) / (f - n))) < 1e-6 &&
-            IMATH_INTERNAL_NAMESPACE::abs<float> (m33 - 1.0) < 1e-6);
+    m = frustum.projectionMatrix ();
+    assert (
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m00 - (2 / (r - l))) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m01) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m02) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m03) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m10) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m11 - (2 / (t - b))) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m12) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m13) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m20) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m21) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m22 - (-2 / (f - n))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m23) < 1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m30 - (-(r + l) / (r - l))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m31 - (-(t + b) / (t - b))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m32 - (-(f + n) / (f - n))) <
+            1e-6f &&
+        IMATH_INTERNAL_NAMESPACE::abs<float> (m33 - 1.0f) < 1e-6f);
     cout << "1";
 
     cout << "\nplanes ";
@@ -297,17 +316,17 @@
     IMATH_INTERNAL_NAMESPACE::Frustum<float> f1 (n, f, l, r, t, b, false);
     IMATH_INTERNAL_NAMESPACE::Frustum<float> f2 (n, f, l, r, t, b, true);
     assert (f1 != f2);
-    f2.set (n + 0.1, f, l, r, t, b, false);
+    f2.set (n + 0.1f, f, l, r, t, b, false);
     assert (f1 != f2);
-    f2.set (n, f + 0.1, l, r, t, b, false);
+    f2.set (n, f + 0.1f, l, r, t, b, false);
     assert (f1 != f2);
-    f2.set (n, f, l + 0.1, r, t, b, false);
+    f2.set (n, f, l + 0.1f, r, t, b, false);
     assert (f1 != f2);
-    f2.set (n, f, l, r + 0.1, t, b, false);
+    f2.set (n, f, l, r + 0.1f, t, b, false);
     assert (f1 != f2);
-    f2.set (n, f, l, r, t + 0.1, b, false);
+    f2.set (n, f, l, r, t + 0.1f, b, false);
     assert (f1 != f2);
-    f2.set (n, f, l, r, t, b + 0.1, false);
+    f2.set (n, f, l, r, t, b + 0.1f, false);
     assert (f1 != f2);
     cout << "\npassed inequality test";
 
@@ -326,8 +345,9 @@
 
     assert (f1 == f2);
 
-    assert (f1.ZToDepth (zMin, zMin, zMax) == f1.ZToDepthExc (zMin, zMin, zMax));
-    assert (f1.normalizedZToDepth (zMin) == f1.normalizedZToDepthExc (zMin));
+    assert (
+        f1.ZToDepth (zMin, zMin, zMax) == f1.ZToDepthExc (zMin, zMin, zMax));
+    assert (f1.normalizedZToDepth (float(zMin)) == f1.normalizedZToDepthExc (float(zMin)));
     assert (f1.DepthToZ (n, zMin, zMax) == f1.DepthToZExc (n, zMin, zMax));
     assert (f1.worldRadius (v3, one) == f1.worldRadiusExc (v3, one));
     assert (f1.screenRadius (v3, one) == f1.screenRadiusExc (v3, one));

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testFrustumTest.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testFrustumTest.cpp Changed

@@ -27,12 +27,12 @@
 
     cout << "\nisVisible(Vec3) ";
 
-    float n = 1.7;
-    float f = 567.0;
-    float l = -3.5;
-    float r = 2.0;
-    float b = -1.3;
-    float t = 0.9;
+    float n = 1.7f;
+    float f = 567.0f;
+    float l = -3.5f;
+    float r = 2.0f;
+    float b = -1.3f;
+    float t = 0.9f;
 
     IMATH_INTERNAL_NAMESPACE::Frustum<float> frustum (n, f, l, r, t, b, false);
 
@@ -56,6 +56,7 @@
     assert (!frustumTest.isVisible (outsideVec_far));
     assert (!frustumTest.isVisible (outsideVec_side));
     assert (!frustumTest.isVisible (outsideVec_up));
+
     cout << "passed Vec3\n";
 
     /////////////////////////////////////////////////////
@@ -73,6 +74,10 @@
             insideVec + tinySize,
             insideVec + tinySize)));
 
+    assert (frustumTest.completelyContains (
+        IMATH_INTERNAL_NAMESPACE::Box<IMATH_INTERNAL_NAMESPACE::Vec3<float>> (
+            insideVec + tinySize, insideVec + tinySize)));
+    
     // Huge boxes inside and outside should be visible
     assert (frustumTest.isVisible (
         IMATH_INTERNAL_NAMESPACE::Box<IMATH_INTERNAL_NAMESPACE::Vec3<float>> (
@@ -123,6 +128,9 @@
     assert (
         frustumTest.isVisible (IMATH_INTERNAL_NAMESPACE::Sphere3<float> (insideVec, tinyRadius)));
 
+    assert (frustumTest.completelyContains(
+        IMATH_INTERNAL_NAMESPACE::Sphere3<float> (insideVec, tinyRadius)));
+
     // Huge spheres inside and outside should be visible
     assert (
         frustumTest.isVisible (IMATH_INTERNAL_NAMESPACE::Sphere3<float> (insideVec, hugeRadius)));

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testFun.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testFun.cpp Changed

@@ -16,7 +16,7 @@
 #include <iostream>
 #include <cstdint>
 #include <stdio.h>
-#include "testFun.h"
+#include <inttypes.h>
 
 using namespace std;
 
@@ -46,11 +46,11 @@
     float spf = IMATH_INTERNAL_NAMESPACE::succf (IMATH_INTERNAL_NAMESPACE::predf (f));
     float psf = IMATH_INTERNAL_NAMESPACE::predf (IMATH_INTERNAL_NAMESPACE::succf (f));
 
-    printf ("f %.9g %x\n", f, bit_cast<uint32_t>(f));
-    printf ("sf %.9g %x\n", sf, bit_cast<uint32_t>(sf));
-    printf ("pf %.9g %x\n", pf, bit_cast<uint32_t>(pf));
-    printf ("spf %.9g %x\n", spf, bit_cast<uint32_t>(spf));
-    printf ("psf %.9g %x\n", psf, bit_cast<uint32_t>(psf));
+    printf ("f %.9g %" PRIx32 "\n", f, bit_cast<uint32_t> (f));
+    printf ("sf %.9g %" PRIx32 "\n", sf, bit_cast<uint32_t> (sf));
+    printf ("pf %.9g %" PRIx32 "\n", pf, bit_cast<uint32_t> (pf));
+    printf ("spf %.9g %" PRIx32 "\n", spf, bit_cast<uint32_t> (spf));
+    printf ("psf %.9g %" PRIx32 "\n", psf, bit_cast<uint32_t> (psf));
 
     fflush (stdout);
 
@@ -87,11 +87,11 @@
     double spd = IMATH_INTERNAL_NAMESPACE::succd (IMATH_INTERNAL_NAMESPACE::predd (d));
     double psd = IMATH_INTERNAL_NAMESPACE::predd (IMATH_INTERNAL_NAMESPACE::succd (d));
 
-    printf ("d   %0.18lg %lx\n", d, bit_cast<uint64_t>(d));
-    printf ("sd  %0.18lg %lx\n", sd, bit_cast<uint64_t>(sd));
-    printf ("pd  %0.18lg %lx\n", pd, bit_cast<uint64_t>(pd));
-    printf ("spd %0.18lg %lx\n", spd, bit_cast<uint64_t>(spd));
-    printf ("psd %0.18lg %lx\n", psd, bit_cast<uint64_t>(psd));
+    printf ("d   %0.18lg %" PRIx64 "\n", d, bit_cast<uint64_t> (d));
+    printf ("sd  %0.18lg %" PRIx64 "\n", sd, bit_cast<uint64_t> (sd));
+    printf ("pd  %0.18lg %" PRIx64 "\n", pd, bit_cast<uint64_t> (pd));
+    printf ("spd %0.18lg %" PRIx64 "\n", spd, bit_cast<uint64_t> (spd));
+    printf ("psd %0.18lg %" PRIx64 "\n", psd, bit_cast<uint64_t> (psd));
 
     fflush (stdout);
 
@@ -252,12 +252,12 @@
     cout << "successor, predecessor" << endl;
 
     testf (0);
-    testf (0.0 * -1.0);
+    testf (0.0f * -1.0f);
     testf (1);
     testf (-1);
     testf (16);
     testf (7);
-    testf (0.7);
+    testf (0.7f);
 
     union {float f; uint32_t i;} u;
     u.i = 0x7f800000; //  inf

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testInterop.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testInterop.cpp Changed

@@ -20,6 +20,7 @@
 using namespace std;
 using namespace IMATH_INTERNAL_NAMESPACE;
 
+#if IMATH_FOREIGN_VECTOR_INTEROP
 
 // Imath::has_subscript fails for std::vector because its length does not
 // appear to be the length of N elements. Carve out an exception here that
@@ -29,7 +30,6 @@
 struct has_subscript<std::vector<T>, T, N> : public std::true_type { };
 IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT
 
-#if IMATH_FOREIGN_VECTOR_INTEROP
 
 
 namespace
@@ -584,9 +584,10 @@
         Matrix22<float> ref;
         SimpleMx<float,2> s;
         for (int j = 0; j < 2; ++j)
-            for (int i = 0; i < 2; ++i) {
-                sji = i + j * 2;
-                refji = i + j * 2;
+            for (int i = 0; i < 2; ++i)
+            {
+                sji   = float(i + j * 2);
+                refji = float(i + j * 2);
             }
         Matrix22<float> v(s);
         assert(v00 == 0 && v01 == 1 &&
@@ -627,9 +628,10 @@
         Matrix33<float> ref;
         SimpleMx<float,3> s;
         for (int j = 0; j < 3; ++j)
-            for (int i = 0; i < 3; ++i) {
-                sji = i + j * 3;
-                refji = i + j * 3;
+            for (int i = 0; i < 3; ++i)
+            {
+                sji   = float(i + j * 3);
+                refji = float(i + j * 3);
             }
         Matrix33<float> v(s);
         assert(v00 == 0 && v01 == 1 && v02 == 2 &&
@@ -672,9 +674,10 @@
         Matrix44<float> ref;
         SimpleMx<float,4> s;
         for (int j = 0; j < 4; ++j)
-            for (int i = 0; i < 4; ++i) {
-                sji = i + j * 4;
-                refji = i + j * 4;
+            for (int i = 0; i < 4; ++i)
+            {
+                sji   = float(i + j * 4);
+                refji = float(i + j * 4);
             }
         Matrix44<float> v(s);
         assert(v00 == 0 && v01 == 1 && v02 == 2 && v03 == 3 &&
@@ -697,12 +700,13 @@
 void
 testInterop()
 {
+#if IMATH_FOREIGN_VECTOR_INTEROP
+    
     cout << "Testing interoperability with foreign types" << endl;
 
-#if IMATH_FOREIGN_VECTOR_INTEROP
-    testInteropVec2();
-    testInteropVec3();
-    testInteropVec4();
+    testInteropVec2 ();
+    testInteropVec3 ();
+    testInteropVec4 ();
 
     testInteropMx2();
     testInteropMx3();

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testInterval.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testInterval.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testInvert.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testInvert.cpp Changed

@@ -81,23 +81,23 @@
 		  0,  0,  0, -1,
 		  0,  0,  1,  0);
 
-	M44f m4 ( 4.683281e-01, -8.749647e-01,  1.229049e-01,  0.000000e+00,
-		  1.251189e-02,  1.456563e-01,  9.892561e-01,  0.000000e+00,
-		 -8.834660e-01, -4.617587e-01,  7.916244e-02,  0.000000e+00,
-		 -4.726541e+00,  3.044795e+00, -6.737138e+00,  1.000000e+00);
+	M44f m4 ( 4.683281e-01f, -8.749647e-01f,  1.229049e-01f,  0.000000e+00f,
+		  1.251189e-02f,  1.456563e-01f,  9.892561e-01f,  0.000000e+00f,
+		 -8.834660e-01f, -4.617587e-01f,  7.916244e-02f,  0.000000e+00f,
+		 -4.726541e+00f,  3.044795e+00f, -6.737138e+00f,  1.000000e+00f);
 
-	M44f m5 ( 4.683281e-01, -8.749647e-01,  1.229049e-01,  1.000000e+00,
-		  1.251189e-02,  1.456563e-01,  9.892561e-01,  2.000000e+00,
-		 -8.834660e-01, -4.617587e-01,  7.916244e-02,  3.000000e+00,
-		 -4.726541e+00,  3.044795e+00, -6.737138e+00,  4.000000e+00);
+	M44f m5 ( 4.683281e-01f, -8.749647e-01f,  1.229049e-01f,  1.000000e+00f,
+		  1.251189e-02f,  1.456563e-01f,  9.892561e-01f,  2.000000e+00f,
+		 -8.834660e-01f, -4.617587e-01f,  7.916244e-02f,  3.000000e+00f,
+		 -4.726541e+00f,  3.044795e+00f, -6.737138e+00f,  4.000000e+00f);
 
         // clang-format on
 
-	invertM44f (m1, 0);
-	invertM44f (m2, 0);
-	invertM44f (m3, 0);
-	invertM44f (m4, 1e-6);
-	invertM44f (m5, 1e-6);
+        invertM44f (m1, 0);
+        invertM44f (m2, 0);
+        invertM44f (m3, 0);
+        invertM44f (m4, 1e-6f);
+        invertM44f (m5, 1e-6f);
     }
 
     {
@@ -117,21 +117,21 @@
 		  0,  0, -1,
 		  0,  1,  0);
 
-	M33f m4 ( 4.683281e-01, -8.749647e-01,  0.000000e+00,
-		  1.251189e-02,  1.456563e-01,  0.000000e+00,
-		  0.000000e+00,  0.000000e+00,  1.000000e+00);
+	M33f m4 ( 4.683281e-01f, -8.749647e-01f,  0.000000e+00f,
+		  1.251189e-02f,  1.456563e-01f,  0.000000e+00f,
+		  0.000000e+00f,  0.000000e+00f,  1.000000e+00f);
 
-	M33f m5 ( 4.683281e-01, -8.749647e-01,  1.229049e-01,
-		  1.251189e-02,  1.456563e-01,  9.892561e-01,
-		 -8.834660e-01, -4.617587e-01,  7.916244e-02);
+	M33f m5 ( 4.683281e-01f, -8.749647e-01f,  1.229049e-01f,
+		  1.251189e-02f,  1.456563e-01f,  9.892561e-01f,
+		 -8.834660e-01f, -4.617587e-01f,  7.916244e-02f);
 
         // clang-format on
 
-	invertM33f (m1, 0);
-	invertM33f (m2, 0);
-	invertM33f (m3, 0);
-	invertM33f (m4, 1e-6);
-	invertM33f (m5, 1e-6);
+        invertM33f (m1, 0);
+        invertM33f (m2, 0);
+        invertM33f (m3, 0);
+        invertM33f (m4, 1e-6f);
+        invertM33f (m5, 1e-6f);
     }
 
     cout << "ok\n" << endl;

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testJacobiEigenSolver.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testJacobiEigenSolver.cpp Changed

@@ -33,10 +33,6 @@
      0.25058694044821,  0.49427229444416,  0.81415724537748,
      0.49427229444416,  0.80192384710853, -0.61674948224910,
      0.81415724537748, -0.61674948224910, -1.28486154645285);
-const Matrix33<double> A33_9 (
-     4,  -30,    60,
-   -30,  300,  -675,
-    60, -675,  1620);
 
 const Matrix44<double> A44_1 ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 );
 const Matrix44<double> A44_2 ( 1, 0, 0, 0, 0,-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 );
@@ -50,11 +46,6 @@
      0.16358123075600,  0.57629829390780,  3.88542912704029,  0.92016316185369,
      0.11541756047409,  3.88542912704029,  0.65367032943707, -0.21971103270410,
     -1.65369223465270,  0.92016316185369, -0.21971103270410, -0.28108876552761);
-const Matrix44<double> A44_9 (
-     4,  -30,    60,   -35,
-   -30,  300,  -675,   420,
-    60, -675,  1620, -1050,
-   -35,  420, -1050,   700);
 
 // clang-format on
 
@@ -62,10 +53,10 @@
 void
 verifyOrthonormal (const TM& A, const typename TM::BaseType threshold)
 {
-    const TM prod = A * A.transposed();
-    for (size_t i = 0; i < TM::dimensions(); ++i)
-        for (size_t j = 0; j < TM::dimensions(); ++j)
-            if (i == j) 
+    const TM prod = A * A.transposed ();
+    for (unsigned int i = 0; i < TM::dimensions (); ++i)
+        for (unsigned int j = 0; j < TM::dimensions (); ++j)
+            if (i == j)
                 assert (std::abs (prodij - 1) < threshold);
             else
                 assert (std::abs (prodij) < threshold);
@@ -78,9 +69,9 @@
    typedef typename TM::BaseType T;
    T maxAbsEntry(0);
 
-   for (size_t i = 0; i < TM::dimensions(); ++i)
-       for (size_t j = 0; j < TM::dimensions(); ++j)
-           maxAbsEntry = std::max (maxAbsEntry, std::abs(Aij));
+    for (unsigned int i = 0; i < TM::dimensions (); ++i)
+        for (unsigned int j = 0; j < TM::dimensions (); ++j)
+            maxAbsEntry = std::max (maxAbsEntry, std::abs (Aij));
 
    const T eps = std::numeric_limits<T>::epsilon();
    maxAbsEntry = std::max(maxAbsEntry, eps);
@@ -113,9 +104,9 @@
 
     // Determinant of A and S
     TM MS;
-    for (size_t i = 0; i < TM::dimensions(); ++i)
-        for (size_t j = 0; j < TM::dimensions(); ++j)
-            if(i == j)
+    for (unsigned int i = 0; i < TM::dimensions (); ++i)
+        for (unsigned int j = 0; j < TM::dimensions (); ++j)
+            if (i == j)
                 MSij = Si;
             else
                 MSij = 0;
@@ -125,9 +116,9 @@
     // A = V * S * V^T
     TM MA = V * MS * V.transposed();
 
-    for (size_t i = 0; i < TM::dimensions(); ++i) 
-        for (size_t j =0; j < TM::dimensions(); ++j) 
-            assert(abs(Aij-MAij) < threshold);
+    for (unsigned int i = 0; i < TM::dimensions (); ++i)
+        for (unsigned int j = 0; j < TM::dimensions (); ++j)
+            assert (abs (Aij - MAij) < threshold);
 }
 
 template<class TM>

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testLimits.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testLimits.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testLineAlgo.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testLineAlgo.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testMatrix.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testMatrix.cpp Changed

@@ -16,6 +16,7 @@
 #include <assert.h>
 #include <iostream>
 #include "testMatrix.h"
+#include <sstream>
 
 // Include ImathForward *after* other headers to validate forward declarations
 #include <ImathForward.h>
@@ -34,7 +35,29 @@
 //
 
 void
-testMatrix()
+testMatrix22ArrayConstructor(const float a22)
+{
+    IMATH_INTERNAL_NAMESPACE::M22f m(a);
+    assert(m == IMATH_INTERNAL_NAMESPACE::M22f());
+}
+
+void
+testMatrix33ArrayConstructor(const float a33)
+{
+    IMATH_INTERNAL_NAMESPACE::M33f m(a);
+    assert(m == IMATH_INTERNAL_NAMESPACE::M33f());
+}
+
+void
+testMatrix44ArrayConstructor(const float a44)
+{
+    IMATH_INTERNAL_NAMESPACE::M44f m(a);
+    assert(m == IMATH_INTERNAL_NAMESPACE::M44f());
+}
+
+
+void
+testMatrix ()
 {
     cout << "Testing functions in ImathMatrix.h" << endl;
 
@@ -59,7 +82,7 @@
         m100 = 99.0f;
         m111 = 101.0f;
 
-        IMATH_INTERNAL_NAMESPACE::M22f test (m1);
+        const IMATH_INTERNAL_NAMESPACE::M22f test (m1);
         assert (test == m1);
 
         IMATH_INTERNAL_NAMESPACE::M22f test2;
@@ -68,6 +91,32 @@
         IMATH_INTERNAL_NAMESPACE::M22f test3;
         test3.makeIdentity();
         assert (test2 == test3);
+
+        const float a22 = {
+            { 1.0f, 0.0f },
+            { 0.0f, 1.0f }
+        };
+        testMatrix22ArrayConstructor(a);
+        
+        m1 = 42;
+        assert (m100 == 42 && m101 == 42 && m110 == 42 && m111 == 42);
+
+        const float* i1 = test.getValue();
+        assert(i10 == 99.0f);
+        assert(i13 == 101.0f);
+        
+        float* i2 = m1.getValue();
+        assert(i20 == 42.0f);
+        assert(i21 == 42.0f);
+        assert(i22 == 42.0f);
+        assert(i23 == 42.0f);
+
+        IMATH_INTERNAL_NAMESPACE::M22f test4;
+        test.getValue(test4);
+        assert (test == test4);
+
+        test4.setTheMatrix(test3);
+        assert(test4 == test3);
     }
 
     {
@@ -96,6 +145,13 @@
 
         assert (test510 == 3.0);
         assert (test511 == 4.0);
+
+        const float a33 = {
+            { 1.0f, 0.0f, 0.0f },
+            { 0.0f, 1.0f, 0.0f },
+            { 0.0f, 0.0f, 1.0f }
+        };
+        testMatrix33ArrayConstructor(a);
     }
 
     {
@@ -142,7 +198,7 @@
 
         cout << "M33f constructors and equality operators" << endl;
 
-        IMATH_INTERNAL_NAMESPACE::M33f test (m2);
+        const IMATH_INTERNAL_NAMESPACE::M33f test (m2);
         assert (test == m2);
 
         IMATH_INTERNAL_NAMESPACE::M33f test2;
@@ -151,6 +207,36 @@
         IMATH_INTERNAL_NAMESPACE::M33f test3;
         test3.makeIdentity();
         assert (test2 == test3);
+
+        m1 = 42;
+        assert (m100 == 42 && m101 == 42 && m102 == 42 &&
+                m110 == 42 && m111 == 42 && m112 == 42 &&
+                m120 == 42 && m121 == 42 && m122 == 42);
+
+        const float* i1 = test.getValue();
+        assert (i10 == 1.0f  && i11 == 4.0f  && i12 == 0.0f &&
+                i13 == 10.0f && i14 == 29.0f && i15 == 0.0f &&
+                i16 == 0.0f  && i17 == 0.0f  && i18 == 1.0f);
+        
+        float* i2 = m1.getValue();
+        assert(i20 == 42.0f);
+        assert(i21 == 42.0f);
+        assert(i22 == 42.0f);
+        assert(i23 == 42.0f);
+
+        IMATH_INTERNAL_NAMESPACE::M33f test4;
+        test.getValue(test4);
+        assert (test == test4);
+
+        test4.setTheMatrix(test3);
+        assert(test4 == test3);
+
+        IMATH_INTERNAL_NAMESPACE::V3f v(2.0f);
+        IMATH_INTERNAL_NAMESPACE::M33f m(2.0f);
+        v *= m;
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v0, 12.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v1, 12.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v2, 12.0f, 0.0001f));
     }
 
     {
@@ -263,6 +349,14 @@
         test3.makeIdentity();
         assert (test2 == test3);
 
+        const float a44 = {
+            { 1.0f, 0.0f, 0.0f, 0.0f },
+            { 0.0f, 1.0f, 0.0f, 0.0f },
+            { 0.0f, 0.0f, 1.0f, 0.0f },
+            { 0.0f, 0.0f, 0.0f, 1.0f }
+        };
+        testMatrix44ArrayConstructor(a);
+
         //
         // Test non-equality when a NAN is in the same
         // place in two identical matrices
@@ -313,7 +407,63 @@
     }
 
     {
-      cout << "M44f inversion operators" << endl;
+        cout << "M44f *= operators" << endl;
+
+        IMATH_INTERNAL_NAMESPACE::V3f v(2.0f);
+        IMATH_INTERNAL_NAMESPACE::M44f m(2.0f);
+        m.setScale(2.0f);
+        v *= m;
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v0, 4.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v1, 4.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v2, 4.0f, 0.0001f));
+
+        IMATH_INTERNAL_NAMESPACE::V4f v4f(2.0f);
+        IMATH_INTERNAL_NAMESPACE::V4f v4f2 = v4f * m;
+        
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v4f20, 4.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v4f21, 4.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v4f22, 4.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(v4f23, 2.0f, 0.0001f));
+
+        v4f *= m;
+        assert (v4f == v4f2);
+        
+        IMATH_INTERNAL_NAMESPACE::M44f a(2.0f);
+        IMATH_INTERNAL_NAMESPACE::M44f b(3.0f);
+        IMATH_INTERNAL_NAMESPACE::M44f c;
+
+        IMATH_INTERNAL_NAMESPACE::M44f::multiply(a, b, c);
+        assert (IMATH_INTERNAL_NAMESPACE::equal(c00, 24.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(c11, 24.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(c22, 24.0f, 0.0001f));
+        assert (IMATH_INTERNAL_NAMESPACE::equal(c33, 24.0f, 0.0001f));
+    }
+    
+    cout << "Matrix << operators" << endl;
+    
+    {
+        std::stringstream s;
+        s << IMATH_INTERNAL_NAMESPACE::identity22f;
+        const char v = "(  1.000000e+00   0.000000e+00\n   0.000000e+00   1.000000e+00)\n";
+        assert (s.str() == v);

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testMiscMatrixAlgo.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testMiscMatrixAlgo.cpp Changed

@@ -30,26 +30,35 @@
 float
 rad (float deg)
 {
-    return deg * (M_PI / 180);
+    return deg * float(M_PI / 180);
 }
 
 void
 testComputeLocalFrame()
 {
-    float eps = 0.00005;
+    float  eps = 0.00005f;
     Rand48 random (0);
     for (int i = 0; i < 100000; ++i)
     {
         debug (("iteration: %d\n", i));
 
         // Random pos
-        V3f p (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10));
+        V3f p (
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)));
 
         // Random xDir
-        V3f xDir (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10));
+        V3f xDir (
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)));
 
         // Random normalDir
-        V3f normalDir (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10));
+        V3f normalDir (
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)));
 
         // Run computeLocalFrame we want to test
         M44f L = computeLocalFrame (p, xDir, normalDir);
@@ -96,16 +105,21 @@
 getRandTRS (Rand48& random, V3f& trans, V3f& rot, V3f& scale)
 {
     // Translate
-    trans = V3f (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10));
+    trans = V3f (
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)),
+            float(random.nextf (-10, 10)));
     // Rotate
-    rot = V3f (rad (random.nextf (-180, 180)),
-               rad (random.nextf (-180, 180)),
-               rad (random.nextf (-180, 180)));
+    rot = V3f (
+        rad (float(random.nextf (-180, 180))),
+        rad (float(random.nextf (-180, 180))),
+        rad (float(random.nextf (-180, 180))));
 
     // Scale
-    V3f s (random.nextf (0.000001, 2.0),
-           random.nextf (0.000001, 2.0),
-           random.nextf (0.000001, 2.0));
+    V3f s (
+        float(random.nextf (0.000001, 2.0)),
+        float(random.nextf (0.000001, 2.0)),
+        float(random.nextf (0.000001, 2.0)));
     for (int j = 0; j < 3; j++)
         if (random.nextf (0.0, 1.0) >= 0.5)
             sj *= -1;
@@ -124,9 +138,10 @@
     M.rotate (r);
 
     // Shear M.
-    V3f h (random.nextf (0.000001, 2.0),
-           random.nextf (0.000001, 2.0),
-           random.nextf (0.000001, 2.0));
+    V3f h (
+        float(random.nextf (0.000001, 2.0)),
+        float(random.nextf (0.000001, 2.0)),
+        float(random.nextf (0.000001, 2.0)));
 
     for (int j = 0; j < 3; j++)
         if (random.nextf (0.0, 1.0) >= 0.5)
@@ -140,7 +155,7 @@
     //
     for (int j = 0; j < 4; ++j)
         for (int k = 0; k < 3; ++k)
-            Mjk += random.nextf (-1e-7, 1e-7);
+            Mjk += float(random.nextf (-1e-7, 1e-7));
 
     V3f sh;
     extractSHRT (M, scale, sh, rot, trans);
@@ -156,7 +171,7 @@
 void
 compareMat (M44f& M, M44f& N)
 {
-    float eps = 0.0001;
+    float eps = 0.0001f;
 
     /// Verify that the entries in M and N do not
     // differ too much.

_service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testNoInterop.cpp Added

@@ -0,0 +1,78 @@
+//
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright Contributors to the OpenEXR Project.
+//
+
+#ifdef NDEBUG
+#    undef NDEBUG
+#endif
+
+#define IMATH_FOREIGN_VECTOR_INTEROP 0
+
+#include <ImathMatrix.h>
+#include <ImathVec.h>
+#include <cassert>
+#include <iostream>
+
+using namespace std;
+
+void
+testNoInterop ()
+{
+    cout << "Testing without interoperability with foreign types" << endl;
+
+    // Construction from a double-indexed array is handled by the
+    // interoperability constructors, unless theyre disabled, in which
+    // there are fallbacks for the simple types.
+    
+    {
+        const float a22 = {
+            { 1.0f, 0.0f },
+            { 0.0f, 1.0f }
+        };
+        IMATH_INTERNAL_NAMESPACE::M22f m(a);
+        assert (m00 == a00);
+        assert (m01 == a01);
+        assert (m10 == a10);
+        assert (m11 == a11);
+    }
+    
+    {
+        const float a33 = {
+            { 1.0f, 0.0f, 0.0f },
+            { 0.0f, 1.0f, 0.0f },
+            { 0.0f, 0.0f, 1.0f } 
+        };
+        IMATH_INTERNAL_NAMESPACE::M33f m(a);
+        assert (m00 == a00);
+        assert (m01 == a01);
+        assert (m02 == a02);
+        assert (m10 == a10);
+        assert (m11 == a11);
+        assert (m12 == a12);
+        assert (m20 == a20);
+        assert (m21 == a21);
+        assert (m22 == a22);
+    }
+    
+    {
+        const float a44 = {
+            { 1.0f, 0.0f, 0.0f, 0.0f },
+            { 0.0f, 1.0f, 0.0f, 0.0f },
+            { 0.0f, 0.0f, 1.0f, 0.0f },
+            { 0.0f, 0.0f, 0.0f, 1.0f } 
+        };
+        IMATH_INTERNAL_NAMESPACE::M44f m(a);
+        assert (m00 == a00);
+        assert (m01 == a01);
+        assert (m02 == a02);
+        assert (m10 == a10);
+        assert (m11 == a11);
+        assert (m12 == a12);
+        assert (m20 == a20);
+        assert (m21 == a21);
+        assert (m22 == a22);
+    }
+    
+    cout << "ok\n" << endl;
+}

_service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testNoInterop.h Added

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testProcrustes.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testProcrustes.cpp Changed

@@ -47,7 +47,7 @@
     const IMATH_INTERNAL_NAMESPACE::M44d m2 =
         procrustesRotationAndTranslation (&from0, &to0, numPoints);
 
-    const T eps = sizeof (T) == 8 ? 1e-8 : 1e-4;
+    const T eps = sizeof (T) == 8 ? T(1e-8) : T(1e-4);
     for (size_t i = 0; i < numPoints; ++i)
     {
         const IMATH_INTERNAL_NAMESPACE::V3d a  = fromi;
@@ -74,13 +74,16 @@
     std::vector<V3> from;
     std::vector<T> weights;
 
-    const float eps = 1e-4;
+    const float eps = 1e-4f;
     std::cout << "numPoints: " << std::flush;
     for (size_t numPoints = 1; numPoints < 10; ++numPoints)
     {
-        from.push_back (V3 (rand.nextf(), rand.nextf(), rand.nextf()));
-        weights.push_back (rand.nextf());
-        std::cout << from.size() << " ";
+        from.push_back (V3(
+            static_cast<T>(rand.nextf()),
+            static_cast<T>(rand.nextf()),
+            static_cast<T>(rand.nextf())));
+        weights.push_back(static_cast<T>(rand.nextf()));
+        std::cout << from.size () << " ";
 
         std::vector<V3> to;
         for (size_t i = 0; i < from.size(); ++i)
@@ -155,8 +158,8 @@
             assert (std::abs (m1ij - m2ij) < eps);
 
     // Now try the weighted version:
-    for (size_t i = 0; i < weights.size(); ++i)
-        weightsi = i + 1;
+    for (size_t i = 0; i < weights.size (); ++i)
+        weightsi = static_cast<T>(i + 1);
 
     IMATH_INTERNAL_NAMESPACE::M44d m =
         procrustesRotationAndTranslation (&from0, &to0, &weights0, n);
@@ -166,7 +169,7 @@
         procrustesRotationAndTranslation (&from0, &to0, &weights0, n, true);
 
     // Verify that it's orthonormal w/ positive determinant.
-    const T det = m.determinant();
+    const T det = static_cast<T>(m.determinant ());
     assert (std::abs (det - T (1)) < eps);
 
     // Verify orthonormal:
@@ -209,16 +212,16 @@
     }
 
     // Try a small scale:
-    IMATH_INTERNAL_NAMESPACE::M44d newMat = ms;
-    const double scaleDiff                = delta;
-    for (size_t i = 0; i < 3; ++i)
-        for (size_t j = 0; j < 3; ++j)
+    IMATH_INTERNAL_NAMESPACE::M44d newMat    = ms;
+    const double                   scaleDiff = delta;
+    for (int i = 0; i < 3; ++i)
+        for (int j = 0; j < 3; ++j)
             newMatij = msij * (1.0 + scaleDiff);
     assert (procrustesError (&from0, &to0, &weights0, n, newMat) >
             procrustesError (&from0, &to0, &weights0, n, ms));
 
-    for (size_t i = 0; i < 3; ++i)
-        for (size_t j = 0; j < 3; ++j)
+    for (int i = 0; i < 3; ++i)
+        for (int j = 0; j < 3; ++j)
             newMatij = msij * (1.0 - scaleDiff);
     assert (procrustesError (&from0, &to0, &weights0, n, newMat) >
             procrustesError (&from0, &to0, &weights0, n, ms));
@@ -230,8 +233,6 @@
     // there is zero net force and zero net torque.
     //
     {
-        IMATH_INTERNAL_NAMESPACE::V3d center (0, 0, 0);
-
         IMATH_INTERNAL_NAMESPACE::V3d netForce (0);
         IMATH_INTERNAL_NAMESPACE::V3d netTorque (0);
         for (size_t iPoint = 0; iPoint < n; ++iPoint)
@@ -342,10 +343,11 @@
     for (size_t i = 0; i < 4; ++i)
     {
         const T theta = T (2 * i) / T (M_PI);
-        fromPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3<T> (cos (theta), sin (theta), 0));
-        toPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3<T> (cos (theta + M_PI / 3.0),
-                                                               sin (theta + M_PI / 3.0),
-                                                               0));
+        const T offset = T(M_PI / 3.0);
+        fromPoints.push_back (
+            IMATH_INTERNAL_NAMESPACE::Vec3<T> (cos (theta), sin (theta), 0));
+        toPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3<T> (
+            cos (theta + offset), sin (theta + offset), 0));
     }
     verifyProcrustes (fromPoints, toPoints);
 
@@ -356,10 +358,14 @@
         toPoints.clear();
         for (size_t i = 0; i < numPoints; ++i)
         {
-            fromPoints.push_back (
-                IMATH_INTERNAL_NAMESPACE::Vec3<T> (random.nextf(), random.nextf(), random.nextf()));
-            toPoints.push_back (
-                IMATH_INTERNAL_NAMESPACE::Vec3<T> (random.nextf(), random.nextf(), random.nextf()));
+            fromPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3<T> (
+                static_cast<T>(random.nextf ()),
+                static_cast<T>(random.nextf ()),
+                static_cast<T>(random.nextf ())));
+            toPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3<T> (
+                static_cast<T>(random.nextf ()),
+                static_cast<T>(random.nextf ()),
+                static_cast<T>(random.nextf ())));
         }
     }
     verifyProcrustes (fromPoints, toPoints);
@@ -377,7 +383,7 @@
     m = m * rot.toMatrix44();
     testProcrustesWithMatrix<T> (m);
 
-    m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (1.5, 6.4, 2.0));
+    m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (T(1.5), T(6.4), T(2.0)));
     testProcrustesWithMatrix<T> (m);
 
     IMATH_INTERNAL_NAMESPACE::Eulerd rot2 (1.0, M_PI, M_PI / 3.0);
@@ -386,7 +392,7 @@
     m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (-1, 1, 1));
     testProcrustesWithMatrix<T> (m);
 
-    m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 0.001, 1));
+    m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, T(0.001), 1));
     testProcrustesWithMatrix<T> (m);
 
     m.scale (IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 1, 0));

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testQuat.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testQuat.cpp Changed

@@ -94,12 +94,12 @@
     //
 
     {
-	Quat<T> q;
-	q.setAxisAngle (Vec3<T> (0, 0, 1), M_PI_2);
-	Vec3<T> v = q.axis();
-	T a = q.angle();
-	assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
-	assert (IMATH_INTERNAL_NAMESPACE::equal (a, T (M_PI_2), e));
+        Quat<T> q;
+        q.setAxisAngle (Vec3<T> (0, 0, 1), T(M_PI_2));
+        Vec3<T> v = q.axis ();
+        T       a = q.angle ();
+        assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
+        assert (IMATH_INTERNAL_NAMESPACE::equal (a, T (M_PI_2), e));
     }
 
     //
@@ -108,39 +108,39 @@
     //
 
     {
-	T t = 10 * std::sqrt (s);
-
-	Quat<T> q;
-	q.setAxisAngle (Vec3<T> (0, 0, 1), t);
-	Vec3<T> v = q.axis();
-	T a = q.angle();
-	assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
-	assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
-
-	q.r *= 1.1;
-	q.v *= 1.1;
-	v = q.axis();
-	a = q.angle();
-	assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
-	assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
+        T t = 10 * std::sqrt (s);
+
+        Quat<T> q;
+        q.setAxisAngle (Vec3<T> (0, 0, 1), t);
+        Vec3<T> v = q.axis ();
+        T       a = q.angle ();
+        assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
+        assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
+
+        q.r *= T(1.1);
+        q.v *= T(1.1);
+        v = q.axis ();
+        a = q.angle ();
+        assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
+        assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
     }
 
     {
-	T t = 0.001 * std::sqrt (s);
-
-	Quat<T> q;
-	q.setAxisAngle (Vec3<T> (0, 0, 1), t);
-	Vec3<T> v = q.axis();
-	T a = q.angle();
-	assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
-	assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
-
-	q.r *= 1.1;
-	q.v *= 1.1;
-	v = q.axis();
-	a = q.angle();
-	assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
-	assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
+        T t = T(0.001) * std::sqrt (s);
+
+        Quat<T> q;
+        q.setAxisAngle (Vec3<T> (0, 0, 1), t);
+        Vec3<T> v = q.axis ();
+        T       a = q.angle ();
+        assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
+        assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
+
+        q.r *= T(1.1);
+        q.v *= T(1.1);
+        v = q.axis ();
+        a = q.angle ();
+        assert (v.equalWithAbsError (Vec3<T> (0, 0, 1), e));
+        assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e));
     }
 
     //

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testQuatSetRotation.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testQuatSetRotation.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testQuatSlerp.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testQuatSlerp.cpp Changed

@@ -93,7 +93,7 @@
 
         for (int n1 = 0; n1 < 4; ++n1)
         {
-            float angle1 = n1 * M_PI / 2;
+            float angle1 = n1 * float(M_PI / 2);
 
             Quatf q1;
             q1.setAxisAngle (axis1, angle1);
@@ -105,7 +105,7 @@
 
                 for (int n2 = 0; n2 < 4; ++n2)
                 {
-                    float angle2 = n2 * M_PI / 2;
+                    float angle2 = n2 * float(M_PI / 2);
 
                     Quatf q2;
                     q2.setAxisAngle (axis2, angle2);
@@ -133,10 +133,10 @@
 
     for (int i = 0; i < 10000; ++i)
     {
-        V3f axis1    = hollowSphereRand<V3f> (rand);
-        V3f axis2    = hollowSphereRand<V3f> (rand);
-        float angle1 = rand.nextf (0, M_PI);
-        float angle2 = rand.nextf (0, M_PI);
+        V3f   axis1  = hollowSphereRand<V3f> (rand);
+        V3f   axis2  = hollowSphereRand<V3f> (rand);
+        float angle1 = float(rand.nextf (0, M_PI));
+        float angle2 = float(rand.nextf (0, M_PI));
 
         Quatf q1, q2;
         q1.setAxisAngle (axis1, angle1);

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testRandom.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testRandom.cpp Changed

@@ -62,6 +62,38 @@
     assert (state2 == 0x306d);
 }
 
+void
+testDrand48 ()
+{
+    std::cout << "testDrand48()" << std::endl;
+    
+    //
+    // Confirm that drand48/lrand48 return the same values as
+    // erand48/nrand48 with the same seed.
+    //
+    
+    unsigned short state3;
+    state2 = 0;
+    state1 = 0;
+    state0 = 0x330e;
+
+    IMATH_INTERNAL_NAMESPACE::srand48(0);
+
+    double e = IMATH_INTERNAL_NAMESPACE::erand48(state);
+    double d = IMATH_INTERNAL_NAMESPACE::drand48();
+    assert (e == d);
+
+    state2 = 0;
+    state1 = 0;
+    state0 = 0x330e;
+
+    IMATH_INTERNAL_NAMESPACE::srand48(0);
+
+    long int n = IMATH_INTERNAL_NAMESPACE::nrand48(state);
+    long int l = IMATH_INTERNAL_NAMESPACE::lrand48();
+    assert (l == n);
+}
+
 template <class Rand>
 void
 testGenerator()
@@ -90,7 +122,7 @@
 
     for (int i = 0; i < M * N; ++i)
     {
-        float r    = rand.nextf (0.0, 1.0);
+        float r    = float(rand.nextf (0.0, 1.0));
         float diff = r - previous;
         previous   = r;
 
@@ -213,12 +245,19 @@
     cout << "erand48(), nrand48()" << endl;
     testErand48();
 
+    cout << "drand48(), lrand48()" << endl;
+    testDrand48 ();
+
     cout << "Rand32" << endl;
     testGenerator<IMATH_INTERNAL_NAMESPACE::Rand32>();
 
     cout << "Rand48" << endl;
     testGenerator<IMATH_INTERNAL_NAMESPACE::Rand48>();
 
+    cout << "Rand48" << endl;
+    testGenerator<IMATH_INTERNAL_NAMESPACE::Rand48> ();
+    
+    
     cout << "solidSphereRand()" << endl;
     testSolidSphere<IMATH_INTERNAL_NAMESPACE::Rand32>();

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testRoots.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testRoots.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/ImathTest/testTinySVD.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/ImathTest/testTinySVD.cpp Changed

@@ -262,75 +262,85 @@
     testTinySVD_3x3<T> (0, 0, 0, 0, 0, 0, 0, 0, 1);
     testTinySVD_3x3<T> (1, 0, 0, 0, 1, 0, 0, 0, 0);
     testTinySVD_3x3<T> (1, 0, 0, 0, 0, 0, 0, 0, 0);
-    testTinySVD_3x3<T> (1, 0, 0, 1e-10, 0, 0, 0, 0, 0);
-    testTinySVD_3x3<T> (1, 0, 0, 1e-10, 0, 0, 0, 0, 100000);
+    testTinySVD_3x3<T> (1, 0, 0, T(1e-10), 0, 0, 0, 0, 0);
+    testTinySVD_3x3<T> (1, 0, 0, T(1e-10), 0, 0, 0, 0, 100000);
     testTinySVD_3x3<T> (1, 2, 3, 4, 5, 6, 7, 8, 9);
     testTinySVD_3x3<T> (1, 2, 3, 4, 5, 6, 7, 8, 9);
-    testTinySVD_3x3<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3<T> (100, 1e-5, 0),
-                                      IMATH_INTERNAL_NAMESPACE::Vec3<T> (100, 1e-5, 0)));
-    testTinySVD_3x3<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1),
-                                      IMATH_INTERNAL_NAMESPACE::Vec3<T> (256, 300, 20)));
-    testTinySVD_3x3<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1),
-                                      IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1)) +
-                        outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 2, 3),
-                                      IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 2, 3)));
+    testTinySVD_3x3<T> (outerProduct (
+        IMATH_INTERNAL_NAMESPACE::Vec3<T> (100, T(1e-5), 0),
+        IMATH_INTERNAL_NAMESPACE::Vec3<T> (100, T(1e-5), 0)));
+    testTinySVD_3x3<T> (outerProduct (
+        IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1),
+        IMATH_INTERNAL_NAMESPACE::Vec3<T> (256, 300, 20)));
+    testTinySVD_3x3<T> (
+        outerProduct (
+            IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1),
+            IMATH_INTERNAL_NAMESPACE::Vec3<T> (245, 20, 1)) +
+        outerProduct (
+            IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 2, 3),
+            IMATH_INTERNAL_NAMESPACE::Vec3<T> (1, 2, 3)));
 
     // Some problematic matrices from SVDTest:
-    testTinySVD_3x3<T> (0.0023588321752040036,
-                        -0.0096558131480729038,
-                        0.0010959850449366493,
-                        0.0088671829608044754,
-                        0.0016771794267033666,
-                        -0.0043081475729438235,
-                        0.003976050440932701,
-                        0.0019880497026345716,
-                        0.0089576046614601966);
-    testTinySVD_3x3<T> (2.3588321752040035e-09,
-                        -9.6558131480729038e-09,
-                        1.0959850449366498e-09,
-                        8.8671829608044748e-09,
-                        1.6771794267033661e-09,
-                        -4.3081475729438225e-09,
-                        3.9760504409327016e-09,
-                        1.9880497026345722e-09,
-                        8.9576046614601957e-09);
-    testTinySVD_3x3<T> (-0.46673855799602715,
-                        0.67466260360310948,
-                        0.97646986796448998,
-                        -0.032460753747103721,
-                        0.046584527749418278,
-                        0.067431228641151142,
-                        -0.088885055229687815,
-                        0.1280389179308779,
-                        0.18532617511453064);
-    testTinySVD_3x3<T> (1e-8, 0, 0, 0, 1e-8, 0, 0, 0, 1e-8);
-    testTinySVD_3x3<T> (1, 0, 0, 0, .00036, 0, 1e-18, 0, .00018);
-    testTinySVD_3x3<T> (1.3, 0, 0, 0, .0003, 0, 1e-17, 0, 0);
-    testTinySVD_3x3<T> (1, 0, 0, 0, 1e-2, 0, 0, 0, 1e-2);
+    testTinySVD_3x3<T> (
+        T(0.0023588321752040036),
+        T(-0.0096558131480729038),
+        T(0.0010959850449366493),
+        T(0.0088671829608044754),
+        T(0.0016771794267033666),
+        T(-0.0043081475729438235),
+        T(0.003976050440932701),
+        T(0.0019880497026345716),
+        T(0.0089576046614601966));
+    testTinySVD_3x3<T> (
+        T(2.3588321752040035e-09),
+        T(-9.6558131480729038e-09),
+        T(1.0959850449366498e-09),
+        T(8.8671829608044748e-09),
+        T(1.6771794267033661e-09),
+        T(-4.3081475729438225e-09),
+        T(3.9760504409327016e-09),
+        T(1.9880497026345722e-09),
+        T(8.9576046614601957e-09));
+    testTinySVD_3x3<T> (
+        T(-0.46673855799602715),
+        T(0.67466260360310948),
+        T(0.97646986796448998),
+        T(-0.032460753747103721),
+        T(0.046584527749418278),
+        T(0.067431228641151142),
+        T(-0.088885055229687815),
+        T(0.1280389179308779),
+        T(0.18532617511453064));
+    testTinySVD_3x3<T> (T(1e-8), 0, 0, 0, T(1e-8), 0, 0, 0, T(1e-8));
+    testTinySVD_3x3<T> (1, 0, 0, 0, T(.00036), 0, T(1e-18), 0, T(.00018));
+    testTinySVD_3x3<T> (T(1.3), 0, 0, 0, T(.0003), 0, T(1e-17), 0, 0);
+    testTinySVD_3x3<T> (1, 0, 0, 0, T(1e-2), 0, 0, 0, T(1e-2));
     testTinySVD_3x3<T> (1, 0, 0, 0, 1, 0, 0, 0, 0);
-    testTinySVD_3x3<T> (1, 0, 0, 0, 1e-3, 0, 0, 0, 1e-6);
-    testTinySVD_3x3<T> (0.59588638570136332,
-                        -0.79761234126107794,
-                        -1,
-                        0.39194500425202045,
-                        0.91763115383440363,
-                        -0.341818175044664,
-                        -0.45056075218951946,
-                        -0.71259057727425101,
-                        0.47125008216720271);
-    testTinySVD_3x3<T> (4.38805348e-09,
-                        -2.53189691e-09,
-                        -4.65678607e-09,
-                        -3.23000099e-10,
-                        1.86370294e-10,
-                        3.42781192e-10,
-                        -4.61572824e-09,
-                        2.6632645e-09,
-                        4.89840346e-09);
+    testTinySVD_3x3<T> (1, 0, 0, 0, T(1e-3), 0, 0, 0, T(1e-6));
+    testTinySVD_3x3<T> (
+        T(0.59588638570136332),
+        T(-0.79761234126107794),
+        -1,
+        T(0.39194500425202045),
+        T(0.91763115383440363),
+        T(-0.341818175044664),
+        T(-0.45056075218951946),
+        T(-0.71259057727425101),
+        T(0.47125008216720271));
+    testTinySVD_3x3<T> (
+        T(4.38805348e-09),
+        T(-2.53189691e-09),
+        T(-4.65678607e-09),
+        T(-3.23000099e-10),
+        T(1.86370294e-10),
+        T(3.42781192e-10),
+        T(-4.61572824e-09),
+        T(2.6632645e-09),
+        T(4.89840346e-09));
     // problematic 2x2 one for lapack on suse (see below), padded with 0's
-    testTinySVD_3x3<T> (0, -1.00000003e-22, 0, 1.00000001e-07, 0, 0, 0, 0, 0);
+    testTinySVD_3x3<T> (0, T(-1.00000003e-22), 0, T(1.00000001e-07), 0, 0, 0, 0, 0);
     // problematic 2x2 one for lapack on suse (see below), padded with 0's and 1
-    testTinySVD_3x3<T> (0, -1.00000003e-22, 0, 1.00000001e-07, 0, 0, 0, 0, 1);
+    testTinySVD_3x3<T> (0, T(-1.00000003e-22), 0, T(1.00000001e-07), 0, 0, 0, 0, 1);
 
     // Now, 4x4 matrices:
     testTinySVD_4x4<T> (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
@@ -340,15 +350,36 @@
     testTinySVD_4x4<T> (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
     testTinySVD_4x4<T> (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
     testTinySVD_4x4<T> (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-    testTinySVD_4x4<T> (0, -1.00000003e-22, 0, 0, 00000001e-07, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-    testTinySVD_4x4<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4<T> (100, 1e-5, 0, 0),
-                                      IMATH_INTERNAL_NAMESPACE::Vec4<T> (100, 1e-5, 0, 0)));
-    testTinySVD_4x4<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4<T> (245, 20, 1, 0.5),
-                                      IMATH_INTERNAL_NAMESPACE::Vec4<T> (256, 300, 20, 10)));
-    testTinySVD_4x4<T> (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4<T> (245, 20, 1, 0.5),
-                                      IMATH_INTERNAL_NAMESPACE::Vec4<T> (256, 300, 20, 10)) +
-                        outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4<T> (30, 10, 10, 10),
-                                      IMATH_INTERNAL_NAMESPACE::Vec4<T> (1, 2, 3, 3)));
+    testTinySVD_4x4<T> (
+        0,
+        T(-1.00000003e-22),
+        0,
+        0,
+        T(00000001e-07),
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1);
+    testTinySVD_4x4<T> (outerProduct (
+        IMATH_INTERNAL_NAMESPACE::Vec4<T> (100, T(1e-5), 0, 0),
+        IMATH_INTERNAL_NAMESPACE::Vec4<T> (100, T(1e-5), 0, 0)));
+    testTinySVD_4x4<T> (outerProduct (
+        IMATH_INTERNAL_NAMESPACE::Vec4<T> (245, 20, 1, T(0.5)),
+        IMATH_INTERNAL_NAMESPACE::Vec4<T> (256, 300, 20, 10)));
+    testTinySVD_4x4<T> (
+        outerProduct (
+            IMATH_INTERNAL_NAMESPACE::Vec4<T> (245, 20, 1, T(0.5)),
+            IMATH_INTERNAL_NAMESPACE::Vec4<T> (256, 300, 20, 10)) +
+        outerProduct (
+            IMATH_INTERNAL_NAMESPACE::Vec4<T> (30, 10, 10, 10),
+            IMATH_INTERNAL_NAMESPACE::Vec4<T> (1, 2, 3, 3)));
 }
 
 void

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathAutovectorize.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathAutovectorize.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathBasicTypes.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathBasicTypes.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathBox.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathBox.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathBoxArrayImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathBoxArrayImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathBufferProtocol.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathBufferProtocol.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathBufferProtocol.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathBufferProtocol.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor3.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor3.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor3ArrayImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor3ArrayImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor4.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor4.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor4Array2DImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor4Array2DImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathColor4ArrayImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathColor4ArrayImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathDecorators.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathDecorators.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathEuler.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathEuler.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathEuler.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathEuler.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFixedArray.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFixedArray.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFixedArray2D.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFixedArray2D.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFixedMatrix.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFixedMatrix.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFixedVArray.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFixedVArray.cpp Changed

@@ -6,6 +6,7 @@
 // clang-format off
 
 
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <boost/python.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/any.hpp>
@@ -367,19 +368,19 @@
         for (size_t i = 0; i < sliceLength; ++i)
         {
             std::vector<T> &d =_ptrraw_ptr_index(start + i*step)*_stride;
-            if (data.len() != d.size())
+            if (data.len() != static_cast<Py_ssize_t>(d.size()))
                 throw std::invalid_argument("FixedVArray::setitem: length of data does not match length of array element");
 
             if (data.isMaskedReference())
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = dataj;
                 }
             }
             else
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = data.direct_index(j);
                 }
@@ -391,19 +392,19 @@
         for (size_t i = 0; i < sliceLength; ++i)
         {
             std::vector<T> &d =_ptr(start + i*step)*_stride;
-            if (data.len() != d.size())
+            if (data.len() != static_cast<Py_ssize_t>(d.size()))
                 throw std::invalid_argument("FixedVArray::setitem: length of data does not match length of array element");
 
             if (data.isMaskedReference())
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = dataj;
                 }
             }
             else
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = data.direct_index(j);
                 }
@@ -428,19 +429,19 @@
             // We don't need to actually look at 'mask' because
             // match_dimensions has already forced some expected condition.
             std::vector<T> &d =_ptrraw_ptr_index(i)*_stride;
-            if (data.len() != d.size())
+            if (data.len() != static_cast<Py_ssize_t>(d.size()))
                 throw std::invalid_argument("FixedVArray::setitem: length of data does not match length of array element");
 
             if (data.isMaskedReference())
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = dataj;
                 }
             }
             else
             {
-                for (size_t j = 0; j < data.len(); ++j)
+                for (Py_ssize_t j = 0; j < data.len(); ++j)
                 {
                     dj = data.direct_index(j);
                 }
@@ -454,19 +455,19 @@
             if (maski)
             {
                 std::vector<T> &d = _ptri*_stride;
-                if (data.len() != d.size())
+                if (data.len() != static_cast<Py_ssize_t>(d.size()))
                     throw std::invalid_argument("FixedVArray::setitem: length of data does not match length of array element");
 
                 if (data.isMaskedReference())
                 {
-                    for (size_t j = 0; j < data.len(); ++j)
+                    for (Py_ssize_t j = 0; j < data.len(); ++j)
                     {
                         dj = dataj;
                     }
                 }
                 else
                 {
-                    for (size_t j = 0; j < data.len(); ++j)
+                    for (Py_ssize_t j = 0; j < data.len(); ++j)
                     {
                         dj = data.direct_index(j);
                     }
@@ -623,7 +624,7 @@
     }
     
     int count = 0;
-    for (size_t i = 0; i < mask.len(); ++i)
+    for (Py_ssize_t i = 0; i < mask.len(); ++i)
     {
         if (maski) count += 1;
     }
@@ -633,7 +634,7 @@
     if (_a._indices)
     {
         size_t index = 0;
-        for (size_t i = 0; i < mask.len(); ++i)
+        for (Py_ssize_t i = 0; i < mask.len(); ++i)
         {
             if (maski)
             {
@@ -645,7 +646,7 @@
     else
     {
         size_t index = 0;
-        for (size_t i = 0; i < mask.len(); ++i)
+        for (Py_ssize_t i = 0; i < mask.len(); ++i)
         {
             if (maski)
             {
@@ -730,7 +731,7 @@
     extract_slice_indices(index,start,end,step,slicelength,_a._length);
         
     // we have a valid range of indices
-    if (size.len() != slicelength) {
+    if (size.len() != static_cast<Py_ssize_t>(slicelength)) {
         PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination");
         boost::python::throw_error_already_set();
     }
@@ -762,16 +763,16 @@
         throw std::invalid_argument("We don't support setting item masks for masked reference arrays.");
     }
 
-    size_t len = _a.match_dimension(mask);
+    Py_ssize_t len = _a.match_dimension(mask);
     if (size.len() == len)
     {
-        for (size_t i = 0; i < len; ++i)
+        for (Py_ssize_t i = 0; i < len; ++i)
             if (maski) _a._ptri*_a._stride.resize(sizei);
     }
     else
     {
-        size_t count = 0;
-        for (size_t i = 0; i < len; ++i)
+        Py_ssize_t count = 0;
+        for (Py_ssize_t i = 0; i < len; ++i)
             if (maski) count++;
 
         if (size.len() != count) {
@@ -779,7 +780,7 @@
         }
 
         Py_ssize_t sizeIndex = 0;
-        for (size_t i = 0; i < len; ++i)
+        for (Py_ssize_t i = 0; i < len; ++i)
         {
             if (maski)
             {

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFixedVArray.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFixedVArray.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFrustum.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFrustum.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFrustum.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFrustum.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathFun.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathFun.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathLine.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathLine.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathLine.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathLine.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathMatrix.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathMatrix.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathMatrix22.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathMatrix22.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathMatrix33.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathMatrix33.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathMatrix44.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathMatrix44.cpp Changed

@@ -8,6 +8,7 @@
 #define BOOST_PYTHON_MAX_ARITY 17
 
 #include <Python.h>
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <boost/python.hpp>
 #include <boost/python/make_constructor.hpp>
 #include <boost/format.hpp>
@@ -522,8 +523,7 @@
 setScaleSc44(Matrix44<T> &mat, const T &s)
 {
     MATH_EXC_ON;
-    Vec3<T> sVec(s, s, s);
-    return mat.setScale(sVec);
+    return mat.setScale(s);
 }
 
 template <class T>
@@ -558,8 +558,7 @@
 setShearV44(Matrix44<T> &mat, const Vec3<T> &sVec)
 {
     MATH_EXC_ON;
-    IMATH_NAMESPACE::Shear6<T> shear(sVec0, sVec1, sVec2, T (0), T (0), T (0));
-    return mat.setShear(shear);
+    return mat.setShear(sVec);
 }
 
 template <class T>
@@ -581,9 +580,8 @@
         s.x = extract<T>(t0);
         s.y = extract<T>(t1);
         s.z = extract<T>(t2);
-        Shear6<T> shear(s);
         
-        return mat.setShear(shear);
+        return mat.setShear(s);
     }
     else if(t.attr("__len__")() == 6)
     {
@@ -1187,7 +1185,7 @@
                      const FixedArray<T> &m, const FixedArray<T> &n, const FixedArray<T> &o, const FixedArray<T> &p)
 {
     MATH_EXC_ON;
-    size_t len = a.len();
+    Py_ssize_t len = a.len();
     if (!( a.len() == len && b.len() == len && c.len() == len && d.len() == len && 
             e.len() == len && f.len() == len && g.len() == len && h.len() == len && 
             i.len() == len && j.len() == len && k.len() == len && l.len() == len &&

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathPlane.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathPlane.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathPlane.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathPlane.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathQuat.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathQuat.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathQuat.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathQuat.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathRandom.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathRandom.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathRandom.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathRandom.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathShear.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathShear.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathShear.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathShear.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathUtil.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathUtil.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec2Impl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec2Impl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec3ArrayImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec3ArrayImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec3Impl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec3Impl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec4ArrayImpl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec4ArrayImpl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/PyImathVec4Impl.h -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/PyImathVec4Impl.h Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImath/imathmodule.cpp -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImath/imathmodule.cpp Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImathSpeedTest/pyImathSpeedTest.in -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathSpeedTest/pyImathSpeedTest.in Changed

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImathTest/CMakeLists.txt -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathTest/CMakeLists.txt Changed

_service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathTest/main.cpp Added

@@ -0,0 +1,2355 @@
+//
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright Contributors to the OpenEXR Project.
+//
+
+#ifdef NDEBUG
+#    undef NDEBUG
+#endif
+
+#include <boost/python.hpp>
+#include <boost/python/handle.hpp>
+#include <boost/python/object.hpp>
+#include <ImathMath.h>
+#include <PyImathBox.h>
+#include <PyImathColor.h>
+#include <PyImathEuler.h>
+#include <PyImathFrustum.h>
+#include <PyImathLine.h>
+#include <PyImathMatrix.h>
+#include <PyImathPlane.h>
+#include <PyImathQuat.h>
+#include <PyImathRandom.h>
+#include <PyImathVec.h>
+#include <PyImathShear.h>
+
+#include <testStringTable.h>
+
+using namespace boost::python;
+
+#define TEST(x) if (argc < 2 || !strcmp (argv1, #x)) x();
+
+PyObject *
+wrapTester (PyObject * /* self */, PyObject *args)
+{
+    try {
+        
+        char *type;
+        if (PyArg_ParseTuple (args, "s", &type))
+        {
+            std::string typeStr (type);
+
+            if (typeStr == "Box2i")
+                return PyImath::Box2i::wrap (Imath::Box2i (Imath::V2i (1, 2), 
+                                                           Imath::V2i (3, 4)));
+            else if (typeStr == "Box2f")
+                return PyImath::Box2f::wrap (Imath::Box2f (Imath::V2f (1.1f, 2.2f), 
+                                                           Imath::V2f (3.3f, 4.4f)));
+            else if (typeStr == "Box2d")
+                return PyImath::Box2d::wrap (Imath::Box2d (Imath::V2d (1.1, 2.2), 
+                                                           Imath::V2d (3.3, 4.4)));
+
+            if (typeStr == "Box3i")
+                return PyImath::Box3i::wrap (Imath::Box3i (Imath::V3i (1, 2, 3), 
+                                                           Imath::V3i (4, 5, 6)));
+            else if (typeStr == "Box3f")
+                return PyImath::Box3f::wrap (Imath::Box3f (Imath::V3f (1.1f, 2.2f, 3.3f), 
+                                                           Imath::V3f (4.4f, 5.5f, 6.6f)));
+            else if (typeStr == "Box3d")
+                return PyImath::Box3d::wrap (Imath::Box3d (Imath::V3d (1.1, 2.2, 3.3), 
+                                                           Imath::V3d (4.4, 5.5, 6.6)));
+
+            else if (typeStr == "Color3c")
+                return PyImath::Color3c::wrap (Imath::Color3c (1, 2, 3));
+            else if (typeStr == "Color3f")
+                return PyImath::Color3f::wrap (Imath::Color3f (1.1f, 2.2f, 3.3f));
+
+            else if (typeStr == "Color4c")
+                return PyImath::Color4c::wrap (Imath::Color4c (1, 2, 3, 4));
+            else if (typeStr == "Color4f")
+                return PyImath::Color4f::wrap (Imath::Color4f (1.1f, 2.2f, 3.3f, 4.4f));
+
+            else if (typeStr == "Eulerf")
+                return PyImath::Eulerf::wrap (Imath::Eulerf (Imath::V3f (1.1f, 2.2f, 3.3f), 
+                                                             Imath::Eulerf::XZY));
+            else if (typeStr == "Eulerd")
+                return PyImath::Eulerd::wrap (Imath::Eulerd (Imath::V3d (1.1f, 2.2f, 3.3f), 
+                                                             Imath::Eulerd::XZY));
+
+            else if (typeStr == "Frustumf")
+                return PyImath::Frustumf::wrap (Imath::Frustumf (1.1f, 2.2f, 3.3f,
+                                                                 4.4f, 5.5f, 6.6f));
+            else if (typeStr == "Frustumd")
+                return PyImath::Frustumd::wrap (Imath::Frustumd (1.1, 2.2, 3.3,
+                                                                 4.4, 5.5, 6.6));
+
+            else if (typeStr == "Line3f")
+                return PyImath::Line3f::wrap (Imath::Line3f (Imath::V3f (1.1f, 2.2f, 3.3f),
+                                                             Imath::V3f (4.4f, 5.5f, 6.6f)));
+            else if (typeStr == "Line3d")
+                return PyImath::Line3d::wrap (Imath::Line3d (Imath::V3d (1.1, 2.2, 3.3),
+                                                             Imath::V3d (4.4, 5.5, 6.6)));
+
+            else if (typeStr == "M33f")
+                return PyImath::M33f::wrap (Imath::M33f (1.1f, 2.2f, 3.3f,
+                                                         4.4f, 5.5f, 6.6f,
+                                                         7.7f, 8.8f, 9.9f));
+            else if (typeStr == "M33d")
+                return PyImath::M33d::wrap (Imath::M33d (1.1, 2.2, 3.3,
+                                                         4.4, 5.5, 6.6,
+                                                         7.7, 8.8, 9.9));
+
+            else if (typeStr == "M44f")
+                return PyImath::M44f::wrap (Imath::M44f (1.1f, 2.2f, 3.3f, 4.4f,
+                                                         5.5f, 6.6f, 7.7f, 8.8f, 
+                                                         9.9f, 10.10f, 11.11f, 12.12f,
+                                                         13.13f, 14.14f, 15.15f, 16.16f));
+            else if (typeStr == "M44d")
+                return PyImath::M44d::wrap (Imath::M44d (1.1, 2.2, 3.3, 4.4,
+                                                         5.5, 6.6, 7.7, 8.8, 
+                                                         9.9, 10.10, 11.11, 12.12,
+                                                         13.13, 14.14, 15.15, 16.16));
+
+            else if (typeStr == "Plane3f")
+                return PyImath::Plane3f::wrap (Imath::Plane3f (Imath::V3f (1.1f, 2.2f, 3.3f), 4.4f));
+            else if (typeStr == "Plane3d")
+                return PyImath::Plane3d::wrap (Imath::Plane3d (Imath::V3d (1.1, 2.2, 3.3), 4.4));
+
+            else if (typeStr == "Quatf")
+                return PyImath::Quatf::wrap (Imath::Quatf (1.1f, 2.2f, 3.3f, 4.4f));
+            else if (typeStr == "Quatd")
+                return PyImath::Quatd::wrap (Imath::Quatd (1.1, 2.2, 3.3, 4.4));
+
+            else if (typeStr == "Rand32")
+                return PyImath::Rand32::wrap (Imath::Rand32 ());
+            else if (typeStr == "Rand48")
+                return PyImath::Rand48::wrap (Imath::Rand48 ());
+
+            else if (typeStr == "Shear6f")
+                return PyImath::Shear6f::wrap (Imath::Shear6f (1.1f, 2.2f, 3.3f,
+                                                               4.4f, 5.5f, 6.6f));
+            else if (typeStr == "Shear6d")
+                return PyImath::Shear6d::wrap (Imath::Shear6d (1.1, 2.2, 3.3,
+                                                               4.4, 5.5, 6.6));
+
+            else if (typeStr == "V2i")
+                return PyImath::V2i::wrap (Imath::V2i (1, 2));
+            else if (typeStr == "V2f")
+                return PyImath::V2f::wrap (Imath::V2f (1.1f, 2.2f));
+            else if (typeStr == "V2d")
+                return PyImath::V2d::wrap (Imath::V2d (1.1, 2.2));
+
+            else if (typeStr == "V3i")
+                return PyImath::V3i::wrap (Imath::V3i (1, 2, 3));
+            else if (typeStr == "V3f")
+                return PyImath::V3f::wrap (Imath::V3f (1.1f, 2.2f, 3.3f));
+            else if (typeStr == "V3d")
+                return PyImath::V3d::wrap (Imath::V3d (1.1, 2.2, 3.3));
+        }
+        PyErr_Clear();
+
+        PyErr_SetString(PyExc_TypeError, "wrap testing failed");
+    }
+    catch (const boost::python::error_already_set& e)	\
+    {							\
+	return 0;					\
+    }							\
+    catch (...)						\
+    {							\
+	boost::python::handle_exception();		\
+	return 0;					\
+    }
+
+    return 0;
+}
+
+PyMethodDef methods =
+{
+    {"wrap", (PyCFunction) wrapTester, METH_VARARGS, ""}, {0, 0}
+};
+
+void
+initWrapTester ()
+{
+#if PY_MAJOR_VERSION >= 3
+    static struct PyModuleDef moduleDef =
+        {
+            PyModuleDef_HEAD_INIT,
+            "wrap",
+            "wrap module",
+            -1,
+            methods
+        };
+
+    PyObject* module   = PyModule_Create(&moduleDef);
+    assert (module != 0);
+    // I (jyost) don't know if there's a better way to do the following,
+    // but this works.  (I did look at the docs and try various things to
+    // see if I could find a better way, and this is what I landed on.)
+    auto sysModule     = PyImport_AddModule("sys");
+    auto sysModuleDict = PyModule_GetDict(sysModule);
+    auto modulesDict   = PyDict_GetItemString(sysModuleDict, "modules");
+    PyDict_SetItemString(modulesDict, moduleDef.m_name, module);
+#else
+    PyObject *module = Py_InitModule ("wrap", methods);
+    assert (module != 0);
+#endif
+}
+
+

_service:tar_scm:Imath-3.1.4.tar.gz/src/python/PyImathTest/pyImathTest.in -> _service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathTest/pyImathTest.in Changed

@@ -4929,7 +4929,7 @@
     print ("M22d")
     testM22x (M22d, V2d)
 
-#testList.append (('testM22',testM22))
+testList.append (('testM22',testM22))
 
 
 # -------------------------------------------------------------------------
@@ -6107,6 +6107,7 @@
     m.extractEulerXYZ(v)
     assert v.equalWithAbsError((0, 0, -a), v.baseTypeEpsilon())
 
+
     # Extract scale, shear, rotation, translation.
 
     s = Vec(1, 2, 3)
@@ -6326,6 +6327,12 @@
     m2 = M22d (m1)
     assert m200 == 0 and m201 == 1
 
+    m2 = M22f(42)
+    assert m200 == 42 and m201 == 42
+    
+    m2 = M22d(42)
+    assert m200 == 42 and m201 == 42
+    
     # The += operator
 
     m2 = Mat(0,1, 2,3)
@@ -6336,6 +6343,9 @@
     m2 += M22d (m1)
     assert m200 == 0 and m201 == 2
     
+    m2 += 1
+    assert m200 == 1 and m201 == 3
+    
     # The -= operator
 
     m2 = Mat(0,1, 2,3)
@@ -6346,6 +6356,9 @@
     m2 -= M22d (m1)
     assert m200 == 0 and m201 == 0
 
+    m2 -= 1
+    assert m200 == -1 and m201 == -1
+
     # The *= operator
 
     m2 = Mat(0,1, 2,3)
@@ -6358,6 +6371,15 @@
     assert m200 == 0*0 + 1*2
     assert m201 == 0*1 + 1*3
         
+    m2 *= 10
+    assert m200 == 20 and m201 == 30
+    
+    # The /= operator
+
+    m2.makeIdentity()
+    m2 /= 10
+    assert equalWithRelErrorScalar(m200, 1/10.0, 0.0001)
+        
     print ("ok")
     return
 
@@ -6374,6 +6396,12 @@
     m2 = M33d (m1)
     assert m200 == 0 and m201 == 1
 
+    m2 = M33f(42)
+    assert m200 == 42 and m201 == 42
+    
+    m2 = M33d(42)
+    assert m200 == 42 and m201 == 42
+    
     # The += operator
 
     m2 = Mat(0,1,2, 3,4,5, 6,7,8)
@@ -6384,6 +6412,9 @@
     m2 += M33d (m1)
     assert m200 == 0 and m201 == 2
     
+    m2 += 1
+    assert m200 == 1 and m201 == 3
+    
     # The -= operator
 
     m2 = Mat(0,1,2, 3,4,5, 6,7,8)
@@ -6394,6 +6425,9 @@
     m2 -= M33d (m1)
     assert m200 == 0 and m201 == 0
 
+    m2 -= 1
+    assert m200 == -1 and m201 == -1
+
     # The *= operator
 
     m2 = Mat(0,1,2, 3,4,5, 6,7,8)
@@ -6406,6 +6440,15 @@
     assert m200 == 0*0 + 1*3 + 2*6
     assert m201 == 0*1 + 1*4 + 2*7
         
+    m2 *= 10
+    assert m200 == (0*0 + 1*3 + 2*6)*10 and m201 == (0*1 + 1*4 + 2*7)*10
+    
+    # The /= operator
+
+    m2.makeIdentity()
+    m2 /= 10
+    assert equalWithRelErrorScalar(m200, 1/10.0, 0.0001)
+        
     print ("ok")
     return
 
@@ -6422,6 +6465,12 @@
     m2 = M44d (m1)
     assert m200 == 0 and m201 == 1 and m202 == 2
 
+    m2 = M44f(42)
+    assert m200 == 42 and m201 == 42
+    
+    m2 = M44d(42)
+    assert m200 == 42 and m201 == 42
+    
     # The += operator
 
     m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
@@ -6432,6 +6481,9 @@
     m2 += M44d (m1)
     assert m200 == 0 and m201 == 2
     
+    m2 += 1
+    assert m200 == 1 and m201 == 3
+
     # The -= operator
 
     m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
@@ -6442,6 +6494,9 @@
     m2 -= M44d (m1)
     assert m200 == 0 and m201 == 0
     
+    m2 -= 1
+    assert m200 == -1 and m201 == -1
+
     # The *= operator
 
     m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
@@ -6454,6 +6509,15 @@
     assert m200 == 0*0 + 1*4 + 2*8 + 3*12
     assert m201 == 0*1 + 1*5 + 2*9 + 3*13
                 
+    m2 *= 10
+    assert m200 == (0*0 + 1*4 + 2*8 + 3*12)*10 and m201 == (0*1 + 1*5 + 2*9 + 3*13)*10
+    
+    # The /= operator
+
+    m2.makeIdentity()
+    m2 /= 10
+    assert equalWithRelErrorScalar(m200, 1/10.0, 0.0001)
+        
     print ("ok")
     return
 
@@ -6483,7 +6547,7 @@
 def testMatConversions ():
 
     print ("M22f")
-#    testM22xConversions (M22f)
+    testM22xConversions (M22f)
     print ("M22d")
     testM22xConversions (M22d)
 
@@ -7938,6 +8002,12 @@
     assert p25.normal().equalWithAbsError(farPlaneN, farPlaneN.baseTypeEpsilon())
     assert equal(p25.distance(), farPlane, 2 * farPlaneN.baseTypeEpsilon())
 
+    m_near = f.nearPlane() - 0.1
+    m_far = f.farPlane() + 100
+    f.modifyNearAndFar(m_near, m_far)
+    assert equal(f.nearPlane(), m_near, 2 * farPlaneN.baseTypeEpsilon())
+    assert equal(f.farPlane(), m_far, 2 * farPlaneN.baseTypeEpsilon())
+
     # Fovy, aspect, projection matrix.
 
     nearPlane = 1
@@ -7961,6 +8031,9 @@
     assert m11 == F
     assert m22 == C
     assert m32 == D
+    # constructor w/ fov and aspect
+    g = Frustum(nearPlane, farPlane, f.fovx(), f.fovy(), f.aspect())
+    assert (g == f)
 
     # Window.
 
@@ -8010,7 +8083,17 @@
     p3dd = V3d (p3d)
     p2d = f.projectPointToScreen(p3dd)
     assert p2d.equalWithAbsError((s, t), p2d.baseTypeEpsilon())

_service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathTest/testStringTable.cpp Added

@@ -0,0 +1,125 @@
+//
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright Contributors to the OpenEXR Project.
+//
+
+#ifdef NDEBUG
+#    undef NDEBUG
+#endif
+
+#include <PyImathStringTable.h>
+#include <iostream>
+#include <assert.h>
+
+using namespace std;
+using namespace PyImath;
+
+namespace {
+
+void
+testString()
+{
+    StringTable st;
+
+    size_t size = st.size();
+    assert(size == 0);
+    assert(!st.hasString("foo"));
+
+    StringTableIndex index = st.intern("foo");
+    assert(index == st.lookup("foo"));
+    assert(st.lookup(index) == "foo");
+    assert(st.hasString("foo"));
+
+    size = st.size();
+    assert(size == 1);
+
+    bool thrown = false;
+    try {
+        index = st.lookup("bar");
+    } catch (std::exception &e) {
+        thrown = true;
+    }
+    assert (thrown);
+
+    thrown = false;
+    try {
+        std::string s = st.lookup(StringTableIndex(1));
+    } catch (std::exception &e) {
+        thrown = true;
+    }
+    assert (thrown);
+    
+    assert(!st.hasString("bar"));
+
+    index = st.intern("bar");
+    assert(index == st.lookup("bar"));
+    assert(st.lookup(index) == "bar");
+    assert(0 == st.lookup("foo").index());
+    assert(st.lookup(StringTableIndex(0)) == "foo");
+    assert(st.hasString("bar"));
+}
+
+void
+testWString()
+{
+    WStringTable st;
+
+    size_t size = st.size();
+    assert(size == 0);
+    assert(!st.hasString(L"foo"));
+
+    StringTableIndex index = st.intern(L"foo");
+    assert(index == st.lookup(L"foo"));
+    assert(st.lookup(index) == L"foo");
+    assert(st.hasString(L"foo"));
+
+    size = st.size();
+    assert(size == 1);
+
+    bool thrown = false;
+    try {
+        index = st.lookup(L"bar");
+    } catch (std::exception &e) {
+        thrown = true;
+    }
+    assert (thrown);
+
+    thrown = false;
+    try {
+        std::wstring s = st.lookup(StringTableIndex(1));
+    } catch (std::exception &e) {
+        thrown = true;
+    }
+    assert (thrown);
+    
+    assert(!st.hasString(L"bar"));
+
+    index = st.intern(L"bar");
+    assert(index == st.lookup(L"bar"));
+    assert(st.lookup(index) == L"bar");
+    assert(0 == st.lookup(L"foo").index());
+    assert(st.lookup(StringTableIndex(0)) == L"foo");
+    assert(st.hasString(L"bar"));
+}
+
+} // namespace
+
+
+void
+testStringTable()
+{
+    cout << "Testing string table:" << endl;
+    
+    try
+    {
+	testString();
+        testWString();
+    }
+    catch (const exception &e)
+    {
+	cerr << "Unexpected exception: " << e.what() << endl;
+	assert(false);
+    }
+
+    cout << "ok\n" << endl;
+}

_service:tar_scm:Imath-3.1.9.tar.gz/src/python/PyImathTest/testStringTable.h Added

Changes of Revision 3