pax_global_header00006660000000000000000000000064141246026360014516gustar00rootroot0000000000000052 comment=3eacdb46ed4e6dcdcbfb3b2f5eefa73f32e1b8a8 .circleci/000077500000000000000000000000001412460263600127155ustar00rootroot00000000000000.circleci/config.yml000066400000000000000000000075331412460263600147150ustar00rootroot00000000000000version: 2 jobs: build: docker: - image: quay.io/fenicsproject/dev-env:latest working_directory: /home/fenics/working steps: - run: name: Clone DOLFIN command: git lfs clone https://bitbucket.org/"${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}".git . - checkout - run: name: Install/update dependencies # Install with sudo as tests not run as superuser in circleci/python command: sudo pip3 install flake8 pytest pytest-xdist sphinx sphinx_rtd_theme --upgrade - run: name: Install FEniCS dependencies command: | DEP_BRANCH_NAME="master" UFL_DEP_BRANCH_NAME="main" # Master branch of UFL is now named main pip3 install git+https://github.com/FEniCS/fiat.git@"${DEP_BRANCH_NAME}" pip3 install git+https://github.com/FEniCS/ufl.git@"${UFL_DEP_BRANCH_NAME}" pip3 install git+https://bitbucket.org/fenics-project/dijitso.git@"${DEP_BRANCH_NAME}" pip3 install git+https://bitbucket.org/fenics-project/ffc.git@"${DEP_BRANCH_NAME}" - run: name: Flake8 checks on pybind11 Python code command: python3 -m flake8 --append-config=python/setup.cfg python/dolfin - run: name: Build DOLFIN C++ documentation command: cd doc && doxygen - run: name: Configure DOLFIN (C++) command: mkdir -p build && cd build && cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ../ - run: name: Build DOLFIN and install (C++) command: cd build && make -j2 install - run: name: Build and run C++ unit tests (serial) command: cd build && make -j2 unittests && ctest -R unittests - run: name: Build and run C++ regressions tests (serial) command: cd build && make -j2 demos && ctest -j2 -R demo -R serial - run: name: Run C++ regression tests (MPI) command: cd build && make -j2 demos && ctest -R demo -R mpi - run: name: Build Python interface command: | cd python pip3 -v install . --user - run: name: Build DOLFIN Python documentation command: cd python/doc && make html - persist_to_workspace: root: /home/fenics/working paths: - python/doc/build/html/ - run: name: Run Python unit tests (serial) command: python3 -m pytest -n 2 python/test/unit/ - run: name: Run Python unit tests (MPI) command: mpirun -n 3 python3 -m pytest python/test/unit/ - run: name: Generate Python demo (regression) programs command: python3 python/demo/generate-demo-files.py - run: name: Run Python regression tests (serial) command: python3 -m pytest -v -n2 python/demo/test.py - run: name: Run Python regression tests (MPI) command: python3 -m pytest -v python/demo/test.py --mpiexec=mpiexec --num-proc=3 pushdoc: docker: - image: circleci/python working_directory: /tmp steps: - attach_workspace: at: /tmp - run: name: Establish authenticity of fenicsproject.org command: mkdir ~/.ssh && echo "fenicsproject.org ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBFbD134YcxSNaHVyio0XPAvJYh8SF90xp/ARqfrbAwOmJaEPTl5CNXm6f3+Sy0k1QTp+j9WawiJON+4/FWQBTD4=" >> ~/.ssh/known_hosts - run: name: Push Python API doc to fenicsproject.org command: cd /tmp/python/doc/build/html && scp -r * docs@fenicsproject.org:/var/www/vhosts/fenicsproject.org/docs/dolfin/dev/python/ workflows: version: 2 build-and-pushdoc: jobs: - build - pushdoc: requires: - build filters: branches: only: - master AUTHORS000066400000000000000000000115731412460263600121410ustar00rootroot00000000000000Authors/contributors in alphabetical order: Ido Akkerman (-) Martin Sandve Alnæs (C) Fredrik Bengzon (-) Aslak Bergersen (C) Jan Blechta (C) Rolv Erlend Bredesen (C) Jed Brown (C) Solveig Bruvoll (C) Cécile Daversin-Catty (c) Jørgen S. Dokken (C) Niklas Ericsson (-) Patrick Farrell (C) Georgios Foufas (C) Tom Gustafsson (C) Joachim B Haga (C) Johan Hake (C) Jack S. Hale (C) Rasmus Hemph (-) David Heintz (-) Johan Hoffman (C) Par Ingelstrom (-) Anders E. Johansen (C) Johan Jansson (C) Niclas Jansson (C) Alexander Jarosch (C) Kristen Kaasbjerg (C) Benjamin Kehlet (C) Arve Knudsen (C) Karin Kraft (-) Aleksandra Krusper (-) Evan Lezar (C) Tianyi Li (C) Matthias Liertzer (C) Dag Lindbo (C) Glenn Terje Lines (C) Anders Logg (C) Nuno Lopes (C) Kent-Andre Mardal (C) Sigvald Marholm (C) Andreas Mark (-) Andre Massing (C) Lawrence Mitchell (C) Marco Morandini (C) Mikael Mortensen (C) Corrado Maurini (C) Pablo De Napoli (-) Harish Narayanan (C) Andreas Nilsson (-) Minh Do-Quang (-) Chris Richardson (C) Johannes Ring (C) Marie E. Rognes (C) John Rudge (-) Bartosz Sawicki (C) Nico Schlömer (C) Kristoffer Selim (C) Angelo Simone (C) Ola Skavhaug (C) Thomas Svedberg (-) Erik Svensson (C) Harald Svensson (-) Andy Terrel (C) Jim Tilander (C) Fredrik Valdmanis (C) Magnus Vikstrøm (C) Walter Villanueva (-) Shawn Walker (C) Garth N. Wells (C) Ilmar Wilbers (C) Cian Wilson (C) Ivan Yashchuk (C) Michele Zaffalon (C) Åsmund Ødegård (C) Kristian Ølgaard (C) (C) = copyright form signed (!) = missing copyright form! (-) = minor change, copyright form not signed Missing credits? Tell us and we will fix it. Send an email to fenics-dev@googlegroups.com CMakeLists.txt000066400000000000000000000747211412460263600136350ustar00rootroot00000000000000# Top level CMakeLists.txt file for DOLFIN # Require CMake 3.5 cmake_minimum_required(VERSION 3.5) #------------------------------------------------------------------------------ # Set project name and version number project(DOLFIN) set(DOLFIN_VERSION_RELEASE 0) set(DOLFIN_VERSION_MAJOR "2019") set(DOLFIN_VERSION_MINOR "2") set(DOLFIN_VERSION_MICRO "0") set(DOLFIN_VERSION "${DOLFIN_VERSION_MAJOR}.${DOLFIN_VERSION_MINOR}.${DOLFIN_VERSION_MICRO}") if (NOT DOLFIN_VERSION_RELEASE) set(DOLFIN_VERSION "${DOLFIN_VERSION}.dev0") endif() #------------------------------------------------------------------------------ # Require and use C++11 # Use C++11 set(CMAKE_CXX_STANDARD 11) # Require C++11 set(CMAKE_CXX_STANDARD_REQUIRED ON) # Do not enable compler-specific extensions set(CMAKE_CXX_EXTENSIONS OFF) #------------------------------------------------------------------------------ # Check compiler version # Check for GCC version - earlier versions have insuffcient C++11 # support, or bugs. if (CMAKE_COMPILER_IS_GNUCXX) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8.3) message(FATAL_ERROR "GCC version must be at least 4.8.3 (for sufficient C++11 support and to avoid some compiler bugs). You have version ${CMAKE_CXX_COMPILER_VERSION}") endif() endif() #------------------------------------------------------------------------------ # Get GIT changeset, if available # Check for git find_program(GIT_FOUND git) if (GIT_FOUND) # Get the commit hash of the working branch execute_process(COMMAND git rev-parse HEAD WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE GIT_COMMIT_HASH OUTPUT_STRIP_TRAILING_WHITESPACE ) else() set(GIT_COMMIT_HASH "unknown") endif() #------------------------------------------------------------------------------ # General configuration # Set CMake options, see `cmake --help-policy CMP000x` if (COMMAND cmake_policy) cmake_policy(SET CMP0003 NEW) cmake_policy(SET CMP0004 NEW) cmake_policy(SET CMP0042 NEW) endif() # Set location of our FindFoo.cmake modules set(DOLFIN_CMAKE_DIR "${DOLFIN_SOURCE_DIR}/cmake" CACHE INTERNAL "") set(CMAKE_MODULE_PATH "${DOLFIN_CMAKE_DIR}/modules") # Make sure CMake uses the correct DOLFINConfig.cmake for tests and demos set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${CMAKE_CURRENT_BINARY_DIR}/dolfin) #------------------------------------------------------------------------------ # Configurable options for how we want to build include(FeatureSummary) option(BUILD_SHARED_LIBS "Build DOLFIN with shared libraries." ON) option(CMAKE_USE_RELATIVE_PATHS "Use relative paths in makefiles and projects." OFF) option(DOLFIN_AUTO_DETECT_MPI "Detect MPI automatically (turn this off to use the MPI compiler wrappers directly via setting CXX, CXX, FC)." ON) option(DOLFIN_DEPRECATION_ERROR "Turn deprecation warnings into errors." OFF) option(DOLFIN_ENABLE_BENCHMARKS "Enable benchmark programs." OFF) option(DOLFIN_ENABLE_CODE_COVERAGE "Enable code coverage." OFF) option(DOLFIN_ENABLE_DOCS "Enable generation of documentation." ON) option(DOLFIN_SKIP_BUILD_TESTS "Skip build tests for testing usability of dependency packages." OFF) option(DOLFIN_WITH_LIBRARY_VERSION "Build with library version information." ON) option(DOLFIN_ENABLE_GEOMETRY_DEBUGGING "Enable geometry debugging (developers only; requires libcgal-dev and libcgal-qt5-dev)." OFF) add_feature_info(BUILD_SHARED_LIBS BUILD_SHARED_LIBS "Build DOLFIN with shared libraries.") add_feature_info(CMAKE_USE_RELATIVE_PATHS CMAKE_USE_RELATIVE_PATHS "Use relative paths in makefiles and projects.") add_feature_info(DOLFIN_AUTO_DETECT_MPI DOLFIN_AUTO_DETECT_MPI "Detect MPI automatically (turn this off to use the MPI compiler wrappers directly via setting CXX, CXX, FC).") add_feature_info(DOLFIN_ENABLE_CODE_COVERAGE DOLFIN_ENABLE_CODE_COVERAGE "Enable code coverage.") add_feature_info(DOLFIN_WITH_LIBRARY_VERSION DOLFIN_WITH_LIBRARY_VERSION "Build with library version information.") add_feature_info(DOLFIN_ENABLE_BENCHMARKS DOLFIN_ENABLE_BENCHMARKS "Enable benchmark programs.") add_feature_info(DOLFIN_ENABLE_DOCS DOLFIN_ENABLE_DOCS "Enable generation of documentation.") add_feature_info(DOLFIN_SKIP_BUILD_TESTS DOLFIN_SKIP_BUILD_TESTS "Skip build tests for testing usability of dependency packages.") add_feature_info(DOLFIN_DEPRECATION_ERROR DOLFIN_DEPRECATION_ERROR "Turn deprecation warnings into errors.") add_feature_info(DOLFIN_ENABLE_GEOMETRY_DEBUGGING DOLFIN_ENABLE_GEOMETRY_DEBUGGING "Enable geometry debugging.") # Add shared library paths so shared libs in non-system paths are found option(CMAKE_INSTALL_RPATH_USE_LINK_PATH "Add paths to linker search and installed rpath." ON) add_feature_info(CMAKE_INSTALL_RPATH_USE_LINK_PATH CMAKE_INSTALL_RPATH_USE_LINK_PATH "Add paths to linker search and installed rpath.") # Hande RPATH on OSX when not installing to a system directory, see # https://groups.google.com/d/msg/fenics-dev/KSCrob4M_1M/zsJwdN-SCAAJ # and https://cmake.org/Wiki/CMake_RPATH_handling#Always_full_RPATH. if (APPLE) # The RPATH to be used when installing, but only if it's not a # system directory SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir) IF("${isSystemDir}" STREQUAL "-1") SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") ENDIF("${isSystemDir}" STREQUAL "-1") endif() #------------------------------------------------------------------------------ # Enable or disable optional packages # List optional packages set(OPTIONAL_PACKAGES "") list(APPEND OPTIONAL_PACKAGES "MPI") list(APPEND OPTIONAL_PACKAGES "PETSc") list(APPEND OPTIONAL_PACKAGES "SLEPc") list(APPEND OPTIONAL_PACKAGES "Trilinos") list(APPEND OPTIONAL_PACKAGES "UMFPACK") list(APPEND OPTIONAL_PACKAGES "CHOLMOD") list(APPEND OPTIONAL_PACKAGES "SCOTCH") list(APPEND OPTIONAL_PACKAGES "ParMETIS") list(APPEND OPTIONAL_PACKAGES "SUNDIALS") list(APPEND OPTIONAL_PACKAGES "zlib") list(APPEND OPTIONAL_PACKAGES "HDF5") # Add options foreach (OPTIONAL_PACKAGE ${OPTIONAL_PACKAGES}) string(TOUPPER "DOLFIN_ENABLE_${OPTIONAL_PACKAGE}" OPTION_NAME) option(${OPTION_NAME} "Compile with support for ${OPTIONAL_PACKAGE}." ON) add_feature_info(${OPTION_NAME} ${OPTION_NAME} "Compile with support for ${OPTIONAL_PACKAGE}.") endforeach() #------------------------------------------------------------------------------ # Package-specific options # None at the moment #------------------------------------------------------------------------------ # Compiler flags # Default build type (can be overridden by user) if (NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build, options are: Debug Developer MinSizeRel Release RelWithDebInfo." FORCE) endif() # Check for some compiler flags include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG(-pipe HAVE_PIPE) if (HAVE_PIPE) set(DOLFIN_CXX_DEVELOPER_FLAGS "-pipe ${DOLFIN_CXX_DEVELOPER_FLAGS}") endif() # Add some strict compiler checks CHECK_CXX_COMPILER_FLAG("-Wall -Werror -pedantic" HAVE_PEDANTIC) if (HAVE_PEDANTIC) set(DOLFIN_CXX_DEVELOPER_FLAGS "-Wall -Werror -pedantic ${DOLFIN_CXX_DEVELOPER_FLAGS}") endif() # Debug flags CHECK_CXX_COMPILER_FLAG(-g HAVE_DEBUG) if (HAVE_DEBUG) set(DOLFIN_CXX_DEVELOPER_FLAGS "-g ${DOLFIN_CXX_DEVELOPER_FLAGS}") endif() CHECK_CXX_COMPILER_FLAG(-O2 HAVE_O2_OPTIMISATION) if (HAVE_O2_OPTIMISATION) set(DOLFIN_CXX_DEVELOPER_FLAGS "-O2 ${DOLFIN_CXX_DEVELOPER_FLAGS}") endif() # Set 'Developer' build type flags set(CMAKE_CXX_FLAGS_DEVELOPER "${DOLFIN_CXX_DEVELOPER_FLAGS}" CACHE STRING "Flags used by the compiler during development." FORCE) # Add flags for generating code coverage reports if (DOLFIN_ENABLE_CODE_COVERAGE AND CMAKE_COMPILER_IS_GNUCXX) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") endif() # Settings for Intel compilers if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") # Use -isystem incluse flag with Intel compiler set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ") # Stop spurious warnings from older Intel compilers if("${CMAKE_CXX_COMPILER_VERSION}" LESS "13") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd654,1125") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -wd654,1125") set(CMAKE_CXX_FLAGS_DEVELOPER "${CMAKE_CXX_FLAGS_DEVELOPER} -wd654,1125") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -wd654,1125") set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -wd654,1125") endif() endif() # Set system include flags to get around CMake bug on OSX with gcc See # http://public.kitware.com/Bug/print_bug_page.php?bug_id=10837 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ") endif() if (APPLE) set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ") set(CMAKE_CXX_FLAGS_DEVELOPER "${CMAKE_CXX_FLAGS_DEVELOPER} -Wno-long-long") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wno-long-long") set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wno-long-long") endif() #------------------------------------------------------------------------------ # Check for MPI # FIXME: Should be set CMake to use the MPI compiler wrappers? if (DOLFIN_ENABLE_MPI) if (DOLFIN_AUTO_DETECT_MPI) find_package(MPI) set_package_properties(MPI PROPERTIES TYPE OPTIONAL DESCRIPTION "Message Passing Interface (MPI)" PURPOSE "Enables DOLFIN to run in parallel with MPI") else() # Assume user has set MPI compiler wrappers (via CXX, etc or # CMAKE_CXX_COMPILER, etc) set(MPI_CXX_FOUND TRUE) set(MPI_C_FOUND TRUE) endif() endif() #------------------------------------------------------------------------------ # Run tests to find required packages # Check for Boost set(BOOST_ROOT $ENV{BOOST_DIR} $ENV{BOOST_HOME}) if (BOOST_ROOT) set(Boost_NO_SYSTEM_PATHS on) endif() # Prevent FindBoost.cmake from looking for system Boost{foo}.cmake # files set(Boost_NO_BOOST_CMAKE true) set(Boost_USE_MULTITHREADED $ENV{BOOST_USE_MULTITHREADED}) find_package(Boost 1.56 QUIET REQUIRED) # Boost public/private libraries to link to. # Note: These should all be private as they do not appear in the # DOLFIN public interface , but there is a linking issues with older # Boost or CMake. Ubuntu 16.04 requires linking DOLFIN programs with # filesystem, whereas Ubuntu 16.10 and macOS (Homebrew) do not. if (Boost_VERSION VERSION_LESS 106100) set(DOLFIN_BOOST_COMPONENTS_PUBLIC filesystem timer) set(DOLFIN_BOOST_COMPONENTS_PRIVATE program_options iostreams) else() set(DOLFIN_BOOST_COMPONENTS_PUBLIC timer) set(DOLFIN_BOOST_COMPONENTS_PRIVATE filesystem program_options iostreams) endif() # Find required Boost libraries find_package(Boost COMPONENTS ${DOLFIN_BOOST_COMPONENTS_PUBLIC} ${DOLFIN_BOOST_COMPONENTS_PRIVATE} REQUIRED) set_package_properties(Boost PROPERTIES TYPE REQUIRED DESCRIPTION "Boost C++ libraries" URL "http://www.boost.org") # Check for required package Eigen3 find_package(Eigen3 3.2.90 REQUIRED) set_package_properties(Eigen3 PROPERTIES TYPE REQUIRED DESCRIPTION "Lightweight C++ template library for linear algebra" URL "http://eigen.tuxfamily.org") #------------------------------------------------------------------------------ # Run tests to find optional packages # Is this still needed? find_package(PythonInterp 3) set_package_properties(PythonInterp PROPERTIES TYPE REQUIRED DESCRIPTION "Interactive high-level object-oriented language" URL "http://www.python.org") # Check for required package UFC find_package(UFC MODULE ${DOLFIN_VERSION_MAJOR}.${DOLFIN_VERSION_MINOR}) set_package_properties(UFC PROPERTIES TYPE REQUIRED DESCRIPTION "Unified language for form-compilers (part of FFC)" URL "https://bitbucket.org/fenics-project/ffc") # Check for PETSc and SLEPc set(PETSC_FOUND FALSE) set(SLEPC_FOUND FALSE) if (DOLFIN_ENABLE_PETSC) find_package(PETSc 3.7) set_package_properties(PETSc PROPERTIES TYPE OPTIONAL DESCRIPTION "Portable, Extensible Toolkit for Scientific Computation" URL "https://www.mcs.anl.gov/petsc/" PURPOSE "Enables the PETSc linear algebra backend") set(SLEPC_FOUND FALSE) if (PETSC_FOUND AND DOLFIN_ENABLE_SLEPC) find_package(SLEPc 3.7) set_package_properties(SLEPc PROPERTIES TYPE OPTIONAL DESCRIPTION "Scalable Library for Eigenvalue Problem Computations" URL "http://slepc.upv.es/") endif() endif() # Check for ParMETIS and SCOTCH if (DOLFIN_ENABLE_MPI AND MPI_C_FOUND) if (DOLFIN_ENABLE_PARMETIS) find_package(ParMETIS 4.0.2) set_package_properties(ParMETIS PROPERTIES TYPE OPTIONAL DESCRIPTION "Parallel Graph Partitioning and Fill-reducing Matrix Ordering" URL "http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview" PURPOSE "Enables parallel graph partitioning") endif() if (DOLFIN_ENABLE_SUNDIALS) find_package(SUNDIALS 3) set_package_properties(SUNDIALS PROPERTIES TYPE OPTIONAL DESCRIPTION "SUite of Nonlinear and DIfferential/ALgebraic Equation Solvers" URL "http://computation.llnl.gov/projects/sundials" PURPOSE "Provides robust time integrators and nonlinear solvers that can easily be incorporated into existing simulation codes.") endif() if (DOLFIN_ENABLE_SCOTCH) find_package(SCOTCH) set_package_properties(SCOTCH PROPERTIES TYPE OPTIONAL DESCRIPTION "Programs and libraries for graph, mesh and hypergraph partitioning" URL "https://www.labri.fr/perso/pelegrin/scotch" PURPOSE "Enables parallel graph partitioning") endif() endif() # Check for UMFPACK if (DOLFIN_ENABLE_UMFPACK) find_package(AMD QUIET) find_package(BLAS QUIET) set_package_properties(BLAS PROPERTIES TYPE OPTIONAL DESCRIPTION "Basic Linear Algebra Subprograms" URL "http://netlib.org/blas/") find_package(UMFPACK) set_package_properties(UMFPACK PROPERTIES TYPE OPTIONAL DESCRIPTION "Sparse LU factorization library" URL "http://faculty.cse.tamu.edu/davis/suitesparse.html") endif() # Check for CHOLMOD if (DOLFIN_ENABLE_CHOLMOD) find_package(CHOLMOD) set_package_properties(CHOLMOD PROPERTIES TYPE OPTIONAL DESCRIPTION "Sparse Cholesky factorization library for sparse matrices" URL "http://faculty.cse.tamu.edu/davis/suitesparse.html") endif() # Check for HDF5 if (DOLFIN_ENABLE_HDF5) if (NOT DEFINED ENV{HDF5_ROOT}) set(ENV{HDF5_ROOT} "$ENV{HDF5_DIR}") endif() set(HDF5_PREFER_PARALLEL FALSE) if (DOLFIN_ENABLE_MPI) set(HDF5_PREFER_PARALLEL TRUE) endif() find_package(HDF5 COMPONENTS C) set_package_properties(HDF5 PROPERTIES TYPE OPTIONAL DESCRIPTION "Hierarchical Data Format 5 (HDF5)" URL "https://www.hdfgroup.org/HDF5") endif() # Check for Trilinos and the requires Trilinos packages if (DOLFIN_ENABLE_TRILINOS) message(STATUS "Checking for Trilinos") find_package(Trilinos QUIET PATHS ${TRILINOS_DIR} ${Trilinos_DIR} $ENV{TRILINOS_DIR}) set(DOLFIN_TRILINOS_PACKAGES "Tpetra;Zoltan;MueLu;Amesos2;Ifpack2;Belos") if ("${Trilinos_VERSION}" VERSION_LESS "12.4.0") set(Trilinos_FOUND FALSE) message(STATUS "Unable to find Trilinos (>= 12.4.0)") endif() set_package_properties(Trilinos PROPERTIES TYPE OPTIONAL DESCRIPTION "Object-oriented framework for large-scale problems" URL "https://trilinos.org") # Check for required packages set(DOLFIN_TRILINOS_PACKAGES_FOUND false) if (Trilinos_FOUND) message(STATUS " Trilinos version ${Trilinos_VERSION} found. Checking for components") # Check that necessary packages are enabled set(DOLFIN_TRILINOS_PACKAGES_FOUND true) foreach (required_package ${DOLFIN_TRILINOS_PACKAGES}) # Search for required package in list of available packages list(FIND Trilinos_PACKAGE_LIST ${required_package} required_trilinos_package_index) if(required_trilinos_package_index EQUAL -1) set(required_trilinos_package_found false) else() set(required_trilinos_package_found true) endif() # Print whether or not package is found if (required_trilinos_package_found) message(STATUS " ${required_package} found") else() message(STATUS " Trilinos found, but required package ${required_package} not found. Trilinos will be disabled.") set(DOLFIN_TRILINOS_PACKAGES_FOUND false) break() endif() endforeach() # Add package libraries if all packages have been found if (DOLFIN_TRILINOS_PACKAGES_FOUND) message(STATUS " All necessary Trilinos components found. Trilinos will be enabled.") set(DOLFIN_TRILINOS_DEFINITIONS) # Loop over each package foreach (package ${DOLFIN_TRILINOS_PACKAGES}) # Loop over libs and get full path foreach (lib ${${package}_LIBRARIES}) find_library(TRILINOS_LIB_${lib} ${lib} PATHS ${${package}_LIBRARY_DIRS} NO_DEFAULT_PATH) # Also search the default paths find_library(TRILINOS_LIB_${lib} ${lib}) if (TRILINOS_LIB_${lib}) list(APPEND DOLFIN_TRILINOS_LIBRARIES ${TRILINOS_LIB_${lib}}) endif() endforeach() endforeach() # Remove duplicates list(REVERSE DOLFIN_TRILINOS_LIBRARIES) list(REMOVE_DUPLICATES DOLFIN_TRILINOS_LIBRARIES) list(REVERSE DOLFIN_TRILINOS_LIBRARIES) endif() else() message(STATUS "Trilinos could not be found") endif() endif() # Check for zlib if (DOLFIN_ENABLE_ZLIB) find_package(ZLIB) set_package_properties(ZLIB PROPERTIES TYPE OPTIONAL DESCRIPTION "Compression library" URL "http://www.zlib.net") endif() # Check for geometry debugging if (DOLFIN_ENABLE_GEOMETRY_DEBUGGING) message(STATUS "Enabling geometry debugging") find_package(CGAL REQUIRED) find_package(GMP REQUIRED) find_package(MPFR REQUIRED) if (NOT CGAL_FOUND) message(FATAL_ERROR "Unable to find package CGAL required for DOLFIN_ENABLE_GEOMETRY_DEBUGGING") endif() if (NOT GMP_FOUND) message(FATAL_ERROR "Unable to find package GMP required for DOLFIN_ENABLE_GEOMETRY_DEBUGGING") endif() if (NOT MPFR_FOUND) message(FATAL_ERROR "Unable to find package MPFR required for DOLFIN_ENABLE_GEOMETRY_DEBUGGING") endif() endif() #------------------------------------------------------------------------------ # Print summary of found and not found optional packages feature_summary(WHAT ALL) #------------------------------------------------------------------------------ # Installation of docstrings #install(DIRECTORY ${CMAKE_SOURCE_DIR}/site-packages/dolfin/docstrings # DESTINATION ${DOLFIN_INSTALL_PYTHON_MODULE_DIR}/dolfin # USE_SOURCE_PERMISSIONS) #------------------------------------------------------------------------------ # Installation of DOLFIN library # Append the library version information to the library target properties if (DOLFIN_WITH_LIBRARY_VERSION) string(REPLACE "+" "" DOLFIN_LIBRARY_VERSION ${DOLFIN_VERSION}) # This setting of SOVERSION assumes that any API change # will increment either the minor or major version number. set(DOLFIN_LIBRARY_PROPERTIES ${DOLFIN_LIBRARY_PROPERTIES} VERSION ${DOLFIN_LIBRARY_VERSION} SOVERSION ${DOLFIN_VERSION_MAJOR}.${DOLFIN_VERSION_MINOR} ) endif() include(GNUInstallDirs) # Set DOLFIN install sub-directories set(DOLFIN_BIN_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH "Binary installation directory.") set(DOLFIN_LIB_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Library installation directory.") set(DOLFIN_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE PATH "C/C++ header installation directory.") set(DOLFIN_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE PATH "pkg-config file installation directory.") set(DOLFIN_SHARE_DIR "${CMAKE_INSTALL_DATAROOTDIR}/dolfin" CACHE PATH "Shared data installation directory.") set(DOLFIN_MAN_DIR "${CMAKE_INSTALL_MANDIR}" CACHE PATH "Manual page installation directory.") set(DOLFIN_DOC_DIR "${CMAKE_INSTALL_DOCDIR}" CACHE PATH "DOLFIN Documentation directory.") set(DOLFIN_ETC_DIR "${CMAKE_INSTALL_SYSCONFDIR}" CACHE PATH "Configuration file directory.") # Add source directory add_subdirectory(dolfin) #------------------------------------------------------------------------------ # Installation of DOLFIN utilities set(DOLFIN_UTILITIES ${DOLFIN_SOURCE_DIR}/scripts/dolfin-convert/dolfin-convert ${DOLFIN_SOURCE_DIR}/scripts/dolfin-order/dolfin-order ${DOLFIN_SOURCE_DIR}/scripts/dolfin-plot/dolfin-plot) install(FILES ${DOLFIN_UTILITIES} DESTINATION ${DOLFIN_BIN_DIR} PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE COMPONENT RuntimeExecutables) #------------------------------------------------------------------------------ # Generate and install helper file dolfin.conf # FIXME: Can CMake provide the library path name variable? if (APPLE) set(OS_LIBRARY_PATH_NAME "DYLD_LIBRARY_PATH") else() set(OS_LIBRARY_PATH_NAME "LD_LIBRARY_PATH") endif() # FIXME: not cross-platform compatible # Create and install dolfin.conf file configure_file(${DOLFIN_CMAKE_DIR}/templates/dolfin.conf.in ${CMAKE_BINARY_DIR}/dolfin.conf @ONLY) install(FILES ${CMAKE_BINARY_DIR}/dolfin.conf DESTINATION ${DOLFIN_SHARE_DIR} COMPONENT Development) #------------------------------------------------------------------------------ # Generate and install helper scripts dolfin-version, fenics-version # FIXME: not cross-platform compatible # Create and install dolfin-version configure_file(${DOLFIN_CMAKE_DIR}/templates/dolfin-version.in ${CMAKE_BINARY_DIR}/dolfin-version @ONLY) install(FILES ${CMAKE_BINARY_DIR}/dolfin-version DESTINATION ${DOLFIN_BIN_DIR} PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE COMPONENT RuntimeExecutables) # Create and install fenics-version configure_file(${DOLFIN_CMAKE_DIR}/templates/fenics-version.in ${CMAKE_BINARY_DIR}/fenics-version @ONLY) install(FILES ${CMAKE_BINARY_DIR}/fenics-version DESTINATION ${DOLFIN_BIN_DIR} PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE COMPONENT RuntimeExecutables) #------------------------------------------------------------------------------ # Generate and install utility script dolfin-get-demos configure_file(${DOLFIN_CMAKE_DIR}/templates/dolfin-get-demos.in ${CMAKE_BINARY_DIR}/dolfin-get-demos @ONLY) install(FILES ${CMAKE_BINARY_DIR}/dolfin-get-demos DESTINATION ${DOLFIN_BIN_DIR} PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE COMPONENT RuntimeExecutables) #------------------------------------------------------------------------------ # Generate demo files from rst if (PYTHONINTERP_FOUND) message(STATUS "") message(STATUS "Generating demo source files from reStructuredText") message(STATUS "--------------------------------------------------") file(GLOB_RECURSE demo_rst_files "demo/*.py.rst" "demo/*.cpp.rst" "demo/*.ufl.rst") foreach(rst_file ${demo_rst_files}) execute_process(COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ./utils/pylit/pylit.py ${rst_file} WORKING_DIRECTORY ${DOLFIN_SOURCE_DIR}) #add_custom_command(TARGET demos_source PRE_BUILD # COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ./utils/pylit/pylit.py ${rst_file} # WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) endforeach() endif() #------------------------------------------------------------------------------ # Generate form files for tests, bench, demos and DOLFIN if not exists # FIXME: Generate files in Build directory instead, at least for # bench, demo and tests set(COPY_DEMO_TEST_DEMO_DATA FALSE) if (NOT EXISTS ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/Poisson.h) message(STATUS "") message(STATUS "Generating form files in demo, test and bench directories. May take some time...") message(STATUS "----------------------------------------------------------------------------------------") execute_process( COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ${DOLFIN_SOURCE_DIR}/cmake/scripts/generate-form-files.py WORKING_DIRECTORY ${DOLFIN_SOURCE_DIR} RESULT_VARIABLE FORM_GENERATION_RESULT OUTPUT_VARIABLE FORM_GENERATION_OUTPUT ERROR_VARIABLE FORM_GENERATION_OUTPUT ) if (FORM_GENERATION_RESULT) # Cleanup so download is triggered next time we run cmake if (EXISTS ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/Poisson.h) file(REMOVE ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/Poisson.h) endif() message(FATAL_ERROR "Generation of form files failed: \n${FORM_GENERATION_OUTPUT}") endif() set(COPY_DEMO_TEST_DEMO_DATA TRUE) endif() #------------------------------------------------------------------------------ # Generate CMakeLists.txt files for bench and demos if not existing # FIXME: Generate files in Build directory instead? # NOTE: We need to call this script after generate-formfiles if (NOT EXISTS ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/CMakeLists.txt) message(STATUS "") message(STATUS "Generating CMakeLists.txt files in demo, test and bench directories") message(STATUS "-------------------------------------------------------------------") execute_process( COMMAND ${PYTHON_EXECUTABLE} ${DOLFIN_SOURCE_DIR}/cmake/scripts/generate-cmakefiles.py WORKING_DIRECTORY ${DOLFIN_SOURCE_DIR} RESULT_VARIABLE CMAKE_GENERATION_RESULT OUTPUT_VARIABLE CMAKE_GENERATION_OUTPUT ERROR_VARIABLE CMAKE_GENERATION_OUTPUT ) if (CMAKE_GENERATION_RESULT) # Cleanup so FFC rebuild is triggered next time we run cmake if (EXISTS ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/CMakeLists.txt) file(REMOVE ${DOLFIN_SOURCE_DIR}/demo/documented/poisson/cpp/CMakeLists.txt) endif() message(FATAL_ERROR "Generation of CMakeLists.txt files failed: \n${CMAKE_GENERATION_OUTPUT}") endif() set(COPY_DEMO_TEST_DEMO_DATA TRUE) endif() #------------------------------------------------------------------------------ # Copy data in demo/bench/test direcories to the build directories # FIXME: We should probably just generate them directly in the build # directory... if (COPY_DEMO_TEST_DEMO_DATA) message(STATUS "") message(STATUS "Copying demo and test data to build directory.") message(STATUS "----------------------------------------------") execute_process( COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ${DOLFIN_SOURCE_DIR}/cmake/scripts/copy-test-demo-data.py ${CMAKE_CURRENT_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} RESULT_VARIABLE COPY_DEMO_DATA_RESULT OUTPUT_VARIABLE COPY_DEMO_DATA_OUTPUT ERROR_VARIABLE COPY_DEMO_DATA_OUTPUT) if (COPY_DEMO_DATA_RESULT) message(FATAL_ERROR "Copy demo data failed: \n${COPY_DEMO_DATA_OUTPUT}") endif() endif() #------------------------------------------------------------------------------ # Add demos and install demo source files and mesh files # Set make program if ("${CMAKE_GENERATOR}" STREQUAL "Unix Makefiles") set(MAKE_PROGRAM "$(MAKE)") else() set(MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}") endif() # Add taget to build .py demo files from Python rst input files, and # create a target to build source files from .cpp.rst and .py.rst # files (using pylit) if (PYTHONINTERP_FOUND) file(GLOB_RECURSE demo_rst_files "demo/*.py.rst" "demo/*.cpp.rst" "demo/*.ufl.rst") add_custom_target(demos_source) foreach(rst_file ${rst_files}) add_custom_command(TARGET demos_source PRE_BUILD COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ./utils/pylit/pylit.py ${rst_file} WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) endforeach() endif() # Install the demo source files install(DIRECTORY demo DESTINATION ${DOLFIN_SHARE_DIR} FILES_MATCHING PATTERN "CMakeLists.txt" PATTERN "*.cpp" PATTERN "*.ufl" PATTERN "*.h" PATTERN "*.py" PATTERN "*.xml*" PATTERN "*.off" PATTERN "CMakeFiles" EXCLUDE) # Install meshes (data directory) install(DIRECTORY data DESTINATION ${DOLFIN_SHARE_DIR}) #------------------------------------------------------------------------------ # Generate documentation #if (DOLFIN_ENABLE_DOCS) # if (NOT SPHINX_FOUND) # message(STATUS "Disabling generation of documentation because Sphinx is missing.") # else() # add_subdirectory(doc-old) # endif() #endif() #------------------------------------------------------------------------------ # Add tests and benchmarks enable_testing() # Add target "unittests", but do not add to default target add_subdirectory(test/unit/cpp EXCLUDE_FROM_ALL) # Add demo but do not add to default target set(CMAKE_MODULE_PATH "${DOLFIN_CMAKE_DIR}/modules") add_subdirectory(demo EXCLUDE_FROM_ALL) # Add target "copy_data_test_demo" add_custom_target(copy_data_test_demo COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" ${DOLFIN_SOURCE_DIR}/cmake/scripts/copy-test-demo-data.py ${CMAKE_CURRENT_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) # Add target "demos" for building the demos add_custom_target(demos COMMAND ${MAKE_PROGRAM} DEPENDS copy_data_test_demo demos_source WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/demo") #if (DOLFIN_ENABLE_BENCHMARKS) # # Add bench but do not add to default target # #add_subdirectory(bench EXCLUDE_FROM_ALL) # # # Add target "bench" for building benchmarks # #add_custom_target(bench # # COMMAND ${MAKE_PROGRAM} # # WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bench")0 # # # Copy files needed to run benchmarks in build directory # file(COPY bench DESTINATION ${CMAKE_CURRENT_BINARY_DIR} # FILES_MATCHING # PATTERN "*" # PATTERN "CMakeFiles" EXCLUDE) # # # Add target "run_bench" for running benchmarks # add_custom_target(run_bench # COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" "bench.py" # DEPENDS bench # WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bench") #endif() #if (DOLFIN_ENABLE_TESTING) # Add target "run_styletest" for running documentation tests #add_custom_target(run_styletest # COMMAND ${PYTHON_EXECUTABLE} "-B" "-u" "test_coding_style.py" # DEPENDS copy_data_test_demo # WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/test/codingstyle") # Create test_coding_style.py in build dir (depends on source path) #configure_file(${CMAKE_SOURCE_DIR}/test/codingstyle/test_coding_style.py.in # ${CMAKE_BINARY_DIR}/test/codingstyle/test_coding_style.py @ONLY) #endif() #------------------------------------------------------------------------------ # Add "make uninstall" target configure_file( "${DOLFIN_CMAKE_DIR}/templates/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") #------------------------------------------------------------------------------ # Print post-install message add_subdirectory(cmake/post-install) #------------------------------------------------------------------------------ COPYING000066400000000000000000001045131412460263600121210ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . COPYING.LESSER000066400000000000000000000167271412460263600131260ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. ChangeLog.rst000066400000000000000000002334211412460263600134500ustar00rootroot00000000000000Change log ========== 2019.2.0.dev0 ------------- - No changes yet. 2019.1.0 (2019-04-19) --------------------- - Support for shape calculus operations, see file: ``python/test/unit/fem/test_coordinatederivative.py`` - Support for PETSc and SLEPc 3.10. - Documented Python elastodynamics demo. - Various bug fixes, e.g. memory leaks, build issues. - Enhancements and additions to pybind11-based Python interface. 2018.1.0 (2018-06-14) --------------------- - Remove python2 support. - Remove SWIG (now use pybind11 for wrapping C++) - Rename ``mpi_comm_world()`` to ``MPI.comm_world``. - Removed ``from fenics import *``, use ``from dolfin import *`` - Rename ``ERROR``, ``CRITICAL`` etc. to ``LogLevel.ERROR``, ``LogLevel.CRITICAL``. 2017.2.0 (2017-12-05) --------------------- - Remove ``UnitQuadMesh`` and ``UnitHexMesh``. Now use ``UnitSquareMesh`` and ``UnitCubeMesh`` with cell type qualifiers. - Remove ``MeshEditor::open`` without cell type. Now you must explicitly specify CellType when opening a ``Mesh`` with ``MeshEditor``. - Rename ``Mesh::size_global`` to ``Mesh::num_entities_global``. - Remove ``Mesh::size``. Use ``Mesh::num_entities`` instead. - Improved mesh topology computation performance. - Remove excessive calls to MPI init. It may now be necessary in some cases to explicitly intialise MPI. - Improvements to sparsity pattern computation. - Addition of some interfaces using ``Eigen::Map/ref`` in addition to ``dolfin::Array(View)``. ``dolfin::Array(View)``interfaces will be removed in favour of Eigen interfaces in the next release. - Update pkg-config (dolfin.pc) file. - CMake modernisations, with more use of exported targets. - Add experimental pybind11 generated Python interface. Will replace the SWIG generated interface in the 2018.1 release. - Remove redundant SLEPc interfaces. Fixes issue `#908 `_. - Bump required Boost version to 1.55. - Remove PETScUserPreconditioner (was unused and untested). - Remove VTK plotting backend. Plotting is no longer available from the C++ interface. Basic plotting is available using ``matplotlib`` and ``x3dom`` backends via the ``plot()`` free function in the Python interface. Users are advised to move to e.g. Paraview for more demanding plotting needs. - Updates for ``ufc::finite_element::evaluate_vertex_values`` interface change. - Add new methods ``XDMFFile::write_checkpoint``, ``XDMFFile::read_checkpoint`` to write and read (checkpoint) functions. - Implement marking vertex and edge mesh functions by ``SubDomain::mark()`` using ``on_boundary`` flag. - Fix quadratic scaling in PETSc matrix allocation with global dofs; assembly with ``Real`` space now exhibits linear scaling in number of dofs. - Add assembly for quadrilateral and hexahedral meshes with CG and DG elements. - Updates for some demos and tests to show usage of quadrilateral and hexahedral meshes. - Deprecate ``CellSize`` (equivalent to ``2*Circumradius``) in favour of new ``CellDiameter``; add ``MinCellEdgeLength`` and ``MaxCellEdgeLength`` - Deprecate subclassing of ``Expression`` in Python; new Python class ``UserExpression`` introduced for user overloads - Deprecate ``VertexFunction``, ``EdgeFunction``, ``FaceFunction``, ``FacetFunction``, ``CellFunction``; use ``MeshFunction`` instead 2017.1.0 (2017-05-09) --------------------- - Refactor PETScLUSolver to use functionality from PETScKrylovSolver. Simplify interface for solving transposed systems. Fixes #815. - Switch default Python version to Python 3. Use `-DDOLFIN_USE_PYTHON3=off` to build with Python 2. - Remove redundant ``solve_transpose`` functions (use solve with bool argument instead) - Remove OpenMpAsssmebler - Remove MPI communicator as argument in GenericVector::init functions (communicator should be passed via constructor) - Remove ``Function::operator[+-*/]`` to prevent memory corruption problems (does not affect Python interface) - Fix XDMF3 output of time series. The default output method is now to assume that all functions have different meshes, and that the meshes change from time step to time step. Two parameters control the output, one limits each function to only one mesh for the whole time series, turn off the default on parameter ``rewrite_function_mesh`` to enable this. You can also make all functions share the same mesh and time series, which currently is better supported in Paraview than the alternative, turn on ``functions_share_mesh`` for this. These two parameters can also be combined in case all functions share the same mesh at all time steps. This creates minimal size files. - Add ``PETScSNESSolver`` and ``PETScTAOSolver`` constructor accepting both communicator and type - Expression("f[0]*f[1]", f=obj) notation now supported for non-scalar GenericFunction obj - Expression("f", f=obj) notation now supports obj of MeshFunction types (only cell based) - Fix MPI deadlock in case of instant compilation failure - Allow using ``Timer`` as context manager and add ``timed`` decorator to measure timings of functions and methods - Add ``NonlinearProblem::J_pc`` and support preconditioning matrix in ``NewtonSolver``, ``PETScSNESSolver`` and ``PETScTAOSolver`` 2016.2.0 [2016-11-30] --------------------- - Updates to XDMFFile interface, now fully supporting MeshFunction and MeshValueCollection with multiple named datasets in one file (useful for volume/boundary markers). Time series now only when a time is explicitly specified for each step. Full support for ASCII/XML XDMF. - Improved X3DOM support - Improved detection of UFC - Add CMake option `-DDOLFIN_USE_PYTHON3` to create a Python 3 build - Require CMake version 3.5 or higher - Add pylit to generate demo doc from rst - More careful checks of Dirichlet BC function spaces - Change definition of FunctionSpace::component() - Adaptive solving now works for tensor-valued unknowns - Improve logging of PETSc errors; details logged at level TRACE 2016.1.0 [2016-06-23] --------------------- - Remove support for 'uint'-valued MeshFunction (replaced by 'size_t') - Major performance improvements and simplifications of the XDMF IO. - Remove Zoltan graph partitioning interface - Add new algorithm for computing mesh entiites. Typical speed-up of two with gcc and four with clang. Reduced memory usage for meshes with irregularly numbered cells. - Remove STLMatrix, STLVector, MUMPSLUSolver and PastixLUSolver classes - Remove PETScPreconditioner::set_near_nullspace and add PETScMatrix::set_near_nullspace - Build system updates for VTK 7.0 - Remove XDMF from File interface. XDMF is XML based, and has many possibilities for file access, which are not accessible through the limited File interface and "<<" ">>" operators. Instead of File, use XDMFFile, and use XDMFFile.read() and XDMFFile.write() for I/O. Demos and tests have been updated to show usage. XDMF now also supports ASCII I/O in serial, useful for compatibility with users who do not have the HDF5 library available. - Require polynomial degree or finite element for Expressions in the Python interface (fixes Issue #355, https://bitbucket.org/fenics-project/dolfin/issues/355) - Switch to Google Test framwork for C++ unit tests - Fix bug when reading domain data from mesh file for a ghosted mesh - Add interface for manipulating mesh geometry using (higher-order) FE functions: free functions set_coordinates, get_coordinates, create_mesh - Fix bug when reading domain data from mesh file for a ghosted mesh. - Remove reference versions of constructors for many classes that store a pointer/reference to the object passed to the constructor. This is an intrusive interface change for C++ users, but necessary to improve code maintainabilty and to improve memory safety. The Python interface is (virtually) unaffected. - Remove class SubSpace. Using FunctionSpace::sub(...) instead - Remove reference versions constructors of NonlinearVariationalSolver - Remove setting of bounds from NonlinearVariationalSolver (was already available through NonlinearVariationalProblem) - Update Trilinos support to include Amesos2, and better support from Python - Rewrite interface of TensorLayout and SparsityPattern; local-to-global maps now handled using new IndexMap class; GenericSparsityPattern class removed - Remove QT (was an optional dependency) - PETScTAOSolver::solve() now returns a pair of number of iterations (std::size_t) and whether iteration converged (bool) - Better quality refinement in 2D in Plaza algorithm, by choosing refinement pattern based on max/min edge ratio - Removed refine_cell() method in CellTypes - Enable marker refinement to work in parallel for 1D meshes too - Add std::abort to Python exception hook to avoid parallel deadlocks - Extend dof_to_vertex_map with unowned dofs, thus making dof_to_vertex_map an inverse of vertex_to_dof_map - Clean-up in PyDOLFIN function space design, issue #576 - Deprecate MixedFunctionSpace and EnrichedFunctionSpace in favour of initialization by suitable UFL element - Add experimental matplotlib-based plotting backend, see mplot demo - Remove method argument of DirichletBC::get_boundary_values() - Change return types of free functions adapt() to shared_ptr 1.6.0 [2015-07-28] ------------------ - Remove redundant pressure boundary condition in Stokes demos - Require Point in RectangleMesh and BoxMesh constructors - Remove BinaryFile (TimeSeries now requires HDF5) - Add (highly experimental) support for Tpetra matrices and vectors from Trilinos, interfacing to Belos, Amesos2, IfPack2 and Muelu. - Enable (highly experimental) support for Quadrilateral and Hexahedral meshes, including some I/O, but no assembly yet. - Enable UMFPACK and CHOLMOD solvers with Eigen backend - Add an MPI_Comm to logger, currently defaulted to MPI_COMM_WORLD allowing better control over output in parallel - Experimental output of quadratic geometry in XDMF files, allows more exact visualisation of P2 Functions - Remove GenericMatrix::compressed (see Issue #61) - Deprecate and PETScKryloveSolver::set_nullspace() and add PETScMatrix::set_nullspace() - Remove uBLAS backend - Remove UmfpackLUSolver and CholmodSolver - Add EigenMatrix/Vector::data() - Remove GenericMatrix/Vector::data() and GenericMatrix/Vector::data() (to use backends that support data(), cast first to backend type, e.g. A = A.as_backend_type() - Remove cmake.local, replaced by fenics-install-component.sh - Make interior facet integrals define - and + cells ordered by cell_domains value. - Remove deprecated arguments *_domains from assemble() and Form(). - Change measure definition notation from dx[mesh_function] to dx(subdomain_data=mesh_function). - Set locale to "C" before reading from file - Change GenericDofMap::cell_dofs return type from const std::vector<..>& to ArrayView - Add ArrayView class for views into arrays - Change fall back linear algebra backend to Eigen - Add Eigen linear algebra backend - Remove deprecated GenericDofMap::geometric_dim function (fixes Issue #443) - Add quadrature rules for multimesh/cut-cell integration up to order 6 - Implement MPI reductions and XML ouput of Table class - list_timings() is now collective and returns MPI average across processes - Add dump_timings_to_xml() - Add enum TimingType { wall, user, system } for selecting wall-clock, user and system time in timing routines - Bump required SWIG version to 3.0.3 - Increase default maximum iterations in NewtonSolver to 50. - Deprecate Python free function homogenize(bc) in favour of member function DirichletBC::homogenize() 1.5.0 [2015-01-12] ------------------ - DG demos working in parallel - Simplify re-use of LU factorisations - CMake 3 compatibility - Make underlying SLEPc object accessible - Full support for linear algebra backends with 64-bit integers - Add smoothed aggregation AMG elasticity demo - Add support for slepc4py - Some self-assignment fixes in mesh data structures - Deprecated GenericDofMap::geometric_dimension() - Experimental support for ghosted meshes (overlapping region in parallel) - Significant memory reduction in dofmap storage - Re-write dofmap construction with significant performance and scaling improvements in parallel - Switch to local (process-wise) indexing for dof indices - Support local (process-wise) indexing in linear algerbra backends - Added support for PETSc 3.5, require version >= 3.3 - Exposed DofMap::tabulate_local_to_global_dofs, MeshEntity::sharing_processes in Python - Added GenericDofmap::local_dimension("all"|"owned"|"unowned") - Added access to SLEPc or slepc4py EPS object of SLEPcEigenSolver (requires slepc4py version >= 3.5.1) - LinearOperator can now be accessed using petsc4py - Add interface (PETScTAOSolver) for the PETSc nonlinear (bound-constrained) optimisation solver (TAO) - Add GenericMatrix::nnz() function to return number of nonzero entries in matrix (fixes #110) - Add smoothed aggregation algerbraic multigrid demo for elasticity - Add argument 'function' to project, to store the result into a preallocated function - Remove CGAL dependency and mesh generation, now provided by mshr - Python 2.7 required - Add experimental Python 3 support. Need swig version 3.0.3 or later - Move to py.test, speed up unit tests and make tests more robust in parallel - Repeated initialization of PETScMatrix is now an error - MPI interface change: num_processes -> size, process_number -> rank - Add optional argument project(..., function=f), to avoid superfluous allocation - Remove excessive printing of points during extrapolation - Clean up DG demos by dropping restrictions of Constants: c('+') -> c - Fix systemassembler warning when a and L both provide the same subdomain data. - Require mesh instead of cell argument to FacetArea, FacetNormal, CellSize, CellVolume, SpatialCoordinate, Circumradius, MinFacetEdgeLength, MaxFacetEdgeLength - Remove argument reset_sparsity to assemble() - Simplify assemble() and Form() signature: remove arguments mesh, coefficients, function_spaces, common_cell. These are now all found by inspecting the UFL form - Speed up assembly of forms with multiple integrals depending on different functions, e.g. f*dx(1) + g*dx(2). - Handle accessing of GenericVectors using numpy arrays in python layer instead of in hard-to-maintain C++ layer - Add support for mpi groups in jit-compilation - Make access to HDFAttributes more dict like - Add 1st and 2nd order Rush Larsen schemes for the PointIntegralSolver - Add vertex assembler for PointIntegrals - Add support for assembly of custom_integral - Add support for multimesh assembly, function spaces, dofmaps and functions - Fix to Cell-Point collision detection to prevent Points inside the mesh from falling between Cells due to rounding errors - Enable reordering of cells and vertices in parallel via SCOTCH and the Giibs-Poole-Stockmeyer algorithm - Efficiency improvements in dof assignment in parallel, working on HPC up to 24000 cores - Introduction of PlazaRefinement methods based on refinement of the Mesh skeleton, giving better quality refinement in 3D in parallel - Basic support for 'ghost cells' allowing integration over interior facets in parallel 1.4.0 [2014-06-02] ------------------ - Feature: Add set_diagonal (with GenericVector) to GenericMatrix - Fix many bugs associated with cell orientations on manifolds - Force all global dofs to be ordered last and to be on the last process in parallel - Speed up dof reordering of mixed space including global dofs by removing the latter from graph reordering - Force all dofs on a shared facet to be owned by the same process - Add FEniCS ('fenics') Python module, identical with DOLFIN Python module - Add function Form::set_some_coefficients() - Remove Boost.MPI dependency - Change GenericMatrix::compresss to return a new matrix (7be3a29) - Add function GenericTensor::empty() - Deprecate resizing of linear algebra via the GenericFoo interfaces (fixes #213) - Deprecate MPI::process_number() in favour of MPI::rank(MPI_Comm) - Use PETSc built-in reference counting to manage lifetime of wrapped PETSc objects - Remove random access function from MeshEntityIterator (fixes #178) - Add support for VTK 6 (fixes #149) - Use MPI communicator in interfaces. Permits the creation of distributed and local objects, e.g. Meshes. - Reduce memory usage and increase speed of mesh topology computation 1.3.0 [2014-01-07] ------------------ - Feature: Enable assignment of sparse MeshValueCollections to MeshFunctions - Feature: Add free function assign that is used for sub function assignment - Feature: Add class FunctionAssigner that cache dofs for sub function assignment - Fix runtime dependency on checking swig version - Deprecate DofMap member methods vertex_to_dof_map and dof_to_vertex_map - Add free functions: vertex_to_dof_map and dof_to_vertex_map, and correct the ordering of the map. - Introduce CompiledSubDomain a more robust version of compiled_subdomains, which is now deprecated - CMake now takes care of calling the correct generate-foo script if so needed. - Feature: Add new built-in computational geometry library (BoundingBoxTree) - Feature: Add support for setting name and label to an Expression when constructed - Feature: Add support for passing a scalar GenericFunction as default value to a CompiledExpression - Feature: Add support for distance queries for 3-D meshes - Feature: Add PointIntegralSolver, which uses the MultiStageSchemes to solve local ODEs at Vertices - Feature: Add RKSolver and MultiStageScheme for general time integral solvers - Feature: Add support for assigning a Function with linear combinations of Functions, which lives in the same FunctionSpace - Added Python wrapper for SystemAssembler - Added a demo using compiled_extension_module with separate source files - Fixes for NumPy 1.7 - Remove DOLFIN wrapper code (moved to FFC) - Add set_options_prefix to PETScKrylovSolver - Remove base class BoundarCondition - Set block size for PETScMatrix when available from TensorLayout - Add support to get block compressed format from STLMatrix - Add detection of block structures in the dofmap for vector equations - Expose PETSc GAMG parameters - Modify SystemAssembler to support separate assembly of A and b 1.2.0 [2013-03-24] ------------------ - Fixes bug where child/parent hierarchy in Python were destroyed - Add utility script dolfin-get-demos - MeshFunctions in python now support iterable protocol - Add timed VTK output for Mesh and MeshFunction in addtion to Functions - Expose ufc::dofmap::tabulate_entity_dofs to GenericDofMap interface - Expose ufc::dofmap::num_entity_dofs to GenericDofMap interface - Allow setting of row dof coordinates in preconditioners (only works with PETSc backed for now) - Expose more PETSc/ML parameters - Improve speed to tabulating coordinates in some DofMap functions - Feature: Add support for passing a Constant as default value to a CompiledExpression - Fix bug in dimension check for 1-D ALE - Remove some redundant graph code - Improvements in speed of parallel dual graph builder - Fix bug in XMDF output for cell-based Functions - Fixes for latest version of clang compiler - LocalSolver class added to efficiently solve cell-wise problems - New implementation of periodic boundary conditions. Now incorporated into the dofmap - Optional arguments to assemblers removed - SymmetricAssembler removed - Domains for assemblers can now only be attached to forms - SubMesh can now be constructed without a CellFunction argument, if the MeshDomain contains marked celldomains. - MeshDomains are propagated to a SubMesh during construction - Simplify generation of a MeshFunction from MeshDomains: No need to call mesh_function with mesh - Rename dolfin-config.cmake to DOLFINConfig.cmake - Use CMake to configure JIT compilation of extension modules - Feature: Add vertex_to_dof_map to DofMap, which map vertex indices to dolfin dofs - Feature: Add support for solving on m dimensional meshes embedded in n >= m dimensions 1.1.0 [2013-01-08] ------------------ - Add support for solving singular problems with Krylov solvers (PETSc only) - Add new typedef dolfin::la_index for consistent indexing with linear algebra backends. - Change default unsigned integer type to std::size_t - Add support to attaching operator null space to preconditioner (required for smoothed aggregation AMG) - Add basic interface to the PETSc AMG preconditioner - Make SCOTCH default graph partitioner (GNU-compatible free license, unlike ParMETIS) - Add scalable construction of mesh dual graph for mesh partitioning - Improve performance of mesh building in parallel - Add mesh output to SVG - Add support for Facet and cell markers to mesh converted from Diffpack - Add support for Facet and cell markers/attributes to mesh converted from Triangle - Change interface for auto-adaptive solvers: these now take the goal functional as a constructor argument - Add memory usage monitor: monitor_memory_usage() - Compare mesh hash in interpolate_vertex_values - Add hash() for Mesh and MeshTopology - Expose GenericVector::operator{+=,-=,+,-}(double) to Python - Add function Function::compute_vertex_values not needing a mesh argument - Add support for XDMF and HDF5 - Add new interface LinearOperator for matrix-free linear systems - Remove MTL4 linear algebra backend - Rename down_cast --> as_type in C++ / as_backend_type in Python - Remove KrylovMatrix interface - Remove quadrature classes - JIT compiled C++ code can now include a dolfin namespace - Expression string parsing now understand C++ namespace such as std::cosh - Fix bug in Expression so one can pass min, max - Fix bug in SystemAssembler, where mesh.init(D-1, D) was not called before assemble - Fix bug where the reference count of Py_None was not increased - Fix bug in reading TimeSeries of size smaller than 3 - Improve code design for Mesh FooIterators to avoid dubious down cast - Bug fix in destruction of PETSc user preconditioners - Add CellVolume(mesh) convenience wrapper to Python interface for UFL function - Fix bug in producing outward pointing normals of BoundaryMesh - Fix bug introduced by SWIG 2.0.5, where typemaps of templated typedefs are not handled correctly - Fix bug introduced by SWIG 2.0.5, which treated uint as Python long - Add check that sample points for TimeSeries are monotone - Fix handling of parameter "report" in Krylov solvers - Add new linear algebra backend "PETScCusp" for GPU-accelerated linear algebra - Add sparray method in the Python interface of GenericMatrix, requires scipy.sparse - Make methods that return a view of contiguous c-arrays, via a NumPy array, keep a reference from the object so it wont get out of scope - Add parameter: "use_petsc_signal_handler", which enables/disable PETSc system signals - Avoid unnecessary resize of result vector for A*b - MPI functionality for distributing values between neighbours - SystemAssembler now works in parallel with topological/geometric boundary search - New symmetric assembler with ability for stand-alone RHS assemble - Major speed-up of DirichletBC computation and mesh marking - Major speed-up of assembly of functions and expressions - Major speed-up of mesh topology computation - Add simple 2D and 3D mesh generation (via CGAL) - Add creation of mesh from triangulations of points (via CGAL) - Split the SWIG interface into six combined modules instead of one - Add has_foo to easy check what solver and preconditioners are available - Add convenience functions for listing available linear_algebra_backends - Change naming convention for cpp unit tests test.cpp -> Foo.cpp - Added cpp unit test for GenericVector::operator{-,+,*,/}= for all la backends - Add functionality for rotating meshes - Add mesh generation based on NETGEN constructive solid geometry - Generalize SparsityPattern and STLMatrix to support column-wise storage - Add interfaces to wrap PaStiX and MUMPS direct solvers - Add CoordinateMatrix class - Make STLMatrix work in parallel - Remove all tr1::tuple and use boost::tuple - Fix wrong link in Python quick reference. 1.0.0 [2011-12-07] ------------------ - Change return value of IntervalCell::facet_area() 0.0 --> 1.0. - Recompile all forms with FFC 1.0.0 - Fix for CGAL 3.9 on OS X - Improve docstrings for Box and Rectangle - Check number of dofs on local patch in extrapolation 1.0-rc2 [2011-11-28] -------------------- - Fix bug in 1D mesh refinement - Fix bug in handling of subdirectories for TimeSeries - Fix logic behind vector assignment, especially in parallel 1.0-rc1 [2011-11-21] -------------------- - 33 bugs fixed - Implement traversal of bounding box trees for all codimensions - Edit and improve all error messages - Added [un]equality operator to FunctionSpace - Remove batch compilation of Expression (Expressions) from Python interface - Added get_value to MeshValueCollection - Added assignment operator to MeshValueCollection 1.0-beta2 [2011-10-26] ---------------------- - Change search path of parameter file to ~/.fenics/dolfin_parameters.xml - Add functions Parameters::has_parameter, Parameters::has_parameter_set - Added option to store all connectivities in a mesh for TimeSeries (false by default) - Added option for gzip compressed binary files for TimeSeries - Propagate global parameters to Krylov and LU solvers - Fix OpenMp assemble of scalars - Make OpenMP assemble over sub domains work - DirichletBC.get_boundary_values, FunctionSpace.collapse now return a dict in Python - Changed name of has_la_backend to has_linear_algebra_backend - Added has_foo functions which can be used instead of the HAS_FOO defines - Less trict check on kwargs for compiled Expression - Add option to not right-justify tables - Rename summary --> list_timings - Add function list_linear_solver_methods - Add function list_lu_solver_methods - Add function list_krylov_solver_methods - Add function list_krylov_solver_preconditioners - Support subdomains in SystemAssembler (not for interior facet integrals) - Add option functionality apply("flush") to PETScMatrix - Add option finalize_tensor=true to assemble functions - Solver parameters can now be passed to solve - Remove deprecated function Variable::disp() - Remove deprecated function logging() - Add new class MeshValueCollection - Add new class MeshDomains replacing old storage of boundary markers as part of MeshData. The following names are no longer supported: - boundary_facet_cells - boundary_facet_numbers - boundary_indicators - material_indicators - cell_domains - interior_facet_domains - exterior_facet_domains - Rename XML tag --> - Rename SubMesh data "global_vertex_indices" --> "parent_vertex_indices" - Get XML input/output of boundary markers working again - Get FacetArea working again 1.0-beta [2011-08-11] --------------------- - Print percentage of non-zero entries when computing sparsity patterns - Use ufl.Real for Constant in Python interface - Add Dirichlet boundary condition argument to Python project function - Add remove functionality for parameter sets - Added out typemap for vector of shared_ptr objects - Fix typemap bug for list of shared_ptr objects - Support parallel XML vector io - Add support for gzipped XML output - Use pugixml for XML output - Move XML SAX parser to libxml2 SAX2 interface - Simplify XML io - Change interface for variational problems, class VariationalProblem removed - Add solve interface: solve(a == L), solve(F == 0) - Add new classes Linear/NonlinearVariationalProblem - Add new classes Linear/NonlinearVariationalSolver - Ad form class aliases ResidualForm and Jacobian form in wrapper code - Default argument to variables in Expression are passed as kwargs in the Python interface - Add has_openmp as utility function in Python interface - Add improved error reporting using dolfin_error - Use Boost to compute Legendre polynolials - Remove ode code - Handle parsing of unrecognized command-line parameters - All const std::vector& now return a read-only NumPy array - Make a robust macro for generating a NumPy array from data - Exposing low level fem functionality to Python, by adding a Cell -> ufc::cell typemap - Added ufl_cell as a method to Mesh in Python interface - Fix memory leak in Zoltan interface - Remove some 'new' for arrays in favour of std::vector - Added cell as an optional argument to Constant - Prevent the use of non contiguous NumPy arrays for most typemaps - Point can now be used to evaluate a Function or Expression in Python - Fixed dimension check for Function and Expression eval in Python - Fix compressed VTK output for tensors in 2D 0.9.11 [2011-05-16] ------------------- - Change license from LGPL v2.1 to LGPL v3 or later - Moved meshconverter to dolfin_utils - Add support for conversion of material markers for Gmsh meshes - Add support for point sources (class PointSource) - Rename logging --> set_log_active - Add parameter "clear_on_write" to TimeSeries - Add support for input/output of nested parameter sets - Check for dimensions in linear solvers - Add support for automated error control for variational problems - Add support for refinement of MeshFunctions after mesh refinement - Change order of test and trial spaces in Form constructors - Make SWIG version >= 2.0 a requirement - Recognize subdomain data in Assembler from both Form and Mesh - Add storage for subdomains (cell_domains etc) in Form class - Rename MeshData "boundary facet cells" --> "boundary_facet_cells" - Rename MeshData "boundary facet numbers" --> "boundary_facet_numbers" - Rename MeshData "boundary indicators" --> "boundary_indicators" - Rename MeshData "exterior facet domains" --> "exterior_facet_domains" - Updates for UFC 2.0.1 - Add FiniteElement::evaluate_basis_derivatives_all - Add support for VTK output of facet-based MeshFunctions - Change default log level from PROGRESS to INFO - Add copy functions to FiniteElement and DofMap - Simplify DofMap - Interpolate vector values when reading from time series 0.9.10 [2011-02-23] ------------------- - Updates for UFC 2.0.0 - Handle TimeSeries stored backward in time (automatic reversal) - Automatic storage of hierarchy during refinement - Remove directory/library 'main', merged into 'common' - dolfin_init --> init, dolfin_set_precision --> set_precision - Remove need for mesh argument to functional assembly when possible - Add function set_output_stream - Add operator () for evaluation at points for Function/Expression in C++ - Add abs() to GenericVector interface - Fix bug for local refinement of manifolds - Interface change: VariationalProblem now takes: a, L or F, (dF) - Map linear algebra objects to processes consistently with mesh partition - Lots of improvemenst to parallel assembly, dof maps and linear algebra - Add lists supported_elements and supported_elements_for_plotting in Python - Add script dolfin-plot for plotting meshes and elements from the command-line - Add support for plotting elements from Python - Add experimental OpenMP assembler - Thread-safe fixed in Function class - Make GenericFunction::eval thread-safe (Data class removed) - Optimize and speedup topology computation (mesh.init()) - Add function Mesh::clean() for cleaning out auxilliary topology data - Improve speed and accuracy of timers - Fix bug in 3D uniform mesh refinement - Add built-in meshes UnitTriangle and UnitTetrahedron - Only create output directories when they don't exist - Make it impossible to set the linear algebra backend to something illegal - Overload value_shape instead of dim for userdefined Python Expressions - Permit unset parameters - Search only for BLAS library (not cblas.h) 0.9.9 [2010-09-01] ------------------ - Change build system to CMake - Add named MeshFunctions: VertexFunction, EdgeFunction, FaceFunction, FacetFunction, CellFunction - Allow setting constant boundary conditions directly without using Constant - Allow setting boundary conditions based on string ("x[0] == 0.0") - Create missing directories if specified as part of file names - Allow re-use of preconditioners for most backends - Fixes for UMFPACK solver on some 32 bit machines - Provide access to more Hypre preconditioners via PETSc - Updates for SLEPc 3.1 - Improve and implement re-use of LU factorizations for all backends - Fix bug in refinement of MeshFunctions 0.9.8 [2010-07-01] ------------------ - Optimize and improve StabilityAnalysis. - Use own implementation of binary search in ODESolution (takes advantage of previous values as initial guess) - Improve reading ODESolution spanning multiple files - Dramatic speedup of progress bar (and algorithms using it) - Fix bug in writing meshes embedded higher dimensions to M-files - Zero vector in uBLASVector::resize() to fix spurious bug in Krylov solver - Handle named fields (u.rename()) in VTK output - Bug fix in computation of FacetArea for tetrahedrons - Add support for direct plotting of Dirichlet boundary conditions: plot(bc) - Updates for PETSc 3.1 - Add relaxation parameter to NewtonSolver - Implement collapse of renumbered dof maps (serial and parallel) - Simplification of DofMapBuilder for parallel dof maps - Improve and simplify DofMap - Add Armadillo dependency for dense linear algebra - Remove LAPACKFoo wrappers - Add abstract base class GenericDofMap - Zero small values in VTK output to avoid VTK crashes - Handle MeshFunction/markers in homogenize bc - Make preconditioner selectable in VariationalProblem (new parameter) - Read/write meshes in binary format - Add parameter "use_ident" in DirichletBC - Issue error by default when solvers don't converge (parameter "error_on_convergence") - Add option to print matrix/vector for a VariationalProblem - Trilinos backend now works in parallel - Remove Mesh refine members functions. Use free refine(...) functions instead - Remove AdapativeObjects - Add Stokes demo using the MINI element - Interface change: operator+ now used to denote enriched function spaces - Interface change: operator+ --> operator* for mixed elements - Add option 'allow_extrapolation' useful when interpolating to refined meshes - Add SpatialCoordinates demo - Add functionality for accessing time series sample times: vector_times(), mesh_times() - Add functionality for snapping mesh to curved boundaries during refinement - Add functionality for smoothing the boundary of a mesh - Speedup assembly over exterior facets by not using BoundaryMesh - Mesh refinement improvements, remove unecessary copying in Python interface - Clean PETSc and Epetra Krylov solvers - Add separate preconditioner classes for PETSc and Epetra solvers - Add function ident_zeros for inserting one on diagonal for zero rows - Add LU support for Trilinos interface 0.9.7 [2010-02-17] ------------------ - Add support for specifying facet orientation in assembly over interior facets - Allow user to choose which LU package PETScLUSolver uses - Add computation of intersection between arbitrary mesh entities - Random access to MeshEntitiyIterators - Modify SWIG flags to prevent leak when using SWIG director feature - Fix memory leak in std::vector typemaps - Add interface for SCOTCH for parallel mesh partitioning - Bug fix in SubDomain::mark, fixes bug in DirichletBC based on SubDomain::inside - Improvements in time series class, recognizing old stored values - Add FacetCell class useful in algorithms iterating over boundary facets - Rename reconstruct --> extrapolate - Remove GTS dependency 0.9.6 [2010-02-03] ------------------ - Simplify access to form compiler parameters, now integrated with global parameters - Add DofMap member function to return set of dofs - Fix memory leak in the LA interface - Do not import cos, sin, exp from NumPy to avoid clash with UFL functions - Fix bug in MTL4Vector assignment - Remove sandbox (moved to separate repository) - Remove matrix factory (dolfin/mf) - Update .ufl files for changes in UFL - Added swig/import/foo.i for easy type importing from dolfin modules - Allow optional argument cell when creating Expression - Change name of Expression argument cpparg --> cppcode - Add simple constructor (dim0, dim1) for C++ matrix Expressions - Add example demonstrating the use of cpparg (C++ code in Python) - Add least squares solver for dense systems (wrapper for DGELS) - New linear algebra wrappers for LAPACK matrices and vectors - Experimental support for reconstruction of higher order functions - Modified interface for eval() and inside() in C++ using Array - Introduce new Array class for simplified wrapping of arrays in SWIG - Improved functionality for intersection detection - Re-implementation of intersection detection using CGAL 0.9.5 [2009-12-03] ------------------ - Set appropriate parameters for symmetric eigenvalue problems with SLEPc - Fix for performance regression in recent uBLAS releases - Simplify Expression interface: f = Expression("sin(x[0])") - Simplify Constant interface: c = Constant(1.0) - Fix bug in periodic boundary conditions - Add simple script dolfin-tetgen for generating DOLFIN XML meshes from STL - Make XML parser append/overwrite parameter set when reading parameters from file - Refinement of function spaces and automatic interpolation of member functions - Allow setting global parameters for Krylov solver - Fix handling of Constants in Python interface to avoid repeated JIT compilation - Allow simple specification of subdomains in Python without needing to subclass SubDomain - Add function homogenize() for simple creation of homogeneous BCs from given BCs - Add copy constructor and possibility to change value for DirichletBC - Add simple wrapper for ufl.cell.n. FacetNormal(mesh) now works again in Python. - Support apply(A), apply(b) and apply(b, x) in PeriodicBC - Enable setting spectral transformation for SLEPc eigenvalue solver 0.9.4 [2009-10-12] ------------------ - Remove set, get and operator() methods from MeshFunction - Added const and none const T &operator[uint/MeshEntity] to MeshFunction - More clean up in SWIG interface files, remove global renames and ignores - Update Python interface to Expression, with extended tests for value ranks - Removed DiscreteFunction class - Require value_shape and geometric_dimension in Expression - Introduce new class Expression replacing user-defined Functions - interpolate_vertex_values --> compute_vertex_values - std::map replaces generated CoefficientSet code - Cleanup logic in Function class as a result of new Expression class - Introduce new Coefficient base class for form coefficients - Replace CellSize::min,max by Mesh::hmin,hmax - Use MUMPS instead of UMFPACK as default direct solver in both serial and parallel - Fix bug in SystemAssembler - Remove support for PETSc 2.3 and support PETSc 3.0.0 only - Remove FacetNormal Function. Use UFL facet normal instead. - Add update() function to FunctionSpace and DofMap for use in adaptive mesh refinement - Require mesh in constructor of functionals (C++) or argument to assemble (Python) 0.9.3 [2009-09-25] ------------------ - Add global parameter "ffc_representation" for form representation in FFC JIT compiler - Make norm() function handle both vectors and functions in Python - Speedup periodic boundary conditions and make work for mixed (vector-valued) elements - Add possibilities to use any number numpy array when assigning matrices and vectors - Add possibilities to use any integer numpy array for indices in matrices and vectors - Fix for int typemaps in PyDOLFIN - Split mult into mult and transpmult - Filter out PETSc argument when parsing command-line parameters - Extend comments to SWIG interface files - Add copyright statements to SWIG interface files (not finished yet) - Add typemaps for misc std::vector in PyDOLFIN - Remove dependencies on std_vector.i reducing SWIG wrapper code size - Use relative %includes in dolfin.i - Changed names on SWIG interface files dolfin_foo.i -> foo.i - Add function interpolate() in Python interface - Fix typmaps for uint in python 2.6 - Use TypeError instead of ValueError in typechecks in typmaps.i - Add in/out shared_ptr typemaps for PyDOLFIN - Fix JIT compiling in parallel - Add a compile_extension_module function in PyDOLFIN - Fix bug in Python vector assignment - Add support for compressed base64 encoded VTK files (using zlib) - Add support for base64 encoded VTK files - Experimental support for parallel assembly and solve - Bug fix in project() function, update to UFL syntax - Remove disp() functions and replace by info(foo, true) - Add fem unit test (Python) - Clean up SystemAssembler - Enable assemble_system through PyDOLFIN - Add 'norm' to GenericMatrix - Efficiency improvements in NewtonSolver - Rename NewtonSolver::get_iteration() to NewtonSolver::iteration() - Improvements to EpetraKrylovSolver::solve - Add constructor Vector::Vector(const GenericVector& x) - Remove SCons deprecation warnings - Memory leak fix in PETScKrylovSolver - Rename dolfin_assert -> assert and use C++ version - Fix debug/optimise flags - Remove AvgMeshSize, InvMeshSize, InvFacetArea from SpecialFunctions - Rename MeshSize -> CellSize - Rewrite parameter system with improved support for command-line parsing, localization of parameters (per class) and usability from Python - Remove OutflowFacet from SpecialFunctions - Rename interpolate(double*) --> interpolate_vertex_values(double*) - Add Python version of Cahn-Hilliard demo - Fix bug in assemble.py - Permit interpolation of functions between non-matching meshes - Remove Function::Function(std::string filename) - Transition to new XML io - Remove GenericSparsityPattern::sort - Require sorted/unsorted parameter in SparsityPattern constructor - Improve performance of SparsityPattern::insert - Replace enums with strings for linear algebra and built-in meshes - Allow direct access to Constant value - Initialize entities in MeshEntity constructor automatically and check range - Add unit tests to the memorycheck - Add call to clean up libxml2 parser at exit - Remove unecessary arguments in DofMap member functions - Remove reference constructors from DofMap, FiniteElement and FunctionSpace - Use a shared_ptr to store the mesh in DofMap objects - Interface change for wrapper code: PoissonBilinearForm --> Poisson::BilinearForm - Add function info_underline() for writing underlined messages - Rename message() --> info() for "compatibility" with Python logging module - Add elementwise multiplication in GeneriVector interface - GenericVector interface in PyDOLFIN now support the sequence protocol - Rename of camelCaps functions names: fooBar --> foo_bar Note: mesh.numVertices() --> mesh.num_vertices(), mesh.numCells() --> mesh.num_cells() - Add slicing capabilities for GenericMatrix interface in PyDOLFIN (only getitem) - Add slicing capabilities for GenericVector interface in PyDOLFIN - Add sum to GenericVector interface 0.9.2 [2009-04-07] ------------------ - Enable setting parameters for Newton solver in VariationalProblem - Simplified and improved implementation of C++ plotting, calling Viper on command-line - Remove precompiled elements and projections - Automatically interpolate user-defined functions on assignment - Add new built-in function MeshCoordinates, useful in ALE simulations - Add new constructor to Function class, Function(V, "vector.xml") - Remove class Array (using std::vector instead) - Add vector_mapping data to MeshData - Use std::vector instead of Array in MeshData - Add assignment operator and copy constructor for MeshFunction - Add function mesh.move(other_mesh) for moving mesh according to matching mesh (for FSI) - Add function mesh.move(u) for moving mesh according to displacement function (for FSI) - Add macro dolfin_not_implemented() - Add new interpolate() function for interpolation of user-defined function to discrete - Make _function_space protected in Function - Added access to crs data from python for uBLAS and MTL4 backend 0.9.1 [2009-02-17] ------------------ - Check Rectangle and Box for non-zero dimensions - ODE solvers now solve the dual problem - New class SubMesh for simple extraction of matching meshes for sub domains - Improvements of multiprecision ODE solver - Fix Function class copy constructor - Bug fixes for errornorm(), updates for new interface - Interface update for MeshData: createMeshFunction --> create_mesh_function etc - Interface update for Rectangle and Box - Add elastodynamics demo - Fix memory leak in IntersectionDetector/GTSInterface - Add check for swig version, in jit and compile functions - Bug fix in dolfin-order script for gzipped files - Make shared_ptr work across C++/Python interface - Replace std::tr1::shared_ptr with boost::shared_ptr - Bug fix in transfinite mean-value interpolation - Less annoying progress bar (silent when progress is fast) - Fix assignment operator for MeshData - Improved adaptive mesh refinement (recursive Rivara) producing better quality meshes 0.9.0 [2009-01-05] ------------------ - Cross-platform fixes - PETScMatrix::copy fix - Some Trilinos fixes - Improvements in MeshData class - Do not use initial guess in Newton solver - Change OutflowFacet to IsOutflowFacet and change syntax - Used shared_ptr for underling linear algebra objects - Cache subspaces in FunctionSpace - Improved plotting, now support plot(grad(u)), plot(div(u)) etc - Simple handling of JIT-compiled functions - Sign change (bug fix) in increment for Newton solver - New class VariationalProblem replacing LinearPDE and NonlinearPDE - Parallel parsing and partitioning of meshes (experimental) - Add script dolfin-order for ordering mesh files - Add new class SubSpace (replacing SubSystem) - Add new class FunctionSpace - Complete redesign of Function class hierarchy, now a single Function class - Increased use of shared_ptr in Function, FunctionSpace, etc - New interface for boundary conditions, form not necessary - Allow simple setting of coefficient functions based on names (not their index) - Don't order mesh automatically, meshes must now be ordered explicitly - Simpler definition of user-defined functions (constructors not necessary) - Make mesh iterators const to allow for const-correct Mesh code 0.8.1 [2008-10-20] ------------------ - Add option to use ML multigrid preconditioner through PETSc - Interface change for ODE solvers: uBLASVector --> double* - Remove homotopy solver - Remove typedef real, now using plain double instead - Add various operators -=, += to GenericMatrix - Don't use -Werror when compiling SWIG generated code - Remove init(n) and init(m, n) from GenericVector/Matrix. Use resize and zero instead - Add new function is_combatible() for checking compatibility of boundary conditions - Use x as initial guess in Krylov solvers (PETSc, uBLAS, ITL) - Add new function errornorm() - Add harmonic ALE mesh smoothing - Refinements of Graph class - Add CholmodCholeskySlover (direct solver for symmetric matrices) - Implement application of Dirichlet boundary conditions within assembly loop - Improve efficiency of SparsityPattern - Allow a variable number of smoothings - Add class Table for pretty-printing of tables - Add experimental MTL4 linear algebra backend - Add OutflowFacet to SpecialFunctions for DG transport problems - Remove unmaintained OpenDX file format - Fix problem with mesh smoothing near nonconvex corners - Simple projection of functions in Python - Add file format: XYZ for use with Xd3d - Add built-in meshes: UnitCircle, Box, Rectangle, UnitSphere 0.8.0 [2008-06-23] ------------------ - Fix input of matrix data from XML - Add function normalize() - Integration with VMTK for reading DOLFIN XML meshes produced by VMTK - Extend mesh XML format to handle boundary indicators - Add support for attaching arbitrarily named data to meshes - Add support for dynamically choosing the linear algebra backend - Add Epetra/Trilinos linear solvers - Add setrow() to matrix interface - Add new solver SingularSolver for solving singular (pressure) systems - Add MeshSize::min(), max() for easy computation of smallest/largest mesh size - LinearSolver now handles all backends and linear solvers - Add access to normal in Function, useful for inflow boundary conditions - Remove GMRES and LU classes, use solve() instead - Improve solve() function, now handles both LU and Krylov + preconditioners - Add ALE mesh interpolation (moving mesh according to new boundary coordinates) 0.7.3 [2008-04-30] ------------------ - Add support for Epetra/Trilinos - Bug fix for order of values in interpolate_vertex_values, now according to UFC - Boundary meshes are now always oriented with respect to outward facet normals - Improved linear algebra, both in C++ and Python - Make periodic boundary conditions work in Python - Fix saving of user-defined functions - Improve plotting - Simple computation of various norms of functions from Python - Evaluation of Functions at arbitrary points in a mesh - Fix bug in assembling over exterior facets (subdomains were ignored) - Make progress bar less annoying - New scons-based build system replaces autotools - Fix bug when choosing iterative solver from Python 0.7.2 [2008-02-18] ------------------ - Improve sparsity pattern generator efficiency - Dimension-independent sparsity pattern generator - Add support for setting strong boundary values for DG elements - Add option setting boundary conditions based on geometrical search - Check UMFPACK return argument for warnings/errors - Simplify setting simple Dirichlet boundary conditions - Much improved integration with FFC in PyDOLFIN - Caching of forms by JIT compiler now works - Updates for UFC 1.1 - Catch exceptions in PyDOLFIN - Work on linear algebra interfaces GenericTensor/Matrix/Vector - Add linear algebra factory (backend) interface - Add support for 1D meshes - Make Assembler independent of linear algebra backend - Add manager for handling sub systems (PETSc and MPI) - Add parallel broadcast of Mesh and MeshFunction - Add experimental support for parallel assembly - Use PETSc MPI matrices when running in parallel - Add predefined functions FacetNormal and AvgMeshSize - Add left/right/crisscross options for UnitSquare - Add more Python demos - Add support for Exodus II format in dolfin-convert - Autogenerate docstrings for PyDOLFIN - Various small bug fixes and improvements 0.7.1 [2007-08-31] ------------------ - Integrate FFC form language into PyDOLFIN - Just-in-time (JIT) compilation of variational forms - Conversion from from Diffpack grid format to DOLFIN XML - Name change: BoundaryCondition --> DirichletBC - Add support for periodic boundary conditions: class PeriodicBC - Redesign default linear algebra interface (Matrix, Vector, KrylovSolver, etc) - Add function to return Vector associated with a DiscreteFunction 0.7.0-1 [2007-06-22] -------------------- - Recompile all forms with latest FFC release - Remove typedefs SparseMatrix and SparseVector - Fix includes in LinearPDE - Rename DofMaps -> DofMapSet 0.7.0 [2007-06-20] ------------------ - Move to UFC interface for code generation - Major rewrite, restructure, cleanup - Add support for Brezzi-Douglas-Marini (BDM) elements - Add support for Raviart-Thomas (RT) elements - Add support for Discontinuous Galerkin (DG) methods - Add support for mesh partitioning (through SCOTCH) - Handle both UMFPACK and UFSPARSE - Local mesh refinement - Mesh smoothing - Built-in plotting (through Viper) - Cleanup log system - Numerous fixes for mesh, in particular MeshFunction - Much improved Python bindings for mesh - Fix Python interface for vertex and cell maps in boundary computation 0.6.4 [2006-12-01] ------------------ - Switch from Python Numeric to Python NumPy - Improved mesh Python bindings - Add input/output support for MeshFunction - Change Mesh::vertices() --> Mesh::coordinates() - Fix bug in output of mesh to MATLAB format - Add plasticty module (experimental) - Fix configure test for Python dev (patch from Åsmund Ødegård) - Add mesh benchmark - Fix memory leak in mesh (data not deleted correctly in MeshTopology) - Fix detection of curses libraries - Remove Tecplot output format 0.6.3 [2006-10-27] ------------------ - Move to new mesh library - Remove dolfin-config and move to pkg-config - Remove unused classes PArray, PList, Table, Tensor - Visualization of 2D solutions in OpenDX is now supported (3D supported before) - Add support for evaluation of functionals - Fix bug in Vector::sum() for uBLAS vectors 0.6.2-1 [2006-09-06] -------------------- - Fix compilation error when using --enable-petsc (dolfin::uBLASVector::PETScVector undefined) 0.6.2 [2006-09-05] ------------------ - Finish chapter in manual on linear algebra - Enable PyDOLFIN by default, use --disable-pydolfin to disable - Disable PETSc by default, use --enable-petsc to enable - Modify ODE solver interface for u0() and f() - Add class ConvectionMatrix - Readd classes LoadVector, MassMatrix, StiffnessMatrix - Add matrix factory for simple creation of standard finite element matrices - Collect static solvers in LU and GMRES - Bug fixes for Python interface PyDOLFIN - Enable use of direct solver for ODE solver (experimental) - Remove demo bistable - Restructure and cleanup linear algebra - Use UMFPACK for LU solver with uBLAS matrix types - Add templated wrapper class for different uBLAS matrix types - Add ILU preconditioning for uBLAS matrices - Add Krylov solver for uBLAS sparse matrices (GMRES and BICGSTAB) - Add first version of new mesh library (NewMesh, experimental) - Add Parametrized::readParameters() to trigger reading of values on set() - Remove output of zeros in Octave matrix file format - Use uBLAS-based vector for Vector if PETSc disabled - Add wrappers for uBLAS compressed_matrix class - Compute eigenvalues using SLEPc (an extension of PETSc) - Clean up assembly and linear algebra - Add function to solve Ax = b for dense matrices and dense vectors - Make it possible to compile without PETSc (--disable-petsc) - Much improved ODE solvers - Complete multi-adaptive benchmarks reaction and wave - Assemble boundary integrals - FEM class cleaned up. - Fix multi-adaptive benchmark problem reaction - Small fixes for Intel C++ compiler version 9.1 - Test for Intel C++ compiler and configure appropriately - Add new classes DenseMatrix and DenseVector (wrappers for ublas) - Fix bug in conversion from Gmsh format 0.6.1 [2006-03-28] ------------------ - Regenerate build system in makedist script - Update for new FFC syntax: BasisFunction --> TestFunction, TrialFunction - Fixes for conversion script dolfin-convert - Initial cleanups and fixes for ODE solvers - Numerous small fixes to improve portability - Remove dolfin:: qualifier on output << in Parameter.h - Don't use anonymous classes in demos, gives errors with some compilers - Remove KrylovSolver::solver() - Fix bug in convection-diffusion demo (boundary condition for pressure), use direct solver - LinearPDE and NewonSolver use umfpack LU solver by default (if available) when doing direct solve - Set PETSc matrix type through Matrix constructor - Allow linear solver and preconditioner type to be passed to NewtonSolver - Fix bug in Stokes demos (wrong boundary conditions) - Cleanup Krylov solver - Remove KrylovSolver::setPreconditioner() etc. and move to constructors - Remove KrylovSolver::setRtol() etc. and replace with parameters - Fix remaining name changes: noFoo() --> numFoo() - Add Cahn-Hilliard equation demo - NewtonSolver option to use residual or incremental convergence criterion - Add separate function to nls to test for convergence of Newton iterations - Fix bug in dolfin-config (wrong version number) 0.6.0 [2006-03-01] ------------------ - Fix bug in XML output format (writing multiple objects) - Fix bug in XML matrix output format (handle zero rows) - Add new nonlinear PDE demo - Restructure PDE class to use envelope-letter design - Add precompiled finite elements for q <= 5 - Add FiniteElementSpec and factor function for FiniteElement - Add input/output of Function to DOLFIN XML - Name change: dof --> node - Name change: noFoo() --> numFoo() - Add conversion from gmsh format in dolfin-convert script - Updates for PETSc 2.3.1 - Add new type of Function (constant) - Simplify use of Function class - Add new demo Stokes + convection-diffusion - Add new demo Stokes (equal-order stabilized) - Add new demo Stokes (Taylor-Hood) - Add new parameter for KrylovSolvers: "monitor convergence" - Add conversion script dolfin-convert for various mesh formats - Add new demo elasticity - Move poisson demo to src/demo/pde/poisson - Move to Mercurial (hg) from CVS - Use libtool to build libraries (including shared) 0.5.12 [2006-01-12] ------------------- - Make Stokes solver dimension independent (2D/3D) - Make Poisson solver dimension independent (2D/3D) - Fix sparse matrix output format for MATLAB - Modify demo problem for Stokes, add exact solution and compute error - Change interface for boundary conditions: operator() --> eval() - Add two benchmark problems for the Navier-Stokes solver - Add support for 2D/3D selection in Navier-Stokes solver - Move tic()/toc() to timing.h - Navier-Stokes solver back online - Make Solver a subclass of Parametrized - Add support for localization of parameters - Redesign of parameter system 0.5.11 [2005-12-15] ------------------- - Add script monitor for monitoring memory usage - Remove meminfo.h (not portable) - Remove dependence on parameter system in log system - Don't use drand48() (not portable) - Don't use strcasecmp() (not portable) - Remove sysinfo.h and class System (not portable) - Don't include (not portable) - Change ::show() --> ::disp() everywhere - Clean out old quadrature classes on triangles and tetrahedra - Clean out old sparse matrix code - Update chapter on Functions in manual - Use std::map to store parameters - Implement class KrylovSolver - Name change: Node --> Vertex - Add nonlinear solver demos - Add support for picking sub functions and components of functions - Update interface for FiniteElement for latest FFC version - Improve and restructure implementation of the Function class - Dynamically adjust safety factor during integration - Improve output Matrix::disp() - Check residual at end of time step, reject step if too large - Implement Vector::sum() - Implement nonlinear solver - New option for ODE solver: "save final solution" --> solution.data - New ODE test problem: reaction - Fixes for automake 1.9 (nobase_include_HEADERS) - Reorganize build system, remove fake install and require make install - Add checks for non-standard PETSc component HYPRE in NSE solver - Make GMRES solver return the number of iterations - Add installation script for Python interface - Add Matrix Market format (Haiko Etzel) - Automatically reinitialize GMRES solver when system size changes - Implement cout << for class Vector 0.5.10 [2005-10-11] ------------------- - Modify ODE solver interface: add T to constructor - Fix compilation on AMD 64 bit systems (add -fPIC) - Add new BLAS mode for form evaluation - Change enum types in File to lowercase - Change default file type for .m to Octave - Add experimental Python interface PyDOLFIN - Fix compilation for gcc 4.0 0.5.9 [2005-09-23] ------------------ - Add Stokes module - Support for arbitrary mixed elements through FFC - VTK output interface now handles time-dependent functions automatically - Fix cout for empty matrix - Change dolfin_start() --> dolfin_end() - Add chapters to manual: about, log system, parameters, reference elements, installation, contributing, license - Use new template fenicsmanual.cls for manual - Add compiler flag -U__STRICT_ANSI__ when compiling under Cygwin - Add class EigenvalueSolver 0.5.8 [2005-07-05] ------------------ - Add new output format Paraview/VTK (Garth N. Wells) - Update Tecplot interface - Move to PETSc 2.3.0 - Complete support for general order Lagrange elements in triangles and tetrahedra - Add test problem in src/demo/fem/convergence/ for general Lagrange elements - Make FEM::assemble() estimate the number of nonzeros in each row - Implement Matrix::init(M, N, nzmax) - Add Matrix::nz(), Matrix::nzsum() and Matrix::nzmax() - Improve Mesh::disp() - Add FiniteElement::disp() and FEM::disp() (useful for debugging) - Remove old class SparseMatrix - Change FEM::setBC() --> FEM::applyBC() - Change Mesh::tetrahedrons --> Mesh::tetrahedra - Implement Dirichlet boundary conditions for tetrahedra - Implement Face::contains(const Point& p) - Add test for shape dimension of mesh and form in FEM::assemble() - Move src/demo/fem/ demo to src/demo/fem/simple/ - Add README file in src/demo/poisson/ (simple manual) - Add simple demo program src/demo/poisson/ - Update computation of alignment of faces to match FFC/FIAT 0.5.7 [2005-06-23] ------------------ - Clean up ODE test problems - Implement automatic detection of sparsity pattern from given matrix - Clean up homotopy solver - Implement automatic computation of Jacobian - Add support for assembly of non-square systems (Andy Terrel) - Make ODE solver report average number of iterations - Make progress bar write first update at 0% - Initialize all values of u before solution in multi-adaptive solver, not only components given by dependencies - Allow user to modify and verify a converging homotopy path - Make homotopy solver save a list of the solutions - Add Matrix::norm() - Add new test problem for CES economy - Remove cast from Parameter to const char* (use std::string) - Make solution data filename optional for homotopy solver - Append homotopy solution data to file during solution - Add dolfin::seed(int) for optionally seeding random number generator - Remove dolfin::max,min (use std::max,min) - Add polynomial-integer (true polynomial) form of general CES system - Compute multi-adaptive efficiency index - Updates for gcc 4.0 (patches by Garth N. Wells) - Add Matrix::mult(const real x[], uint row) (temporary fix, assumes uniprocessor case) - Add Matrix::mult(const Vector& x, uint row) (temporary fix, assumes uniprocessor case) - Update shortcuts MassMatrix and StiffnessMatrix to new system - Add missing friend to Face.h (reported by Garth N. Wells) 0.5.6 [2005-05-17] ------------------ - Implementation of boundary conditions for general order Lagrange (experimental) - Use interpolation function automatically generated by FFC - Put computation of map into class AffineMap - Clean up assembly - Use dof maps automatically generated by FFC (experimental) - Modify interface FiniteElement for new version of FFC - Update ODE homotopy test problems - Add cross product to class Point - Sort mesh entities locally according to ordering used by FIAT and FFC - Add new format for dof maps (preparation for higher-order elements) - Code cleanups: NewFoo --> Foo complete - Updates for new version of FFC (0.1.7) - Bypass log system when finalizing PETSc (may be out of scope) 0.5.5 [2005-04-26] ------------------ - Fix broken log system, curses works again - Much improved multi-adaptive time-stepping - Move elasticity module to new system based on FFC - Add boundary conditions for systems - Improve regulation of time steps - Clean out old assembly classes - Clean out old form classes - Remove kernel module map - Remove kernel module element - Move convection-diffusion module to new system based on FFC - Add iterators for cell neighbors of edges and faces - Implement polynomial for of CES economy - Rename all new linear algebra classes: NewFoo --> Foo - Clean out old linear algebra - Speedup setting of boundary conditions (add MAT_KEEP_ZEROED_ROWS) - Fix bug for option --disable-curses 0.5.4 [2005-03-29] ------------------ - Remove option to compile with PETSc 2.2.0 (2.2.1 required) - Make make install work again (fix missing includes) - Add support for mixing multiple finite elements (through FFC) - Improve functionality of homotopy solver - Simple creation of piecewise linear functions (without having an element) - Simple creation of piecewise linear elements - Add support of automatic creation of simple meshes (unit cube, unit square) 0.5.3 [2005-02-26] ------------------ - Change to PETSc version 2.2.1 - Add flag --with-petsc= to configure script - Move Poisson's equation to system based on FFC - Add support for automatic creation of homotopies - Make all ODE solvers automatically handle complex ODEs: (M) z' = f(z,t) - Implement version of mono-adaptive solver for implicit ODEs: M u' = f(u,t) - Implement Newton's method for multi- and mono-adaptive ODE solvers - Update PETSc wrappers NewVector, NewMatrix, and NewGMRES - Fix initialization of PETSc - Add mono-adaptive cG(q) and dG(q) solvers (experimental) - Implementation of new assebly: NewFEM, using output from FFC - Add access to mesh for nodes, cells, faces and edges - Add Tecplot I/O interface; contributed by Garth N. Wells 0.5.2 [2005-01-26] ------------------ - Benchmarks for DOLFIN vs PETSc (src/demo/form and src/demo/test) - Complete rewrite of the multi-adaptive ODE solver (experimental) - Add wrapper for PETSc GMRES solver - Update class Point with new operators - Complete rewrite of the multi-adaptive solver to improve performance - Add PETSc wrappers NewMatrix and NewVector - Add DOLFIN/PETSc benchmarks 0.5.1 [2004-11-10] ------------------ - Experimental support for automatic generation of forms using FFC - Allow user to supply Jacobian to ODE solver - Add optional test to check if a dependency already exists (Sparsity) - Modify sparse matrix output (Matrix::show()) - Add FGMRES solver in new format (patch from eriksv) - Add non-const version of quick-access of sparse matrices - Add linear mappings for simple computation of derivatives - Add check of matrix dimensions for ODE sparsity pattern - Include missing cmath in Function.cpp 0.5.0 [2004-08-18] ------------------ - First prototype of new form evaluation system - New classes Jacobi, SOR, Richardson (preconditioners and linear solvers) - Add integrals on the boundary (ds), partly working - Add maps from boundary of reference cell - Add evaluation of map from reference cell - New Matrix functions: max, min, norm, and sum of rows and columns (erik) - Derivatives/gradients of ElementFunction (coefficients f.ex.) implemented - Enable assignment to all elements of a NewArray - Add functions Boundary::noNodes(), noFaces(), noEdges() - New class GaussSeidel (preconditioner and linear solver) - New classes Preconditioner and LinearSolver - Bug fix for tetrahedral mesh refinement (ingelstrom) - Add iterators for Edge and Face on Boundary - Add functionality to Map: bdet() and cell() - Add connectivity face-cell and edge-cell - New interface for assembly: Galerkin --> FEM - Bug fix for PDE systems of size > 3 0.4.11 [2004-04-23] ------------------- - Add multigrid solver (experimental) - Update manual 0.4.10 ------ - Automatic model reduction (experimental) - Fix bug in ParticleSystem (divide by mass) - Improve control of integration (add function ODE::update()) - Load/save parameters in XML-format - Add assembly test - Add simple StiffnessMatrix, MassMatrix, and LoadVector - Change dK --> dx - Change dx() --> ddx() - Add support for GiD file format - Add performance tests for multi-adaptivity (both stiff and non-stiff) - First version of Newton for the multi-adaptive solver - Test for Newton for the multi-adaptive solver 0.4.9 ----- - Add multi-adaptive solver for the bistable equation - Add BiCGSTAB solver (thsv) - Fix bug in SOR (thsv) - Improved visual program for OpenDX - Fix OpenDX file format for scalar functions - Allow access to samples of multi-adaptive solution - New patch from thsv for gcc 3.4.0 and 3.5.0 - Make progress step a parameter - New function ODE::sparse(const Matrix& A) - Access nodes, cells, edges, faces by id - New function Matrix::lump() 0.4.8 ----- - Add support for systems (jansson and bengzon) - Add new module wave - Add new module wave-vector - Add new module elasticity - Add new module elasticity-stationary - Multi-adaptive updates - Fix compilation error in LogStream - Fix local Newton iteration for higher order elements - Init matrix to given type - Add output of cG(q) and dG(q) weights in matrix format - Fix numbering of frames from plotslab script - Add png output for plotslab script - Add script for running stiff test problems, plot solutions - Fix bug in MeshInit (node neighbors of node) - Modify output of sysinfo() - Compile with -Wall -Werror -pedantic -ansi -std=c++98 (thsv) 0.4.7 ----- - Make all stiff test problems work - Display status report also when using step() - Improve adaptive damping for stiff problems (remove spikes) - Modify Octave/Matlab format for solution data (speed improvement) - Adaptive sampling of solution (optional) - Restructure stiff test problems - Check if value of right-hand side is valid - Modify divergence test in AdaptiveIterationLevel1 0.4.6 ----- - Save vectors and matrices from Matlab/Octave (foufas) - Rename writexml.m to xmlmesh.m - Inlining of important functions - Optimize evaluation of elements - Optimize Lagrange polynomials - Optimize sparsity: use stl containers - Optimize choice of discrete residual for multi-adaptive solver - Don't save solution in benchmark proble - Improve computation of divergence factor for underdamped systems - Don't check residual on first slab for fixed time step - Decrease largest (default) time step to 0.1 - Add missing in TimeStepper - Move real into dolfin namespace 0.4.5 ----- - Rename function.h to enable compilation under Cygwin - Add new benchmark problem for multi-adaptive solver - Bug fix for ParticleSystem - Initialization of first time step - Improve time step regulation (threshold) - Improve stabilization - Improve TimeStepper interface (Ko Project) - Use iterators instead of recursively calling TimeSlab::update() - Clean up ODESolver - Add iterators for elements in time slabs and element groups - Add -f to creation of symbolic links 0.4.4 ----- - Add support for 3D graphics in Octave using Open Inventor (jj) 0.4.3 ----- - Stabilization of multi-adaptive solver (experimental) - Improved non-support for curses (--disable-curses) - New class MechanicalSystem for simulating mechanical systems - Save debug info from primal and dual (plotslab.m) - Fix bug in progress bar - Add missing include file in Components.h (kakr) - New function dolfin_end(const char* msg, ...) - Move numerical differentiation to RHS - New class Event for limited display of messages - Fix bug in LogStream (large numbers in floating point format) - Specify individual time steps for different components - Compile without warnings - Add -Werror to option enable-debug - Specify individual methods for different components - Fix bug in dGqMethods - Fix bug (delete old block) in ElementData - Add parameters for method and order - New test problem reaction - New class FixedPointIteration - Fix bug in grid refinement 0.4.2 ----- - Fix bug in computation of residual (divide by k) - Add automatic generation and solution of the dual problem - Automatic selection of file names for primal and dual - Fix bug in progress bar (TerminalLogger) - Many updates of multi-adaptive solver - Add class ODEFunction - Update function class hierarchies - Move functions to a separate directory - Store multi-adaptive solution binary on disk with cache 0.4.1 ----- - First version of multi-adaptive solver working - Clean up file formats - Start changing from int to unsigned int where necessary - Fix bool->int when using stdard in Parameter - Add NewArray and NewList (will replace Array and List) 0.4.0 ----- - Initiation of the FEniCS project - Change syntax of mesh files: grid -> mesh - Create symbolic links instead of copying files - Tanganyika -> ODE - Add Heat module - Grid -> Mesh - Move forms and mappings to separate libraries - Fix missing include of DirectSolver.h 0.3.12 ------ - Adaptive grid refinement (!) - Add User Manual - Add function dolfin_log() to turn logging on/off - Change from pointers to references for Node, Cell, Edge, Face - Update writexml.m - Add new grid files and rename old grid files 0.3.11 ------ - Add configure option --disable-curses - Grid refinement updates - Make OpenDX file format work for grids (output) - Add volume() and diameter() in cell - New classes TriGridRefinement and TetGridRefinement - Add iterators for faces and edges on a boundary - New class GridHierarchy 0.3.10 ------ - Use new boundary structure in Galerkin - Make dolfin_start() and dolfin_end() work - Make dolfin_assert() raise segmentation fault for plain text mode - Add configure option --enable-debug - Use autoreconf instead of scripts/preconfigure - Rename configure.in -> configure.ac - New class FaceIterator - New class Face - Move computation of boundary from GridInit to BoundaryInit - New class BoundaryData - New class BoundaryInit - New class Boundary - Make InitGrid compute edges - Add test program for generic matrix in src/demo/la - Clean up Grid classes - Add new class GridRefinementData - Move data from Cell to GenericCell - Make GMRES work with user defined matrix, only mult() needed - GMRES now uses only one function to compute residual() - Change Matrix structure (a modified envelope/letter) - Update script checkerror.m for Poisson - Add function dolfin_info_aptr() - Add cast to element pointer for iterators - Clean up and improve the Tensor class - New class: List - Name change: List -> Table - Name change: ShortList -> Array - Make functions in GridRefinement static - Make functions in GridInit static - Fix bug in GridInit (eriksv) - Add output to OpenDX format for 3D grids - Clean up ShortList class - Clean up List class - New class ODE, Equation replaced by PDE - Add Lorenz test problem - Add new problem type for ODEs - Add new module ode - Work on multi-adaptive ODE solver (lots of new stuff) - Work on grid refinement - Write all macros in LoggerMacros in one line - Add transpose functions to Matrix (Erik) 0.3.9 ----- - Update Krylov solver (Erik, Johan) - Add new LU factorization and LU solve (Niklas) - Add benchmark test in src/demo/bench - Add silent logger 0.3.8 ----- - Make sure dolfin-config is regenerated every time - Add demo program for cG(q) and dG(q) - Add dG(q) precalc of nodal points and weights - Add cG(q) precalc of nodal points and weights - Fix a bug in configure.in (AC_INIT with README) - Add Lagrange polynomials - Add multiplication with transpose - Add scalar products with rows and columns - Add A[i][j] index operator for quick access to dense matrix 0.3.7 ----- - Add new Matlab-like syntax like A(i,all) = x or A(3,all) = A(4,all) - Add dolfin_assert() macro enabled if debug is defined - Redesign of Matrix/DenseMatrix/SparseMatrix to use Matrix as common interface - Include missing cmath in Legendre.cpp and GaussianQuadrature.cpp 0.3.6 ----- - Add output functionality in DenseMatrix - Add high precision solver to DirectSolver - Clean up error messages in Matrix - Make solvers directly accessible through Matrix and DenseMatrix - Add quadrature (Gauss, Radau, and Lobatto) from Tanganyika - Start merge with Tanganyika - Add support for automatic documentation using doxygen - Update configure scripts - Add greeting at end of compilation 0.3.5 ----- - Define version number only in the file configure.in - Fix compilation problem (missing depcomp) 0.3.4 ----- - Fix bugs in some of the ElementFunction operators - Make convection-diffusion solver work again - Fix bug in integration, move multiplication with the determinant - Fix memory leaks in ElementFunction - Add parameter to choose output format - Make OctaveFile and MatlabFile subclasses of MFile - Add classes ScalarExpressionFunction and VectorExpressionFunction - Make progress bars work cleaner - Get ctrl-c in curses logger - Remove Settings-classes and use dolfin_parameter() - Redesign settings to match the structure of the log system - Add vector functions: Function::Vector - Add vector element functions: ElementFunction::Vector 0.3.3 ----- - Increased functionality of curses-based interface - Add progress bars to log system 0.3.2 ----- - More work on grid refinement - Add new curses based log system 0.3.1 ----- - Makefile updates: make install should now work properly - KrylovSolver updates - Preparation for grid refinement - Matrix and Vector updates 0.3.0 ----- - Make poisson work again, other modules still not working - Add output format for octave - Fix code to compile with g++-3.2 -Wall -Werror - New operators for Matrix - New and faster GMRES solver (speedup factor 4) - Changed name from SparseMatrix to Matrix - Remove old unused code - Add subdirectory math containing mathematical functions - Better access for A(i,j) += to improve speed in assembling - Add benchmark for linear algebra - New definition of finite element - Add algebra for function spaces - Convert grids in data/grids to xml.gz - Add iterators for Nodes and Cells - Change from .hh to .h - Add operators to Vector class (foufas) - Add dependence on libxml2 - Change from .C to .cpp to make Jim happy. - Change input/output functionality to streams - Change to new data structure for Grid - Change to object-oriented API at top level - Add use of C++ namespaces - Complete and major restructuring of the code - Fix compilation error in src/config - Fix name of keyword for convection-diffusion 0.2.11-1 -------- - Fix compilation error (`source`) on Solaris 0.2.11 ------ - Automate build process to simplify addition of new modules - Fix bug in matlab_write_field() (walter) - Fix bug in SparseMatrix::GetCopy() (foufas) 0.2.10-1 -------- - Fix compilation errors on RedHat (thsv) 0.2.10 ------ - Fix compilation of problems to use correct compiler - Change default test problems to the ones in the report - Improve memory management using mpatrol for tracking allocations - Change bool to int for va_arg, seems to be a problem with gcc > 3.0 - Improve input / output support: GiD, Matlab, OpenDX 0.2.8 ----- - Navier-Stokes starting to work again - Add Navier-Stokes 2d - Bug fixes 0.2.7 ----- - Add support for 2D problems - Add module convection-diffusion - Add local/global fields in equation/problem - Bug fixes - Navier-Stokes updates (still broken) 0.2.6 [2002-02-19] ------------------ - Navier-Stokes updates (still broken) - Output to matlab format 0.2.5 ----- - Add variational formulation with overloaded operators for systems - ShapeFunction/LocalField/FiniteElement according to Scott & Brenner 0.2.4 ----- - Add boundary conditions - Poisson seems to work ok 0.2.3 ----- - Add GMRES solver - Add CG solver - Add direct solver - Add Poisson solver - Big changes to the organisation of the source tree - Add kwdist.sh script - Bug fixes 0.2.2: ------ - Remove curses temporarily 0.2.1: ------ - Remove all PETSc stuff. Finally! - Gauss-Seidel cannot handle the pressure equation 0.2.0: ------ - First GPL release - Remove all of Klas Samuelssons proprietary grid code - Adaptivity and refinement broken, include in next release INSTALL000066400000000000000000000045371412460263600121240ustar00rootroot00000000000000Requirements ------------ DOLFIN uses CMake for configuration and installation. DOLFIN also relies on a number of other third-party libraries. Your system will be probed for these libraries as part of the configuration process. Simple build and install ------------------------ In the simplest case, just issue the commands mkdir build cd build cmake .. make install This will first configure DOLFIN for your system and then compile and install DOLFIN in your system's default installation direcory, for example in /usr/local/ or /opt/local/. Local installation ------------------ It may sometimes be advantageous to install DOLFIN locally as part of the DOLFIN source tree. To do this, simply type mkdir build cd build cmake -DCMAKE_INSTALL_PREFIX=$PWD/../local .. make install This configures, compiles, and install DOLFIN in a directory named 'local' in the DOLFIN source tree. (Re-)generating the SWIG interface and docstrings ------------------------------------------------- In order to regenerate the SWIG interface and update the documentation, respectively, run the generator scripts: ./cmake/scripts/generate-swig-interface ./cmake/scripts/generate-swig-docstrings Customized builds ----------------- To customize the configuration of DOLFIN, it is convenient to use one of the graphical user interfaces for CMake, such as either ccmake or cmake-gui. These frontends to CMake allow simple manipulation of variables that control the configuration of DOLFIN. DOLFIN must be built 'out-of-source' which means that all files generated by the build process end up in a separate directory without cluttering the source tree. To make an out-of-source build for DOLFIN using a graphical interface to CMake, simply type mkdir build cd build cmake-gui .. make install Building demos and tests ------------------------ To build demos, enter the build directory (if any) and type make demo This will build all demos. To build a specific demo, just name the demo you want to build, for example the Poisson demo, and type make poisson_demo Alternatively, you may navigate to the demo directory directly, for example demo/documented/poisson/cpp and then build the demo using CMake: cmake . make Python demos can be run directly by navigating to the directory of the demo and typing (in the case of the Poisson demo) python demo_poisson.py README.rst000066400000000000000000000054661412460263600125640ustar00rootroot00000000000000====== DOLFIN ====== DOLFIN is the computational backend of FEniCS and implements the FEniCS Problem Solving Environment in Python and C++. We are currently working on a highly experimental version of DOLFIN at: https://github.com/FEniCS/dolfinx Installation ============ To build DOLFIN, run:: mkdir build cd build cmake .. make install For detailed instructions, see the file INSTALL. Documentation ============= Documentation can be viewed at http://fenics-dolfin.readthedocs.org/. .. image:: https://readthedocs.org/projects/fenics-dolfin/badge/?version=latest :target: http://fenics.readthedocs.io/projects/dolfin/en/latest/?badge=latest :alt: Documentation Status Automated Testing ================= We use Bitbucket Pipelines and Atlassian Bamboo to perform automated testing. .. image:: https://bitbucket-badges.useast.atlassian.io/badge/fenics-project/dolfin.svg :target: https://bitbucket.org/fenics-project/dolfin/addon/pipelines/home :alt: Pipelines Build Status .. image:: http://magpie.bpi.cam.ac.uk:8085/plugins/servlet/wittified/build-status/DOL-DODO :target: http://magpie.bpi.cam.ac.uk:8085/browse/DOL-DODO/latest :alt: Bamboo Build Status Code Coverage ============= Code coverage reports can be viewed at https://coveralls.io/bitbucket/fenics-project/dolfin. .. image:: https://coveralls.io/repos/bitbucket/fenics-project/dolfin/badge.svg?branch=master :target: https://coveralls.io/bitbucket/fenics-project/dolfin?branch=master :alt: Coverage Status License ======= DOLFIN is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. DOLFIN is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with DOLFIN. If not, see . Contact ======= For comments and requests, send an email to the FEniCS mailing list: fenics-dev@googlegroups.com For questions related to obtaining, building or installing DOLFIN, send an email to the FEniCS support mailing list: fenics-support@googlegroups.com For questions about using DOLFIN, visit the FEniCS Q&A page: http://fenicsproject.org/qa For bug reports, visit the DOLFIN Bitbucket page: http://bitbucket.org/fenics-project/dolfin About ===== DOLFIN is developed by a group of mathematicians, computational scientists and engineers distributed around the world. A list of authors can be found in the file AUTHORS. For more information about DOLFIN, visit http://fenicsproject.orgbench/000077500000000000000000000000001412460263600121415ustar00rootroot00000000000000bench/CMakeLists.txt000066400000000000000000000016121412460263600147010ustar00rootroot00000000000000# Require CMake 2.8 cmake_minimum_required(VERSION 3.5) # Find DOLFIN config file (not used here, but check that benchmarks will be # able to find it find_package(DOLFIN REQUIRED) # If config file is found, add all demo sub-directories, else print helper # message if (DOLFIN_FOUND) # Build list of all cpp directories file( GLOB_RECURSE list "main.cpp") list( SORT list ) string(REGEX REPLACE "/main.cpp" "" list "${list}") # Add each C++ code directory foreach (cpp_dir ${list}) #message(STATUS "Add C++ benchmark: ${cpp_dir}") add_subdirectory(${cpp_dir}) endforeach() # Add fem/speedup/cpp manually (no main.cpp so not picked up automatically) add_subdirectory(fem/speedup/cpp) else() message(STATUS "Could not locate DOLFINConfig.cmake file. Did you do 'make install' for the DOLFIN library and set the appropriate paths (source /dolfin.conf)?") endif() bench/README000066400000000000000000000016241412460263600130240ustar00rootroot00000000000000This directory (and its sub directories) contain a benchmark suite for DOLFIN. To run all benchmarks, simply run the script demo.py. This script runs all executables/scripts named 'bench' found in the directory tree and records the result for benchmark found in foo/bar under the name 'foo-bar' in logs/bench.log. Two pieces of information are extracted from each benchmark: 1. A short description of the benchmark. This is extracted as the first line of output from the benchmark. 2. One or more timings. These are extracted from output in the form BENCH BENCH If no output is given (or is not given), then the total running time of the program is recorded. Important notice: To run the benchmarks correctly, you need to compile DOLFIN with option --enable-optimization. Compiling DOLFIN with --enable-debug will slow down some of the benchmarks considerably. bench/bench.py000066400000000000000000000060531412460263600135760ustar00rootroot00000000000000"Run all benchmarks" # Copyright (C) 2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Johannes Ring, 2011, 2012 from __future__ import print_function import os, sys, time failed = [] def run_bench(arg, directory, files): # Skip directories not containing a benchmark bench_exec = "bench_" + "_".join(directory.split(os.path.sep)[1:]) if not bench_exec in files: return # Get name of benchmark name = directory.replace("./", "").replace("/", "-") print("Running benchmark %s..." % name) # Remove old logfile cwd = os.getcwd() logfile = os.path.join(cwd, "logs", name + ".log") try: os.remove(logfile) except: pass # Run benchmark os.chdir(directory) t0 = time.time() status = os.system(os.path.join(os.curdir, bench_exec) + " > %s" % logfile) elapsed_time = time.time() - t0 # Change to toplevel directory os.chdir(cwd) # Report timing if status == 0: print("Completed in %g seconds\n" % elapsed_time) else: global failed failed.append(name) print("*** Failed\n") return # Get description of benchmark f = open(logfile) description = f.read().split("\n")[0] f.close() # Get timings (if any) f = open(logfile) run_timings = [("", elapsed_time)] for line in [line for line in f.read().split("\n") if "BENCH" in line]: words = [word.strip() for word in line.split()] # Override total time if len(words) == 2: run_timings[0] = ("", float(words[1])) # Add sub timing elif len(words) == 3: run_timings.append((words[1].lower(), float(words[2]))) f.close() # Append to log file d = time.gmtime() date = str((d.tm_year, d.tm_mon, d.tm_mday, d.tm_hour, d.tm_min, d.tm_sec)) f = open(os.path.join("logs", "bench.log"), "a") for (postfix, timing) in run_timings: if postfix == "": n = name d = description else: n = "%s-%s" % (name, postfix) d = "%s ((%s))" % (description, postfix) f.write('%s %s %g "%s"\n' % (date, n, timing, d)) return status == 0 # Iterate over benchmarks os.path.walk(".", run_bench, None) # Print summary if len(failed) == 0: print("All benchmarks OK") else: print("%d benchmark(s) failed:" % len(failed)) for name in failed: print(" " + name) sys.exit(len(failed)) bench/common/000077500000000000000000000000001412460263600134315ustar00rootroot00000000000000bench/common/progress/000077500000000000000000000000001412460263600152755ustar00rootroot00000000000000bench/common/progress/cpp/000077500000000000000000000000001412460263600160575ustar00rootroot00000000000000bench/common/progress/cpp/main.cpp000066400000000000000000000023241412460263600175100ustar00rootroot00000000000000// Copyright (C) 2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-06-29 // Last changed: 2010-11-16 #include using namespace dolfin; #define NUM_REPS 5 #define SIZE 500000000 int main(int argc, char* argv[]) { info("Creating progress bar with %d steps (%d repetitions)", SIZE, NUM_REPS); for (int i = 0; i < NUM_REPS; i++) { Progress p("Stepping", SIZE); double sum = 0.0; for (int j = 0; j < SIZE; j++) { sum += 0.1; p++; } dolfin::cout << "sum = " << sum << dolfin::endl; } return 0; } bench/common/timing/000077500000000000000000000000001412460263600147205ustar00rootroot00000000000000bench/common/timing/cpp/000077500000000000000000000000001412460263600155025ustar00rootroot00000000000000bench/common/timing/cpp/main.cpp000066400000000000000000000031441412460263600171340ustar00rootroot00000000000000// Copyright (C) 2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-11-16 // Last changed: 2010-11-16 #include using namespace dolfin; #define NUM_REPS 10000000 int main(int argc, char* argv[]) { info("Timing access and registration of timings (%d repetitions)", NUM_REPS); // Access to timer double sum = 0.0; double t0 = time(); double t1 = t0; Timer timer_function("time() function"); for (int i = 0; i < NUM_REPS; i++) { t0 = time(); t1 = time(); sum += t1 - t0; } timer_function.stop(); dolfin::cout << "sum = " << sum << dolfin::endl << dolfin::endl; // Test timer Timer timer_loop("timer start/stop"); Timer timer_class("Timer class"); for (int i = 0; i < NUM_REPS; i++) { timer_loop.start(); timer_loop.stop(); } timer_class.stop(); // Report timings list_timings(TimingClear::keep, { TimingType::wall, TimingType::user, TimingType::system }); return 0; } bench/fem/000077500000000000000000000000001412460263600127105ustar00rootroot00000000000000bench/fem/assembly/000077500000000000000000000000001412460263600145275ustar00rootroot00000000000000bench/fem/assembly/cpp/000077500000000000000000000000001412460263600153115ustar00rootroot00000000000000bench/fem/assembly/cpp/forms.h000066400000000000000000000063161412460263600166160ustar00rootroot00000000000000// Copyright (C) 2008-2009 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2008-07-22 // Last changed: 2010-05-03 #include #include #include "forms/Poisson2DP1.h" #include "forms/Poisson2DP2.h" #include "forms/Poisson2DP3.h" #include "forms/THStokes2D.h" #include "forms/StabStokes2D.h" #include "forms/Elasticity3D.h" #include "forms/NSEMomentum3D.h" #define SIZE_2D 256 #define SIZE_3D 32 using namespace dolfin; double bench_form(std::string form_name, double (*foo)(Form&)) { if (form_name == "poisson1") { auto mesh = std::make_shared(SIZE_2D, SIZE_2D); auto V = std::make_shared(mesh); Poisson2DP1::BilinearForm form(V, V); return foo(form); } else if (form_name == "poisson2") { auto mesh = std::make_shared(SIZE_2D, SIZE_2D); auto V = std::make_shared(mesh); Poisson2DP2::BilinearForm form(V, V); return foo(form); } else if (form_name == "poisson3") { auto mesh = std::make_shared(SIZE_2D, SIZE_2D); auto V = std::make_shared(mesh); Poisson2DP3::BilinearForm form(V, V); return foo(form); } else if (form_name == "stokes") { auto mesh = std::make_shared(SIZE_2D, SIZE_2D); auto V = std::make_shared(mesh); THStokes2D::BilinearForm form(V, V); return foo(form); } else if (form_name == "stabilization") { auto mesh = std::make_shared(SIZE_2D, SIZE_2D); auto V = std::make_shared(mesh); auto h = std::make_shared(1.0); StabStokes2D::BilinearForm form(V, V, h); return foo(form); } else if (form_name == "elasticity") { auto mesh = std::make_shared(SIZE_3D, SIZE_3D, SIZE_3D); auto V = std::make_shared(mesh); Elasticity3D::BilinearForm form(V, V); return foo(form); } else if (form_name == "navierstokes") { auto mesh = std::make_shared(SIZE_3D, SIZE_3D, SIZE_3D); auto V = std::make_shared(mesh); auto w = std::make_shared(1.0, 1.0, 1.0); auto d1 = std::make_shared(1.0); auto d2 = std::make_shared(1.0); auto k = std::make_shared(1.0); auto nu = std::make_shared(1.0); NSEMomentum3D::BilinearForm form(V, V, w, d1, d2, k, nu); return foo(form); } else { error("Unknown form: %s.", form_name.c_str()); } return 0.0; } bench/fem/assembly/cpp/forms/000077500000000000000000000000001412460263600164375ustar00rootroot00000000000000bench/fem/assembly/cpp/forms/Elasticity3D.ufl000066400000000000000000000005501412460263600214500ustar00rootroot00000000000000element = VectorElement("Lagrange", tetrahedron, 1) v = TestFunction(element) u = TrialFunction(element) E = 10.0 nu = 0.3 mu = E / (2*(1 + nu)) lmbda = E*nu / ((1 + nu)*(1 - 2*nu)) def epsilon(v): return 0.5*(grad(v) + (grad(v)).T) def sigma(v): return 2*mu*epsilon(v) + lmbda*tr(epsilon(v))*Identity(len(v)) a = inner(grad(v), sigma(u))*dx bench/fem/assembly/cpp/forms/NSEMomentum3D.ufl000066400000000000000000000011611412460263600215040ustar00rootroot00000000000000element = VectorElement("Lagrange", tetrahedron, 1) v = TestFunction(element) u = TrialFunction(element) constant_scalar = FiniteElement("Discontinuous Lagrange", tetrahedron, 0) constant_vector = VectorElement("Discontinuous Lagrange", tetrahedron, 0) w = Coefficient(constant_vector) d1 = Coefficient(constant_scalar) d2 = Coefficient(constant_scalar) k = Coefficient(constant_scalar) nu = Coefficient(constant_scalar) G_a = inner(v, u)*dx + 0.5*k*nu*inner(grad(v), grad(u))*dx + 0.5*k*inner(v, dot(w, grad(u)))*dx SD_a = d1*0.5*k*dot(dot(w, grad(v)), dot(w, grad(u)))*dx + d2*0.5*k*div(v)*div(u)*dx a = G_a + SD_a bench/fem/assembly/cpp/forms/Poisson2DP1.ufl000066400000000000000000000002051412460263600211650ustar00rootroot00000000000000element = FiniteElement("Lagrange", triangle, 1) v = TestFunction(element) u = TrialFunction(element) a = dot(grad(v), grad(u))*dx bench/fem/assembly/cpp/forms/Poisson2DP2.ufl000066400000000000000000000002051412460263600211660ustar00rootroot00000000000000element = FiniteElement("Lagrange", triangle, 2) v = TestFunction(element) u = TrialFunction(element) a = dot(grad(v), grad(u))*dx bench/fem/assembly/cpp/forms/Poisson2DP3.ufl000066400000000000000000000002051412460263600211670ustar00rootroot00000000000000element = FiniteElement("Lagrange", triangle, 3) v = TestFunction(element) u = TrialFunction(element) a = dot(grad(v), grad(u))*dx bench/fem/assembly/cpp/forms/StabStokes2D.ufl000066400000000000000000000005151412460263600214200ustar00rootroot00000000000000vector = VectorElement("Lagrange", triangle, 1) scalar = FiniteElement("Discontinuous Lagrange", triangle, 0) element = vector * scalar (v, q) = TestFunctions(element) (u, p) = TrialFunctions(element) h = Coefficient(scalar) delta = 0.2*h*h a = (inner(grad(v), grad(u)) - div(v)*p + q*div(u) + delta*inner(grad(q), grad(p)))*dx bench/fem/assembly/cpp/forms/THStokes2D.ufl000066400000000000000000000003661412460263600210460ustar00rootroot00000000000000vector = VectorElement("Lagrange", triangle, 2) scalar = FiniteElement("Lagrange", triangle, 1) element = vector * scalar (v, q) = TestFunctions(element) (u, p) = TrialFunctions(element) a = (inner(grad(v), grad(u)) - div(v)*p + q*div(u))*dx bench/fem/assembly/cpp/main.cpp000066400000000000000000000121421412460263600167410ustar00rootroot00000000000000// Copyright (C) 2008-2010 Dag Lindbo, Anders Logg and Ilmar Wilbers // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2008-07-22 // Last changed: 2011-09-21 #include #include #include #include #include "forms.h" using namespace dolfin; double assemble_form(Form& form) { // Assemble once const double t0 = time(); Matrix A; Assembler assembler; assembler.assemble(A, form); return time() - t0; } double reassemble_form(Form& form) { // Assemble once Matrix A; Assembler assembler; assembler.assemble(A, form); // Reassemble const double t0 = time(); assembler.assemble(A, form); return time() - t0; } int main(int argc, char* argv[]) { info("Assembly for various forms and backends"); set_log_active(false); // FIXME: Why? parameters["reorder_dofs_serial"] = false; // Forms std::vector forms; forms.push_back("poisson1"); forms.push_back("poisson2"); forms.push_back("poisson3"); forms.push_back("stokes"); forms.push_back("stabilization"); forms.push_back("elasticity"); forms.push_back("navierstokes"); // Backends std::vector backends = {"PETSc", "Tpetra", "Eigen"}; { for (auto it = backends.begin(); it != backends.end();) if (has_linear_algebra_backend(*it)) ++it; else it = backends.erase(it); } // Override forms and backends with command-line arguments if (argc == 3) { forms.clear(); forms.push_back(argv[1]); backends.clear(); backends.push_back(argv[2]); } else if (argc != 1) { std::cout << "Usage: bench [form] [backend]" << std::endl; exit(1); } // Tables for results Table t0("Assemble total"); Table t1("Init dofmap"); Table t2("Build sparsity"); Table t3("Init tensor"); Table t4("Delete sparsity"); Table t5("Assemble cells"); Table t6("Overhead"); Table t7("Reassemble total"); // Benchmark assembly for (unsigned int i = 0; i < forms.size(); i++) { std::cout << "Form: " << forms[i] << std::endl; for (unsigned int j = 0; j < backends.size(); j++) { parameters["linear_algebra_backend"] = backends[j]; parameters["timer_prefix"] = backends[j]; std::cout << " Backend: " << backends[j] << std::endl; const double tt0 = bench_form(forms[i], assemble_form); const auto timing1 = timing(backends[j] + t1.name(), TimingClear::clear); const auto timing2 = timing(backends[j] + t2.name(), TimingClear::clear); const auto timing3 = timing(backends[j] + t3.name(), TimingClear::clear); const auto timing4 = timing(backends[j] + t4.name(), TimingClear::clear); const auto timing5 = timing(backends[j] + t5.name(), TimingClear::clear); const double tt1 = std::get<1>(timing1)/static_cast(std::get<0>(timing1)); const double tt2 = std::get<1>(timing2)/static_cast(std::get<0>(timing2)); const double tt3 = std::get<1>(timing3)/static_cast(std::get<0>(timing3)); const double tt4 = std::get<1>(timing4)/static_cast(std::get<0>(timing4)); const double tt5 = std::get<1>(timing5)/static_cast(std::get<0>(timing5)); t0(forms[i], backends[j]) = tt0; t1(forms[i], backends[j]) = tt1; t2(forms[i], backends[j]) = tt2; t3(forms[i], backends[j]) = tt3; t4(forms[i], backends[j]) = tt4; t5(forms[i], backends[j]) = tt5; t6(forms[i], backends[j]) = tt0 - tt1 - tt2 - tt3 - tt4 - tt5; std::cout << " BENCH " << forms[i] << "-" << backends[j] << " " << tt0 << std::endl; } } // Benchmark reassembly if (argc == 1) { for (unsigned int i = 0; i < forms.size(); i++) { std::cout << "Form: " << forms[i] << std::endl; for (unsigned int j = 0; j < backends.size(); j++) { parameters["linear_algebra_backend"] = backends[j]; parameters["timer_prefix"] = backends[j]; std::cout << " Backend: " << backends[j] << std::endl; t7(forms[i], backends[j]) = bench_form(forms[i], reassemble_form); } } } // Display results set_log_active(true); std::cout << std::endl; info(t0, true); std::cout << std::endl; info(t1, true); std::cout << std::endl; info(t2, true); std::cout << std::endl; info(t3, true); std::cout << std::endl; info(t4, true); std::cout << std::endl; info(t5, true); std::cout << std::endl; info(t6, true); if (argc == 1) std::cout << std::endl; info(t7, true); return 0; } bench/fem/assembly/python/000077500000000000000000000000001412460263600160505ustar00rootroot00000000000000bench/fem/assembly/python/broken000077500000000000000000000052411412460263600172600ustar00rootroot00000000000000# Copyright (C) 2008 Ilmar Wilbers # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Anders Logg, 2008. # # First added: 2008-06-04 # Last changed: 2008-07-21 # Be careful to first run the benchmark once in order for # the Python extensions to be created, or else the timings # will not be correct. from dolfin import * from time import time import sys def make_form(name, mesh): globals()['mesh'] = mesh execfile("../forms/" + name + '.form', globals()) try: return a except: print "No object 'a' to return in file %s.form" %name return None def bench_form(form, mesh, reps=1): totaltime = 0.0 t0 = time() A = assemble(form, mesh) totaltime += time() - t0 for i in range(reps - 1): t0 = time() assemble(form, mesh, tensor=A, reset_sparsity=False) totaltime += time() - t0 return totaltime / float(reps) def make_mesh(name, dim): if dim == 3: N = 32 mesh = UnitCube(N, N, N) return mesh else: N = 256 mesh = UnitSquare(N, N) return mesh if __name__ == "__main__": try: reps = int(sys.argv[1]) except: print 'Usage: %s number_of_repetitions [1]' %sys.argv[0] reps = 1 # Backends backends = ["uBLAS", "PETSc", "Tpetra", "Eigen"] # Forms forms = ["Elasticity3D", "PoissonP1", "PoissonP2", "PoissonP3", "THStokes2D", "NSEMomentum3D", "StabStokes2D"] dolfin_set("output destination", "silent") results = Table("Assembly benchmark") for backend in backends: dolfin_set("linear algebra backend", backend) for form in forms: dim = 2 if not form.find("3D") > -1 else 3 m = make_mesh(form, dim) a = make_form(form, m) print "Assembling %s with %s" % (form, backend) t = bench_form(a, m, reps=reps) results.set(backend, form, t) dolfin_set("output destination", "terminal") print "" results.disp() list_timings(TimingClear_keep, [TimingType_wall, TimingType_user, TimingType_system]) bench/fem/convergence/000077500000000000000000000000001412460263600152065ustar00rootroot00000000000000bench/fem/convergence/cpp/000077500000000000000000000000001412460263600157705ustar00rootroot00000000000000bench/fem/convergence/cpp/Poisson2D_1.ufl000066400000000000000000000017011412460263600205370ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 2D for q = 1 element = FiniteElement("Lagrange", triangle, 1) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson2D_2.ufl000066400000000000000000000017011412460263600205400ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 2D for q = 2 element = FiniteElement("Lagrange", triangle, 2) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson2D_3.ufl000066400000000000000000000017011412460263600205410ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 2D for q = 3 element = FiniteElement("Lagrange", triangle, 3) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson2D_4.ufl000066400000000000000000000017011412460263600205420ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 2D for q = 4 element = FiniteElement("Lagrange", triangle, 4) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson2D_5.ufl000066400000000000000000000017011412460263600205430ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 2D for q = 5 element = FiniteElement("Lagrange", triangle, 5) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson3D_1.ufl000066400000000000000000000017041412460263600205430ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 3D for q = 1 element = FiniteElement("Lagrange", tetrahedron, 1) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson3D_2.ufl000066400000000000000000000017101412460263600205410ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 3D for q = 2 element = FiniteElement("Lagrange", tetrahedron, 2) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson3D_3.ufl000066400000000000000000000017041412460263600205450ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 3D for q = 3 element = FiniteElement("Lagrange", tetrahedron, 3) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/Poisson3D_4.ufl000066400000000000000000000017041412460263600205460ustar00rootroot00000000000000# Copyright (C) 2005-2006 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2005 # Last changed: 2006-03-28 # # Poisson's equation in 3D for q = 4 element = FiniteElement("Lagrange", tetrahedron, 4) v = TestFunction(element) U = TrialFunction(element) f = Coefficient(element) a = v.dx(i)*U.dx(i)*dx L = v*f*dx bench/fem/convergence/cpp/README000066400000000000000000000024101412460263600166450ustar00rootroot00000000000000This test program solves Poisson's equation - div grad u = f on the unit square and on the unit cube with homogeneous Dirichlet boundary conditions. In 2D, the right-hand side f is given by f(x, y) = 2 pi^2 sin(x) sin(y) and the exact solution is u(x, y) = sin(x) sin(y). In 3D, the right-hand side f is given by f(x, y) = 3 pi^2 sin(x) sin(y) sin(z) and the exact solution is u(x, y) = sin(x) sin(y) sin(z). The solution is computed with Lagrange finite elements of degree 1-5 and the error is computed in the maximum norm (maximum taken only over the values at vertices). Here are the results (2005-06-30, DOLFIN version 0.5.7+): Maximum norm error in 2D: ------------------------- | h = 1/2 h = 1/4 h = 1/8 ------------------------------------ q = 1 | 3.831e-01 1.375e-01 3.748e-02 q = 2 | 1.067e-02 1.782e-03 1.480e-04 q = 3 | 3.675e-03 5.417e-04 4.243e-05 q = 4 | 1.027e-03 2.644e-05 4.862e-07 q = 5 | 1.639e-05 1.803e-06 3.985e-08 Maximum norm error in 3D: ------------------------- | h = 1/2 h = 1/4 h = 1/8 ------------------------------------ q = 1 | 5.065e-01 2.129e-01 6.127e-02 q = 2 | 3.890e-02 6.874e-03 5.589e-04 q = 3 | 1.088e-03 1.722e-03 1.535e-04 q = 4 | 6.868e-03 2.154e-04 3.983e-06 q = 5 | 3.821e-04 1.450e-05 3.598e-07 bench/fem/convergence/cpp/main.cpp000066400000000000000000000155431412460263600174300ustar00rootroot00000000000000// Copyright (C) 2005-2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . #include #include "Poisson2D_1.h" #include "Poisson2D_2.h" #include "Poisson2D_3.h" #include "Poisson2D_4.h" #include "Poisson2D_5.h" #include "Poisson3D_1.h" #include "Poisson3D_2.h" #include "Poisson3D_3.h" #include "Poisson3D_4.h" using namespace dolfin; // Boundary condition class DirichletBoundary : public SubDomain { public: DirichletBoundary() {} bool inside(const Array& x, bool on_boundary) const { return on_boundary; } }; // Right-hand side, 2D class Source2D : public Expression { void eval(Array& values, const Array& x) const { values[0] = 2.0*DOLFIN_PI*DOLFIN_PI*sin(DOLFIN_PI*x[0])*sin(DOLFIN_PI*x[1]); } }; // Right-hand side, 3D class Source3D : public Expression { void eval(Array& values, const Array& x) const { values[0] = 3.0*DOLFIN_PI*DOLFIN_PI*sin(DOLFIN_PI*x[0])*sin(DOLFIN_PI*x[1])*sin(DOLFIN_PI*x[2]); } }; // Solve equation and compute error, 2D double solve2D(int q, int n) { printf("Solving Poisson's equation in 2D for q = %d, n = %d.\n", q, n); // Set up problem auto mesh = std::make_shared(n, n); auto f = std::make_shared(); auto zero = std::make_shared(0.0); // Choose forms Form* a = 0; Form* L = 0; std::shared_ptr V; switch (q) { case 1: V = std::make_shared(mesh); a = new Poisson2D_1::BilinearForm(V, V); L = new Poisson2D_1::LinearForm(V, f); break; case 2: V = std::make_shared(mesh); a = new Poisson2D_2::BilinearForm(V, V); L = new Poisson2D_2::LinearForm(V, f); break; case 3: V = std::make_shared(mesh); a = new Poisson2D_3::BilinearForm(V, V); L = new Poisson2D_3::LinearForm(V, f); break; case 4: V = std::make_shared(mesh); a = new Poisson2D_4::BilinearForm(V, V); L = new Poisson2D_4::LinearForm(V, f); break; case 5: V = std::make_shared(mesh); a = new Poisson2D_5::BilinearForm(V, V); L = new Poisson2D_5::LinearForm(V, f); break; default: error("Forms not compiled for q = %d.", q); } // Set up boundary conditions auto boundary = std::make_shared(); DirichletBC bc(V, zero, boundary); // Discretize equation Matrix A; Vector x, b; assemble(A, *a); assemble(b, *L); bc.apply(A, b); // Solve the linear system KrylovSolver solver("gmres"); solver.parameters["relative_tolerance"] = 1e-14; solver.solve(A, x, b); // Compute maximum norm of error double emax = 0.0; std::vector U; x.get_local(U); for (VertexIterator v(*mesh); !v.end(); ++v) { const Point p = v->point(); const double u = sin(DOLFIN_PI*p.x())*sin(DOLFIN_PI*p.y()); const double e = std::abs(U[v->index()] - u); emax = std::max(emax, e); } delete a; delete L; return emax; } // Solve equation and compute error, 3D double solve3D(int q, int n) { printf("Solving Poisson's equation in 3D for q = %d, n = %d.\n", q, n); // Set up problem auto mesh = std::make_shared(n, n, n); auto f = std::make_shared(); auto zero = std::make_shared(0.0); // Choose forms Form* a = 0; Form* L = 0; std::shared_ptr V; switch (q) { case 1: V = std::make_shared(mesh); a = new Poisson3D_1::BilinearForm(V, V); L = new Poisson3D_1::LinearForm(V, f); break; case 2: V = std::make_shared(mesh); a = new Poisson3D_2::BilinearForm(V, V); L = new Poisson3D_2::LinearForm(V, f); break; case 3: V = std::make_shared(mesh); a = new Poisson3D_3::BilinearForm(V, V); L = new Poisson3D_3::LinearForm(V, f); break; case 4: V = std::make_shared(mesh); a = new Poisson3D_4::BilinearForm(V, V); L = new Poisson3D_4::LinearForm(V, f); break; default: error("Forms not compiled for q = %d.", q); } // Set up boundary conditions auto boundary = std::make_shared(); DirichletBC bc(V, zero, boundary); // Discretize equation Matrix A; Vector x, b; assemble(A, *a); assemble(b, *L); bc.apply(A, b); // Solve the linear system KrylovSolver solver("gmres"); solver.parameters["relative_tolerance"] = 1e-14; solver.solve(A, x, b); // Compute maximum norm of error double emax = 0.0; std::vector U; x.get_local(U); for (VertexIterator v(*mesh); !v.end(); ++v) { const Point p = v->point(); const double u = sin(DOLFIN_PI*p.x())*sin(DOLFIN_PI*p.y())*sin(DOLFIN_PI*p.z()); const double e = std::abs(U[v->index()] - u); emax = std::max(emax, e); } delete a; delete L; return emax; } int main() { info("Runtime of convergence benchmark"); set_log_active(false); const int qmax_2D = 5; const int qmax_3D = 4; const int num_meshes = 3; std::vector> e2D(qmax_2D, std::vector(num_meshes)); std::vector> e3D(qmax_3D, std::vector(num_meshes)); // Compute errors in 2D for (int q = 1; q <= qmax_2D; q++) { int n = 2; for (int i = 0; i < num_meshes; i++) { e2D[q - 1][i] = solve2D(q, n); n *= 2; } } // Compute errors in 3D for (int q = 1; q <= qmax_3D; q++) { int n = 2; for (int i = 0; i < num_meshes; i++) { e3D[q - 1][i] = solve3D(q, n); n *= 2; } } // Write errors in 2D printf("\nMaximum norm error in 2D:\n"); printf("-------------------------\n"); for (int q = 1; q <= qmax_2D; q++) { printf("q = %d:", q); for (int i = 0; i < num_meshes; i++) printf(" %.3e", e2D[q - 1][i]); printf("\n"); } // Write errors in 3D printf("\nMaximum norm error in 3D:\n"); printf("-------------------------\n"); for (int q = 1; q <= qmax_3D; q++) { printf("q = %d:", q); for (int i = 0; i < num_meshes; i++) printf(" %.3e", e3D[q - 1][i]); printf("\n"); } } bench/fem/jit/000077500000000000000000000000001412460263600134765ustar00rootroot00000000000000bench/fem/jit/python/000077500000000000000000000000001412460263600150175ustar00rootroot00000000000000bench/fem/jit/python/bench_fem_jit_python000077500000000000000000000036251412460263600211300ustar00rootroot00000000000000#!/usr/bin/env python """This script provides a benchmark for the JIT compiler, in particular the speed of the in-memory cache.""" # Copyright (C) 2008-2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2008-09-04 # Last changed: 2010-05-03 from dolfin import * from time import time print "JIT compilation (in memory cache)" # Benchmark parameters NUM_REPS = 10 SIZE = 3 # Create mesh mesh = UnitCubeMesh(SIZE, SIZE, SIZE) # Create form (velocity equation for "G2") V = VectorFunctionSpace(mesh, "Lagrange", 1) Q = FunctionSpace(mesh, "Lagrange", 1) DG = FunctionSpace(mesh, "DG", 0) DGv = VectorFunctionSpace(mesh, "DG", 0) v = TestFunction(V) q = TestFunction(Q) u = TrialFunction(V) p = TrialFunction(Q) u0 = Function(V) p1 = Function(Q) W = Function(DGv) nu = Constant(0.1) k = Constant(0.1) h = 2*Circumradius(mesh) d1 = h d2 = 2.0*h U = 0.5*(u0 + u) F = (1.0/k)*inner(v, u - u0) + inner(v, grad(U)*W) + nu*inner(grad(v), grad(U)) - div(v)*p1 + \ d1*inner(grad(v)*W, grad(U)*W) + d2*div(v)*div(U) a = lhs(F*dx) # JIT compile once t0 = time() jit(a) t1 = time() - t0 # Then JIT compile some more t0 = time() for i in range(NUM_REPS): jit(a) t2 = (time() - t0) / float(NUM_REPS) print "Disk cache: ", t1 print "In-memory cache:", t2 print "BENCH", t2 bench/fem/speedup/000077500000000000000000000000001412460263600143555ustar00rootroot00000000000000bench/fem/speedup/cpp/000077500000000000000000000000001412460263600151375ustar00rootroot00000000000000bench/fem/speedup/cpp/Poisson.ufl000066400000000000000000000017631412460263600173100ustar00rootroot00000000000000# Copyright (C) 2009 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2009-09-15 # Last changed: 2009-09-15 # # The bilinear form a(v, u) and linear form L(v) for # Poisson's equation. element = FiniteElement("Lagrange", tetrahedron, 1) v = TestFunction(element) u = TrialFunction(element) f = Coefficient(element) a = inner(grad(v), grad(u))*dx L = v*f*dx bench/fem/speedup/cpp/README000066400000000000000000000011351412460263600160170ustar00rootroot00000000000000This benchmark tests parallel speedup for assembly and solve. It is organized as follows: assemble-poisson: simple program for assembling Poisson matrix solve-poisson: simple program for solving Poisson's equation submit-bench: script for submitting jobs using dolfin_utils.pjobs analyse-bench: script for analysing output from submit-bench bench: script used on benchbot for simple checking of speedup Possible future improvements: 1. MUMPS vs UMFPACK gives skewed results (MUMPS faster?) 2. Time assemble_cells and apply separately 3. Use barriers between timings bench/fem/speedup/cpp/analyse-bench000077500000000000000000000057411412460263600176050ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (C) 2009 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Johan Hake, 2009. # # First added: 2009-09-15 # Last changed: 2011-01-04 # FIXME: Not checked if working! from dolfin import * from glob import glob from numpy import arange # Size of mesh size = 128 # Number of processes to use # NOTE: Largest number of processors to run is 2^EXP EXP = 6 num_processes = list(2**arange(EXP+1)) # Function for extracting log file def get_filename(pattern): filenames = glob(pattern) if len(filenames) == 0: raise IOError, "Unable to open file: %s" % pattern elif len(filenames) > 1: raise RuntimeError, "More than one data file, don't know which one to pick: " + ", ".join(filenames) filename = filenames[0] print "Reading data from %s..." % filename return filename # Iterate over process range assemble_time = [] assemble_second_time = [] solve_time = [] # Remove run with one processor if 1 in num_processes: num_processes.remove(1) for np in num_processes: # Read timings for assemble benchmark lines = open(get_filename(\ "assemble-poisson_np_%d_size_%d.log*" % (np, size))).readlines() assemble_time.append(float([line for line in lines \ if "TIME (first assembly):" in \ line][0].split("TIME (first assembly): ")[-1])) assemble_second_time.append(float([line for line in lines \ if "TIME (second assembly):" in \ line][0].split("TIME (second assembly): ")[-1])) # Read timings for solve benchmark filename = get_filename("solve-poisson_np_%d_size_%d.log*" % (np, size)) solve_time.append(float([line for line in open(filename).readlines()\ if "TIME:" in line][0].split("TIME: ")[-1])) # Compute speedups scale_assemble = [assemble_time[0] / t for t in assemble_time] scale_second_assemble = [assemble_second_time[0] / t for t in assemble_second_time] scale_solve = [solve_time[0] / t for t in solve_time] # Print results table = Table("Speedup") for i, np in enumerate(num_processes): table.set(str(np), "Assemble (first)", scale_assemble[i]) table.set(str(np), "Assemble (second)", scale_second_assemble[i]) table.set(str(np), "Solve", scale_solve[i]) print "" info(table, True) bench/fem/speedup/cpp/assemble-poisson.cpp000066400000000000000000000034551412460263600211350ustar00rootroot00000000000000// Copyright (C) 2009 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2009-09-15 // Last changed: 2012-12-12 // // Simple Poisson assembler #include #include #include "Poisson.h" using namespace dolfin; int main(int argc, char* argv[]) { // Parse command-line arguments if (argc != 2) { info("Usage: solve-poisson n"); return 1; } int n = atoi(argv[1]); // Create mesh and function space auto mesh = std::make_shared(n, n, n); auto V = std::make_shared(mesh); const MPI_Comm comm = mesh->mpi_comm(); // Assemble matrix Poisson::BilinearForm a(V, V); Matrix A; dolfin::MPI::barrier(comm); double t = time(); Assembler assembler; assembler.assemble(A, a); dolfin::MPI::barrier(comm); t = time() - t; // Report timing if (dolfin::MPI::rank(comm) == 0) info("TIME (first assembly): %.5g", t); // Re-assemble matrix dolfin::MPI::barrier(comm); t = time(); assembler.assemble(A, a); dolfin::MPI::barrier(comm); t = time() - t; // Report timing if (dolfin::MPI::rank(comm) == 0) info("TIME (second assembly): %.5g", t); return 0; } bench/fem/speedup/cpp/bench_fem_speedup_cpp000077500000000000000000000050421412460263600213630ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (C) 2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Garth N. Wells, 2011. # Modified by Johannes Ring, 2011. # # First added: 2010-05-03 # Last changed: 2011-04-05 import commands # Parameters for benchmark SIZE = 64 NUM_PROCS = 4 print "Assembly/solve speedup running on %s processors" % NUM_PROCS # Function for extracting test name and time from benchmark def get_time(output): lines = [line for line in output.split("\n") if "TIME" in line] timing = [] for line in lines: time = float(line.split(":")[-1]) name = line.split(":")[-2].strip("Process 0: ").strip("TIME").strip(None).replace("(", "").replace(")", "") timing.append( (name, time) ) return timing # Serial assembly output = commands.getoutput("./bench_assemble-poisson %d" % SIZE) assembly_t1 = get_time(output) print "Serial assembly:", assembly_t1 # Parallel assembly output = commands.getoutput("mpirun -n %d ./bench_assemble-poisson %d" % (NUM_PROCS, SIZE)) assembly_t2 = get_time(output) print "Parallel assembly:", assembly_t2 # Serial solve output = commands.getoutput("./bench_solve-poisson %d" % SIZE) solve_t1 = get_time(output) print "Serial solve:", solve_t1 # Parallel solve output = commands.getoutput("mpirun -n %d ./bench_solve-poisson %d" % (NUM_PROCS, SIZE)) solve_t2 = get_time(output) print "Parallel solve:", solve_t2 print "assembly" for test1, test2 in zip(assembly_t1, assembly_t2): print " ", test1[0] + ":", test1[1]/test2[1] print "solve" for test1, test2 in zip(solve_t1, solve_t2): print " ", test1[0] + ":", test1[1]/test2[1] print "BENCH assembly_1st", assembly_t1[0][1] / assembly_t2[0][1] print "BENCH assembly_2nd", assembly_t1[1][1] / assembly_t2[1][1] print "BENCH solve_1st", solve_t1[0][1] / solve_t2[0][1] print "BENCH solve_same_pc_pattern", solve_t1[1][1] / solve_t2[2][1] print "BENCH solve_same_pc", solve_t1[2][1] / solve_t2[2][1] bench/fem/speedup/cpp/clean.sh000077500000000000000000000001341412460263600165560ustar00rootroot00000000000000#!/bin/sh # Clean out old log files rm -f assemble-poisson*.log* rm -f solve-poisson*.log* bench/fem/speedup/cpp/solve-poisson.cpp000066400000000000000000000061351412460263600204700ustar00rootroot00000000000000// Copyright (C) 2009 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2009-09-15 // Last changed: 2012-12-12 // // Simple Poisson solver #include #include #include "Poisson.h" using namespace dolfin; int main(int argc, char* argv[]) { #ifdef HAS_PETSC parameters["linear_algebra_backend"] = "PETSc"; // Parse command-line arguments if (argc != 2) { info("Usage: solve-poisson n"); return 1; } int n = atoi(argv[1]); // Create mesh and function space auto mesh = std::make_shared(n, n, n); auto V = std::make_shared(mesh); // MPI communicator const MPI_Comm comm = mesh->mpi_comm(); // Define boundary condition auto u0 = std::make_shared(0.0); auto boundary = std::make_shared(); DirichletBC bc(V, u0, boundary); // Define variational problem Poisson::BilinearForm a(V, V); Poisson::LinearForm L(V); auto f= std::make_shared(1.0); L.f = f; Function u(V); // Prepare iterative solver const auto pc = std::make_shared("petsc_amg"); PETScKrylovSolver solver("cg", pc); // Assemble matrix and vector, and apply Dirichlet boundary conditions Matrix A; Vector b; assemble(A, a); assemble(b, L); bc.apply(A, b); bc.apply(*u.vector()); // Solve linear system dolfin::MPI::barrier(comm); double t = time(); solver.solve(A, *u.vector(), b); dolfin::MPI::barrier(comm); t = time() - t; if (dolfin::MPI::rank(comm) == 0) info("TIME (first time): %.5g", t); // Solve linear system (preconditioner assuming same non-zero pattern) if (solver.parameters.has_key("preconditioner")) solver.parameters("preconditioner")["structure"] = "same_nonzero_pattern"; u.vector()->zero(); dolfin::MPI::barrier(comm); t = time(); solver.solve(A, *u.vector(), b); dolfin::MPI::barrier(comm); t = time() - t; if (dolfin::MPI::rank(comm) == 0) info("TIME (same nonzero pattern): %.5g", t); // Solve linear system (re-use preconditioner) if (solver.parameters.has_key("preconditioner")) solver.parameters("preconditioner")["structure"] = "same"; u.vector()->zero(); dolfin::MPI::barrier(comm); t = time(); solver.solve(A, *u.vector(), b); dolfin::MPI::barrier(comm); t = time() - t; if (dolfin::MPI::rank(comm) == 0) info("TIME (re-use preconditioner): %.5g", t); #else error("This benchmark requires PETSc."); #endif return 0; } bench/fem/speedup/cpp/submit-bench000077500000000000000000000035041412460263600174470ustar00rootroot00000000000000#!/usr/bin/env python # # This script submits jobs for measuring parallel speedup. # # Copyright (C) 2009 Johan Hake # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Anders Logg, 2009. # # First added: 2009-09-15 # Last changed: 2011-01-04 from dolfin_utils.pjobs import submit from numpy import arange import sys # Parameters for benchmark SIZE = 128 # Number of processes to use # NOTE: Largest number of processors to run is 2^EXP EXP = 6 num_processes = list(2**arange(EXP+1)) # Check command-line arguments dryrun = True if 'dryrun' in sys.argv else False # Iterate over process range for np in num_processes: if np == 1: run_cmd = "" else: run_cmd = "mpirun.openmpi -n %d " % np # Submit assemble benchmark submit("%s./assemble-poisson %d" % (run_cmd, SIZE), nodes=max(1, np/8), ppn=8, # Grab all cores on a node name="assemble-poisson_np_%d_size_%d.log" % (np, SIZE), dryrun=dryrun) # Submit solve benchmark submit("%s./solve-poisson %d" % (run_cmd, SIZE), nodes=max(1, np/8), ppn=8, # Grab all cores on a node name="solve-poisson_np_%d_size_%d.log" % (np, SIZE), dryrun=dryrun) bench/function/000077500000000000000000000000001412460263600137665ustar00rootroot00000000000000bench/function/evaluation/000077500000000000000000000000001412460263600161355ustar00rootroot00000000000000bench/function/evaluation/cpp/000077500000000000000000000000001412460263600167175ustar00rootroot00000000000000bench/function/evaluation/cpp/P1.ufl000066400000000000000000000016721412460263600177150ustar00rootroot00000000000000# Copyright (C) 2009 Garth N. Wells # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2009-06-18 # Last changed: # # The bilinear form a(v, u) and linear form L(v) for # projection onto piecewise quadratics. # # Compile this form with FFC: ffc -l dolfin P1.ufl element = FiniteElement("Lagrange", tetrahedron, 1) bench/function/evaluation/cpp/main.cpp000066400000000000000000000042051412460263600203500ustar00rootroot00000000000000// Copyright (C) 2010 Andre Massing // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-06-10 // Last changed: 2012-12-12 // // Description: Benchmark for the evaluations of functions at arbitrary points. #include #include "P1.h" using namespace dolfin; class F : public Expression { public: void eval(Array& values, const Array& x) const { values[0] = sin(3.0*x[0])*sin(3.0*x[1])*sin(3.0*x[2]); } }; int main(int argc, char* argv[]) { not_working_in_parallel("Function evalutation benchmark"); info("Evaluations of functions at arbitrary points."); const std::size_t mesh_max_size = 32; const std::size_t num_points = 10000000; // Start timing tic(); for (std::size_t N = 10; N < mesh_max_size; N += 2) { const auto mesh = std::make_shared(N, N, N); const auto V0 = std::make_shared(mesh); Function f0(V0); F f; f0.interpolate(f); Array X(3); Array value(1); // Initialize random generator generator (produces same sequence each test). srand(1); for (std::size_t i = 1; i <= num_points; ++i) { X[0] = std::rand()/static_cast(RAND_MAX); X[1] = std::rand()/static_cast(RAND_MAX); X[2] = std::rand()/static_cast(RAND_MAX); f.eval(value, X); } // Use X variable. info("x = %.12e\ty = %.12e\tz = %.12e\tf(x) = %.12e", X[0], X[1], X[2], value[0]); } info("BENCH %g",toc()); return 0; } bench/function/extrapolation/000077500000000000000000000000001412460263600166575ustar00rootroot00000000000000bench/function/extrapolation/python/000077500000000000000000000000001412460263600202005ustar00rootroot00000000000000bench/function/extrapolation/python/bench_function_extrapolation_python000077500000000000000000000025751412460263600274750ustar00rootroot00000000000000#!/usr/bin/env python """This script provides a benchmark for Extrapolation""" # Copyright (C) 2010 Marie E. Rognes # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2010-06-07 # Last changed: 2013-06-17 from dolfin import * from time import time SIZE = 4 info("Extrapolation from P2*dP1 to P3*dP2 on UnitCubeMesh(%d, %d, %d)" % (SIZE, SIZE, SIZE)) mesh = UnitCubeMesh(SIZE, SIZE, SIZE) cell = mesh.ufl_cell() V = FunctionSpace(mesh, VectorElement("CG", cell, 2) * FiniteElement("DG", cell, 1)) W = FunctionSpace(mesh, VectorElement("CG", cell, 3) * FiniteElement("DG", cell, 2)) u = Expression(("sin(x[0])", "1.0", "x[0]*x[1]", "0.0"), degree=3) u = interpolate(u, V) w = Function(W) tic = time() w.extrapolate(u) t = time() - tic print "BENCH: ", t bench/function/interpolation/000077500000000000000000000000001412460263600166555ustar00rootroot00000000000000bench/function/interpolation/python/000077500000000000000000000000001412460263600201765ustar00rootroot00000000000000bench/function/interpolation/python/bench_function_interpolation_python000077500000000000000000000026321412460263600274630ustar00rootroot00000000000000#!/usr/bin/env python """This script provides a benchmark for interpolation between meshes""" # Copyright (C) 2013 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2013-06-17 # Last changed: 2013-06-21 from dolfin import * from time import time SIZE_0 = 21 #71 SIZE_1 = 23 #73 info("Extrapolation from P1 on UnitCubeMesh(%d, %d, %d) to " "P1 on UnitCubeMesh(%d, %d, %d)" % (SIZE_0, SIZE_0, SIZE_0, SIZE_1, SIZE_1, SIZE_1)) parameters["allow_extrapolation"] = True mesh_0 = UnitCubeMesh(SIZE_0, SIZE_0, SIZE_0) mesh_1 = UnitCubeMesh(SIZE_1, SIZE_1, SIZE_1) V0 = FunctionSpace(mesh_0, "CG", 1) V1 = FunctionSpace(mesh_1, "CG", 1) v0 = interpolate(Expression("sin(5*x[0])*cos(7*x[1])"), V0) tic = time() v1 = interpolate(v0, V1) t = time() - tic print "BENCH: ", t bench/geometry/000077500000000000000000000000001412460263600137745ustar00rootroot00000000000000bench/geometry/bounding_box_tree_build/000077500000000000000000000000001412460263600206475ustar00rootroot00000000000000bench/geometry/bounding_box_tree_build/cpp/000077500000000000000000000000001412460263600214315ustar00rootroot00000000000000bench/geometry/bounding_box_tree_build/cpp/main.cpp000066400000000000000000000024371412460263600230670ustar00rootroot00000000000000// Copyright (C) 2013 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // This benchmark measures the performance of building a BoundingBoxTree (and // one call to compute_entities, which is dominated by building). // // First added: 2013-04-18 // Last changed: 2013-06-25 #include #include using namespace dolfin; #define SIZE 128 int main(int argc, char* argv[]) { info("Build bounding box tree on UnitCubeMesh(%d, %d, %d)", SIZE, SIZE, SIZE); // Create mesh UnitCubeMesh mesh(SIZE, SIZE, SIZE); // Create and build tree tic(); BoundingBoxTree tree; tree.build(mesh); info("BENCH %g", toc()); return 0; } bench/geometry/bounding_box_tree_compute_closest_entity/000077500000000000000000000000001412460263600243545ustar00rootroot00000000000000bench/geometry/bounding_box_tree_compute_closest_entity/cpp/000077500000000000000000000000001412460263600251365ustar00rootroot00000000000000bench/geometry/bounding_box_tree_compute_closest_entity/cpp/main.cpp000066400000000000000000000030771412460263600265750ustar00rootroot00000000000000// Copyright (C) 2013 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // This benchmark measures the performance of compute_entity_collisions. // // First added: 2013-05-23 // Last changed: 2013-09-04 #include #include using namespace dolfin; #define NUM_REPS 1000000 #define SIZE 64 int main(int argc, char* argv[]) { info("Compute closest entity on UnitCubeMesh(%d, %d, %d)", SIZE, SIZE, SIZE); // Create mesh UnitCubeMesh mesh(SIZE, SIZE, SIZE); // First call BoundingBoxTree tree; tree.build(mesh); Point point(-1.0, -1.0, 0.0); tree.compute_closest_entity(point); cout << "Built tree, searching for closest point" << endl; // Call repeatedly tic(); for (int i = 0; i < NUM_REPS; i++) { tree.compute_closest_entity(point); point.coordinates()[1] += 2.0 / static_cast(NUM_REPS); } const double t = toc(); // Report result info("BENCH %g", t); return 0; } bench/geometry/bounding_box_tree_compute_entity_collisions/000077500000000000000000000000001412460263600250565ustar00rootroot00000000000000bench/geometry/bounding_box_tree_compute_entity_collisions/cpp/000077500000000000000000000000001412460263600256405ustar00rootroot00000000000000bench/geometry/bounding_box_tree_compute_entity_collisions/cpp/main.cpp000066400000000000000000000032641412460263600272750ustar00rootroot00000000000000// Copyright (C) 2013 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // This benchmark measures the performance of compute_entity_collisions. // // First added: 2013-05-23 // Last changed: 2013-09-04 #include #include using namespace dolfin; #define NUM_REPS 5000000 #define SIZE 64 int main(int argc, char* argv[]) { info("Compute entity collisions on UnitCubeMesh(%d, %d, %d)", SIZE, SIZE, SIZE); // Create mesh UnitCubeMesh mesh(SIZE, SIZE, SIZE); // First call BoundingBoxTree tree; tree.build(mesh); Point point(0.0, 0.0, 0.0); tree.compute_entity_collisions(point); // Call repeatedly tic(); for (int i = 0; i < NUM_REPS; i++) { point.coordinates()[0] += 1.0 / static_cast(NUM_REPS); point.coordinates()[1] += 1.0 / static_cast(NUM_REPS); point.coordinates()[2] += 1.0 / static_cast(NUM_REPS); std::vector entities = tree.compute_entity_collisions(point); } const double t = toc(); // Report result info("BENCH %g", t); return 0; } bench/la/000077500000000000000000000000001412460263600125355ustar00rootroot00000000000000bench/la/vector/000077500000000000000000000000001412460263600140375ustar00rootroot00000000000000bench/la/vector/access/000077500000000000000000000000001412460263600153005ustar00rootroot00000000000000bench/la/vector/access/cpp/000077500000000000000000000000001412460263600160625ustar00rootroot00000000000000bench/la/vector/access/cpp/main.cpp000066400000000000000000000024211412460263600175110ustar00rootroot00000000000000// Copyright (C) 2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // Modified by Anders Logg, 2010. // // First added: 2010-03-30 // Last changed: 2010-05-03 #include using namespace dolfin; #define SIZE 10000000 #define NUM_REPS 100 int main(int argc, char* argv[]) { info("Accessing vector of size %d (%d repetitions)", SIZE, NUM_REPS); parameters.parse(argc, argv); Vector x(MPI_COMM_WORLD, SIZE); x.zero(); double sum = 0.0; for (unsigned int i = 0; i < NUM_REPS; i++) for (unsigned int j = 0; j < SIZE; j++) sum += x[j]; dolfin::cout << "Sum is " << sum << dolfin::endl; return 0; } bench/la/vector/assignment/000077500000000000000000000000001412460263600162075ustar00rootroot00000000000000bench/la/vector/assignment/cpp/000077500000000000000000000000001412460263600167715ustar00rootroot00000000000000bench/la/vector/assignment/cpp/main.cpp000066400000000000000000000023111412460263600204160ustar00rootroot00000000000000// Copyright (C) 2006 Garth N. Wells // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // Modified by Anders Logg, 2010. // // First added: 2006-08-18 // Last changed: 2010-05-03 #include using namespace dolfin; #define NUM_REPS 100 #define SIZE 10000000 int main(int argc, char* argv[]) { info("Assigning to vector of size %d (%d repetitions)", SIZE, NUM_REPS); parameters.parse(argc, argv); Vector x(MPI_COMM_WORLD, SIZE); for (unsigned int i = 0; i < NUM_REPS; i++) for (unsigned int j = 0; j < SIZE; j++) x.setitem(j, 1.0); return 0; } bench/logs/000077500000000000000000000000001412460263600131055ustar00rootroot00000000000000bench/logs/bench.log000066400000000000000000073566171412460263600147200ustar00rootroot00000000000000(2008, 4, 30, 14, 12, 50) la-vector-access-cpp 15.8298 "Accessing vector of size 10000000 (100 repetitions)" (2008, 4, 30, 14, 13, 9) la-vector-assignment-cpp 18.8627 "Assigning to vector of size 10000000 (100 repetitions)" (2008, 4, 30, 14, 13, 16) fem-jit-python 0.555803 "JIT compilation (in memory cache)" (2008, 4, 30, 14, 13, 28) fem-convergence-cpp 11.4321 "Solving Poisson's equation in 2D for q = 1, n = 2." (2008, 4, 30, 14, 13, 34) mesh-unitcube-cpp 6.08171 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2008, 4, 30, 14, 14, 50) mesh-refinement-cpp 75.8 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2008, 4, 30, 14, 15, 5) mesh-iteration-cpp 14.4 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2008, 4, 30, 14, 38, 58) common-progress-cpp 526.775 "Creating progress bar with 500000000 steps (5 repetitions)" (2008, 6, 23, 14, 18, 43) la-vector-access-cpp 15.0198 "Accessing vector of size 10000000 (100 repetitions)" (2008, 6, 23, 14, 19, 4) la-vector-assignment-cpp 20.8082 "Assigning to vector of size 10000000 (100 repetitions)" (2008, 6, 23, 14, 19, 5) fem-jit-python 5.6982e-06 "JIT compilation (in memory cache)" (2008, 6, 23, 14, 19, 20) fem-convergence-cpp 14.7388 "Solving Poisson's equation in 2D for q = 1, n = 2." (2008, 6, 23, 14, 21, 44) fem-assembly-cpp 143.513 "Assembly for various forms and backends" (2008, 6, 23, 14, 21, 49) mesh-unitcube-cpp 5.86431 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2008, 6, 23, 14, 23, 5) mesh-refinement-cpp 75.54 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2008, 6, 23, 14, 23, 20) mesh-iteration-cpp 14.43 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2008, 6, 23, 14, 25, 4) common-progress-cpp 520.776 "Creating progress bar with 500000000 steps (5 repetitions)" (2008, 10, 20, 14, 31, 31) la-vector-access-cpp 14.8214 "Accessing vector of size 10000000 (100 repetitions)" (2008, 10, 20, 14, 31, 52) la-vector-assignment-cpp 20.3453 "Assigning to vector of size 10000000 (100 repetitions)" (2008, 10, 20, 14, 31, 57) fem-jit-python 9.65118e-05 "JIT compilation (in memory cache)" (2008, 10, 20, 14, 32, 8) fem-convergence-cpp 11.3695 "Solving Poisson's equation in 2D for q = 1, n = 2." (2008, 10, 20, 14, 36, 28) fem-assembly-cpp 259.766 "Assembly for various forms and backends" (2008, 10, 20, 14, 36, 34) mesh-unitcube-cpp 6.17667 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2008, 10, 20, 14, 37, 50) mesh-refinement-cpp 75.76 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2008, 10, 20, 14, 38, 5) mesh-iteration-cpp 13.98 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2008, 10, 20, 14, 5, 48) common-progress-cpp 520.887 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 1, 5, 14, 40, 18) la-vector-access-cpp 15.5729 "Accessing vector of size 10000000 (100 repetitions)" (2009, 1, 5, 14, 40, 37) la-vector-assignment-cpp 19.2912 "Assigning to vector of size 10000000 (100 repetitions)" (2009, 1, 5, 14, 40, 42) fem-jit-python 9.86099e-05 "JIT compilation (in memory cache)" (2009, 1, 5, 14, 40, 53) fem-convergence-cpp 11.4639 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 1, 5, 14, 45, 15) fem-assembly-cpp 261.595 "Assembly for various forms and backends" (2009, 1, 5, 14, 45, 52) mesh-unitcube-cpp 37.4356 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 1, 5, 14, 47, 14) mesh-refinement-cpp 81.26 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 1, 5, 14, 47, 32) mesh-iteration-cpp 13.98 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 1, 5, 13, 51, 51) common-progress-cpp 511.406 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 2, 17, 14, 50, 21) la-vector-access-cpp 14.8237 "Accessing vector of size 10000000 (100 repetitions)" (2009, 2, 17, 14, 50, 41) la-vector-assignment-cpp 20.2998 "Assigning to vector of size 10000000 (100 repetitions)" (2009, 2, 17, 14, 50, 46) fem-jit-python 0.00846782 "JIT compilation (in memory cache)" (2009, 2, 17, 14, 50, 57) fem-convergence-cpp 11.3066 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 2, 17, 14, 55, 21) fem-assembly-cpp 263.869 "Assembly for various forms and backends" (2009, 2, 17, 14, 55, 59) mesh-unitcube-cpp 38.0645 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 2, 17, 14, 57, 22) mesh-refinement-cpp 82.32 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 2, 17, 14, 57, 40) mesh-iteration-cpp 13.98 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 2, 17, 13, 36, 44) common-progress-cpp 520.814 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 4, 7, 15, 0, 43) la-vector-access-cpp 15.8316 "Accessing vector of size 10000000 (100 repetitions)" (2009, 4, 7, 15, 1, 2) la-vector-assignment-cpp 19.2988 "Assigning to vector of size 10000000 (100 repetitions)" (2009, 4, 7, 15, 1, 7) fem-jit-python 0.00636039 "JIT compilation (in memory cache)" (2009, 4, 7, 15, 1, 42) fem-convergence-cpp 35.5486 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 4, 7, 15, 11, 21) fem-assembly-cpp 579.254 "Assembly for various forms and backends" (2009, 4, 7, 15, 12, 0) mesh-unitcube-cpp 38.1176 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 4, 7, 15, 13, 22) mesh-refinement-cpp 82.04 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 4, 7, 15, 13, 40) mesh-iteration-cpp 13.97 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 4, 7, 11, 40, 54) common-progress-cpp 520.816 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 9, 26, 11, 5, 0) common-progress-cpp 595.635 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 9, 26, 11, 12, 6) fem-assembly-cpp 425.772 "Assembly for various forms and backends" (2009, 9, 26, 11, 12, 32) fem-convergence-cpp 26.3695 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 9, 26, 11, 12, 40) fem-jit-python 0.0060529 "JIT compilation (in memory cache)" (2009, 9, 26, 11, 19, 38) fem-speedup-cpp 417.534 "Assembly/solve speedup running on 4 processors" (2009, 9, 26, 11, 19, 38) fem-speedup-cpp-assembly 2.56383 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2009, 9, 26, 11, 19, 38) fem-speedup-cpp-solve 1.81727 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2009, 9, 26, 11, 21, 24) mesh-refinement-cpp 105.12 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 9, 26, 11, 22, 8) mesh-unitcube-cpp 44.2465 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 9, 26, 11, 22, 49) mesh-iteration-cpp 36.16 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 9, 26, 11, 23, 11) function-evaluation-cpp 22.0644 "Evaluations of functions at arbitrary points." (2009, 9, 26, 11, 23, 11) function-evaluation-cpp 21.94 "Evaluations of functions at arbitrary points." (2009, 9, 26, 11, 24, 2) la-vector-access-cpp 50.4373 "Accessing vector of size 10000000 (100 repetitions)" (2009, 9, 26, 11, 24, 24) la-vector-assignment-cpp 22.8032 "Assigning to vector of size 10000000 (100 repetitions)" (2009, 10, 12, 10, 7, 22) common-progress-cpp 596.983 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 10, 12, 10, 14, 27) fem-assembly-cpp 425.915 "Assembly for various forms and backends" (2009, 10, 12, 10, 14, 54) fem-convergence-cpp 26.3268 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 10, 12, 10, 15, 22) fem-jit-python 0.0067857 "JIT compilation (in memory cache)" (2009, 10, 12, 10, 23, 20) fem-speedup-cpp 477.349 "Assembly/solve speedup running on 4 processors" (2009, 10, 12, 10, 23, 20) fem-speedup-cpp-assembly 2.57143 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2009, 10, 12, 10, 23, 20) fem-speedup-cpp-solve 2.65017 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2009, 10, 12, 10, 25, 5) mesh-refinement-cpp 104.54 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 10, 12, 10, 25, 49) mesh-unitcube-cpp 44.1032 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 10, 12, 10, 26, 30) mesh-iteration-cpp 36.16 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 10, 12, 10, 26, 51) function-evaluation-cpp 21.0695 "Evaluations of functions at arbitrary points." (2009, 10, 12, 10, 26, 51) function-evaluation-cpp 20.95 "Evaluations of functions at arbitrary points." (2009, 10, 12, 10, 27, 38) la-vector-access-cpp 46.9329 "Accessing vector of size 10000000 (100 repetitions)" (2009, 10, 12, 10, 28, 1) la-vector-assignment-cpp 22.8043 "Assigning to vector of size 10000000 (100 repetitions)" (2009, 12, 4, 9, 4, 57) common-progress-cpp 596.335 "Creating progress bar with 500000000 steps (5 repetitions)" (2009, 12, 4, 9, 12, 2) fem-assembly-cpp 425.04 "Assembly for various forms and backends" (2009, 12, 4, 9, 12, 27) fem-convergence-cpp 25.672 "Solving Poisson's equation in 2D for q = 1, n = 2." (2009, 12, 4, 9, 12, 28) fem-jit-python 0.0059581 "JIT compilation (in memory cache)" (2009, 12, 4, 9, 20, 40) fem-speedup-cpp 491.809 "Assembly/solve speedup running on 4 processors" (2009, 12, 4, 9, 20, 40) fem-speedup-cpp-assembly 2.54639 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2009, 12, 4, 9, 20, 40) fem-speedup-cpp-solve 2.55689 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2009, 12, 4, 9, 22, 27) mesh-refinement-cpp 105.47 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2009, 12, 4, 9, 23, 11) mesh-unitcube-cpp 44.4285 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2009, 12, 4, 9, 23, 52) mesh-iteration-cpp 36.12 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2009, 12, 4, 9, 24, 13) function-evaluation-cpp 20.8032 "Evaluations of functions at arbitrary points." (2009, 12, 4, 9, 24, 13) function-evaluation-cpp 20.69 "Evaluations of functions at arbitrary points." (2009, 12, 4, 9, 25, 0) la-vector-access-cpp 46.9343 "Accessing vector of size 10000000 (100 repetitions)" (2009, 12, 4, 9, 25, 23) la-vector-assignment-cpp 23.3136 "Assigning to vector of size 10000000 (100 repetitions)" (2010, 2, 3, 9, 28, 57) common-progress-cpp 597.902 "Creating progress bar with 500000000 steps (5 repetitions)" (2010, 2, 3, 9, 36, 18) fem-assembly-cpp 440.361 "Assembly for various forms and backends" (2010, 2, 3, 9, 36, 31) fem-convergence-cpp 12.7566 "Solving Poisson's equation in 2D for q = 1, n = 2." (2010, 2, 3, 9, 36, 33) fem-jit-python 0.0244736 "JIT compilation (in memory cache)" (2010, 2, 3, 9, 44, 34) fem-speedup-cpp 480.786 "Assembly/solve speedup running on 4 processors" (2010, 2, 3, 9, 44, 34) fem-speedup-cpp-assembly 2.50538 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2010, 2, 3, 9, 44, 34) fem-speedup-cpp-solve 2.34291 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2010, 2, 3, 9, 46, 20) mesh-refinement-cpp 105.43 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2010, 2, 3, 9, 47, 10) mesh-unitcube-cpp 49.6756 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2010, 2, 3, 9, 47, 51) mesh-iteration-cpp 36.14 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2010, 2, 3, 9, 48, 13) function-evaluation-cpp 22.2158 "Evaluations of functions at arbitrary points." (2010, 2, 3, 9, 48, 13) function-evaluation-cpp 22.06 "Evaluations of functions at arbitrary points." (2010, 2, 3, 9, 49, 4) la-vector-access-cpp 50.4234 "Accessing vector of size 10000000 (100 repetitions)" (2010, 2, 3, 9, 49, 28) la-vector-assignment-cpp 24.811 "Assigning to vector of size 10000000 (100 repetitions)" (2010, 2, 17, 10, 44, 42) common-progress-cpp 593.092 "Creating progress bar with 500000000 steps (5 repetitions)" (2010, 2, 17, 10, 52, 2) fem-assembly-cpp 439.682 "Assembly for various forms and backends" (2010, 2, 17, 10, 52, 15) fem-convergence-cpp 12.9031 "Solving Poisson's equation in 2D for q = 1, n = 2." (2010, 2, 17, 10, 52, 17) fem-jit-python 0.0251185 "JIT compilation (in memory cache)" (2010, 2, 17, 10, 59, 34) fem-speedup-cpp 436.864 "Assembly/solve speedup running on 4 processors" (2010, 2, 17, 10, 59, 34) fem-speedup-cpp-assembly 2.47917 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2010, 2, 17, 10, 59, 34) fem-speedup-cpp-solve 1.4417 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2010, 2, 17, 11, 1, 32) mesh-refinement-cpp 117.03 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2010, 2, 17, 11, 2, 17) mesh-unitcube-cpp 44.5587 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2010, 2, 17, 11, 2, 58) mesh-iteration-cpp 36.21 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2010, 2, 17, 11, 3, 20) function-evaluation-cpp 22.2584 "Evaluations of functions at arbitrary points." (2010, 2, 17, 11, 3, 20) function-evaluation-cpp 22.14 "Evaluations of functions at arbitrary points." (2010, 2, 17, 11, 4, 7) la-vector-access-cpp 46.4237 "Accessing vector of size 10000000 (100 repetitions)" (2010, 2, 17, 11, 4, 30) la-vector-assignment-cpp 23.8103 "Assigning to vector of size 10000000 (100 repetitions)" (2010, 7, 1, 11, 18, 53) common-progress-cpp 33.9116 "Creating progress bar with 500000000 steps (5 repetitions)" (2010, 7, 1, 11, 22, 53) fem-assembly-cpp 239.567 "Assembly for various forms and backends" (2010, 7, 1, 11, 23, 5) fem-convergence-cpp 12.7182 "Solving Poisson's equation in 2D for q = 1, n = 2." (2010, 7, 1, 11, 23, 8) fem-jit-python 0.0250931 "JIT compilation (in memory cache)" (2010, 7, 1, 11, 25, 42) fem-speedup-cpp 153.886 "Assembly/solve speedup running on 4 processors" (2010, 7, 1, 11, 25, 42) fem-speedup-cpp-assembly 2.48235 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2010, 7, 1, 11, 25, 42) fem-speedup-cpp-solve 1.5378 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2010, 7, 1, 11, 27, 22) mesh-refinement-cpp 99.99 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2010, 7, 1, 11, 27, 39) mesh-unitcube-cpp 17.167 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2010, 7, 1, 11, 28, 17) mesh-iteration-cpp 36.2 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2010, 7, 1, 11, 28, 39) function-evaluation-cpp 21.9734 "Evaluations of functions at arbitrary points." (2010, 7, 1, 11, 28, 39) function-evaluation-cpp 21.89 "Evaluations of functions at arbitrary points." (2010, 7, 1, 11, 29, 30) la-vector-access-cpp 50.9623 "Accessing vector of size 10000000 (100 repetitions)" (2010, 7, 1, 11, 29, 54) la-vector-assignment-cpp 23.8196 "Assigning to vector of size 10000000 (100 repetitions)" (2010, 9, 2, 11, 36, 6) common-progress-cpp 28.1953 "Creating progress bar with 500000000 steps (5 repetitions)" (2010, 9, 2, 11, 40, 5) fem-assembly-cpp 239.167 "Assembly for various forms and backends" (2010, 9, 2, 11, 40, 17) fem-convergence-cpp 12.6995 "Solving Poisson's equation in 2D for q = 1, n = 2." (2010, 9, 2, 11, 40, 18) fem-jit-python 0.000318193 "JIT compilation (in memory cache)" (2010, 9, 2, 11, 42, 50) fem-speedup-cpp 151.885 "Assembly/solve speedup running on 4 processors" (2010, 9, 2, 11, 42, 50) fem-speedup-cpp-assembly 2.44578 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2010, 9, 2, 11, 42, 50) fem-speedup-cpp-solve 1.39037 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2010, 9, 2, 11, 44, 31) mesh-refinement-cpp 100.49 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2010, 9, 2, 11, 44, 46) mesh-unitcube-cpp 15.3218 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2010, 9, 2, 11, 45, 27) mesh-iteration-cpp 38.47 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2010, 9, 2, 11, 45, 48) function-evaluation-cpp 21.9537 "Evaluations of functions at arbitrary points." (2010, 9, 2, 11, 45, 48) function-evaluation-cpp 21.83 "Evaluations of functions at arbitrary points." (2010, 9, 2, 11, 46, 41) la-vector-access-cpp 47.9873 "Accessing vector of size 10000000 (100 repetitions)" (2010, 9, 2, 11, 47, 3) la-vector-assignment-cpp 21.8435 "Assigning to vector of size 10000000 (100 repetitions)" (2011, 2, 23, 12, 11, 27) common-progress-cpp 35.2089 "Creating progress bar with 500000000 steps (5 repetitions)" (2011, 2, 23, 12, 11, 54) common-timing-cpp 26.9492 "Timing access and registration of timings (10000000 repetitions)" (2011, 2, 23, 12, 12, 7) fem-multicore-cpp 13.1911 "Coloring mesh." (2011, 2, 23, 12, 16, 32) fem-assembly-cpp 264.223 "Assembly for various forms and backends" (2011, 2, 23, 12, 16, 45) fem-convergence-cpp 13.6343 "Solving Poisson's equation in 2D for q = 1, n = 2." (2011, 2, 23, 12, 16, 46) fem-jit-python 0.000336289 "JIT compilation (in memory cache)" (2011, 2, 23, 12, 22, 54) fem-speedup-cpp 367.888 "Assembly/solve speedup running on 4 processors" (2011, 2, 23, 12, 22, 54) fem-speedup-cpp-assembly 5.58102 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2011, 2, 23, 12, 22, 54) fem-speedup-cpp-solve 1.40411 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2011, 2, 23, 12, 23, 41) mesh-refinement-cpp 45.4596 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2011, 2, 23, 12, 24, 21) mesh-topology-cpp 39.6228 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2011, 2, 23, 12, 24, 39) mesh-unitcube-cpp 18.1147 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2011, 2, 23, 12, 25, 17) mesh-iteration-cpp 36.588 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2011, 2, 23, 12, 25, 40) function-evaluation-cpp 22.5863 "Evaluations of functions at arbitrary points." (2011, 2, 23, 12, 25, 40) function-evaluation-cpp 22.4607 "Evaluations of functions at arbitrary points." (2011, 2, 23, 12, 26, 0) la-vector-access-cpp 20.5366 "Accessing vector of size 10000000 (100 repetitions)" (2011, 2, 23, 12, 26, 21) la-vector-assignment-cpp 20.7975 "Assigning to vector of size 10000000 (100 repetitions)" (2011, 5, 16, 10, 48, 7) common-progress-cpp 33.9909 "Creating progress bar with 500000000 steps (5 repetitions)" (2011, 5, 16, 10, 48, 33) common-timing-cpp 26.2898 "Timing access and registration of timings (10000000 repetitions)" (2011, 5, 16, 10, 48, 44) fem-multicore-cpp 10.3499 "Coloring mesh." (2011, 5, 16, 10, 52, 42) fem-assembly-cpp 238.558 "Assembly for various forms and backends" (2011, 5, 16, 10, 52, 56) fem-convergence-cpp 13.8223 "*** Warning: The function 'logging' is deprecated, use 'set_log_active'." (2011, 5, 16, 10, 52, 59) fem-jit-python 0.000444913 "JIT compilation (in memory cache)" (2011, 5, 16, 10, 58, 47) fem-speedup-cpp 348.541 "Assembly/solve speedup running on 4 processors" (2011, 5, 16, 10, 58, 47) fem-speedup-cpp-assembly 5.41016 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2011, 5, 16, 10, 58, 47) fem-speedup-cpp-solve 1.91566 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2011, 5, 16, 10, 59, 33) mesh-refinement-cpp 45.1063 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2011, 5, 16, 11, 0, 14) mesh-topology-cpp 40.5342 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2011, 5, 16, 11, 0, 32) mesh-unitcube-cpp 18.4513 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2011, 5, 16, 11, 1, 14) mesh-iteration-cpp 39.5328 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2011, 5, 16, 11, 1, 36) function-evaluation-cpp 22.2639 "Evaluations of functions at arbitrary points." (2011, 5, 16, 11, 1, 36) function-evaluation-cpp 22.1138 "Evaluations of functions at arbitrary points." (2011, 5, 16, 11, 1, 54) la-vector-access-cpp 17.6943 "Accessing vector of size 10000000 (100 repetitions)" (2011, 5, 16, 11, 2, 16) la-vector-assignment-cpp 22.7888 "Assigning to vector of size 10000000 (100 repetitions)" (2011, 8, 11, 6, 24, 7) common-progress-cpp 27.676 "Creating progress bar with 500000000 steps (5 repetitions)" (2011, 8, 11, 6, 24, 34) common-timing-cpp 27.158 "Timing access and registration of timings (10000000 repetitions)" (2011, 8, 11, 6, 24, 44) fem-multicore-cpp 10.3709 "Coloring mesh." (2011, 8, 11, 6, 28, 43) fem-assembly-cpp 239.121 "Assembly for various forms and backends" (2011, 8, 11, 6, 28, 57) fem-convergence-cpp 13.9848 "*** Warning: The function 'logging' is deprecated, use 'set_log_active'." (2011, 8, 11, 6, 29, 0) fem-jit-python 0.000418997 "JIT compilation (in memory cache)" (2011, 8, 11, 6, 35, 12) fem-speedup-cpp 371.482 "Assembly/solve speedup running on 4 processors" (2011, 8, 11, 6, 35, 12) fem-speedup-cpp-assembly 5.55195 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2011, 8, 11, 6, 35, 12) fem-speedup-cpp-solve 1.50643 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2011, 8, 11, 6, 35, 58) mesh-refinement-cpp 44.3073 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2011, 8, 11, 6, 36, 38) mesh-topology-cpp 40.0738 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2011, 8, 11, 6, 36, 56) mesh-unitcube-cpp 18.2183 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2011, 8, 11, 6, 37, 36) mesh-iteration-cpp 37.6003 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2011, 8, 11, 6, 37, 59) function-evaluation-cpp 22.8748 "Evaluations of functions at arbitrary points." (2011, 8, 11, 6, 37, 59) function-evaluation-cpp 22.7168 "Evaluations of functions at arbitrary points." (2011, 8, 11, 6, 38, 17) la-vector-access-cpp 17.9047 "Accessing vector of size 10000000 (100 repetitions)" (2011, 8, 11, 6, 38, 38) la-vector-assignment-cpp 21.3412 "Assigning to vector of size 10000000 (100 repetitions)" (2011, 12, 7, 8, 35, 11) common-progress-cpp 29.2316 "Creating progress bar with 500000000 steps (5 repetitions)" (2011, 12, 7, 8, 35, 40) common-timing-cpp 29.0057 "Timing access and registration of timings (10000000 repetitions)" (2011, 12, 7, 8, 35, 50) fem-multicore-cpp 10.5959 "Coloring mesh." (2011, 12, 7, 8, 40, 4) fem-assembly-cpp 253.54 "Assembly for various forms and backends" (2011, 12, 7, 8, 40, 17) fem-convergence-cpp 13.6581 "Solving Poisson's equation in 2D for q = 1, n = 2." (2011, 12, 7, 8, 40, 18) fem-jit-python 0.000432897 "JIT compilation (in memory cache)" (2011, 12, 7, 8, 47, 5) fem-speedup-cpp 406.216 "Assembly/solve speedup running on 4 processors" (2011, 12, 7, 8, 47, 5) fem-speedup-cpp-assembly 5.71627 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2011, 12, 7, 8, 47, 5) fem-speedup-cpp-solve 1.39569 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2011, 12, 7, 8, 48, 13) mesh-refinement-cpp 66.4876 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2011, 12, 7, 8, 48, 53) mesh-topology-cpp 40.1815 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2011, 12, 7, 8, 49, 13) mesh-unitcube-cpp 20.2862 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2011, 12, 7, 8, 49, 58) mesh-iteration-cpp 42.3196 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2011, 12, 7, 8, 50, 22) la-vector-access-cpp 23.939 "Accessing vector of size 10000000 (100 repetitions)" (2011, 12, 7, 8, 50, 46) la-vector-assignment-cpp 24.4505 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 14, 10, 39, 5) common-progress-cpp 29.6111 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 14, 10, 39, 34) common-timing-cpp 28.8854 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 14, 10, 39, 44) fem-multicore-cpp 10.1149 "Coloring mesh." (2012, 2, 14, 10, 43, 1) fem-assembly-cpp 196.373 "Assembly for various forms and backends" (2012, 2, 14, 10, 43, 12) fem-convergence-cpp 11.7074 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 14, 10, 43, 13) fem-jit-python 0.000421596 "JIT compilation (in memory cache)" (2012, 2, 14, 10, 48, 31) fem-speedup-cpp 318.02 "Assembly/solve speedup running on 4 processors" (2012, 2, 14, 10, 48, 31) fem-speedup-cpp-assembly 5.51232 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 14, 10, 48, 31) fem-speedup-cpp-solve 2.04125 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 14, 10, 49, 2) mesh-refinement-cpp 29.417 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 14, 10, 49, 38) mesh-topology-cpp 35.8703 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 14, 10, 50, 0) mesh-unitcube-cpp 22.188 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 14, 10, 50, 46) mesh-iteration-cpp 43.2879 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 14, 10, 50, 53) function-extrapolation-python 6.7923 "BENCH: 1.92506408691" (2012, 2, 14, 10, 50, 53) function-extrapolation-python 1.92506 "BENCH: 1.92506408691" (2012, 2, 14, 10, 51, 16) la-vector-access-cpp 23.545 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 14, 10, 51, 42) la-vector-assignment-cpp 25.4055 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 15, 2, 10, 45) common-progress-cpp 36.4267 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 15, 2, 11, 14) common-timing-cpp 28.9545 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 15, 2, 11, 24) fem-multicore-cpp 10.1293 "Coloring mesh." (2012, 2, 15, 2, 14, 41) fem-assembly-cpp 197.194 "Assembly for various forms and backends" (2012, 2, 15, 2, 14, 53) fem-convergence-cpp 11.9123 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 15, 2, 14, 54) fem-jit-python 0.000424099 "JIT compilation (in memory cache)" (2012, 2, 15, 2, 20, 42) fem-speedup-cpp 348.098 "Assembly/solve speedup running on 4 processors" (2012, 2, 15, 2, 20, 42) fem-speedup-cpp-assembly 5.49244 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 15, 2, 20, 42) fem-speedup-cpp-solve 1.48337 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 15, 2, 21, 13) mesh-refinement-cpp 29.2876 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 15, 2, 21, 49) mesh-topology-cpp 35.7988 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 15, 2, 22, 11) mesh-unitcube-cpp 22.0805 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 15, 2, 22, 56) mesh-iteration-cpp 42.3068 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 15, 2, 23, 3) function-extrapolation-python 6.6989 "BENCH: 1.95823812485" (2012, 2, 15, 2, 23, 3) function-extrapolation-python 1.95824 "BENCH: 1.95823812485" (2012, 2, 15, 2, 23, 28) la-vector-access-cpp 24.7837 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 15, 2, 23, 53) la-vector-assignment-cpp 25.4381 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 16, 2, 11, 13) common-progress-cpp 29.7211 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 16, 2, 11, 41) common-timing-cpp 27.9184 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 16, 2, 11, 51) fem-multicore-cpp 10.0904 "Coloring mesh." (2012, 2, 16, 2, 15, 8) fem-assembly-cpp 197.416 "Assembly for various forms and backends" (2012, 2, 16, 2, 15, 20) fem-convergence-cpp 11.7719 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 16, 2, 15, 23) fem-jit-python 0.000430512 "JIT compilation (in memory cache)" (2012, 2, 16, 2, 21, 0) fem-speedup-cpp 337.021 "Assembly/solve speedup running on 4 processors" (2012, 2, 16, 2, 21, 0) fem-speedup-cpp-assembly 5.41916 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 16, 2, 21, 0) fem-speedup-cpp-solve 1.57975 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 16, 2, 21, 24) mesh-refinement-cpp 22.9859 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 16, 2, 21, 46) mesh-topology-cpp 21.6153 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 16, 2, 22, 12) mesh-unitcube-cpp 25.9115 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 16, 2, 23, 6) mesh-iteration-cpp 51.0314 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 16, 2, 23, 13) function-extrapolation-python 6.67041 "BENCH: 1.85507106781" (2012, 2, 16, 2, 23, 13) function-extrapolation-python 1.85507 "BENCH: 1.85507106781" (2012, 2, 16, 2, 23, 35) la-vector-access-cpp 22.4256 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 16, 2, 24, 1) la-vector-assignment-cpp 25.3903 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 17, 2, 11, 2) common-progress-cpp 29.5262 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 17, 2, 11, 29) common-timing-cpp 27.0658 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 17, 2, 11, 39) fem-multicore-cpp 10.0568 "Coloring mesh." (2012, 2, 17, 2, 14, 55) fem-assembly-cpp 196.196 "Assembly for various forms and backends" (2012, 2, 17, 2, 15, 7) fem-convergence-cpp 11.6798 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 17, 2, 15, 8) fem-jit-python 0.000422406 "JIT compilation (in memory cache)" (2012, 2, 17, 2, 20, 18) fem-speedup-cpp 310.227 "Assembly/solve speedup running on 4 processors" (2012, 2, 17, 2, 20, 18) fem-speedup-cpp-assembly 5.45884 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 17, 2, 20, 18) fem-speedup-cpp-solve 2.02068 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 17, 2, 20, 42) mesh-refinement-cpp 22.2379 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 17, 2, 21, 3) mesh-topology-cpp 21.1826 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 17, 2, 21, 24) mesh-unitcube-cpp 20.9564 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 17, 2, 22, 7) mesh-iteration-cpp 41.0497 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 17, 2, 22, 14) function-extrapolation-python 6.83684 "BENCH: 1.89804196358" (2012, 2, 17, 2, 22, 14) function-extrapolation-python 1.89804 "BENCH: 1.89804196358" (2012, 2, 17, 2, 22, 37) la-vector-access-cpp 22.4288 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 17, 2, 23, 2) la-vector-assignment-cpp 25.3919 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 18, 2, 11, 9) common-progress-cpp 29.3891 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 18, 2, 11, 36) common-timing-cpp 27.1296 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 18, 2, 11, 46) fem-multicore-cpp 10.0048 "Coloring mesh." (2012, 2, 18, 2, 15, 1) fem-assembly-cpp 195.306 "Assembly for various forms and backends" (2012, 2, 18, 2, 15, 13) fem-convergence-cpp 11.5941 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 18, 2, 15, 14) fem-jit-python 0.000431204 "JIT compilation (in memory cache)" (2012, 2, 18, 2, 20, 39) fem-speedup-cpp 324.538 "Assembly/solve speedup running on 4 processors" (2012, 2, 18, 2, 20, 39) fem-speedup-cpp-assembly 5.52437 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 18, 2, 20, 39) fem-speedup-cpp-solve 1.74741 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 18, 2, 21, 2) mesh-refinement-cpp 22.3391 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 18, 2, 21, 24) mesh-topology-cpp 21.1066 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 18, 2, 21, 45) mesh-unitcube-cpp 21.0726 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 18, 2, 22, 29) mesh-iteration-cpp 41.6188 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 18, 2, 22, 36) function-extrapolation-python 6.7424 "BENCH: 1.93186807632" (2012, 2, 18, 2, 22, 36) function-extrapolation-python 1.93187 "BENCH: 1.93186807632" (2012, 2, 18, 2, 23, 0) la-vector-access-cpp 23.8191 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 18, 2, 23, 25) la-vector-assignment-cpp 25.388 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 19, 2, 11, 3) common-progress-cpp 29.4786 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 19, 2, 11, 31) common-timing-cpp 28.1226 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 19, 2, 11, 41) fem-multicore-cpp 10.0208 "Coloring mesh." (2012, 2, 19, 2, 14, 56) fem-assembly-cpp 195.034 "Assembly for various forms and backends" (2012, 2, 19, 2, 15, 8) fem-convergence-cpp 11.6263 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 19, 2, 15, 9) fem-jit-python 0.000423598 "JIT compilation (in memory cache)" (2012, 2, 19, 2, 20, 29) fem-speedup-cpp 319.491 "Assembly/solve speedup running on 4 processors" (2012, 2, 19, 2, 20, 29) fem-speedup-cpp-assembly 5.5499 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 19, 2, 20, 29) fem-speedup-cpp-solve 1.87927 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 19, 2, 20, 52) mesh-refinement-cpp 22.2182 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 19, 2, 21, 14) mesh-topology-cpp 21.1064 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 19, 2, 21, 35) mesh-unitcube-cpp 20.9159 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 19, 2, 22, 19) mesh-iteration-cpp 42.1144 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 19, 2, 22, 26) function-extrapolation-python 6.7728 "BENCH: 1.94360399246" (2012, 2, 19, 2, 22, 26) function-extrapolation-python 1.9436 "BENCH: 1.94360399246" (2012, 2, 19, 2, 22, 49) la-vector-access-cpp 22.4431 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 19, 2, 23, 14) la-vector-assignment-cpp 25.3972 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 20, 2, 11, 1) common-progress-cpp 37.7044 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 20, 2, 11, 29) common-timing-cpp 27.8028 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 20, 2, 11, 39) fem-multicore-cpp 10.0327 "Coloring mesh." (2012, 2, 20, 2, 14, 54) fem-assembly-cpp 195.107 "Assembly for various forms and backends" (2012, 2, 20, 2, 15, 6) fem-convergence-cpp 11.5751 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 20, 2, 15, 7) fem-jit-python 0.000422311 "JIT compilation (in memory cache)" (2012, 2, 20, 2, 20, 32) fem-speedup-cpp 324.725 "Assembly/solve speedup running on 4 processors" (2012, 2, 20, 2, 20, 32) fem-speedup-cpp-assembly 5.53876 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 20, 2, 20, 32) fem-speedup-cpp-solve 1.73764 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 20, 2, 20, 56) mesh-refinement-cpp 22.2203 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 20, 2, 21, 17) mesh-topology-cpp 21.1084 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 20, 2, 21, 38) mesh-unitcube-cpp 21.0358 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 20, 2, 22, 22) mesh-iteration-cpp 41.62 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 20, 2, 22, 29) function-extrapolation-python 6.77272 "BENCH: 1.94126605988" (2012, 2, 20, 2, 22, 29) function-extrapolation-python 1.94127 "BENCH: 1.94126605988" (2012, 2, 20, 2, 22, 53) la-vector-access-cpp 24.4551 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 20, 2, 23, 19) la-vector-assignment-cpp 25.3988 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 21, 2, 10, 52) common-progress-cpp 29.4553 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 21, 2, 11, 19) common-timing-cpp 27.1758 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 21, 2, 11, 29) fem-multicore-cpp 10.0762 "Coloring mesh." (2012, 2, 21, 2, 14, 45) fem-assembly-cpp 195.472 "Assembly for various forms and backends" (2012, 2, 21, 2, 14, 56) fem-convergence-cpp 11.5682 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 21, 2, 14, 57) fem-jit-python 0.000425005 "JIT compilation (in memory cache)" (2012, 2, 21, 2, 20, 15) fem-speedup-cpp 317.829 "Assembly/solve speedup running on 4 processors" (2012, 2, 21, 2, 20, 15) fem-speedup-cpp-assembly 5.49712 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 21, 2, 20, 15) fem-speedup-cpp-solve 1.88517 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 21, 2, 20, 39) mesh-refinement-cpp 22.2217 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 21, 2, 21, 0) mesh-topology-cpp 21.1646 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 21, 2, 21, 21) mesh-unitcube-cpp 21.0428 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 21, 2, 22, 5) mesh-iteration-cpp 41.6181 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 21, 2, 22, 12) function-extrapolation-python 6.78422 "BENCH: 1.94494700432" (2012, 2, 21, 2, 22, 12) function-extrapolation-python 1.94495 "BENCH: 1.94494700432" (2012, 2, 21, 2, 22, 37) la-vector-access-cpp 24.4507 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 21, 2, 23, 2) la-vector-assignment-cpp 25.4279 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 22, 2, 11, 9) common-progress-cpp 29.6217 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 22, 2, 11, 35) common-timing-cpp 26.1961 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 22, 2, 11, 45) fem-multicore-cpp 10.0101 "Coloring mesh." (2012, 2, 22, 2, 15, 1) fem-assembly-cpp 196.141 "Assembly for various forms and backends" (2012, 2, 22, 2, 15, 12) fem-convergence-cpp 11.6069 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 22, 2, 15, 14) fem-jit-python 0.000419712 "JIT compilation (in memory cache)" (2012, 2, 22, 2, 20, 37) fem-speedup-cpp 323.285 "Assembly/solve speedup running on 4 processors" (2012, 2, 22, 2, 20, 37) fem-speedup-cpp-assembly 5.53815 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 22, 2, 20, 37) fem-speedup-cpp-solve 1.79809 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 22, 2, 21, 1) mesh-refinement-cpp 22.2328 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 22, 2, 21, 22) mesh-topology-cpp 21.2685 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 22, 2, 21, 43) mesh-unitcube-cpp 21.0014 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 22, 2, 22, 28) mesh-iteration-cpp 42.3159 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 22, 2, 22, 35) function-extrapolation-python 6.66545 "BENCH: 1.88887500763" (2012, 2, 22, 2, 22, 35) function-extrapolation-python 1.88888 "BENCH: 1.88887500763" (2012, 2, 22, 2, 22, 57) la-vector-access-cpp 22.439 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 22, 2, 23, 22) la-vector-assignment-cpp 24.9489 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 23, 2, 11, 29) common-progress-cpp 29.6307 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 23, 2, 11, 57) common-timing-cpp 27.7839 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 23, 2, 12, 7) fem-multicore-cpp 10.0873 "Coloring mesh." (2012, 2, 23, 2, 15, 47) fem-assembly-cpp 219.493 "Assembly for various forms and backends" (2012, 2, 23, 2, 15, 58) fem-convergence-cpp 11.584 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 23, 2, 15, 59) fem-jit-python 0.000422287 "JIT compilation (in memory cache)" (2012, 2, 23, 2, 21, 21) fem-speedup-cpp 322.164 "Assembly/solve speedup running on 4 processors" (2012, 2, 23, 2, 21, 21) fem-speedup-cpp-assembly 5.50432 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 23, 2, 21, 21) fem-speedup-cpp-solve 1.81969 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 23, 2, 21, 45) mesh-refinement-cpp 22.2776 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 23, 2, 22, 7) mesh-topology-cpp 21.2501 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 23, 2, 22, 28) mesh-unitcube-cpp 20.993 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 23, 2, 23, 12) mesh-iteration-cpp 41.6129 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 23, 2, 23, 19) function-extrapolation-python 6.73588 "BENCH: 1.9055120945" (2012, 2, 23, 2, 23, 19) function-extrapolation-python 1.90551 "BENCH: 1.9055120945" (2012, 2, 23, 2, 23, 41) la-vector-access-cpp 22.4054 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 23, 2, 24, 9) la-vector-assignment-cpp 27.9088 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 25, 2, 10, 48) common-progress-cpp 29.7488 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 25, 2, 11, 16) common-timing-cpp 27.6256 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 25, 2, 11, 26) fem-multicore-cpp 10.0566 "Coloring mesh." (2012, 2, 25, 2, 15, 6) fem-assembly-cpp 219.736 "Assembly for various forms and backends" (2012, 2, 25, 2, 15, 17) fem-convergence-cpp 11.7109 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 25, 2, 15, 20) fem-jit-python 0.000421286 "JIT compilation (in memory cache)" (2012, 2, 25, 2, 20, 54) fem-speedup-cpp 333.872 "Assembly/solve speedup running on 4 processors" (2012, 2, 25, 2, 20, 54) fem-speedup-cpp-assembly 5.41226 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 25, 2, 20, 54) fem-speedup-cpp-solve 1.6144 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 25, 2, 21, 18) mesh-refinement-cpp 22.2431 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 25, 2, 21, 39) mesh-topology-cpp 21.2707 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 25, 2, 22, 0) mesh-unitcube-cpp 20.9687 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 25, 2, 22, 45) mesh-iteration-cpp 42.4139 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 25, 2, 22, 52) function-extrapolation-python 6.61425 "BENCH: 1.86223196983" (2012, 2, 25, 2, 22, 52) function-extrapolation-python 1.86223 "BENCH: 1.86223196983" (2012, 2, 25, 2, 23, 14) la-vector-access-cpp 22.4096 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 25, 2, 23, 39) la-vector-assignment-cpp 24.938 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 26, 2, 10, 39) common-progress-cpp 29.6827 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 26, 2, 11, 7) common-timing-cpp 27.5193 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 26, 2, 11, 17) fem-multicore-cpp 10.0022 "Coloring mesh." (2012, 2, 26, 2, 14, 57) fem-assembly-cpp 220.613 "Assembly for various forms and backends" (2012, 2, 26, 2, 15, 9) fem-convergence-cpp 11.6063 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 26, 2, 15, 10) fem-jit-python 0.000416684 "JIT compilation (in memory cache)" (2012, 2, 26, 2, 20, 26) fem-speedup-cpp 316.075 "Assembly/solve speedup running on 4 processors" (2012, 2, 26, 2, 20, 26) fem-speedup-cpp-assembly 5.48959 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 26, 2, 20, 26) fem-speedup-cpp-solve 1.94827 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 26, 2, 20, 50) mesh-refinement-cpp 22.2992 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 26, 2, 21, 11) mesh-topology-cpp 21.2619 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 26, 2, 21, 32) mesh-unitcube-cpp 21.0136 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 26, 2, 22, 17) mesh-iteration-cpp 42.2499 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 26, 2, 22, 24) function-extrapolation-python 6.62892 "BENCH: 1.87784814835" (2012, 2, 26, 2, 22, 24) function-extrapolation-python 1.87785 "BENCH: 1.87784814835" (2012, 2, 26, 2, 22, 46) la-vector-access-cpp 22.4038 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 26, 2, 23, 11) la-vector-assignment-cpp 24.9438 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 27, 2, 10, 49) common-progress-cpp 38.9561 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 27, 2, 11, 16) common-timing-cpp 26.7055 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 27, 2, 11, 26) fem-multicore-cpp 10.0724 "Coloring mesh." (2012, 2, 27, 2, 15, 6) fem-assembly-cpp 220.394 "Assembly for various forms and backends" (2012, 2, 27, 2, 15, 18) fem-convergence-cpp 11.5158 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 27, 2, 15, 19) fem-jit-python 0.000419307 "JIT compilation (in memory cache)" (2012, 2, 27, 2, 20, 44) fem-speedup-cpp 325.516 "Assembly/solve speedup running on 4 processors" (2012, 2, 27, 2, 20, 44) fem-speedup-cpp-assembly 5.53022 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 27, 2, 20, 44) fem-speedup-cpp-solve 1.76675 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 27, 2, 21, 8) mesh-refinement-cpp 22.2457 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 27, 2, 21, 30) mesh-topology-cpp 21.3388 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 27, 2, 21, 51) mesh-unitcube-cpp 21.0537 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 27, 2, 22, 39) mesh-iteration-cpp 46.0111 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 27, 2, 22, 46) function-extrapolation-python 6.71978 "BENCH: 1.99281311035" (2012, 2, 27, 2, 22, 46) function-extrapolation-python 1.99281 "BENCH: 1.99281311035" (2012, 2, 27, 2, 23, 10) la-vector-access-cpp 23.6024 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 27, 2, 23, 35) la-vector-assignment-cpp 24.9446 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 28, 2, 11, 26) common-progress-cpp 29.7783 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 28, 2, 11, 53) common-timing-cpp 26.5032 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 28, 2, 12, 3) fem-multicore-cpp 9.99451 "Coloring mesh." (2012, 2, 28, 2, 12, 15) fem-convergence-cpp 11.6563 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 28, 2, 12, 17) fem-jit-python 0.000420713 "JIT compilation (in memory cache)" (2012, 2, 28, 2, 17, 44) fem-speedup-cpp 326.469 "Assembly/solve speedup running on 4 processors" (2012, 2, 28, 2, 17, 44) fem-speedup-cpp-assembly 5.4348 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 28, 2, 17, 44) fem-speedup-cpp-solve 1.73334 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 28, 2, 18, 8) mesh-refinement-cpp 22.2341 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 28, 2, 18, 29) mesh-topology-cpp 21.111 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 28, 2, 18, 50) mesh-unitcube-cpp 21.0633 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 28, 2, 19, 34) mesh-iteration-cpp 41.6393 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 28, 2, 19, 41) function-extrapolation-python 6.56976 "BENCH: 1.87061309814" (2012, 2, 28, 2, 19, 41) function-extrapolation-python 1.87061 "BENCH: 1.87061309814" (2012, 2, 28, 2, 20, 7) la-vector-access-cpp 25.7875 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 28, 2, 20, 32) la-vector-assignment-cpp 25.4388 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 2, 29, 2, 11, 15) common-progress-cpp 29.6144 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 2, 29, 2, 11, 43) common-timing-cpp 27.9701 "Timing access and registration of timings (10000000 repetitions)" (2012, 2, 29, 2, 11, 53) fem-multicore-cpp 10.097 "Coloring mesh." (2012, 2, 29, 2, 12, 5) fem-convergence-cpp 11.5951 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 2, 29, 2, 12, 6) fem-jit-python 0.0004251 "JIT compilation (in memory cache)" (2012, 2, 29, 2, 17, 17) fem-speedup-cpp 311.177 "Assembly/solve speedup running on 4 processors" (2012, 2, 29, 2, 17, 17) fem-speedup-cpp-assembly 5.52424 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 2, 29, 2, 17, 17) fem-speedup-cpp-solve 2.03784 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 2, 29, 2, 17, 41) mesh-refinement-cpp 22.2815 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 2, 29, 2, 18, 2) mesh-topology-cpp 21.1173 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 2, 29, 2, 18, 23) mesh-unitcube-cpp 21.269 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 2, 29, 2, 19, 7) mesh-iteration-cpp 41.7044 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 2, 29, 2, 19, 14) function-extrapolation-python 6.58109 "BENCH: 1.89537906647" (2012, 2, 29, 2, 19, 14) function-extrapolation-python 1.89538 "BENCH: 1.89537906647" (2012, 2, 29, 2, 19, 37) la-vector-access-cpp 22.4255 "Accessing vector of size 10000000 (100 repetitions)" (2012, 2, 29, 2, 20, 2) la-vector-assignment-cpp 25.4497 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 2, 2, 11, 11) common-progress-cpp 37.7166 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 2, 2, 11, 38) common-timing-cpp 27.1555 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 2, 2, 11, 48) fem-multicore-cpp 10.0269 "Coloring mesh." (2012, 3, 2, 2, 12, 0) fem-convergence-cpp 11.6895 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 2, 2, 12, 1) fem-jit-python 0.000437784 "JIT compilation (in memory cache)" (2012, 3, 2, 2, 17, 23) fem-speedup-cpp 321.856 "Assembly/solve speedup running on 4 processors" (2012, 3, 2, 2, 17, 23) fem-speedup-cpp-assembly 5.45692 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 2, 2, 17, 23) fem-speedup-cpp-solve 1.80895 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 2, 2, 17, 46) mesh-refinement-cpp 22.2671 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 2, 2, 18, 8) mesh-topology-cpp 21.1164 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 2, 2, 18, 29) mesh-unitcube-cpp 21.1234 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 2, 2, 19, 13) mesh-iteration-cpp 41.9632 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 2, 2, 19, 20) function-extrapolation-python 6.54491 "BENCH: 1.88551902771" (2012, 3, 2, 2, 19, 20) function-extrapolation-python 1.88552 "BENCH: 1.88551902771" (2012, 3, 2, 2, 19, 43) la-vector-access-cpp 22.4787 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 2, 2, 20, 10) la-vector-assignment-cpp 27.899 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 3, 2, 11, 35) common-progress-cpp 47.7445 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 3, 2, 12, 2) common-timing-cpp 27.0265 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 3, 2, 12, 12) fem-multicore-cpp 10.0606 "Coloring mesh." (2012, 3, 3, 2, 15, 22) fem-assembly-cpp 190.543 "Assembly for various forms and backends" (2012, 3, 3, 2, 15, 34) fem-convergence-cpp 11.6461 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 3, 2, 15, 35) fem-jit-python 0.000424099 "JIT compilation (in memory cache)" (2012, 3, 3, 2, 21, 15) fem-speedup-cpp 340.129 "Assembly/solve speedup running on 4 processors" (2012, 3, 3, 2, 21, 15) fem-speedup-cpp-assembly 5.55108 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 3, 2, 21, 15) fem-speedup-cpp-solve 1.49924 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 3, 2, 21, 39) mesh-refinement-cpp 22.2783 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 3, 2, 22, 0) mesh-topology-cpp 21.0959 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 3, 2, 22, 22) mesh-unitcube-cpp 21.5152 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 3, 2, 23, 6) mesh-iteration-cpp 41.9603 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 3, 2, 23, 13) function-extrapolation-python 6.71577 "BENCH: 1.8930618763" (2012, 3, 3, 2, 23, 13) function-extrapolation-python 1.89306 "BENCH: 1.8930618763" (2012, 3, 3, 2, 23, 35) la-vector-access-cpp 22.412 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 3, 2, 24, 3) la-vector-assignment-cpp 27.8896 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 4, 2, 11, 22) common-progress-cpp 29.5126 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 4, 2, 11, 50) common-timing-cpp 28.1364 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 4, 2, 12, 1) fem-multicore-cpp 10.3041 "Coloring mesh." (2012, 3, 4, 2, 15, 8) fem-assembly-cpp 186.78 "Assembly for various forms and backends" (2012, 3, 4, 2, 15, 19) fem-convergence-cpp 11.6616 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 4, 2, 15, 20) fem-jit-python 0.000426793 "JIT compilation (in memory cache)" (2012, 3, 4, 2, 20, 32) fem-speedup-cpp 311.883 "Assembly/solve speedup running on 4 processors" (2012, 3, 4, 2, 20, 32) fem-speedup-cpp-assembly 5.39823 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 4, 2, 20, 32) fem-speedup-cpp-solve 2.01846 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 4, 2, 20, 56) mesh-refinement-cpp 22.2624 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 4, 2, 21, 17) mesh-topology-cpp 21.2362 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 4, 2, 21, 39) mesh-unitcube-cpp 21.3107 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 4, 2, 22, 26) mesh-iteration-cpp 44.5811 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 4, 2, 22, 33) function-extrapolation-python 6.90531 "BENCH: 1.89593982697" (2012, 3, 4, 2, 22, 33) function-extrapolation-python 1.89594 "BENCH: 1.89593982697" (2012, 3, 4, 2, 22, 57) la-vector-access-cpp 23.9349 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 4, 2, 23, 25) la-vector-assignment-cpp 27.8937 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 5, 2, 10, 59) common-progress-cpp 29.584 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 5, 2, 11, 27) common-timing-cpp 27.7145 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 5, 2, 11, 37) fem-multicore-cpp 10.082 "Coloring mesh." (2012, 3, 5, 2, 14, 44) fem-assembly-cpp 186.607 "Assembly for various forms and backends" (2012, 3, 5, 2, 14, 55) fem-convergence-cpp 11.6288 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 5, 2, 14, 56) fem-jit-python 0.000422382 "JIT compilation (in memory cache)" (2012, 3, 5, 2, 20, 25) fem-speedup-cpp 328.423 "Assembly/solve speedup running on 4 processors" (2012, 3, 5, 2, 20, 25) fem-speedup-cpp-assembly 5.54144 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 5, 2, 20, 25) fem-speedup-cpp-solve 1.67243 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 5, 2, 20, 49) mesh-refinement-cpp 22.3152 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 5, 2, 21, 10) mesh-topology-cpp 21.2385 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 5, 2, 21, 31) mesh-unitcube-cpp 21.0795 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 5, 2, 22, 15) mesh-iteration-cpp 41.964 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 5, 2, 22, 22) function-extrapolation-python 6.66317 "BENCH: 1.8630437851" (2012, 3, 5, 2, 22, 22) function-extrapolation-python 1.86304 "BENCH: 1.8630437851" (2012, 3, 5, 2, 22, 45) la-vector-access-cpp 23.0149 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 5, 2, 23, 13) la-vector-assignment-cpp 27.8911 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 6, 2, 11, 0) common-progress-cpp 29.6071 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 6, 2, 11, 28) common-timing-cpp 27.6214 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 6, 2, 11, 38) fem-multicore-cpp 10.1785 "Coloring mesh." (2012, 3, 6, 2, 14, 45) fem-assembly-cpp 186.838 "Assembly for various forms and backends" (2012, 3, 6, 2, 14, 57) fem-convergence-cpp 11.6171 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 6, 2, 14, 58) fem-jit-python 0.000423288 "JIT compilation (in memory cache)" (2012, 3, 6, 2, 20, 13) fem-speedup-cpp 315.16 "Assembly/solve speedup running on 4 processors" (2012, 3, 6, 2, 20, 13) fem-speedup-cpp-assembly 5.44692 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 6, 2, 20, 13) fem-speedup-cpp-solve 1.92397 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 6, 2, 20, 37) mesh-refinement-cpp 22.3169 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 6, 2, 20, 58) mesh-topology-cpp 21.2779 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 6, 2, 21, 19) mesh-unitcube-cpp 21.0917 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 6, 2, 22, 4) mesh-iteration-cpp 41.9681 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 6, 2, 22, 11) function-extrapolation-python 6.67543 "BENCH: 1.88750600815" (2012, 3, 6, 2, 22, 11) function-extrapolation-python 1.88751 "BENCH: 1.88750600815" (2012, 3, 6, 2, 22, 33) la-vector-access-cpp 22.4076 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 6, 2, 23, 1) la-vector-assignment-cpp 27.8987 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 7, 2, 11, 12) common-progress-cpp 30.0316 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 7, 2, 11, 40) common-timing-cpp 28.4918 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 7, 2, 11, 51) fem-multicore-cpp 10.0993 "Coloring mesh." (2012, 3, 7, 2, 15, 0) fem-assembly-cpp 189.731 "Assembly for various forms and backends" (2012, 3, 7, 2, 15, 12) fem-convergence-cpp 11.9791 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 7, 2, 15, 13) fem-jit-python 0.000421 "JIT compilation (in memory cache)" (2012, 3, 7, 2, 20, 26) fem-speedup-cpp 312.125 "Assembly/solve speedup running on 4 processors" (2012, 3, 7, 2, 20, 26) fem-speedup-cpp-assembly 5.53894 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 7, 2, 20, 26) fem-speedup-cpp-solve 2.03647 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 7, 2, 20, 49) mesh-refinement-cpp 22.458 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 7, 2, 21, 11) mesh-topology-cpp 21.2026 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 7, 2, 21, 33) mesh-unitcube-cpp 21.8754 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 7, 2, 22, 17) mesh-iteration-cpp 41.9637 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 7, 2, 22, 24) function-extrapolation-python 6.59471 "BENCH: 1.89239001274" (2012, 3, 7, 2, 22, 24) function-extrapolation-python 1.89239 "BENCH: 1.89239001274" (2012, 3, 7, 2, 22, 48) la-vector-access-cpp 23.9145 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 7, 2, 23, 16) la-vector-assignment-cpp 27.8893 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 8, 2, 11, 19) common-progress-cpp 29.6021 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 8, 2, 11, 46) common-timing-cpp 27.6614 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 8, 2, 11, 57) fem-multicore-cpp 10.2437 "Coloring mesh." (2012, 3, 8, 2, 15, 5) fem-assembly-cpp 188.78 "Assembly for various forms and backends" (2012, 3, 8, 2, 15, 17) fem-convergence-cpp 11.9243 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 8, 2, 15, 18) fem-jit-python 0.000425601 "JIT compilation (in memory cache)" (2012, 3, 8, 2, 20, 40) fem-speedup-cpp 322.013 "Assembly/solve speedup running on 4 processors" (2012, 3, 8, 2, 20, 40) fem-speedup-cpp-assembly 5.52599 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 8, 2, 20, 40) fem-speedup-cpp-solve 1.84482 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 8, 2, 21, 4) mesh-refinement-cpp 22.3857 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 8, 2, 21, 26) mesh-topology-cpp 21.3154 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 8, 2, 21, 48) mesh-unitcube-cpp 21.7511 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 8, 2, 22, 33) mesh-iteration-cpp 42.9272 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 8, 2, 22, 40) function-extrapolation-python 6.65543 "BENCH: 1.8642950058" (2012, 3, 8, 2, 22, 40) function-extrapolation-python 1.8643 "BENCH: 1.8642950058" (2012, 3, 8, 2, 23, 2) la-vector-access-cpp 22.4013 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 8, 2, 23, 30) la-vector-assignment-cpp 27.8904 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 9, 2, 11, 18) common-progress-cpp 29.6102 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 9, 2, 11, 45) common-timing-cpp 27.094 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 9, 2, 11, 56) fem-multicore-cpp 10.1509 "Coloring mesh." (2012, 3, 9, 2, 15, 11) fem-assembly-cpp 194.975 "Assembly for various forms and backends" (2012, 3, 9, 2, 15, 22) fem-convergence-cpp 11.9128 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 9, 2, 15, 24) fem-jit-python 0.000434899 "JIT compilation (in memory cache)" (2012, 3, 9, 2, 20, 49) fem-speedup-cpp 325.179 "Assembly/solve speedup running on 4 processors" (2012, 3, 9, 2, 20, 49) fem-speedup-cpp-assembly 5.54605 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 9, 2, 20, 49) fem-speedup-cpp-solve 1.76131 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 9, 2, 21, 13) mesh-refinement-cpp 22.4204 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 9, 2, 21, 34) mesh-topology-cpp 21.1347 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 9, 2, 21, 56) mesh-unitcube-cpp 22.103 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 9, 2, 22, 40) mesh-iteration-cpp 41.956 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 9, 2, 23, 10) function-extrapolation-python 29.4167 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 3, 9, 2, 23, 10) function-extrapolation-python 1.88691 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 3, 9, 2, 23, 33) la-vector-access-cpp 22.4162 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 9, 2, 24, 0) la-vector-assignment-cpp 27.8992 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 10, 2, 11, 12) common-progress-cpp 29.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 10, 2, 11, 40) common-timing-cpp 27.756 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 10, 2, 11, 50) fem-multicore-cpp 10.1681 "Coloring mesh." (2012, 3, 10, 2, 15, 2) fem-assembly-cpp 192.075 "Assembly for various forms and backends" (2012, 3, 10, 2, 15, 14) fem-convergence-cpp 11.9193 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 10, 2, 15, 15) fem-jit-python 0.000426817 "JIT compilation (in memory cache)" (2012, 3, 10, 2, 20, 39) fem-speedup-cpp 323.822 "Assembly/solve speedup running on 4 processors" (2012, 3, 10, 2, 20, 39) fem-speedup-cpp-assembly 5.53006 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 10, 2, 20, 39) fem-speedup-cpp-solve 1.756 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 10, 2, 21, 3) mesh-refinement-cpp 22.4384 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 10, 2, 21, 25) mesh-topology-cpp 21.1909 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 10, 2, 21, 47) mesh-unitcube-cpp 21.9534 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 10, 2, 22, 34) mesh-iteration-cpp 44.8074 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 10, 2, 22, 41) function-extrapolation-python 6.84385 "BENCH: 1.87336993217" (2012, 3, 10, 2, 22, 41) function-extrapolation-python 1.87337 "BENCH: 1.87336993217" (2012, 3, 10, 2, 23, 4) la-vector-access-cpp 22.4098 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 10, 2, 23, 29) la-vector-assignment-cpp 25.0954 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 11, 2, 11, 14) common-progress-cpp 38.9438 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 11, 2, 11, 44) common-timing-cpp 29.2966 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 11, 2, 11, 54) fem-multicore-cpp 10.2232 "Coloring mesh." (2012, 3, 11, 2, 15, 7) fem-assembly-cpp 192.633 "Assembly for various forms and backends" (2012, 3, 11, 2, 15, 19) fem-convergence-cpp 11.8992 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 11, 2, 15, 20) fem-jit-python 0.000436997 "JIT compilation (in memory cache)" (2012, 3, 11, 2, 20, 32) fem-speedup-cpp 312.868 "Assembly/solve speedup running on 4 processors" (2012, 3, 11, 2, 20, 32) fem-speedup-cpp-assembly 5.49065 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 11, 2, 20, 32) fem-speedup-cpp-solve 2.00588 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 11, 2, 20, 57) mesh-refinement-cpp 22.7526 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 11, 2, 21, 18) mesh-topology-cpp 21.2829 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 11, 2, 21, 41) mesh-unitcube-cpp 23.1452 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 11, 2, 22, 27) mesh-iteration-cpp 42.9893 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 11, 2, 22, 34) function-extrapolation-python 6.74763 "BENCH: 1.89597916603" (2012, 3, 11, 2, 22, 34) function-extrapolation-python 1.89598 "BENCH: 1.89597916603" (2012, 3, 11, 2, 22, 56) la-vector-access-cpp 22.4736 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 11, 2, 23, 24) la-vector-assignment-cpp 27.89 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 12, 2, 10, 56) common-progress-cpp 29.2054 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 12, 2, 11, 25) common-timing-cpp 29.0935 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 12, 2, 11, 35) fem-multicore-cpp 10.2215 "Coloring mesh." (2012, 3, 12, 2, 14, 47) fem-assembly-cpp 192.444 "Assembly for various forms and backends" (2012, 3, 12, 2, 14, 59) fem-convergence-cpp 11.9014 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 12, 2, 15, 0) fem-jit-python 0.000441289 "JIT compilation (in memory cache)" (2012, 3, 12, 2, 20, 32) fem-speedup-cpp 331.154 "Assembly/solve speedup running on 4 processors" (2012, 3, 12, 2, 20, 32) fem-speedup-cpp-assembly 5.47798 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 12, 2, 20, 32) fem-speedup-cpp-solve 1.65601 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 12, 2, 20, 56) mesh-refinement-cpp 22.7983 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 12, 2, 21, 17) mesh-topology-cpp 21.3877 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 12, 2, 21, 41) mesh-unitcube-cpp 23.618 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 12, 2, 22, 27) mesh-iteration-cpp 42.9459 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 12, 2, 22, 33) function-extrapolation-python 6.70933 "BENCH: 1.89374995232" (2012, 3, 12, 2, 22, 33) function-extrapolation-python 1.89375 "BENCH: 1.89374995232" (2012, 3, 12, 2, 22, 58) la-vector-access-cpp 24.453 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 12, 2, 23, 26) la-vector-assignment-cpp 27.8885 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 13, 2, 11, 12) common-progress-cpp 29.5275 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 13, 2, 11, 40) common-timing-cpp 27.9414 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 13, 2, 11, 50) fem-multicore-cpp 10.0836 "Coloring mesh." (2012, 3, 13, 2, 15, 2) fem-assembly-cpp 191.731 "Assembly for various forms and backends" (2012, 3, 13, 2, 15, 14) fem-convergence-cpp 11.8683 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 13, 2, 15, 15) fem-jit-python 0.000435519 "JIT compilation (in memory cache)" (2012, 3, 13, 2, 20, 37) fem-speedup-cpp 321.986 "Assembly/solve speedup running on 4 processors" (2012, 3, 13, 2, 20, 37) fem-speedup-cpp-assembly 5.51489 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 13, 2, 20, 37) fem-speedup-cpp-solve 1.80728 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 13, 2, 21, 1) mesh-refinement-cpp 22.6107 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 13, 2, 21, 23) mesh-topology-cpp 21.2844 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 13, 2, 21, 45) mesh-unitcube-cpp 22.1244 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 13, 2, 22, 30) mesh-iteration-cpp 42.9091 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 13, 2, 22, 58) la-vector-access-cpp 22.6403 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 13, 2, 23, 26) la-vector-assignment-cpp 27.8896 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 14, 2, 11, 8) common-progress-cpp 29.1833 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 14, 2, 11, 37) common-timing-cpp 28.0877 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 14, 2, 11, 47) fem-multicore-cpp 10.1264 "Coloring mesh." (2012, 3, 14, 2, 14, 58) fem-assembly-cpp 191.468 "Assembly for various forms and backends" (2012, 3, 14, 2, 15, 10) fem-convergence-cpp 11.8851 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 14, 2, 15, 11) fem-jit-python 0.000440598 "JIT compilation (in memory cache)" (2012, 3, 14, 2, 20, 22) fem-speedup-cpp 311.137 "Assembly/solve speedup running on 4 processors" (2012, 3, 14, 2, 20, 22) fem-speedup-cpp-assembly 5.54597 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 14, 2, 20, 22) fem-speedup-cpp-solve 2.02177 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 14, 2, 20, 46) mesh-refinement-cpp 22.5597 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 14, 2, 21, 8) mesh-topology-cpp 21.1568 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 14, 2, 21, 30) mesh-unitcube-cpp 22.1763 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 14, 2, 22, 15) mesh-iteration-cpp 42.9753 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 14, 2, 22, 45) la-vector-access-cpp 24.9016 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 14, 2, 23, 13) la-vector-assignment-cpp 27.8919 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 15, 2, 10, 55) common-progress-cpp 29.7919 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 15, 2, 11, 25) common-timing-cpp 29.2994 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 15, 2, 11, 35) fem-multicore-cpp 10.176 "Coloring mesh." (2012, 3, 15, 2, 14, 46) fem-assembly-cpp 191.525 "Assembly for various forms and backends" (2012, 3, 15, 2, 14, 58) fem-convergence-cpp 11.9635 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 15, 2, 14, 59) fem-jit-python 0.000433612 "JIT compilation (in memory cache)" (2012, 3, 15, 2, 20, 29) fem-speedup-cpp 329.9 "Assembly/solve speedup running on 4 processors" (2012, 3, 15, 2, 20, 29) fem-speedup-cpp-assembly 5.53121 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 15, 2, 20, 29) fem-speedup-cpp-solve 1.67331 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 15, 2, 20, 53) mesh-refinement-cpp 22.4721 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 15, 2, 21, 15) mesh-topology-cpp 21.0975 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 15, 2, 21, 38) mesh-unitcube-cpp 23.535 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 15, 2, 22, 24) mesh-iteration-cpp 42.9694 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 15, 2, 22, 51) la-vector-access-cpp 22.624 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 15, 2, 23, 23) la-vector-assignment-cpp 31.8963 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 16, 2, 11, 20) common-progress-cpp 29.1769 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 16, 2, 11, 49) common-timing-cpp 29.4311 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 16, 2, 11, 59) fem-multicore-cpp 10.1385 "Coloring mesh." (2012, 3, 16, 2, 15, 9) fem-assembly-cpp 189.965 "Assembly for various forms and backends" (2012, 3, 16, 2, 15, 21) fem-convergence-cpp 11.587 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 16, 2, 15, 22) fem-jit-python 0.000426602 "JIT compilation (in memory cache)" (2012, 3, 16, 2, 20, 38) fem-speedup-cpp 316.379 "Assembly/solve speedup running on 4 processors" (2012, 3, 16, 2, 20, 38) fem-speedup-cpp-assembly 5.57773 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 16, 2, 20, 38) fem-speedup-cpp-solve 1.93243 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 16, 2, 21, 2) mesh-refinement-cpp 22.4445 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 16, 2, 21, 23) mesh-topology-cpp 21.0381 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 16, 2, 21, 47) mesh-unitcube-cpp 23.7185 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 16, 2, 22, 31) mesh-iteration-cpp 41.9583 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 16, 2, 23, 0) la-vector-access-cpp 23.7331 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 16, 2, 23, 28) la-vector-assignment-cpp 27.9023 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 17, 2, 11, 3) common-progress-cpp 29.6218 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 17, 2, 11, 33) common-timing-cpp 30.1059 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 17, 2, 11, 43) fem-multicore-cpp 10.2326 "Coloring mesh." (2012, 3, 17, 2, 14, 56) fem-assembly-cpp 193.14 "Assembly for various forms and backends" (2012, 3, 17, 2, 15, 8) fem-convergence-cpp 11.8484 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 17, 2, 15, 9) fem-jit-python 0.000442004 "JIT compilation (in memory cache)" (2012, 3, 17, 2, 20, 21) fem-speedup-cpp 311.462 "Assembly/solve speedup running on 4 processors" (2012, 3, 17, 2, 20, 21) fem-speedup-cpp-assembly 5.47218 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 17, 2, 20, 21) fem-speedup-cpp-solve 2.02193 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 17, 2, 20, 44) mesh-refinement-cpp 22.4131 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 17, 2, 21, 6) mesh-topology-cpp 21.1438 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 17, 2, 21, 27) mesh-unitcube-cpp 21.165 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 17, 2, 22, 12) mesh-iteration-cpp 42.9161 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 17, 2, 22, 40) la-vector-access-cpp 22.6284 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 17, 2, 23, 8) la-vector-assignment-cpp 27.9458 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 18, 2, 11, 14) common-progress-cpp 29.7763 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 18, 2, 11, 43) common-timing-cpp 29.1075 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 18, 2, 11, 53) fem-multicore-cpp 10.0955 "Coloring mesh." (2012, 3, 18, 2, 14, 59) fem-assembly-cpp 186.284 "Assembly for various forms and backends" (2012, 3, 18, 2, 15, 11) fem-convergence-cpp 11.8973 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 18, 2, 15, 12) fem-jit-python 0.000438499 "JIT compilation (in memory cache)" (2012, 3, 18, 2, 20, 29) fem-speedup-cpp 316.308 "Assembly/solve speedup running on 4 processors" (2012, 3, 18, 2, 20, 29) fem-speedup-cpp-assembly 5.50749 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 18, 2, 20, 29) fem-speedup-cpp-solve 1.93064 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 18, 2, 20, 53) mesh-refinement-cpp 22.4646 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 18, 2, 21, 14) mesh-topology-cpp 21.1607 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 18, 2, 21, 36) mesh-unitcube-cpp 21.9807 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 18, 2, 22, 24) mesh-iteration-cpp 45.6159 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 18, 2, 22, 52) la-vector-access-cpp 22.6539 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 18, 2, 23, 20) la-vector-assignment-cpp 27.9433 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 19, 2, 10, 59) common-progress-cpp 29.7581 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 19, 2, 11, 29) common-timing-cpp 29.3136 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 19, 2, 11, 39) fem-multicore-cpp 10.1749 "Coloring mesh." (2012, 3, 19, 2, 14, 46) fem-assembly-cpp 186.641 "Assembly for various forms and backends" (2012, 3, 19, 2, 14, 57) fem-convergence-cpp 11.8723 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 19, 2, 14, 58) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2012, 3, 19, 2, 20, 22) fem-speedup-cpp 323.96 "Assembly/solve speedup running on 4 processors" (2012, 3, 19, 2, 20, 22) fem-speedup-cpp-assembly 5.52268 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 19, 2, 20, 22) fem-speedup-cpp-solve 1.77541 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 19, 2, 20, 46) mesh-refinement-cpp 22.3813 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 19, 2, 21, 8) mesh-topology-cpp 21.1015 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 19, 2, 21, 30) mesh-unitcube-cpp 21.9139 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 19, 2, 22, 23) mesh-iteration-cpp 51.0405 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 19, 2, 22, 53) la-vector-access-cpp 24.595 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 19, 2, 23, 23) la-vector-assignment-cpp 29.8894 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 20, 2, 11, 0) common-progress-cpp 29.6163 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 20, 2, 11, 30) common-timing-cpp 29.1732 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 20, 2, 11, 40) fem-multicore-cpp 10.1176 "Coloring mesh." (2012, 3, 20, 2, 14, 46) fem-assembly-cpp 186.541 "Assembly for various forms and backends" (2012, 3, 20, 2, 14, 58) fem-convergence-cpp 11.8774 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 20, 2, 14, 59) fem-jit-python 0.000426602 "JIT compilation (in memory cache)" (2012, 3, 20, 2, 20, 11) fem-speedup-cpp 312.039 "Assembly/solve speedup running on 4 processors" (2012, 3, 20, 2, 20, 11) fem-speedup-cpp-assembly 5.47704 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 20, 2, 20, 11) fem-speedup-cpp-solve 2.00028 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 20, 2, 20, 35) mesh-refinement-cpp 22.3899 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 20, 2, 20, 57) mesh-topology-cpp 21.1438 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 20, 2, 21, 19) mesh-unitcube-cpp 21.9657 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 20, 2, 22, 3) mesh-iteration-cpp 41.9575 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 20, 2, 22, 33) la-vector-access-cpp 24.7075 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 20, 2, 23, 1) la-vector-assignment-cpp 27.9425 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 21, 2, 11, 20) common-progress-cpp 29.6446 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 21, 2, 11, 50) common-timing-cpp 29.5241 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 21, 2, 12, 0) fem-multicore-cpp 10.0781 "Coloring mesh." (2012, 3, 21, 2, 15, 6) fem-assembly-cpp 186.525 "Assembly for various forms and backends" (2012, 3, 21, 2, 15, 18) fem-convergence-cpp 11.5829 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 21, 2, 15, 19) fem-jit-python 0.000426292 "JIT compilation (in memory cache)" (2012, 3, 21, 2, 20, 30) fem-speedup-cpp 311.429 "Assembly/solve speedup running on 4 processors" (2012, 3, 21, 2, 20, 30) fem-speedup-cpp-assembly 5.50763 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 21, 2, 20, 30) fem-speedup-cpp-solve 2.02043 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 21, 2, 20, 54) mesh-refinement-cpp 22.4093 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 21, 2, 21, 16) mesh-topology-cpp 21.1356 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 21, 2, 21, 38) mesh-unitcube-cpp 21.942 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 21, 2, 22, 22) mesh-iteration-cpp 41.9617 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 21, 2, 22, 49) la-vector-access-cpp 22.6346 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 21, 2, 23, 17) la-vector-assignment-cpp 27.9443 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 22, 2, 11, 6) common-progress-cpp 29.6124 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 22, 2, 11, 36) common-timing-cpp 29.527 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 22, 2, 11, 46) fem-multicore-cpp 10.0475 "Coloring mesh." (2012, 3, 22, 2, 14, 53) fem-assembly-cpp 186.811 "Assembly for various forms and backends" (2012, 3, 22, 2, 15, 5) fem-convergence-cpp 11.8756 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 22, 2, 15, 6) fem-jit-python 0.000440311 "JIT compilation (in memory cache)" (2012, 3, 22, 2, 20, 32) fem-speedup-cpp 325.998 "Assembly/solve speedup running on 4 processors" (2012, 3, 22, 2, 20, 32) fem-speedup-cpp-assembly 5.49121 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 22, 2, 20, 32) fem-speedup-cpp-solve 1.7379 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 22, 2, 20, 56) mesh-refinement-cpp 22.5104 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 22, 2, 21, 17) mesh-topology-cpp 21.1518 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 22, 2, 21, 39) mesh-unitcube-cpp 21.9391 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 22, 2, 22, 24) mesh-iteration-cpp 41.9631 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 22, 2, 22, 51) la-vector-access-cpp 22.6449 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 22, 2, 23, 20) la-vector-assignment-cpp 27.9458 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 23, 10, 18, 15) common-progress-cpp 29.2502 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 23, 10, 18, 44) common-timing-cpp 28.9173 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 23, 10, 18, 54) fem-multicore-cpp 10.1337 "Coloring mesh." (2012, 3, 23, 10, 22, 2) fem-assembly-cpp 187.907 "Assembly for various forms and backends" (2012, 3, 23, 10, 22, 14) fem-convergence-cpp 11.855 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 23, 10, 22, 15) fem-jit-python 0.000434303 "JIT compilation (in memory cache)" (2012, 3, 23, 10, 28, 3) fem-speedup-cpp 347.987 "Assembly/solve speedup running on 4 processors" (2012, 3, 23, 10, 28, 3) fem-speedup-cpp-assembly 5.52104 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 23, 10, 28, 3) fem-speedup-cpp-solve 1.40722 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 23, 10, 28, 27) mesh-refinement-cpp 22.7465 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 23, 10, 28, 48) mesh-topology-cpp 21.129 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 23, 10, 29, 10) mesh-unitcube-cpp 21.2977 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 23, 10, 29, 55) mesh-iteration-cpp 42.8558 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 23, 10, 30, 16) function-evaluation-cpp 21.3397 "Evaluations of functions at arbitrary points." (2012, 3, 23, 10, 30, 16) function-evaluation-cpp 21.2454 "Evaluations of functions at arbitrary points." (2012, 3, 23, 10, 30, 23) function-extrapolation-python 7.08951 "BENCH: 1.91053199768" (2012, 3, 23, 10, 30, 23) function-extrapolation-python 1.91053 "BENCH: 1.91053199768" (2012, 3, 23, 10, 30, 46) la-vector-access-cpp 22.4567 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 23, 10, 31, 14) la-vector-assignment-cpp 27.9451 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 24, 2, 11, 35) common-progress-cpp 29.8481 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 24, 2, 12, 6) common-timing-cpp 30.0109 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 24, 2, 12, 16) fem-multicore-cpp 10.011 "Coloring mesh." (2012, 3, 24, 2, 15, 24) fem-assembly-cpp 188.197 "Assembly for various forms and backends" (2012, 3, 24, 2, 15, 36) fem-convergence-cpp 11.9155 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 24, 2, 15, 48) fem-jit-python 0.000569606 "JIT compilation (in memory cache)" (2012, 3, 24, 2, 21, 35) fem-speedup-cpp 346.566 "Assembly/solve speedup running on 4 processors" (2012, 3, 24, 2, 21, 35) fem-speedup-cpp-assembly 5.51891 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 24, 2, 21, 35) fem-speedup-cpp-solve 1.43412 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 24, 2, 21, 59) mesh-refinement-cpp 22.7388 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 24, 2, 22, 20) mesh-topology-cpp 21.1862 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 24, 2, 22, 42) mesh-unitcube-cpp 21.3518 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 24, 2, 23, 27) mesh-iteration-cpp 42.6707 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 24, 2, 23, 48) function-evaluation-cpp 21.3317 "Evaluations of functions at arbitrary points." (2012, 3, 24, 2, 23, 48) function-evaluation-cpp 21.2392 "Evaluations of functions at arbitrary points." (2012, 3, 24, 2, 24, 39) function-extrapolation-python 50.6951 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2012, 3, 24, 2, 24, 39) function-extrapolation-python 1.89467 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2012, 3, 24, 2, 25, 3) la-vector-access-cpp 23.8564 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 24, 2, 25, 35) la-vector-assignment-cpp 31.9083 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 25, 1, 11, 12) common-progress-cpp 29.5972 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 25, 1, 11, 42) common-timing-cpp 29.5222 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 25, 1, 11, 52) fem-multicore-cpp 10.0221 "Coloring mesh." (2012, 3, 25, 1, 15, 0) fem-assembly-cpp 188.188 "Assembly for various forms and backends" (2012, 3, 25, 1, 15, 12) fem-convergence-cpp 11.8477 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 25, 1, 15, 13) fem-jit-python 0.000525594 "JIT compilation (in memory cache)" (2012, 3, 25, 1, 20, 24) fem-speedup-cpp 311.519 "Assembly/solve speedup running on 4 processors" (2012, 3, 25, 1, 20, 24) fem-speedup-cpp-assembly 5.53704 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 25, 1, 20, 24) fem-speedup-cpp-solve 2.03861 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 25, 1, 20, 49) mesh-refinement-cpp 22.7542 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 25, 1, 21, 10) mesh-topology-cpp 21.1512 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 25, 1, 21, 31) mesh-unitcube-cpp 21.3332 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 25, 1, 22, 17) mesh-iteration-cpp 42.8488 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 25, 1, 22, 38) function-evaluation-cpp 21.385 "Evaluations of functions at arbitrary points." (2012, 3, 25, 1, 22, 38) function-evaluation-cpp 21.3041 "Evaluations of functions at arbitrary points." (2012, 3, 25, 1, 22, 45) function-extrapolation-python 6.80304 "BENCH: 1.9065849781" (2012, 3, 25, 1, 22, 45) function-extrapolation-python 1.90658 "BENCH: 1.9065849781" (2012, 3, 25, 1, 23, 9) la-vector-access-cpp 23.8583 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 25, 1, 23, 37) la-vector-assignment-cpp 27.9519 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 26, 1, 11, 12) common-progress-cpp 29.6833 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 26, 1, 11, 41) common-timing-cpp 29.1034 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 26, 1, 11, 51) fem-multicore-cpp 9.94161 "Coloring mesh." (2012, 3, 26, 1, 14, 58) fem-assembly-cpp 187.507 "Assembly for various forms and backends" (2012, 3, 26, 1, 15, 10) fem-convergence-cpp 11.8326 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 26, 1, 15, 11) fem-jit-python 0.000517201 "JIT compilation (in memory cache)" (2012, 3, 26, 1, 20, 27) fem-speedup-cpp 316.115 "Assembly/solve speedup running on 4 processors" (2012, 3, 26, 1, 20, 27) fem-speedup-cpp-assembly 5.53409 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 26, 1, 20, 27) fem-speedup-cpp-solve 1.92683 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 26, 1, 20, 51) mesh-refinement-cpp 22.7083 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 26, 1, 21, 13) mesh-topology-cpp 21.2153 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 26, 1, 21, 34) mesh-unitcube-cpp 21.2683 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 26, 1, 22, 19) mesh-iteration-cpp 42.8333 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 26, 1, 22, 41) function-evaluation-cpp 21.5819 "Evaluations of functions at arbitrary points." (2012, 3, 26, 1, 22, 41) function-evaluation-cpp 21.4958 "Evaluations of functions at arbitrary points." (2012, 3, 26, 1, 22, 48) function-extrapolation-python 6.67678 "BENCH: 1.91194415092" (2012, 3, 26, 1, 22, 48) function-extrapolation-python 1.91194 "BENCH: 1.91194415092" (2012, 3, 26, 1, 23, 10) la-vector-access-cpp 22.447 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 26, 1, 23, 38) la-vector-assignment-cpp 27.9534 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 27, 1, 11, 10) common-progress-cpp 29.8119 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 27, 1, 11, 40) common-timing-cpp 29.6736 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 27, 1, 11, 50) fem-multicore-cpp 10.1445 "Coloring mesh." (2012, 3, 27, 1, 14, 57) fem-assembly-cpp 187.423 "Assembly for various forms and backends" (2012, 3, 27, 1, 15, 9) fem-convergence-cpp 11.8745 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 27, 1, 15, 10) fem-jit-python 0.000532913 "JIT compilation (in memory cache)" (2012, 3, 27, 1, 20, 31) fem-speedup-cpp 320.54 "Assembly/solve speedup running on 4 processors" (2012, 3, 27, 1, 20, 31) fem-speedup-cpp-assembly 5.54247 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 27, 1, 20, 31) fem-speedup-cpp-solve 1.83288 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 27, 1, 20, 55) mesh-refinement-cpp 22.6726 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 27, 1, 21, 16) mesh-topology-cpp 21.0875 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 27, 1, 21, 37) mesh-unitcube-cpp 21.2453 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 27, 1, 22, 23) mesh-iteration-cpp 42.867 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 27, 1, 22, 44) function-evaluation-cpp 21.3268 "Evaluations of functions at arbitrary points." (2012, 3, 27, 1, 22, 44) function-evaluation-cpp 21.246 "Evaluations of functions at arbitrary points." (2012, 3, 27, 1, 22, 51) function-extrapolation-python 6.80449 "BENCH: 1.96759700775" (2012, 3, 27, 1, 22, 51) function-extrapolation-python 1.9676 "BENCH: 1.96759700775" (2012, 3, 27, 1, 23, 13) la-vector-access-cpp 22.4477 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 27, 1, 23, 41) la-vector-assignment-cpp 27.9519 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 28, 1, 11, 35) common-progress-cpp 36.4359 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 28, 1, 12, 5) common-timing-cpp 29.7557 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 28, 1, 12, 15) fem-multicore-cpp 10.0797 "Coloring mesh." (2012, 3, 28, 1, 15, 28) fem-assembly-cpp 193.158 "Assembly for various forms and backends" (2012, 3, 28, 1, 15, 40) fem-convergence-cpp 11.8458 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 28, 1, 15, 41) fem-jit-python 0.000517321 "JIT compilation (in memory cache)" (2012, 3, 28, 1, 20, 53) fem-speedup-cpp 311.816 "Assembly/solve speedup running on 4 processors" (2012, 3, 28, 1, 20, 53) fem-speedup-cpp-assembly 5.35381 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 28, 1, 20, 53) fem-speedup-cpp-solve 2 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 28, 1, 21, 17) mesh-refinement-cpp 22.5773 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 28, 1, 21, 39) mesh-topology-cpp 21.4724 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 28, 1, 22, 0) mesh-unitcube-cpp 21.5984 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 28, 1, 22, 46) mesh-iteration-cpp 42.9169 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 28, 1, 23, 7) function-evaluation-cpp 21.2531 "Evaluations of functions at arbitrary points." (2012, 3, 28, 1, 23, 7) function-evaluation-cpp 21.1721 "Evaluations of functions at arbitrary points." (2012, 3, 28, 1, 23, 14) function-extrapolation-python 6.65458 "BENCH: 1.91735506058" (2012, 3, 28, 1, 23, 14) function-extrapolation-python 1.91736 "BENCH: 1.91735506058" (2012, 3, 28, 1, 23, 36) la-vector-access-cpp 22.4146 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 28, 1, 24, 4) la-vector-assignment-cpp 27.9528 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 29, 1, 11, 44) common-progress-cpp 47.7206 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 29, 1, 12, 13) common-timing-cpp 29.4658 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 29, 1, 12, 23) fem-multicore-cpp 10.1128 "Coloring mesh." (2012, 3, 29, 1, 15, 36) fem-assembly-cpp 192.811 "Assembly for various forms and backends" (2012, 3, 29, 1, 15, 48) fem-convergence-cpp 11.8379 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 29, 1, 15, 49) fem-jit-python 0.000525403 "JIT compilation (in memory cache)" (2012, 3, 29, 1, 21, 2) fem-speedup-cpp 313.254 "Assembly/solve speedup running on 4 processors" (2012, 3, 29, 1, 21, 2) fem-speedup-cpp-assembly 5.33967 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 29, 1, 21, 2) fem-speedup-cpp-solve 1.9766 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 29, 1, 21, 26) mesh-refinement-cpp 22.5234 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 29, 1, 21, 48) mesh-topology-cpp 21.3866 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 29, 1, 22, 10) mesh-unitcube-cpp 21.6283 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 29, 1, 22, 55) mesh-iteration-cpp 42.9465 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 29, 1, 23, 16) function-evaluation-cpp 21.3256 "Evaluations of functions at arbitrary points." (2012, 3, 29, 1, 23, 16) function-evaluation-cpp 21.2446 "Evaluations of functions at arbitrary points." (2012, 3, 29, 1, 23, 23) function-extrapolation-python 6.77774 "BENCH: 1.9107670784" (2012, 3, 29, 1, 23, 23) function-extrapolation-python 1.91077 "BENCH: 1.9107670784" (2012, 3, 29, 1, 23, 47) la-vector-access-cpp 23.8877 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 29, 1, 24, 15) la-vector-assignment-cpp 27.951 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 30, 1, 11, 13) common-progress-cpp 29.1799 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 30, 1, 11, 43) common-timing-cpp 30.3009 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 30, 1, 11, 53) fem-multicore-cpp 9.98761 "Coloring mesh." (2012, 3, 30, 1, 15, 6) fem-assembly-cpp 193.031 "Assembly for various forms and backends" (2012, 3, 30, 1, 15, 18) fem-convergence-cpp 11.8157 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 30, 1, 15, 19) fem-jit-python 0.0011179 "JIT compilation (in memory cache)" (2012, 3, 30, 1, 20, 31) fem-speedup-cpp 312.07 "Assembly/solve speedup running on 4 processors" (2012, 3, 30, 1, 20, 31) fem-speedup-cpp-assembly 5.35266 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 30, 1, 20, 31) fem-speedup-cpp-solve 2.00995 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 30, 1, 20, 55) mesh-refinement-cpp 22.5618 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 30, 1, 21, 17) mesh-topology-cpp 21.4106 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 30, 1, 21, 39) mesh-unitcube-cpp 21.6636 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 30, 1, 22, 24) mesh-iteration-cpp 42.9289 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 30, 1, 22, 45) function-evaluation-cpp 21.312 "Evaluations of functions at arbitrary points." (2012, 3, 30, 1, 22, 45) function-evaluation-cpp 21.231 "Evaluations of functions at arbitrary points." (2012, 3, 30, 1, 22, 52) function-extrapolation-python 6.82452 "BENCH: 1.90303897858" (2012, 3, 30, 1, 22, 52) function-extrapolation-python 1.90304 "BENCH: 1.90303897858" (2012, 3, 30, 1, 23, 18) la-vector-access-cpp 25.4073 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 30, 1, 23, 46) la-vector-assignment-cpp 27.9508 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 3, 31, 1, 11, 16) common-progress-cpp 29.9434 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 3, 31, 1, 11, 46) common-timing-cpp 29.9282 "Timing access and registration of timings (10000000 repetitions)" (2012, 3, 31, 1, 11, 56) fem-multicore-cpp 10.0462 "Coloring mesh." (2012, 3, 31, 1, 15, 9) fem-assembly-cpp 192.654 "Assembly for various forms and backends" (2012, 3, 31, 1, 15, 21) fem-convergence-cpp 11.8577 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 3, 31, 1, 15, 22) fem-jit-python 0.000411105 "JIT compilation (in memory cache)" (2012, 3, 31, 1, 20, 40) fem-speedup-cpp 317.603 "Assembly/solve speedup running on 4 processors" (2012, 3, 31, 1, 20, 40) fem-speedup-cpp-assembly 5.33456 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 3, 31, 1, 20, 40) fem-speedup-cpp-solve 1.91342 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 3, 31, 1, 21, 4) mesh-refinement-cpp 22.5222 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 3, 31, 1, 21, 25) mesh-topology-cpp 21.3206 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 3, 31, 1, 21, 47) mesh-unitcube-cpp 21.6934 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 3, 31, 1, 22, 36) mesh-iteration-cpp 46.0533 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 3, 31, 1, 22, 57) function-evaluation-cpp 21.3194 "Evaluations of functions at arbitrary points." (2012, 3, 31, 1, 22, 57) function-evaluation-cpp 21.2383 "Evaluations of functions at arbitrary points." (2012, 3, 31, 1, 23, 4) function-extrapolation-python 6.69082 "BENCH: 1.8820579052" (2012, 3, 31, 1, 23, 4) function-extrapolation-python 1.88206 "BENCH: 1.8820579052" (2012, 3, 31, 1, 23, 26) la-vector-access-cpp 22.4411 "Accessing vector of size 10000000 (100 repetitions)" (2012, 3, 31, 1, 23, 54) la-vector-assignment-cpp 27.9711 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 1, 1, 11, 29) common-progress-cpp 29.6234 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 1, 1, 11, 57) common-timing-cpp 28.0265 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 1, 1, 12, 7) fem-multicore-cpp 10.0726 "Coloring mesh." (2012, 4, 1, 1, 15, 20) fem-assembly-cpp 193.379 "Assembly for various forms and backends" (2012, 4, 1, 1, 15, 32) fem-convergence-cpp 11.5822 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 1, 1, 15, 33) fem-jit-python 0.000422621 "JIT compilation (in memory cache)" (2012, 4, 1, 1, 20, 43) fem-speedup-cpp 310.266 "Assembly/solve speedup running on 4 processors" (2012, 4, 1, 1, 20, 43) fem-speedup-cpp-assembly 5.57014 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 1, 1, 20, 43) fem-speedup-cpp-solve 2.03339 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 1, 1, 21, 7) mesh-refinement-cpp 22.6896 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 1, 1, 21, 29) mesh-topology-cpp 21.5138 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 1, 1, 21, 52) mesh-unitcube-cpp 22.3731 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 1, 1, 22, 37) mesh-iteration-cpp 42.9926 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 1, 1, 22, 58) function-evaluation-cpp 21.3313 "Evaluations of functions at arbitrary points." (2012, 4, 1, 1, 22, 58) function-evaluation-cpp 21.2499 "Evaluations of functions at arbitrary points." (2012, 4, 1, 1, 23, 5) function-extrapolation-python 6.78079 "BENCH: 1.89290785789" (2012, 4, 1, 1, 23, 5) function-extrapolation-python 1.89291 "BENCH: 1.89290785789" (2012, 4, 1, 1, 23, 28) la-vector-access-cpp 22.8901 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 1, 1, 23, 56) la-vector-assignment-cpp 27.955 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 2, 1, 11, 27) common-progress-cpp 29.5912 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 2, 1, 11, 55) common-timing-cpp 27.9926 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 2, 1, 12, 5) fem-multicore-cpp 9.94763 "Coloring mesh." (2012, 4, 2, 1, 15, 17) fem-assembly-cpp 192.68 "Assembly for various forms and backends" (2012, 4, 2, 1, 15, 29) fem-convergence-cpp 11.839 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 2, 1, 15, 30) fem-jit-python 0.000409603 "JIT compilation (in memory cache)" (2012, 4, 2, 1, 20, 54) fem-speedup-cpp 323.953 "Assembly/solve speedup running on 4 processors" (2012, 4, 2, 1, 20, 54) fem-speedup-cpp-assembly 5.57919 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 2, 1, 20, 54) fem-speedup-cpp-solve 1.78626 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 2, 1, 21, 19) mesh-refinement-cpp 22.7456 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 2, 1, 21, 40) mesh-topology-cpp 21.3414 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 2, 1, 22, 3) mesh-unitcube-cpp 22.3971 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 2, 1, 22, 53) mesh-iteration-cpp 48.5393 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 2, 1, 23, 14) function-evaluation-cpp 20.8662 "Evaluations of functions at arbitrary points." (2012, 4, 2, 1, 23, 14) function-evaluation-cpp 20.7852 "Evaluations of functions at arbitrary points." (2012, 4, 2, 1, 23, 21) function-extrapolation-python 6.82069 "BENCH: 1.89127898216" (2012, 4, 2, 1, 23, 21) function-extrapolation-python 1.89128 "BENCH: 1.89127898216" (2012, 4, 2, 1, 23, 44) la-vector-access-cpp 22.9127 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 2, 1, 24, 12) la-vector-assignment-cpp 27.9095 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 3, 1, 11, 30) common-progress-cpp 29.6125 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 3, 1, 12, 0) common-timing-cpp 29.2451 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 3, 1, 12, 10) fem-multicore-cpp 10.0172 "Coloring mesh." (2012, 4, 3, 1, 15, 23) fem-assembly-cpp 192.942 "Assembly for various forms and backends" (2012, 4, 3, 1, 15, 34) fem-convergence-cpp 11.8779 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 3, 1, 15, 36) fem-jit-python 0.000404787 "JIT compilation (in memory cache)" (2012, 4, 3, 1, 20, 48) fem-speedup-cpp 311.927 "Assembly/solve speedup running on 4 processors" (2012, 4, 3, 1, 20, 48) fem-speedup-cpp-assembly 5.57805 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 3, 1, 20, 48) fem-speedup-cpp-solve 2.03223 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 3, 1, 21, 12) mesh-refinement-cpp 22.7041 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 3, 1, 21, 33) mesh-topology-cpp 21.4215 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 3, 1, 21, 56) mesh-unitcube-cpp 22.4044 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 3, 1, 22, 41) mesh-iteration-cpp 42.9646 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 3, 1, 23, 2) function-evaluation-cpp 21.3042 "Evaluations of functions at arbitrary points." (2012, 4, 3, 1, 23, 2) function-evaluation-cpp 21.2234 "Evaluations of functions at arbitrary points." (2012, 4, 3, 1, 23, 9) function-extrapolation-python 6.59291 "BENCH: 1.90084600449" (2012, 4, 3, 1, 23, 9) function-extrapolation-python 1.90085 "BENCH: 1.90084600449" (2012, 4, 3, 1, 23, 33) la-vector-access-cpp 23.9183 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 3, 1, 24, 3) la-vector-assignment-cpp 29.9047 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 4, 1, 11, 33) common-progress-cpp 29.801 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 4, 1, 12, 1) common-timing-cpp 28.113 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 4, 1, 12, 11) fem-multicore-cpp 10.1021 "Coloring mesh." (2012, 4, 4, 1, 15, 25) fem-assembly-cpp 193.557 "Assembly for various forms and backends" (2012, 4, 4, 1, 15, 37) fem-convergence-cpp 11.8598 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 4, 1, 15, 38) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2012, 4, 4, 1, 20, 53) fem-speedup-cpp 315.101 "Assembly/solve speedup running on 4 processors" (2012, 4, 4, 1, 20, 53) fem-speedup-cpp-assembly 5.39718 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 4, 1, 20, 53) fem-speedup-cpp-solve 1.93364 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 4, 1, 21, 17) mesh-refinement-cpp 22.7536 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 4, 1, 21, 39) mesh-topology-cpp 21.3588 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 4, 1, 22, 1) mesh-unitcube-cpp 22.1709 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 4, 1, 22, 47) mesh-iteration-cpp 43.03 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 4, 1, 23, 8) function-evaluation-cpp 21.5658 "Evaluations of functions at arbitrary points." (2012, 4, 4, 1, 23, 8) function-evaluation-cpp 21.4845 "Evaluations of functions at arbitrary points." (2012, 4, 4, 1, 23, 15) function-extrapolation-python 6.80863 "BENCH: 1.88338589668" (2012, 4, 4, 1, 23, 15) function-extrapolation-python 1.88339 "BENCH: 1.88338589668" (2012, 4, 4, 1, 23, 39) la-vector-access-cpp 23.9452 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 4, 1, 24, 4) la-vector-assignment-cpp 24.9566 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 5, 1, 11, 24) common-progress-cpp 29.8204 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 5, 1, 11, 53) common-timing-cpp 29.478 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 5, 1, 12, 3) fem-multicore-cpp 9.97172 "Coloring mesh." (2012, 4, 5, 1, 15, 15) fem-assembly-cpp 191.927 "Assembly for various forms and backends" (2012, 4, 5, 1, 15, 27) fem-convergence-cpp 11.8568 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 5, 1, 15, 28) fem-jit-python 0.000405502 "JIT compilation (in memory cache)" (2012, 4, 5, 1, 20, 50) fem-speedup-cpp 322.331 "Assembly/solve speedup running on 4 processors" (2012, 4, 5, 1, 20, 50) fem-speedup-cpp-assembly 5.60304 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 5, 1, 20, 50) fem-speedup-cpp-solve 1.8112 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 5, 1, 21, 15) mesh-refinement-cpp 22.9131 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 5, 1, 21, 36) mesh-topology-cpp 21.2879 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 5, 1, 21, 59) mesh-unitcube-cpp 22.1745 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 5, 1, 22, 44) mesh-iteration-cpp 43.0736 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 5, 1, 23, 6) function-evaluation-cpp 21.3185 "Evaluations of functions at arbitrary points." (2012, 4, 5, 1, 23, 6) function-evaluation-cpp 21.2377 "Evaluations of functions at arbitrary points." (2012, 4, 5, 1, 23, 12) function-extrapolation-python 6.78808 "BENCH: 1.92564797401" (2012, 4, 5, 1, 23, 12) function-extrapolation-python 1.92565 "BENCH: 1.92564797401" (2012, 4, 5, 1, 23, 35) la-vector-access-cpp 22.4427 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 5, 1, 24, 0) la-vector-assignment-cpp 24.9598 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 6, 1, 11, 24) common-progress-cpp 29.5914 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 6, 1, 11, 54) common-timing-cpp 30.9051 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 6, 1, 12, 4) fem-multicore-cpp 10.0022 "Coloring mesh." (2012, 4, 6, 1, 15, 19) fem-assembly-cpp 194.833 "Assembly for various forms and backends" (2012, 4, 6, 1, 15, 31) fem-convergence-cpp 11.8686 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 6, 1, 15, 32) fem-jit-python 0.000404692 "JIT compilation (in memory cache)" (2012, 4, 6, 1, 20, 45) fem-speedup-cpp 312.888 "Assembly/solve speedup running on 4 processors" (2012, 4, 6, 1, 20, 45) fem-speedup-cpp-assembly 5.51397 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 6, 1, 20, 45) fem-speedup-cpp-solve 1.96147 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 6, 1, 21, 9) mesh-refinement-cpp 22.655 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 6, 1, 21, 31) mesh-topology-cpp 21.3078 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 6, 1, 21, 52) mesh-unitcube-cpp 21.6501 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 6, 1, 22, 37) mesh-iteration-cpp 41.9631 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 6, 1, 22, 59) function-evaluation-cpp 21.9918 "Evaluations of functions at arbitrary points." (2012, 4, 6, 1, 22, 59) function-evaluation-cpp 21.9108 "Evaluations of functions at arbitrary points." (2012, 4, 6, 1, 23, 6) function-extrapolation-python 6.64582 "BENCH: 1.92029690742" (2012, 4, 6, 1, 23, 6) function-extrapolation-python 1.9203 "BENCH: 1.92029690742" (2012, 4, 6, 1, 23, 29) la-vector-access-cpp 23.4188 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 6, 1, 23, 54) la-vector-assignment-cpp 25.1107 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 7, 1, 11, 8) common-progress-cpp 29.6045 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 7, 1, 11, 37) common-timing-cpp 29.2484 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 7, 1, 11, 47) fem-multicore-cpp 10.1002 "Coloring mesh." (2012, 4, 7, 1, 15, 2) fem-assembly-cpp 194.759 "Assembly for various forms and backends" (2012, 4, 7, 1, 15, 14) fem-convergence-cpp 11.8038 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 7, 1, 15, 15) fem-jit-python 0.00042491 "JIT compilation (in memory cache)" (2012, 4, 7, 1, 20, 26) fem-speedup-cpp 310.96 "Assembly/solve speedup running on 4 processors" (2012, 4, 7, 1, 20, 26) fem-speedup-cpp-assembly 5.5059 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 7, 1, 20, 26) fem-speedup-cpp-solve 2.03805 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 7, 1, 20, 50) mesh-refinement-cpp 22.6697 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 7, 1, 21, 12) mesh-topology-cpp 21.3257 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 7, 1, 21, 33) mesh-unitcube-cpp 21.5497 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 7, 1, 22, 18) mesh-iteration-cpp 41.9542 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 7, 1, 22, 39) function-evaluation-cpp 21.3445 "Evaluations of functions at arbitrary points." (2012, 4, 7, 1, 22, 39) function-evaluation-cpp 21.2634 "Evaluations of functions at arbitrary points." (2012, 4, 7, 1, 22, 46) function-extrapolation-python 6.7778 "BENCH: 1.91542887688" (2012, 4, 7, 1, 22, 46) function-extrapolation-python 1.91543 "BENCH: 1.91542887688" (2012, 4, 7, 1, 23, 10) la-vector-access-cpp 23.8879 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 7, 1, 23, 35) la-vector-assignment-cpp 24.9626 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 8, 1, 11, 10) common-progress-cpp 29.6068 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 8, 1, 11, 40) common-timing-cpp 29.3383 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 8, 1, 11, 50) fem-multicore-cpp 10.0317 "Coloring mesh." (2012, 4, 8, 1, 15, 4) fem-assembly-cpp 193.816 "Assembly for various forms and backends" (2012, 4, 8, 1, 15, 15) fem-convergence-cpp 11.9014 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 8, 1, 15, 17) fem-jit-python 0.000415492 "JIT compilation (in memory cache)" (2012, 4, 8, 1, 20, 36) fem-speedup-cpp 319.491 "Assembly/solve speedup running on 4 processors" (2012, 4, 8, 1, 20, 36) fem-speedup-cpp-assembly 5.53892 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 8, 1, 20, 36) fem-speedup-cpp-solve 1.83568 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 8, 1, 21, 0) mesh-refinement-cpp 22.6556 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 8, 1, 21, 22) mesh-topology-cpp 21.2851 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 8, 1, 21, 43) mesh-unitcube-cpp 21.5829 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 8, 1, 22, 28) mesh-iteration-cpp 41.959 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 8, 1, 22, 49) function-evaluation-cpp 21.2914 "Evaluations of functions at arbitrary points." (2012, 4, 8, 1, 22, 49) function-evaluation-cpp 21.2098 "Evaluations of functions at arbitrary points." (2012, 4, 8, 1, 22, 56) function-extrapolation-python 6.80206 "BENCH: 1.91059112549" (2012, 4, 8, 1, 22, 56) function-extrapolation-python 1.91059 "BENCH: 1.91059112549" (2012, 4, 8, 1, 23, 21) la-vector-access-cpp 24.7488 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 8, 1, 23, 46) la-vector-assignment-cpp 24.9565 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 9, 1, 11, 10) common-progress-cpp 29.6139 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 9, 1, 11, 40) common-timing-cpp 29.3154 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 9, 1, 11, 50) fem-multicore-cpp 10.1391 "Coloring mesh." (2012, 4, 9, 1, 15, 5) fem-assembly-cpp 195.676 "Assembly for various forms and backends" (2012, 4, 9, 1, 15, 17) fem-convergence-cpp 11.8654 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 9, 1, 15, 18) fem-jit-python 0.000416708 "JIT compilation (in memory cache)" (2012, 4, 9, 1, 20, 46) fem-speedup-cpp 327.076 "Assembly/solve speedup running on 4 processors" (2012, 4, 9, 1, 20, 46) fem-speedup-cpp-assembly 5.38924 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 9, 1, 20, 46) fem-speedup-cpp-solve 1.72854 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 9, 1, 21, 10) mesh-refinement-cpp 22.6798 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 9, 1, 21, 31) mesh-topology-cpp 21.3687 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 9, 1, 21, 53) mesh-unitcube-cpp 21.5628 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 9, 1, 22, 41) mesh-iteration-cpp 45.5416 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 9, 1, 23, 2) function-evaluation-cpp 21.3215 "Evaluations of functions at arbitrary points." (2012, 4, 9, 1, 23, 2) function-evaluation-cpp 21.2402 "Evaluations of functions at arbitrary points." (2012, 4, 9, 1, 23, 9) function-extrapolation-python 6.67455 "BENCH: 1.87760996819" (2012, 4, 9, 1, 23, 9) function-extrapolation-python 1.87761 "BENCH: 1.87760996819" (2012, 4, 9, 1, 23, 32) la-vector-access-cpp 22.8976 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 9, 1, 24, 0) la-vector-assignment-cpp 27.909 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 10, 1, 11, 11) common-progress-cpp 29.6185 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 10, 1, 11, 41) common-timing-cpp 30.2668 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 10, 1, 11, 51) fem-multicore-cpp 10.051 "Coloring mesh." (2012, 4, 10, 1, 15, 6) fem-assembly-cpp 194.713 "Assembly for various forms and backends" (2012, 4, 10, 1, 15, 18) fem-convergence-cpp 11.8898 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 10, 1, 15, 19) fem-jit-python 0.000405598 "JIT compilation (in memory cache)" (2012, 4, 10, 1, 20, 31) fem-speedup-cpp 312.221 "Assembly/solve speedup running on 4 processors" (2012, 4, 10, 1, 20, 31) fem-speedup-cpp-assembly 5.50767 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 10, 1, 20, 31) fem-speedup-cpp-solve 2.00828 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 10, 1, 20, 55) mesh-refinement-cpp 22.6637 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 10, 1, 21, 16) mesh-topology-cpp 21.2887 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 10, 1, 21, 38) mesh-unitcube-cpp 21.5207 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 10, 1, 22, 22) mesh-iteration-cpp 41.9577 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 10, 1, 22, 44) function-evaluation-cpp 21.2886 "Evaluations of functions at arbitrary points." (2012, 4, 10, 1, 22, 44) function-evaluation-cpp 21.2079 "Evaluations of functions at arbitrary points." (2012, 4, 10, 1, 22, 51) function-extrapolation-python 6.71729 "BENCH: 1.90854501724" (2012, 4, 10, 1, 22, 51) function-extrapolation-python 1.90855 "BENCH: 1.90854501724" (2012, 4, 10, 1, 23, 13) la-vector-access-cpp 22.8883 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 10, 1, 23, 38) la-vector-assignment-cpp 24.8592 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 11, 1, 11, 39) common-progress-cpp 37.6901 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 11, 1, 12, 9) common-timing-cpp 30.061 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 11, 1, 12, 19) fem-multicore-cpp 10.031 "Coloring mesh." (2012, 4, 11, 1, 15, 34) fem-assembly-cpp 195.459 "Assembly for various forms and backends" (2012, 4, 11, 1, 15, 46) fem-convergence-cpp 11.8761 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 11, 1, 15, 59) fem-jit-python 0.000437808 "JIT compilation (in memory cache)" (2012, 4, 11, 1, 21, 24) fem-speedup-cpp 325.611 "Assembly/solve speedup running on 4 processors" (2012, 4, 11, 1, 21, 24) fem-speedup-cpp-assembly 5.53267 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 11, 1, 21, 24) fem-speedup-cpp-solve 1.75802 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 11, 1, 21, 49) mesh-refinement-cpp 22.7249 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 11, 1, 22, 10) mesh-topology-cpp 21.2921 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 11, 1, 22, 32) mesh-unitcube-cpp 21.554 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 11, 1, 23, 16) mesh-iteration-cpp 41.9561 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 11, 1, 23, 38) function-evaluation-cpp 21.3437 "Evaluations of functions at arbitrary points." (2012, 4, 11, 1, 23, 38) function-evaluation-cpp 21.2627 "Evaluations of functions at arbitrary points." (2012, 4, 11, 1, 24, 28) function-extrapolation-python 50.3287 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2012, 4, 11, 1, 24, 28) function-extrapolation-python 1.87041 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2012, 4, 11, 1, 24, 52) la-vector-access-cpp 23.9218 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 11, 1, 25, 17) la-vector-assignment-cpp 24.958 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 12, 1, 11, 28) common-progress-cpp 29.5758 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 12, 1, 11, 58) common-timing-cpp 29.4504 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 12, 1, 12, 8) fem-multicore-cpp 10.0968 "Coloring mesh." (2012, 4, 12, 1, 15, 23) fem-assembly-cpp 195.389 "Assembly for various forms and backends" (2012, 4, 12, 1, 15, 35) fem-convergence-cpp 11.9012 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 12, 1, 15, 36) fem-jit-python 0.000413799 "JIT compilation (in memory cache)" (2012, 4, 12, 1, 20, 51) fem-speedup-cpp 314.38 "Assembly/solve speedup running on 4 processors" (2012, 4, 12, 1, 20, 51) fem-speedup-cpp-assembly 5.49665 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 12, 1, 20, 51) fem-speedup-cpp-solve 1.96089 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 12, 1, 21, 15) mesh-refinement-cpp 22.6922 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 12, 1, 21, 36) mesh-topology-cpp 21.328 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 12, 1, 21, 58) mesh-unitcube-cpp 21.5581 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 12, 1, 22, 42) mesh-iteration-cpp 41.9564 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 12, 1, 23, 3) function-evaluation-cpp 21.3275 "Evaluations of functions at arbitrary points." (2012, 4, 12, 1, 23, 3) function-evaluation-cpp 21.2465 "Evaluations of functions at arbitrary points." (2012, 4, 12, 1, 23, 10) function-extrapolation-python 6.86228 "BENCH: 1.91826319695" (2012, 4, 12, 1, 23, 10) function-extrapolation-python 1.91826 "BENCH: 1.91826319695" (2012, 4, 12, 1, 23, 33) la-vector-access-cpp 22.8895 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 12, 1, 23, 58) la-vector-assignment-cpp 24.947 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 13, 1, 11, 5) common-progress-cpp 29.7275 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 13, 1, 11, 35) common-timing-cpp 29.3219 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 13, 1, 11, 45) fem-multicore-cpp 10.0317 "Coloring mesh." (2012, 4, 13, 1, 15, 0) fem-assembly-cpp 195.012 "Assembly for various forms and backends" (2012, 4, 13, 1, 15, 12) fem-convergence-cpp 11.8576 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 13, 1, 15, 13) fem-jit-python 0.000402689 "JIT compilation (in memory cache)" (2012, 4, 13, 1, 20, 23) fem-speedup-cpp 309.903 "Assembly/solve speedup running on 4 processors" (2012, 4, 13, 1, 20, 23) fem-speedup-cpp-assembly 5.44764 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 13, 1, 20, 23) fem-speedup-cpp-solve 2.00791 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 13, 1, 20, 47) mesh-refinement-cpp 22.6317 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 13, 1, 21, 8) mesh-topology-cpp 21.2982 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 13, 1, 21, 30) mesh-unitcube-cpp 21.5571 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 13, 1, 22, 14) mesh-iteration-cpp 41.9579 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 13, 1, 22, 35) function-evaluation-cpp 20.895 "Evaluations of functions at arbitrary points." (2012, 4, 13, 1, 22, 35) function-evaluation-cpp 20.8135 "Evaluations of functions at arbitrary points." (2012, 4, 13, 1, 22, 42) function-extrapolation-python 6.69723 "BENCH: 1.91965317726" (2012, 4, 13, 1, 22, 42) function-extrapolation-python 1.91965 "BENCH: 1.91965317726" (2012, 4, 13, 1, 23, 5) la-vector-access-cpp 22.8961 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 13, 1, 23, 30) la-vector-assignment-cpp 24.9554 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 14, 1, 11, 13) common-progress-cpp 29.5913 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 14, 1, 11, 42) common-timing-cpp 29.3513 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 14, 1, 11, 52) fem-multicore-cpp 9.95149 "Coloring mesh." (2012, 4, 14, 1, 15, 7) fem-assembly-cpp 194.398 "Assembly for various forms and backends" (2012, 4, 14, 1, 15, 19) fem-convergence-cpp 11.9192 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 14, 1, 15, 20) fem-jit-python 0.000419497 "JIT compilation (in memory cache)" (2012, 4, 14, 1, 20, 37) fem-speedup-cpp 317.428 "Assembly/solve speedup running on 4 processors" (2012, 4, 14, 1, 20, 37) fem-speedup-cpp-assembly 5.50765 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 14, 1, 20, 37) fem-speedup-cpp-solve 1.88947 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 14, 1, 21, 1) mesh-refinement-cpp 22.6315 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 14, 1, 21, 23) mesh-topology-cpp 21.315 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 14, 1, 21, 44) mesh-unitcube-cpp 21.5444 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 14, 1, 22, 29) mesh-iteration-cpp 41.9574 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 14, 1, 22, 50) function-evaluation-cpp 21.312 "Evaluations of functions at arbitrary points." (2012, 4, 14, 1, 22, 50) function-evaluation-cpp 21.2305 "Evaluations of functions at arbitrary points." (2012, 4, 14, 1, 22, 57) function-extrapolation-python 6.84253 "BENCH: 1.91713786125" (2012, 4, 14, 1, 22, 57) function-extrapolation-python 1.91714 "BENCH: 1.91713786125" (2012, 4, 14, 1, 23, 20) la-vector-access-cpp 23.4699 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 14, 1, 23, 49) la-vector-assignment-cpp 28.4046 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 15, 1, 11, 1) common-progress-cpp 29.6471 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 15, 1, 11, 30) common-timing-cpp 29.3415 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 15, 1, 11, 40) fem-multicore-cpp 10.0903 "Coloring mesh." (2012, 4, 15, 1, 14, 55) fem-assembly-cpp 195.025 "Assembly for various forms and backends" (2012, 4, 15, 1, 15, 7) fem-convergence-cpp 11.9013 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 15, 1, 15, 8) fem-jit-python 0.000399303 "JIT compilation (in memory cache)" (2012, 4, 15, 1, 20, 30) fem-speedup-cpp 321.279 "Assembly/solve speedup running on 4 processors" (2012, 4, 15, 1, 20, 30) fem-speedup-cpp-assembly 5.52572 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 15, 1, 20, 30) fem-speedup-cpp-solve 1.79201 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 15, 1, 20, 54) mesh-refinement-cpp 22.6588 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 15, 1, 21, 15) mesh-topology-cpp 21.3575 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 15, 1, 21, 37) mesh-unitcube-cpp 21.5732 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 15, 1, 22, 21) mesh-iteration-cpp 41.9679 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 15, 1, 22, 43) function-evaluation-cpp 21.4094 "Evaluations of functions at arbitrary points." (2012, 4, 15, 1, 22, 43) function-evaluation-cpp 21.3282 "Evaluations of functions at arbitrary points." (2012, 4, 15, 1, 22, 50) function-extrapolation-python 6.84848 "BENCH: 1.93561601639" (2012, 4, 15, 1, 22, 50) function-extrapolation-python 1.93562 "BENCH: 1.93561601639" (2012, 4, 15, 1, 23, 15) la-vector-access-cpp 25.3845 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 15, 1, 23, 40) la-vector-assignment-cpp 24.9474 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 16, 1, 11, 8) common-progress-cpp 29.8776 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 16, 1, 11, 37) common-timing-cpp 29.6351 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 16, 1, 11, 47) fem-multicore-cpp 10.0687 "Coloring mesh." (2012, 4, 16, 1, 15, 2) fem-assembly-cpp 195.05 "Assembly for various forms and backends" (2012, 4, 16, 1, 15, 14) fem-convergence-cpp 11.8756 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 16, 1, 15, 15) fem-jit-python 0.000411296 "JIT compilation (in memory cache)" (2012, 4, 16, 1, 20, 33) fem-speedup-cpp 317.598 "Assembly/solve speedup running on 4 processors" (2012, 4, 16, 1, 20, 33) fem-speedup-cpp-assembly 5.48247 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 16, 1, 20, 33) fem-speedup-cpp-solve 1.8917 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 16, 1, 20, 57) mesh-refinement-cpp 22.6601 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 16, 1, 21, 19) mesh-topology-cpp 21.3013 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 16, 1, 21, 40) mesh-unitcube-cpp 21.5678 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 16, 1, 22, 25) mesh-iteration-cpp 41.9616 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 16, 1, 22, 46) function-evaluation-cpp 21.2234 "Evaluations of functions at arbitrary points." (2012, 4, 16, 1, 22, 46) function-evaluation-cpp 21.1426 "Evaluations of functions at arbitrary points." (2012, 4, 16, 1, 22, 53) function-extrapolation-python 6.62327 "BENCH: 1.9081389904" (2012, 4, 16, 1, 22, 53) function-extrapolation-python 1.90814 "BENCH: 1.9081389904" (2012, 4, 16, 1, 23, 16) la-vector-access-cpp 22.8958 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 16, 1, 23, 41) la-vector-assignment-cpp 25.3182 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 17, 1, 11, 24) common-progress-cpp 29.5943 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 17, 1, 11, 53) common-timing-cpp 29.3269 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 17, 1, 12, 3) fem-multicore-cpp 10.0395 "Coloring mesh." (2012, 4, 17, 1, 15, 18) fem-assembly-cpp 195.046 "Assembly for various forms and backends" (2012, 4, 17, 1, 15, 30) fem-convergence-cpp 11.8156 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 17, 1, 15, 31) fem-jit-python 0.000405502 "JIT compilation (in memory cache)" (2012, 4, 17, 1, 20, 52) fem-speedup-cpp 321.085 "Assembly/solve speedup running on 4 processors" (2012, 4, 17, 1, 20, 52) fem-speedup-cpp-assembly 5.49989 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 17, 1, 20, 52) fem-speedup-cpp-solve 1.80138 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 17, 1, 21, 17) mesh-refinement-cpp 22.6523 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 17, 1, 21, 38) mesh-topology-cpp 21.3286 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 17, 1, 22, 0) mesh-unitcube-cpp 21.538 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 17, 1, 22, 45) mesh-iteration-cpp 42.9854 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 17, 1, 23, 7) function-evaluation-cpp 21.5716 "Evaluations of functions at arbitrary points." (2012, 4, 17, 1, 23, 7) function-evaluation-cpp 21.491 "Evaluations of functions at arbitrary points." (2012, 4, 17, 1, 23, 13) function-extrapolation-python 6.70889 "BENCH: 1.91690993309" (2012, 4, 17, 1, 23, 13) function-extrapolation-python 1.91691 "BENCH: 1.91690993309" (2012, 4, 17, 1, 23, 38) la-vector-access-cpp 24.7413 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 17, 1, 24, 6) la-vector-assignment-cpp 27.898 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 18, 1, 11, 18) common-progress-cpp 29.5696 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 18, 1, 11, 49) common-timing-cpp 31.2141 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 18, 1, 11, 59) fem-multicore-cpp 10.0536 "Coloring mesh." (2012, 4, 18, 1, 15, 14) fem-assembly-cpp 195.05 "Assembly for various forms and backends" (2012, 4, 18, 1, 15, 26) fem-convergence-cpp 11.9287 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 18, 1, 15, 27) fem-jit-python 0.000406384 "JIT compilation (in memory cache)" (2012, 4, 18, 1, 20, 38) fem-speedup-cpp 310.697 "Assembly/solve speedup running on 4 processors" (2012, 4, 18, 1, 20, 38) fem-speedup-cpp-assembly 5.44698 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 18, 1, 20, 38) fem-speedup-cpp-solve 2.02891 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 18, 1, 21, 2) mesh-refinement-cpp 22.6653 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 18, 1, 21, 24) mesh-topology-cpp 21.3476 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 18, 1, 21, 46) mesh-unitcube-cpp 22.4067 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 18, 1, 22, 31) mesh-iteration-cpp 41.9577 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 18, 1, 22, 52) function-evaluation-cpp 21.3133 "Evaluations of functions at arbitrary points." (2012, 4, 18, 1, 22, 52) function-evaluation-cpp 21.2324 "Evaluations of functions at arbitrary points." (2012, 4, 18, 1, 22, 59) function-extrapolation-python 6.75713 "BENCH: 1.90683197975" (2012, 4, 18, 1, 22, 59) function-extrapolation-python 1.90683 "BENCH: 1.90683197975" (2012, 4, 18, 1, 23, 22) la-vector-access-cpp 23.4111 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 18, 1, 23, 47) la-vector-assignment-cpp 24.9726 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 19, 1, 11, 3) common-progress-cpp 29.6664 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 19, 1, 11, 34) common-timing-cpp 31.1433 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 19, 1, 11, 44) fem-multicore-cpp 10.2088 "Coloring mesh." (2012, 4, 19, 1, 14, 58) fem-assembly-cpp 194.265 "Assembly for various forms and backends" (2012, 4, 19, 1, 15, 10) fem-convergence-cpp 11.5099 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 19, 1, 15, 11) fem-jit-python 0.000402379 "JIT compilation (in memory cache)" (2012, 4, 19, 1, 20, 31) fem-speedup-cpp 320.158 "Assembly/solve speedup running on 4 processors" (2012, 4, 19, 1, 20, 31) fem-speedup-cpp-assembly 5.41944 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 19, 1, 20, 31) fem-speedup-cpp-solve 1.86275 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 19, 1, 20, 55) mesh-refinement-cpp 22.646 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 19, 1, 21, 17) mesh-topology-cpp 21.4082 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 19, 1, 21, 39) mesh-unitcube-cpp 22.4364 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 19, 1, 22, 24) mesh-iteration-cpp 41.9751 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 19, 1, 22, 46) function-evaluation-cpp 22.0381 "Evaluations of functions at arbitrary points." (2012, 4, 19, 1, 22, 46) function-evaluation-cpp 21.947 "Evaluations of functions at arbitrary points." (2012, 4, 19, 1, 22, 53) function-extrapolation-python 6.80468 "BENCH: 1.90234613419" (2012, 4, 19, 1, 22, 53) function-extrapolation-python 1.90235 "BENCH: 1.90234613419" (2012, 4, 19, 1, 23, 15) la-vector-access-cpp 22.4238 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 19, 1, 23, 43) la-vector-assignment-cpp 27.8512 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 20, 1, 11, 2) common-progress-cpp 29.7221 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 20, 1, 11, 33) common-timing-cpp 30.9285 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 20, 1, 11, 43) fem-multicore-cpp 10.0384 "Coloring mesh." (2012, 4, 20, 1, 14, 57) fem-assembly-cpp 194.188 "Assembly for various forms and backends" (2012, 4, 20, 1, 15, 9) fem-convergence-cpp 11.8689 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 20, 1, 15, 10) fem-jit-python 0.000417686 "JIT compilation (in memory cache)" (2012, 4, 20, 1, 20, 29) fem-speedup-cpp 318.508 "Assembly/solve speedup running on 4 processors" (2012, 4, 20, 1, 20, 29) fem-speedup-cpp-assembly 5.40301 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 20, 1, 20, 29) fem-speedup-cpp-solve 1.8532 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 20, 1, 20, 53) mesh-refinement-cpp 22.6916 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 20, 1, 21, 14) mesh-topology-cpp 21.3408 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 20, 1, 21, 37) mesh-unitcube-cpp 22.4068 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 20, 1, 22, 21) mesh-iteration-cpp 41.9578 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 20, 1, 22, 43) function-evaluation-cpp 21.3187 "Evaluations of functions at arbitrary points." (2012, 4, 20, 1, 22, 43) function-evaluation-cpp 21.237 "Evaluations of functions at arbitrary points." (2012, 4, 20, 1, 22, 49) function-extrapolation-python 6.67374 "BENCH: 1.90048503876" (2012, 4, 20, 1, 22, 49) function-extrapolation-python 1.90049 "BENCH: 1.90048503876" (2012, 4, 20, 1, 23, 13) la-vector-access-cpp 23.6049 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 20, 1, 23, 41) la-vector-assignment-cpp 27.8924 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 21, 1, 11, 12) common-progress-cpp 29.9227 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 21, 1, 11, 42) common-timing-cpp 30.6816 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 21, 1, 11, 53) fem-multicore-cpp 10.1222 "Coloring mesh." (2012, 4, 21, 1, 15, 7) fem-assembly-cpp 194.172 "Assembly for various forms and backends" (2012, 4, 21, 1, 15, 19) fem-convergence-cpp 11.8828 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 21, 1, 15, 20) fem-jit-python 0.000417018 "JIT compilation (in memory cache)" (2012, 4, 21, 1, 20, 32) fem-speedup-cpp 312.361 "Assembly/solve speedup running on 4 processors" (2012, 4, 21, 1, 20, 32) fem-speedup-cpp-assembly 5.44887 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 21, 1, 20, 32) fem-speedup-cpp-solve 1.98505 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 21, 1, 20, 56) mesh-refinement-cpp 22.7131 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 21, 1, 21, 18) mesh-topology-cpp 21.5561 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 21, 1, 21, 40) mesh-unitcube-cpp 22.4071 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 21, 1, 22, 31) mesh-iteration-cpp 47.9581 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 21, 1, 22, 52) function-evaluation-cpp 21.2446 "Evaluations of functions at arbitrary points." (2012, 4, 21, 1, 22, 52) function-evaluation-cpp 21.1633 "Evaluations of functions at arbitrary points." (2012, 4, 21, 1, 22, 59) function-extrapolation-python 6.72554 "BENCH: 1.90550684929" (2012, 4, 21, 1, 22, 59) function-extrapolation-python 1.90551 "BENCH: 1.90550684929" (2012, 4, 21, 1, 23, 21) la-vector-access-cpp 22.4383 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 21, 1, 23, 46) la-vector-assignment-cpp 24.9547 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 22, 1, 11, 1) common-progress-cpp 29.5646 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 22, 1, 11, 33) common-timing-cpp 31.3225 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 22, 1, 11, 43) fem-multicore-cpp 9.93637 "Coloring mesh." (2012, 4, 22, 1, 14, 57) fem-assembly-cpp 193.893 "Assembly for various forms and backends" (2012, 4, 22, 1, 15, 8) fem-convergence-cpp 11.8767 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 22, 1, 15, 10) fem-jit-python 0.000411415 "JIT compilation (in memory cache)" (2012, 4, 22, 1, 20, 23) fem-speedup-cpp 313.282 "Assembly/solve speedup running on 4 processors" (2012, 4, 22, 1, 20, 23) fem-speedup-cpp-assembly 5.428 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 22, 1, 20, 23) fem-speedup-cpp-solve 1.98766 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 22, 1, 20, 47) mesh-refinement-cpp 22.6643 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 22, 1, 21, 8) mesh-topology-cpp 21.3226 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 22, 1, 21, 31) mesh-unitcube-cpp 22.4335 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 22, 1, 22, 15) mesh-iteration-cpp 41.9536 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 22, 1, 22, 37) function-evaluation-cpp 21.3033 "Evaluations of functions at arbitrary points." (2012, 4, 22, 1, 22, 37) function-evaluation-cpp 21.222 "Evaluations of functions at arbitrary points." (2012, 4, 22, 1, 22, 44) function-extrapolation-python 6.77616 "BENCH: 1.90428900719" (2012, 4, 22, 1, 22, 44) function-extrapolation-python 1.90429 "BENCH: 1.90428900719" (2012, 4, 22, 1, 23, 6) la-vector-access-cpp 22.4397 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 22, 1, 23, 31) la-vector-assignment-cpp 24.9604 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 23, 1, 11, 4) common-progress-cpp 29.5794 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 23, 1, 11, 35) common-timing-cpp 30.9283 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 23, 1, 11, 45) fem-multicore-cpp 10.087 "Coloring mesh." (2012, 4, 23, 1, 14, 59) fem-assembly-cpp 193.737 "Assembly for various forms and backends" (2012, 4, 23, 1, 15, 11) fem-convergence-cpp 11.9053 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 23, 1, 15, 12) fem-jit-python 0.000401783 "JIT compilation (in memory cache)" (2012, 4, 23, 1, 20, 29) fem-speedup-cpp 317.045 "Assembly/solve speedup running on 4 processors" (2012, 4, 23, 1, 20, 29) fem-speedup-cpp-assembly 5.43166 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 23, 1, 20, 29) fem-speedup-cpp-solve 1.91184 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 23, 1, 20, 53) mesh-refinement-cpp 22.6769 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 23, 1, 21, 15) mesh-topology-cpp 21.3928 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 23, 1, 21, 37) mesh-unitcube-cpp 22.3844 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 23, 1, 22, 23) mesh-iteration-cpp 42.7467 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 23, 1, 22, 44) function-evaluation-cpp 21.368 "Evaluations of functions at arbitrary points." (2012, 4, 23, 1, 22, 44) function-evaluation-cpp 21.2797 "Evaluations of functions at arbitrary points." (2012, 4, 23, 1, 22, 51) function-extrapolation-python 6.57987 "BENCH: 1.87099385262" (2012, 4, 23, 1, 22, 51) function-extrapolation-python 1.87099 "BENCH: 1.87099385262" (2012, 4, 23, 1, 23, 14) la-vector-access-cpp 23.0003 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 23, 1, 23, 39) la-vector-assignment-cpp 25.0918 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 24, 1, 11, 24) common-progress-cpp 29.8705 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 24, 1, 11, 55) common-timing-cpp 30.5995 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 24, 1, 12, 5) fem-multicore-cpp 10.0213 "Coloring mesh." (2012, 4, 24, 1, 15, 19) fem-assembly-cpp 194.317 "Assembly for various forms and backends" (2012, 4, 24, 1, 15, 31) fem-convergence-cpp 11.8945 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 24, 1, 15, 32) fem-jit-python 0.000413299 "JIT compilation (in memory cache)" (2012, 4, 24, 1, 20, 45) fem-speedup-cpp 312.664 "Assembly/solve speedup running on 4 processors" (2012, 4, 24, 1, 20, 45) fem-speedup-cpp-assembly 5.43314 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 24, 1, 20, 45) fem-speedup-cpp-solve 1.9839 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 24, 1, 21, 9) mesh-refinement-cpp 22.6099 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 24, 1, 21, 31) mesh-topology-cpp 21.3277 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 24, 1, 21, 53) mesh-unitcube-cpp 22.4734 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 24, 1, 22, 38) mesh-iteration-cpp 41.9552 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 24, 1, 22, 59) function-evaluation-cpp 21.2943 "Evaluations of functions at arbitrary points." (2012, 4, 24, 1, 22, 59) function-evaluation-cpp 21.213 "Evaluations of functions at arbitrary points." (2012, 4, 24, 1, 23, 6) function-extrapolation-python 6.79949 "BENCH: 1.90289306641" (2012, 4, 24, 1, 23, 6) function-extrapolation-python 1.90289 "BENCH: 1.90289306641" (2012, 4, 24, 1, 23, 28) la-vector-access-cpp 22.4134 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 24, 1, 23, 53) la-vector-assignment-cpp 24.9436 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 25, 1, 11, 20) common-progress-cpp 29.6066 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 25, 1, 11, 51) common-timing-cpp 30.8745 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 25, 1, 12, 1) fem-multicore-cpp 10.0471 "Coloring mesh." (2012, 4, 25, 1, 15, 15) fem-assembly-cpp 194.202 "Assembly for various forms and backends" (2012, 4, 25, 1, 15, 27) fem-convergence-cpp 11.8709 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 25, 1, 15, 28) fem-jit-python 0.000406599 "JIT compilation (in memory cache)" (2012, 4, 25, 1, 20, 37) fem-speedup-cpp 309.563 "Assembly/solve speedup running on 4 processors" (2012, 4, 25, 1, 20, 37) fem-speedup-cpp-assembly 5.05148 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 25, 1, 20, 37) fem-speedup-cpp-solve 2.0173 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 25, 1, 21, 2) mesh-refinement-cpp 22.8024 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 25, 1, 21, 23) mesh-topology-cpp 21.2844 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 25, 1, 21, 46) mesh-unitcube-cpp 22.8737 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 25, 1, 22, 30) mesh-iteration-cpp 41.963 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 25, 1, 22, 52) function-evaluation-cpp 21.3133 "Evaluations of functions at arbitrary points." (2012, 4, 25, 1, 22, 52) function-evaluation-cpp 21.2323 "Evaluations of functions at arbitrary points." (2012, 4, 25, 1, 22, 59) function-extrapolation-python 6.72501 "BENCH: 1.9053709507" (2012, 4, 25, 1, 22, 59) function-extrapolation-python 1.90537 "BENCH: 1.9053709507" (2012, 4, 25, 1, 23, 22) la-vector-access-cpp 22.8958 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 25, 1, 23, 47) la-vector-assignment-cpp 24.9489 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 26, 1, 11, 3) common-progress-cpp 29.578 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 26, 1, 11, 33) common-timing-cpp 30.2781 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 26, 1, 11, 43) fem-multicore-cpp 10.0408 "Coloring mesh." (2012, 4, 26, 1, 14, 56) fem-assembly-cpp 192.944 "Assembly for various forms and backends" (2012, 4, 26, 1, 15, 8) fem-convergence-cpp 11.8974 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 26, 1, 15, 9) fem-jit-python 0.000407696 "JIT compilation (in memory cache)" (2012, 4, 26, 1, 20, 20) fem-speedup-cpp 311.103 "Assembly/solve speedup running on 4 processors" (2012, 4, 26, 1, 20, 20) fem-speedup-cpp-assembly 5.50609 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 26, 1, 20, 20) fem-speedup-cpp-solve 2.01727 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 26, 1, 20, 44) mesh-refinement-cpp 22.8465 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 26, 1, 21, 6) mesh-topology-cpp 21.1994 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 26, 1, 21, 29) mesh-unitcube-cpp 22.9647 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 26, 1, 22, 13) mesh-iteration-cpp 41.9606 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 26, 1, 22, 34) function-evaluation-cpp 21.1027 "Evaluations of functions at arbitrary points." (2012, 4, 26, 1, 22, 34) function-evaluation-cpp 21.0216 "Evaluations of functions at arbitrary points." (2012, 4, 26, 1, 22, 41) function-extrapolation-python 6.72148 "BENCH: 1.90126991272" (2012, 4, 26, 1, 22, 41) function-extrapolation-python 1.90127 "BENCH: 1.90126991272" (2012, 4, 26, 1, 23, 4) la-vector-access-cpp 22.8984 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 26, 1, 23, 32) la-vector-assignment-cpp 27.8939 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 27, 1, 11, 33) common-progress-cpp 29.6143 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 27, 1, 12, 3) common-timing-cpp 30.0286 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 27, 1, 12, 13) fem-multicore-cpp 9.96386 "Coloring mesh." (2012, 4, 27, 1, 15, 27) fem-assembly-cpp 193.596 "Assembly for various forms and backends" (2012, 4, 27, 1, 15, 39) fem-convergence-cpp 11.8802 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 27, 1, 15, 40) fem-jit-python 0.000405693 "JIT compilation (in memory cache)" (2012, 4, 27, 1, 20, 51) fem-speedup-cpp 310.826 "Assembly/solve speedup running on 4 processors" (2012, 4, 27, 1, 20, 51) fem-speedup-cpp-assembly 5.3286 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 27, 1, 20, 51) fem-speedup-cpp-solve 2.01275 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 27, 1, 21, 15) mesh-refinement-cpp 22.5063 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 27, 1, 21, 36) mesh-topology-cpp 21.3384 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 27, 1, 22, 0) mesh-unitcube-cpp 23.3504 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 27, 1, 22, 47) mesh-iteration-cpp 44.7476 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 27, 1, 23, 8) function-evaluation-cpp 21.3546 "Evaluations of functions at arbitrary points." (2012, 4, 27, 1, 23, 8) function-evaluation-cpp 21.2732 "Evaluations of functions at arbitrary points." (2012, 4, 27, 1, 23, 15) function-extrapolation-python 6.73874 "BENCH: 1.90335917473" (2012, 4, 27, 1, 23, 15) function-extrapolation-python 1.90336 "BENCH: 1.90335917473" (2012, 4, 27, 1, 23, 38) la-vector-access-cpp 22.9011 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 27, 1, 24, 3) la-vector-assignment-cpp 24.9626 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 28, 1, 11, 3) common-progress-cpp 29.5722 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 28, 1, 11, 34) common-timing-cpp 30.8464 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 28, 1, 11, 44) fem-multicore-cpp 9.97898 "Coloring mesh." (2012, 4, 28, 1, 14, 56) fem-assembly-cpp 191.886 "Assembly for various forms and backends" (2012, 4, 28, 1, 15, 8) fem-convergence-cpp 11.9076 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 28, 1, 15, 9) fem-jit-python 0.000423503 "JIT compilation (in memory cache)" (2012, 4, 28, 1, 20, 20) fem-speedup-cpp 311.399 "Assembly/solve speedup running on 4 processors" (2012, 4, 28, 1, 20, 20) fem-speedup-cpp-assembly 5.43823 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 28, 1, 20, 20) fem-speedup-cpp-solve 2.03134 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 28, 1, 20, 44) mesh-refinement-cpp 22.5445 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 28, 1, 21, 5) mesh-topology-cpp 21.164 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 28, 1, 21, 28) mesh-unitcube-cpp 22.9426 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 28, 1, 22, 16) mesh-iteration-cpp 45.5473 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 28, 1, 22, 38) function-evaluation-cpp 21.3854 "Evaluations of functions at arbitrary points." (2012, 4, 28, 1, 22, 38) function-evaluation-cpp 21.3044 "Evaluations of functions at arbitrary points." (2012, 4, 28, 1, 22, 45) function-extrapolation-python 6.73951 "BENCH: 1.89307403564" (2012, 4, 28, 1, 22, 45) function-extrapolation-python 1.89307 "BENCH: 1.89307403564" (2012, 4, 28, 1, 23, 9) la-vector-access-cpp 24.3891 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 28, 1, 23, 34) la-vector-assignment-cpp 24.9493 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 29, 1, 11, 9) common-progress-cpp 36.4359 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 29, 1, 11, 40) common-timing-cpp 31.5174 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 29, 1, 11, 50) fem-multicore-cpp 10.0968 "Coloring mesh." (2012, 4, 29, 1, 15, 4) fem-assembly-cpp 193.244 "Assembly for various forms and backends" (2012, 4, 29, 1, 15, 15) fem-convergence-cpp 11.8429 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 29, 1, 15, 17) fem-jit-python 0.000413609 "JIT compilation (in memory cache)" (2012, 4, 29, 1, 20, 30) fem-speedup-cpp 313.846 "Assembly/solve speedup running on 4 processors" (2012, 4, 29, 1, 20, 30) fem-speedup-cpp-assembly 5.43797 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 29, 1, 20, 30) fem-speedup-cpp-solve 1.98952 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 29, 1, 20, 55) mesh-refinement-cpp 22.6393 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 29, 1, 21, 16) mesh-topology-cpp 21.2768 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 29, 1, 21, 39) mesh-unitcube-cpp 23.0451 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 29, 1, 22, 24) mesh-iteration-cpp 42.5439 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 29, 1, 22, 46) function-evaluation-cpp 21.2636 "Evaluations of functions at arbitrary points." (2012, 4, 29, 1, 22, 46) function-evaluation-cpp 21.1828 "Evaluations of functions at arbitrary points." (2012, 4, 29, 1, 22, 52) function-extrapolation-python 6.72058 "BENCH: 1.91814398766" (2012, 4, 29, 1, 22, 52) function-extrapolation-python 1.91814 "BENCH: 1.91814398766" (2012, 4, 29, 1, 23, 15) la-vector-access-cpp 22.8914 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 29, 1, 23, 40) la-vector-assignment-cpp 24.9444 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 4, 30, 1, 11, 6) common-progress-cpp 37.6897 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 4, 30, 1, 11, 38) common-timing-cpp 31.2945 "Timing access and registration of timings (10000000 repetitions)" (2012, 4, 30, 1, 11, 48) fem-multicore-cpp 10.0715 "Coloring mesh." (2012, 4, 30, 1, 15, 0) fem-assembly-cpp 192.317 "Assembly for various forms and backends" (2012, 4, 30, 1, 15, 12) fem-convergence-cpp 11.8947 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 4, 30, 1, 15, 13) fem-jit-python 0.000404596 "JIT compilation (in memory cache)" (2012, 4, 30, 1, 20, 24) fem-speedup-cpp 311.524 "Assembly/solve speedup running on 4 processors" (2012, 4, 30, 1, 20, 24) fem-speedup-cpp-assembly 5.43241 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 4, 30, 1, 20, 24) fem-speedup-cpp-solve 2.01566 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 4, 30, 1, 20, 48) mesh-refinement-cpp 22.4807 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 4, 30, 1, 21, 10) mesh-topology-cpp 21.147 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 4, 30, 1, 21, 33) mesh-unitcube-cpp 23.0136 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 4, 30, 1, 22, 17) mesh-iteration-cpp 41.9589 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 4, 30, 1, 22, 39) function-evaluation-cpp 21.2606 "Evaluations of functions at arbitrary points." (2012, 4, 30, 1, 22, 39) function-evaluation-cpp 21.1795 "Evaluations of functions at arbitrary points." (2012, 4, 30, 1, 22, 45) function-extrapolation-python 6.77603 "BENCH: 1.95966100693" (2012, 4, 30, 1, 22, 45) function-extrapolation-python 1.95966 "BENCH: 1.95966100693" (2012, 4, 30, 1, 23, 8) la-vector-access-cpp 22.8911 "Accessing vector of size 10000000 (100 repetitions)" (2012, 4, 30, 1, 23, 33) la-vector-assignment-cpp 24.9481 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 1, 1, 11, 14) common-progress-cpp 29.6728 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 1, 1, 11, 45) common-timing-cpp 30.7784 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 1, 1, 11, 55) fem-multicore-cpp 10.0783 "Coloring mesh." (2012, 5, 1, 1, 15, 8) fem-assembly-cpp 192.609 "Assembly for various forms and backends" (2012, 5, 1, 1, 15, 20) fem-convergence-cpp 11.9016 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 1, 1, 15, 21) fem-jit-python 0.000410104 "JIT compilation (in memory cache)" (2012, 5, 1, 1, 20, 31) fem-speedup-cpp 309.921 "Assembly/solve speedup running on 4 processors" (2012, 5, 1, 1, 20, 31) fem-speedup-cpp-assembly 5.45925 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 1, 1, 20, 31) fem-speedup-cpp-solve 2.01244 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 1, 1, 20, 55) mesh-refinement-cpp 22.5479 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 1, 1, 21, 16) mesh-topology-cpp 21.1494 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 1, 1, 21, 39) mesh-unitcube-cpp 23.0437 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 1, 1, 22, 24) mesh-iteration-cpp 41.9561 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 1, 1, 22, 45) function-evaluation-cpp 20.9268 "Evaluations of functions at arbitrary points." (2012, 5, 1, 1, 22, 45) function-evaluation-cpp 20.8392 "Evaluations of functions at arbitrary points." (2012, 5, 1, 1, 22, 52) function-extrapolation-python 6.90457 "BENCH: 1.95063400269" (2012, 5, 1, 1, 22, 52) function-extrapolation-python 1.95063 "BENCH: 1.95063400269" (2012, 5, 1, 1, 23, 14) la-vector-access-cpp 22.8938 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 1, 1, 23, 39) la-vector-assignment-cpp 24.9443 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 2, 1, 11, 2) common-progress-cpp 29.5664 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 2, 1, 11, 32) common-timing-cpp 30.7228 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 2, 1, 11, 42) fem-multicore-cpp 10.0352 "Coloring mesh." (2012, 5, 2, 1, 14, 55) fem-assembly-cpp 192.826 "Assembly for various forms and backends" (2012, 5, 2, 1, 15, 7) fem-convergence-cpp 11.916 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 2, 1, 15, 8) fem-jit-python 0.000402808 "JIT compilation (in memory cache)" (2012, 5, 2, 1, 20, 20) fem-speedup-cpp 311.846 "Assembly/solve speedup running on 4 processors" (2012, 5, 2, 1, 20, 20) fem-speedup-cpp-assembly 5.34273 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 2, 1, 20, 20) fem-speedup-cpp-solve 1.99734 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 2, 1, 20, 44) mesh-refinement-cpp 22.5059 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 2, 1, 21, 5) mesh-topology-cpp 21.2231 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 2, 1, 21, 29) mesh-unitcube-cpp 23.0814 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 2, 1, 22, 13) mesh-iteration-cpp 41.9839 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 2, 1, 22, 35) function-evaluation-cpp 22.006 "Evaluations of functions at arbitrary points." (2012, 5, 2, 1, 22, 35) function-evaluation-cpp 21.9155 "Evaluations of functions at arbitrary points." (2012, 5, 2, 1, 22, 42) function-extrapolation-python 6.72567 "BENCH: 1.94297981262" (2012, 5, 2, 1, 22, 42) function-extrapolation-python 1.94298 "BENCH: 1.94297981262" (2012, 5, 2, 1, 23, 5) la-vector-access-cpp 22.8918 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 2, 1, 23, 30) la-vector-assignment-cpp 24.947 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 3, 1, 11, 0) common-progress-cpp 29.6279 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 3, 1, 11, 32) common-timing-cpp 31.5957 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 3, 1, 11, 42) fem-multicore-cpp 10.0787 "Coloring mesh." (2012, 5, 3, 1, 14, 55) fem-assembly-cpp 193.423 "Assembly for various forms and backends" (2012, 5, 3, 1, 15, 7) fem-convergence-cpp 11.8753 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 3, 1, 15, 8) fem-jit-python 0.000418901 "JIT compilation (in memory cache)" (2012, 5, 3, 1, 20, 20) fem-speedup-cpp 311.621 "Assembly/solve speedup running on 4 processors" (2012, 5, 3, 1, 20, 20) fem-speedup-cpp-assembly 5.45161 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 3, 1, 20, 20) fem-speedup-cpp-solve 2.00328 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 3, 1, 20, 44) mesh-refinement-cpp 22.5706 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 3, 1, 21, 5) mesh-topology-cpp 21.1757 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 3, 1, 21, 28) mesh-unitcube-cpp 22.97 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 3, 1, 22, 17) mesh-iteration-cpp 46.5573 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 3, 1, 22, 39) function-evaluation-cpp 21.341 "Evaluations of functions at arbitrary points." (2012, 5, 3, 1, 22, 39) function-evaluation-cpp 21.2462 "Evaluations of functions at arbitrary points." (2012, 5, 3, 1, 22, 45) function-extrapolation-python 6.77149 "BENCH: 1.94217681885" (2012, 5, 3, 1, 22, 45) function-extrapolation-python 1.94218 "BENCH: 1.94217681885" (2012, 5, 3, 1, 23, 8) la-vector-access-cpp 22.8919 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 3, 1, 23, 33) la-vector-assignment-cpp 24.9502 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 4, 1, 11, 11) common-progress-cpp 37.69 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 4, 1, 11, 42) common-timing-cpp 31.0577 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 4, 1, 11, 52) fem-multicore-cpp 10.1671 "Coloring mesh." (2012, 5, 4, 1, 15, 4) fem-assembly-cpp 192.233 "Assembly for various forms and backends" (2012, 5, 4, 1, 15, 16) fem-convergence-cpp 11.8399 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 4, 1, 15, 17) fem-jit-python 0.000430417 "JIT compilation (in memory cache)" (2012, 5, 4, 1, 20, 28) fem-speedup-cpp 310.953 "Assembly/solve speedup running on 4 processors" (2012, 5, 4, 1, 20, 28) fem-speedup-cpp-assembly 5.45039 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 4, 1, 20, 28) fem-speedup-cpp-solve 2.03963 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 4, 1, 20, 52) mesh-refinement-cpp 22.5244 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 4, 1, 21, 14) mesh-topology-cpp 21.281 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 4, 1, 21, 37) mesh-unitcube-cpp 22.9758 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 4, 1, 22, 22) mesh-iteration-cpp 42.2445 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 4, 1, 22, 43) function-evaluation-cpp 21.338 "Evaluations of functions at arbitrary points." (2012, 5, 4, 1, 22, 43) function-evaluation-cpp 21.2268 "Evaluations of functions at arbitrary points." (2012, 5, 4, 1, 22, 50) function-extrapolation-python 6.82877 "BENCH: 1.91648793221" (2012, 5, 4, 1, 22, 50) function-extrapolation-python 1.91649 "BENCH: 1.91648793221" (2012, 5, 4, 1, 23, 13) la-vector-access-cpp 22.9364 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 4, 1, 23, 38) la-vector-assignment-cpp 24.9838 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 5, 1, 11, 11) common-progress-cpp 29.1965 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 5, 1, 11, 42) common-timing-cpp 30.9071 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 5, 1, 11, 52) fem-multicore-cpp 10.0601 "Coloring mesh." (2012, 5, 5, 1, 15, 5) fem-assembly-cpp 192.683 "Assembly for various forms and backends" (2012, 5, 5, 1, 15, 17) fem-convergence-cpp 11.8871 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 5, 1, 15, 18) fem-jit-python 0.000421309 "JIT compilation (in memory cache)" (2012, 5, 5, 1, 20, 29) fem-speedup-cpp 310.873 "Assembly/solve speedup running on 4 processors" (2012, 5, 5, 1, 20, 29) fem-speedup-cpp-assembly 5.45015 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 5, 1, 20, 29) fem-speedup-cpp-solve 2.01026 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 5, 1, 20, 53) mesh-refinement-cpp 22.5522 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 5, 1, 21, 14) mesh-topology-cpp 21.1878 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 5, 1, 21, 37) mesh-unitcube-cpp 23.0094 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 5, 1, 22, 25) mesh-iteration-cpp 45.3021 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 5, 1, 22, 47) function-evaluation-cpp 21.413 "Evaluations of functions at arbitrary points." (2012, 5, 5, 1, 22, 47) function-evaluation-cpp 21.3094 "Evaluations of functions at arbitrary points." (2012, 5, 5, 1, 22, 54) function-extrapolation-python 6.90105 "BENCH: 1.92252421379" (2012, 5, 5, 1, 22, 54) function-extrapolation-python 1.92252 "BENCH: 1.92252421379" (2012, 5, 5, 1, 23, 18) la-vector-access-cpp 23.9142 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 5, 1, 23, 46) la-vector-assignment-cpp 28.3928 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 6, 1, 11, 2) common-progress-cpp 29.6295 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 6, 1, 11, 33) common-timing-cpp 31.2813 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 6, 1, 11, 44) fem-multicore-cpp 10.0412 "Coloring mesh." (2012, 5, 6, 1, 14, 56) fem-assembly-cpp 192.481 "Assembly for various forms and backends" (2012, 5, 6, 1, 15, 8) fem-convergence-cpp 11.9005 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 6, 1, 15, 9) fem-jit-python 0.000402188 "JIT compilation (in memory cache)" (2012, 5, 6, 1, 20, 19) fem-speedup-cpp 309.897 "Assembly/solve speedup running on 4 processors" (2012, 5, 6, 1, 20, 19) fem-speedup-cpp-assembly 5.44467 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 6, 1, 20, 19) fem-speedup-cpp-solve 2.01761 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 6, 1, 20, 43) mesh-refinement-cpp 22.5436 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 6, 1, 21, 4) mesh-topology-cpp 21.1975 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 6, 1, 21, 27) mesh-unitcube-cpp 22.9573 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 6, 1, 22, 12) mesh-iteration-cpp 41.9624 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 6, 1, 22, 33) function-evaluation-cpp 21.2298 "Evaluations of functions at arbitrary points." (2012, 5, 6, 1, 22, 33) function-evaluation-cpp 21.1328 "Evaluations of functions at arbitrary points." (2012, 5, 6, 1, 22, 40) function-extrapolation-python 6.71783 "BENCH: 1.91616392136" (2012, 5, 6, 1, 22, 40) function-extrapolation-python 1.91616 "BENCH: 1.91616392136" (2012, 5, 6, 1, 23, 3) la-vector-access-cpp 23.4161 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 6, 1, 23, 28) la-vector-assignment-cpp 24.9585 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 7, 1, 11, 0) common-progress-cpp 29.6013 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 7, 1, 11, 30) common-timing-cpp 30.0344 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 7, 1, 11, 40) fem-multicore-cpp 9.99313 "Coloring mesh." (2012, 5, 7, 1, 14, 53) fem-assembly-cpp 192.48 "Assembly for various forms and backends" (2012, 5, 7, 1, 15, 5) fem-convergence-cpp 11.8372 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 7, 1, 15, 6) fem-jit-python 0.000398088 "JIT compilation (in memory cache)" (2012, 5, 7, 1, 20, 17) fem-speedup-cpp 311.283 "Assembly/solve speedup running on 4 processors" (2012, 5, 7, 1, 20, 17) fem-speedup-cpp-assembly 5.43498 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 7, 1, 20, 17) fem-speedup-cpp-solve 2.01416 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 7, 1, 20, 41) mesh-refinement-cpp 22.5004 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 7, 1, 21, 2) mesh-topology-cpp 21.2803 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 7, 1, 21, 26) mesh-unitcube-cpp 22.9786 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 7, 1, 22, 10) mesh-iteration-cpp 41.9612 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 7, 1, 22, 31) function-evaluation-cpp 21.3234 "Evaluations of functions at arbitrary points." (2012, 5, 7, 1, 22, 31) function-evaluation-cpp 21.2195 "Evaluations of functions at arbitrary points." (2012, 5, 7, 1, 22, 38) function-extrapolation-python 6.7076 "BENCH: 1.92141985893" (2012, 5, 7, 1, 22, 38) function-extrapolation-python 1.92142 "BENCH: 1.92141985893" (2012, 5, 7, 1, 23, 2) la-vector-access-cpp 23.8888 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 7, 1, 23, 31) la-vector-assignment-cpp 28.3937 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 8, 1, 11, 26) common-progress-cpp 36.4364 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 8, 1, 11, 57) common-timing-cpp 30.5164 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 8, 1, 12, 7) fem-multicore-cpp 9.97117 "Coloring mesh." (2012, 5, 8, 1, 15, 20) fem-assembly-cpp 193.292 "Assembly for various forms and backends" (2012, 5, 8, 1, 15, 32) fem-convergence-cpp 11.8957 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 8, 1, 15, 33) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2012, 5, 8, 1, 20, 42) fem-speedup-cpp 309.092 "Assembly/solve speedup running on 4 processors" (2012, 5, 8, 1, 20, 42) fem-speedup-cpp-assembly 5.43502 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 8, 1, 20, 42) fem-speedup-cpp-solve 2.03607 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 8, 1, 21, 6) mesh-refinement-cpp 22.6704 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 8, 1, 21, 28) mesh-topology-cpp 21.2208 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 8, 1, 21, 51) mesh-unitcube-cpp 22.9858 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 8, 1, 22, 36) mesh-iteration-cpp 42.8899 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 8, 1, 22, 57) function-evaluation-cpp 21.2983 "Evaluations of functions at arbitrary points." (2012, 5, 8, 1, 22, 57) function-evaluation-cpp 21.2043 "Evaluations of functions at arbitrary points." (2012, 5, 8, 1, 23, 4) function-extrapolation-python 6.8849 "BENCH: 1.92250800133" (2012, 5, 8, 1, 23, 4) function-extrapolation-python 1.92251 "BENCH: 1.92250800133" (2012, 5, 8, 1, 23, 27) la-vector-access-cpp 22.8915 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 8, 1, 23, 52) la-vector-assignment-cpp 25.0577 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 9, 1, 11, 1) common-progress-cpp 29.6455 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 9, 1, 11, 30) common-timing-cpp 29.4995 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 9, 1, 11, 40) fem-multicore-cpp 10.0212 "Coloring mesh." (2012, 5, 9, 1, 14, 54) fem-assembly-cpp 193.563 "Assembly for various forms and backends" (2012, 5, 9, 1, 15, 6) fem-convergence-cpp 11.8537 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 9, 1, 15, 7) fem-jit-python 0.000412583 "JIT compilation (in memory cache)" (2012, 5, 9, 1, 20, 18) fem-speedup-cpp 311.161 "Assembly/solve speedup running on 4 processors" (2012, 5, 9, 1, 20, 18) fem-speedup-cpp-assembly 5.46736 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 9, 1, 20, 18) fem-speedup-cpp-solve 1.99382 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 9, 1, 20, 42) mesh-refinement-cpp 22.5486 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 9, 1, 21, 4) mesh-topology-cpp 21.1867 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 9, 1, 21, 27) mesh-unitcube-cpp 22.9638 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 9, 1, 22, 12) mesh-iteration-cpp 42.8809 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 9, 1, 22, 33) function-evaluation-cpp 20.8885 "Evaluations of functions at arbitrary points." (2012, 5, 9, 1, 22, 33) function-evaluation-cpp 20.7947 "Evaluations of functions at arbitrary points." (2012, 5, 9, 1, 22, 40) function-extrapolation-python 6.70674 "BENCH: 1.90486907959" (2012, 5, 9, 1, 22, 40) function-extrapolation-python 1.90487 "BENCH: 1.90486907959" (2012, 5, 9, 1, 23, 3) la-vector-access-cpp 22.8905 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 9, 1, 23, 28) la-vector-assignment-cpp 24.8887 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 10, 1, 11, 28) common-progress-cpp 29.6713 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 10, 1, 11, 58) common-timing-cpp 30.5341 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 10, 1, 12, 8) fem-multicore-cpp 10.0569 "Coloring mesh." (2012, 5, 10, 1, 15, 21) fem-assembly-cpp 192.536 "Assembly for various forms and backends" (2012, 5, 10, 1, 15, 33) fem-convergence-cpp 11.8702 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 10, 1, 15, 34) fem-jit-python 0.000415206 "JIT compilation (in memory cache)" (2012, 5, 10, 1, 20, 44) fem-speedup-cpp 310.053 "Assembly/solve speedup running on 4 processors" (2012, 5, 10, 1, 20, 44) fem-speedup-cpp-assembly 5.39773 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 10, 1, 20, 44) fem-speedup-cpp-solve 2.0472 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 10, 1, 21, 8) mesh-refinement-cpp 22.5867 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 10, 1, 21, 29) mesh-topology-cpp 21.0902 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 10, 1, 21, 53) mesh-unitcube-cpp 23.345 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 10, 1, 22, 37) mesh-iteration-cpp 41.9572 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 10, 1, 22, 59) function-evaluation-cpp 21.3066 "Evaluations of functions at arbitrary points." (2012, 5, 10, 1, 22, 59) function-evaluation-cpp 21.214 "Evaluations of functions at arbitrary points." (2012, 5, 10, 1, 23, 5) function-extrapolation-python 6.62941 "BENCH: 1.90426087379" (2012, 5, 10, 1, 23, 5) function-extrapolation-python 1.90426 "BENCH: 1.90426087379" (2012, 5, 10, 1, 23, 28) la-vector-access-cpp 22.889 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 10, 1, 23, 56) la-vector-assignment-cpp 27.8939 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 11, 1, 11, 14) common-progress-cpp 29.5793 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 11, 1, 11, 44) common-timing-cpp 29.4822 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 11, 1, 11, 54) fem-multicore-cpp 10.091 "Coloring mesh." (2012, 5, 11, 1, 15, 6) fem-assembly-cpp 192.076 "Assembly for various forms and backends" (2012, 5, 11, 1, 15, 18) fem-convergence-cpp 11.8655 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 11, 1, 15, 19) fem-jit-python 0.000414896 "JIT compilation (in memory cache)" (2012, 5, 11, 1, 20, 29) fem-speedup-cpp 310.324 "Assembly/solve speedup running on 4 processors" (2012, 5, 11, 1, 20, 29) fem-speedup-cpp-assembly 5.39041 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 11, 1, 20, 29) fem-speedup-cpp-solve 1.99685 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 11, 1, 20, 53) mesh-refinement-cpp 22.4623 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 11, 1, 21, 15) mesh-topology-cpp 21.4203 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 11, 1, 21, 38) mesh-unitcube-cpp 22.959 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 11, 1, 22, 27) mesh-iteration-cpp 46.0242 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 11, 1, 22, 48) function-evaluation-cpp 21.1649 "Evaluations of functions at arbitrary points." (2012, 5, 11, 1, 22, 48) function-evaluation-cpp 21.0715 "Evaluations of functions at arbitrary points." (2012, 5, 11, 1, 22, 55) function-extrapolation-python 6.70405 "BENCH: 1.9132399559" (2012, 5, 11, 1, 22, 55) function-extrapolation-python 1.91324 "BENCH: 1.9132399559" (2012, 5, 11, 1, 23, 18) la-vector-access-cpp 22.8891 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 11, 1, 23, 45) la-vector-assignment-cpp 27.8901 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 12, 1, 11, 38) common-progress-cpp 29.1726 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 12, 1, 12, 8) common-timing-cpp 29.1381 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 12, 1, 12, 18) fem-multicore-cpp 10.2136 "Coloring mesh." (2012, 5, 12, 1, 15, 31) fem-assembly-cpp 192.958 "Assembly for various forms and backends" (2012, 5, 12, 1, 15, 43) fem-convergence-cpp 11.9306 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 12, 1, 15, 44) fem-jit-python 0.000427794 "JIT compilation (in memory cache)" (2012, 5, 12, 1, 20, 56) fem-speedup-cpp 312.037 "Assembly/solve speedup running on 4 processors" (2012, 5, 12, 1, 20, 56) fem-speedup-cpp-assembly 5.52015 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 12, 1, 20, 56) fem-speedup-cpp-solve 1.99804 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 12, 1, 21, 20) mesh-refinement-cpp 22.8419 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 12, 1, 21, 42) mesh-topology-cpp 21.3096 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 12, 1, 22, 5) mesh-unitcube-cpp 22.934 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 12, 1, 22, 48) mesh-iteration-cpp 40.3834 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 12, 1, 23, 9) function-evaluation-cpp 21.1984 "Evaluations of functions at arbitrary points." (2012, 5, 12, 1, 23, 9) function-evaluation-cpp 21.1019 "Evaluations of functions at arbitrary points." (2012, 5, 12, 1, 23, 16) function-extrapolation-python 6.95653 "BENCH: 1.93875288963" (2012, 5, 12, 1, 23, 16) function-extrapolation-python 1.93875 "BENCH: 1.93875288963" (2012, 5, 12, 1, 23, 39) la-vector-access-cpp 22.6201 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 12, 1, 24, 4) la-vector-assignment-cpp 24.9544 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 13, 1, 11, 5) common-progress-cpp 29.6152 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 13, 1, 11, 34) common-timing-cpp 29.6787 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 13, 1, 11, 44) fem-multicore-cpp 10.0758 "Coloring mesh." (2012, 5, 13, 1, 14, 59) fem-assembly-cpp 194.653 "Assembly for various forms and backends" (2012, 5, 13, 1, 15, 11) fem-convergence-cpp 11.8781 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 13, 1, 15, 12) fem-jit-python 0.000433397 "JIT compilation (in memory cache)" (2012, 5, 13, 1, 20, 24) fem-speedup-cpp 311.862 "Assembly/solve speedup running on 4 processors" (2012, 5, 13, 1, 20, 24) fem-speedup-cpp-assembly 5.53048 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 13, 1, 20, 24) fem-speedup-cpp-solve 1.97858 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 13, 1, 20, 48) mesh-refinement-cpp 22.8472 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 13, 1, 21, 10) mesh-topology-cpp 21.4051 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 13, 1, 21, 33) mesh-unitcube-cpp 22.8578 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 13, 1, 22, 16) mesh-iteration-cpp 40.3815 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 13, 1, 22, 37) function-evaluation-cpp 21.3066 "Evaluations of functions at arbitrary points." (2012, 5, 13, 1, 22, 37) function-evaluation-cpp 21.2131 "Evaluations of functions at arbitrary points." (2012, 5, 13, 1, 22, 44) function-extrapolation-python 6.69725 "BENCH: 1.91420412064" (2012, 5, 13, 1, 22, 44) function-extrapolation-python 1.9142 "BENCH: 1.91420412064" (2012, 5, 13, 1, 23, 6) la-vector-access-cpp 22.4094 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 13, 1, 23, 31) la-vector-assignment-cpp 24.947 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 14, 1, 11, 0) common-progress-cpp 29.7758 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 14, 1, 11, 29) common-timing-cpp 29.1657 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 14, 1, 11, 39) fem-multicore-cpp 10.0339 "Coloring mesh." (2012, 5, 14, 1, 14, 53) fem-assembly-cpp 193.756 "Assembly for various forms and backends" (2012, 5, 14, 1, 15, 5) fem-convergence-cpp 11.8774 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 14, 1, 15, 6) fem-jit-python 0.000419116 "JIT compilation (in memory cache)" (2012, 5, 14, 1, 20, 20) fem-speedup-cpp 313.853 "Assembly/solve speedup running on 4 processors" (2012, 5, 14, 1, 20, 20) fem-speedup-cpp-assembly 5.50463 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 14, 1, 20, 20) fem-speedup-cpp-solve 1.99162 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 14, 1, 20, 44) mesh-refinement-cpp 22.8547 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 14, 1, 21, 6) mesh-topology-cpp 21.2888 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 14, 1, 21, 29) mesh-unitcube-cpp 23.0275 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 14, 1, 22, 12) mesh-iteration-cpp 40.3848 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 14, 1, 22, 33) function-evaluation-cpp 21.3024 "Evaluations of functions at arbitrary points." (2012, 5, 14, 1, 22, 33) function-evaluation-cpp 21.2207 "Evaluations of functions at arbitrary points." (2012, 5, 14, 1, 22, 40) function-extrapolation-python 6.68933 "BENCH: 1.89248800278" (2012, 5, 14, 1, 22, 40) function-extrapolation-python 1.89249 "BENCH: 1.89248800278" (2012, 5, 14, 1, 23, 5) la-vector-access-cpp 24.754 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 14, 1, 23, 33) la-vector-assignment-cpp 27.9046 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 15, 1, 11, 24) common-progress-cpp 29.595 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 15, 1, 11, 54) common-timing-cpp 30.1962 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 15, 1, 12, 4) fem-multicore-cpp 10.0939 "Coloring mesh." (2012, 5, 15, 1, 15, 17) fem-assembly-cpp 192.951 "Assembly for various forms and backends" (2012, 5, 15, 1, 15, 29) fem-convergence-cpp 11.9242 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 15, 1, 15, 30) fem-jit-python 0.000412488 "JIT compilation (in memory cache)" (2012, 5, 15, 1, 20, 42) fem-speedup-cpp 311.361 "Assembly/solve speedup running on 4 processors" (2012, 5, 15, 1, 20, 42) fem-speedup-cpp-assembly 5.52625 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 15, 1, 20, 42) fem-speedup-cpp-solve 2.03731 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 15, 1, 21, 6) mesh-refinement-cpp 22.8064 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 15, 1, 21, 28) mesh-topology-cpp 21.3559 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 15, 1, 21, 51) mesh-unitcube-cpp 22.8974 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 15, 1, 22, 34) mesh-iteration-cpp 40.4361 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 15, 1, 22, 55) function-evaluation-cpp 21.0107 "Evaluations of functions at arbitrary points." (2012, 5, 15, 1, 22, 55) function-evaluation-cpp 20.9296 "Evaluations of functions at arbitrary points." (2012, 5, 15, 1, 23, 2) function-extrapolation-python 6.73524 "BENCH: 1.90603494644" (2012, 5, 15, 1, 23, 2) function-extrapolation-python 1.90603 "BENCH: 1.90603494644" (2012, 5, 15, 1, 23, 24) la-vector-access-cpp 22.4213 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 15, 1, 23, 49) la-vector-assignment-cpp 24.9484 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 16, 1, 11, 13) common-progress-cpp 29.1853 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 16, 1, 11, 42) common-timing-cpp 29.18 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 16, 1, 11, 52) fem-multicore-cpp 10.1642 "Coloring mesh." (2012, 5, 16, 1, 15, 6) fem-assembly-cpp 193.686 "Assembly for various forms and backends" (2012, 5, 16, 1, 15, 18) fem-convergence-cpp 11.903 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 16, 1, 15, 19) fem-jit-python 0.000425601 "JIT compilation (in memory cache)" (2012, 5, 16, 1, 20, 33) fem-speedup-cpp 313.797 "Assembly/solve speedup running on 4 processors" (2012, 5, 16, 1, 20, 33) fem-speedup-cpp-assembly 5.51376 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 16, 1, 20, 33) fem-speedup-cpp-solve 1.97963 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 16, 1, 20, 57) mesh-refinement-cpp 22.8326 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 16, 1, 21, 19) mesh-topology-cpp 21.3055 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 16, 1, 21, 42) mesh-unitcube-cpp 22.8758 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 16, 1, 22, 27) mesh-iteration-cpp 42.8695 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 16, 1, 22, 48) function-evaluation-cpp 20.8951 "Evaluations of functions at arbitrary points." (2012, 5, 16, 1, 22, 48) function-evaluation-cpp 20.814 "Evaluations of functions at arbitrary points." (2012, 5, 16, 1, 22, 55) function-extrapolation-python 6.72322 "BENCH: 1.92462015152" (2012, 5, 16, 1, 22, 55) function-extrapolation-python 1.92462 "BENCH: 1.92462015152" (2012, 5, 16, 1, 23, 17) la-vector-access-cpp 22.4294 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 16, 1, 23, 42) la-vector-assignment-cpp 24.945 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 17, 1, 11, 6) common-progress-cpp 29.5754 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 17, 1, 11, 35) common-timing-cpp 29.1286 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 17, 1, 11, 45) fem-multicore-cpp 10.0872 "Coloring mesh." (2012, 5, 17, 1, 14, 59) fem-assembly-cpp 193.744 "Assembly for various forms and backends" (2012, 5, 17, 1, 15, 11) fem-convergence-cpp 11.8708 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 17, 1, 15, 12) fem-jit-python 0.000419092 "JIT compilation (in memory cache)" (2012, 5, 17, 1, 20, 22) fem-speedup-cpp 309.934 "Assembly/solve speedup running on 4 processors" (2012, 5, 17, 1, 20, 22) fem-speedup-cpp-assembly 5.42661 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 17, 1, 20, 22) fem-speedup-cpp-solve 2.0576 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 17, 1, 20, 46) mesh-refinement-cpp 22.8354 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 17, 1, 21, 7) mesh-topology-cpp 21.3649 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 17, 1, 21, 30) mesh-unitcube-cpp 22.9045 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 17, 1, 22, 14) mesh-iteration-cpp 41.6378 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 17, 1, 22, 36) function-evaluation-cpp 21.3132 "Evaluations of functions at arbitrary points." (2012, 5, 17, 1, 22, 36) function-evaluation-cpp 21.204 "Evaluations of functions at arbitrary points." (2012, 5, 17, 1, 22, 42) function-extrapolation-python 6.10387 "BENCH: 1.83741283417" (2012, 5, 17, 1, 22, 42) function-extrapolation-python 1.83741 "BENCH: 1.83741283417" (2012, 5, 17, 1, 23, 4) la-vector-access-cpp 22.4361 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 17, 1, 23, 29) la-vector-assignment-cpp 24.9543 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 18, 1, 11, 2) common-progress-cpp 29.185 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 18, 1, 11, 32) common-timing-cpp 29.8661 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 18, 1, 11, 42) fem-multicore-cpp 10.0076 "Coloring mesh." (2012, 5, 18, 1, 14, 56) fem-assembly-cpp 193.839 "Assembly for various forms and backends" (2012, 5, 18, 1, 15, 7) fem-convergence-cpp 11.4298 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 18, 1, 15, 9) fem-jit-python 0.000420213 "JIT compilation (in memory cache)" (2012, 5, 18, 1, 20, 19) fem-speedup-cpp 310.263 "Assembly/solve speedup running on 4 processors" (2012, 5, 18, 1, 20, 19) fem-speedup-cpp-assembly 5.51431 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 18, 1, 20, 19) fem-speedup-cpp-solve 2.02309 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 18, 1, 20, 43) mesh-refinement-cpp 22.8483 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 18, 1, 21, 5) mesh-topology-cpp 21.3057 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 18, 1, 21, 28) mesh-unitcube-cpp 22.9116 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 18, 1, 22, 10) mesh-iteration-cpp 40.376 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 18, 1, 22, 32) function-evaluation-cpp 21.338 "Evaluations of functions at arbitrary points." (2012, 5, 18, 1, 22, 32) function-evaluation-cpp 21.2566 "Evaluations of functions at arbitrary points." (2012, 5, 18, 1, 22, 39) function-extrapolation-python 6.72392 "BENCH: 1.90056300163" (2012, 5, 18, 1, 22, 39) function-extrapolation-python 1.90056 "BENCH: 1.90056300163" (2012, 5, 18, 1, 23, 1) la-vector-access-cpp 22.4229 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 18, 1, 23, 30) la-vector-assignment-cpp 28.3925 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 19, 1, 11, 23) common-progress-cpp 29.5897 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 19, 1, 11, 52) common-timing-cpp 29.5265 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 19, 1, 12, 2) fem-multicore-cpp 10.1856 "Coloring mesh." (2012, 5, 19, 1, 15, 15) fem-assembly-cpp 192.455 "Assembly for various forms and backends" (2012, 5, 19, 1, 15, 27) fem-convergence-cpp 11.9157 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 19, 1, 15, 28) fem-jit-python 0.000427103 "JIT compilation (in memory cache)" (2012, 5, 19, 1, 20, 40) fem-speedup-cpp 312.269 "Assembly/solve speedup running on 4 processors" (2012, 5, 19, 1, 20, 40) fem-speedup-cpp-assembly 5.27967 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 19, 1, 20, 40) fem-speedup-cpp-solve 2.02355 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 19, 1, 21, 4) mesh-refinement-cpp 22.8047 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 19, 1, 21, 26) mesh-topology-cpp 21.5603 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 19, 1, 21, 48) mesh-unitcube-cpp 21.9737 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 19, 1, 22, 33) mesh-iteration-cpp 42.2436 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 19, 1, 22, 54) function-evaluation-cpp 21.3128 "Evaluations of functions at arbitrary points." (2012, 5, 19, 1, 22, 54) function-evaluation-cpp 21.2252 "Evaluations of functions at arbitrary points." (2012, 5, 19, 1, 23, 1) function-extrapolation-python 6.93798 "BENCH: 1.97170209885" (2012, 5, 19, 1, 23, 1) function-extrapolation-python 1.9717 "BENCH: 1.97170209885" (2012, 5, 19, 1, 23, 24) la-vector-access-cpp 22.8908 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 19, 1, 23, 49) la-vector-assignment-cpp 24.9476 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 20, 1, 11, 4) common-progress-cpp 29.0307 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 20, 1, 11, 35) common-timing-cpp 30.4833 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 20, 1, 11, 45) fem-multicore-cpp 10.1456 "Coloring mesh." (2012, 5, 20, 1, 14, 56) fem-assembly-cpp 191.331 "Assembly for various forms and backends" (2012, 5, 20, 1, 15, 8) fem-convergence-cpp 11.8639 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 20, 1, 15, 9) fem-jit-python 0.000417089 "JIT compilation (in memory cache)" (2012, 5, 20, 1, 20, 20) fem-speedup-cpp 310.484 "Assembly/solve speedup running on 4 processors" (2012, 5, 20, 1, 20, 20) fem-speedup-cpp-assembly 5.29232 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 20, 1, 20, 20) fem-speedup-cpp-solve 2.04355 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 20, 1, 20, 44) mesh-refinement-cpp 22.8065 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 20, 1, 21, 6) mesh-topology-cpp 21.6726 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 20, 1, 21, 28) mesh-unitcube-cpp 22.0115 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 20, 1, 22, 11) mesh-iteration-cpp 40.402 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 20, 1, 22, 32) function-evaluation-cpp 21.3065 "Evaluations of functions at arbitrary points." (2012, 5, 20, 1, 22, 32) function-evaluation-cpp 21.2248 "Evaluations of functions at arbitrary points." (2012, 5, 20, 1, 22, 39) function-extrapolation-python 6.85689 "BENCH: 1.93156290054" (2012, 5, 20, 1, 22, 39) function-extrapolation-python 1.93156 "BENCH: 1.93156290054" (2012, 5, 20, 1, 23, 2) la-vector-access-cpp 22.8902 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 20, 1, 23, 31) la-vector-assignment-cpp 28.3952 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 21, 1, 11, 19) common-progress-cpp 37.6875 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 21, 1, 11, 49) common-timing-cpp 29.6896 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 21, 1, 11, 59) fem-multicore-cpp 10.1579 "Coloring mesh." (2012, 5, 21, 1, 15, 10) fem-assembly-cpp 191.493 "Assembly for various forms and backends" (2012, 5, 21, 1, 15, 22) fem-convergence-cpp 11.8256 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 21, 1, 15, 23) fem-jit-python 0.000413799 "JIT compilation (in memory cache)" (2012, 5, 21, 1, 20, 37) fem-speedup-cpp 313.637 "Assembly/solve speedup running on 4 processors" (2012, 5, 21, 1, 20, 37) fem-speedup-cpp-assembly 5.26765 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 21, 1, 20, 37) fem-speedup-cpp-solve 2.00019 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 21, 1, 21, 1) mesh-refinement-cpp 22.7476 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 21, 1, 21, 23) mesh-topology-cpp 21.5406 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 21, 1, 21, 45) mesh-unitcube-cpp 22.0132 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 21, 1, 22, 28) mesh-iteration-cpp 40.3793 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 21, 1, 22, 49) function-evaluation-cpp 21.3211 "Evaluations of functions at arbitrary points." (2012, 5, 21, 1, 22, 49) function-evaluation-cpp 21.2394 "Evaluations of functions at arbitrary points." (2012, 5, 21, 1, 22, 56) function-extrapolation-python 6.86756 "BENCH: 1.92921495438" (2012, 5, 21, 1, 22, 56) function-extrapolation-python 1.92921 "BENCH: 1.92921495438" (2012, 5, 21, 1, 23, 19) la-vector-access-cpp 22.8928 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 21, 1, 23, 47) la-vector-assignment-cpp 28.4031 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 22, 1, 11, 8) common-progress-cpp 29.8733 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 22, 1, 11, 38) common-timing-cpp 29.5155 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 22, 1, 11, 48) fem-multicore-cpp 10.073 "Coloring mesh." (2012, 5, 22, 1, 14, 59) fem-assembly-cpp 191.628 "Assembly for various forms and backends" (2012, 5, 22, 1, 15, 11) fem-convergence-cpp 11.6046 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 22, 1, 15, 12) fem-jit-python 0.000409889 "JIT compilation (in memory cache)" (2012, 5, 22, 1, 20, 23) fem-speedup-cpp 311.306 "Assembly/solve speedup running on 4 processors" (2012, 5, 22, 1, 20, 23) fem-speedup-cpp-assembly 5.25755 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 22, 1, 20, 23) fem-speedup-cpp-solve 2.03365 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 22, 1, 20, 48) mesh-refinement-cpp 22.7463 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 22, 1, 21, 9) mesh-topology-cpp 21.5485 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 22, 1, 21, 31) mesh-unitcube-cpp 21.921 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 22, 1, 22, 15) mesh-iteration-cpp 41.64 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 22, 1, 22, 38) function-evaluation-cpp 22.0231 "Evaluations of functions at arbitrary points." (2012, 5, 22, 1, 22, 38) function-evaluation-cpp 21.9416 "Evaluations of functions at arbitrary points." (2012, 5, 22, 1, 22, 45) function-extrapolation-python 6.91431 "BENCH: 1.91852498055" (2012, 5, 22, 1, 22, 45) function-extrapolation-python 1.91852 "BENCH: 1.91852498055" (2012, 5, 22, 1, 23, 10) la-vector-access-cpp 25.397 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 22, 1, 23, 35) la-vector-assignment-cpp 24.948 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 23, 1, 11, 24) common-progress-cpp 29.6142 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 23, 1, 11, 53) common-timing-cpp 29.3618 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 23, 1, 12, 3) fem-multicore-cpp 10.1015 "Coloring mesh." (2012, 5, 23, 1, 15, 15) fem-assembly-cpp 191.992 "Assembly for various forms and backends" (2012, 5, 23, 1, 15, 27) fem-convergence-cpp 11.895 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 23, 1, 15, 28) fem-jit-python 0.000430393 "JIT compilation (in memory cache)" (2012, 5, 23, 1, 20, 44) fem-speedup-cpp 316.339 "Assembly/solve speedup running on 4 processors" (2012, 5, 23, 1, 20, 44) fem-speedup-cpp-assembly 5.27512 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 23, 1, 20, 44) fem-speedup-cpp-solve 1.8932 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 23, 1, 21, 9) mesh-refinement-cpp 22.7397 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 23, 1, 21, 30) mesh-topology-cpp 21.5146 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 23, 1, 21, 52) mesh-unitcube-cpp 22.0919 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 23, 1, 22, 35) mesh-iteration-cpp 40.3782 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 23, 1, 22, 56) function-evaluation-cpp 21.3599 "Evaluations of functions at arbitrary points." (2012, 5, 23, 1, 22, 56) function-evaluation-cpp 21.278 "Evaluations of functions at arbitrary points." (2012, 5, 23, 1, 23, 3) function-extrapolation-python 6.84355 "BENCH: 1.92967581749" (2012, 5, 23, 1, 23, 3) function-extrapolation-python 1.92968 "BENCH: 1.92967581749" (2012, 5, 23, 1, 23, 27) la-vector-access-cpp 23.89 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 23, 1, 23, 52) la-vector-assignment-cpp 24.9497 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 24, 1, 11, 33) common-progress-cpp 36.4364 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 24, 1, 12, 3) common-timing-cpp 29.917 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 24, 1, 12, 13) fem-multicore-cpp 10.0968 "Coloring mesh." (2012, 5, 24, 1, 15, 24) fem-assembly-cpp 191.1 "Assembly for various forms and backends" (2012, 5, 24, 1, 15, 36) fem-convergence-cpp 11.8609 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 24, 1, 15, 37) fem-jit-python 0.000411296 "JIT compilation (in memory cache)" (2012, 5, 24, 1, 20, 48) fem-speedup-cpp 310.716 "Assembly/solve speedup running on 4 processors" (2012, 5, 24, 1, 20, 48) fem-speedup-cpp-assembly 5.25731 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 24, 1, 20, 48) fem-speedup-cpp-solve 2.03826 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 24, 1, 21, 12) mesh-refinement-cpp 22.8164 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 24, 1, 21, 34) mesh-topology-cpp 21.4963 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 24, 1, 21, 56) mesh-unitcube-cpp 21.9298 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 24, 1, 22, 39) mesh-iteration-cpp 40.3869 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 24, 1, 23, 0) function-evaluation-cpp 21.1227 "Evaluations of functions at arbitrary points." (2012, 5, 24, 1, 23, 0) function-evaluation-cpp 21.0415 "Evaluations of functions at arbitrary points." (2012, 5, 24, 1, 23, 7) function-extrapolation-python 6.83394 "BENCH: 1.90448999405" (2012, 5, 24, 1, 23, 7) function-extrapolation-python 1.90449 "BENCH: 1.90448999405" (2012, 5, 24, 1, 23, 30) la-vector-access-cpp 23.1083 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 24, 1, 23, 55) la-vector-assignment-cpp 24.949 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 25, 1, 11, 20) common-progress-cpp 29.8839 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 25, 1, 11, 49) common-timing-cpp 28.9127 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 25, 1, 11, 59) fem-multicore-cpp 10.1458 "Coloring mesh." (2012, 5, 25, 1, 15, 11) fem-assembly-cpp 191.513 "Assembly for various forms and backends" (2012, 5, 25, 1, 15, 23) fem-convergence-cpp 11.9113 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 25, 1, 15, 24) fem-jit-python 0.000434804 "JIT compilation (in memory cache)" (2012, 5, 25, 1, 20, 37) fem-speedup-cpp 312.898 "Assembly/solve speedup running on 4 processors" (2012, 5, 25, 1, 20, 37) fem-speedup-cpp-assembly 5.34011 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 25, 1, 20, 37) fem-speedup-cpp-solve 2.00523 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 25, 1, 21, 1) mesh-refinement-cpp 22.6056 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 25, 1, 21, 23) mesh-topology-cpp 21.546 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 25, 1, 21, 45) mesh-unitcube-cpp 21.8756 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 25, 1, 22, 30) mesh-iteration-cpp 43.465 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 25, 1, 22, 52) function-evaluation-cpp 21.331 "Evaluations of functions at arbitrary points." (2012, 5, 25, 1, 22, 52) function-evaluation-cpp 21.2401 "Evaluations of functions at arbitrary points." (2012, 5, 25, 1, 22, 59) function-extrapolation-python 6.76543 "BENCH: 1.93370103836" (2012, 5, 25, 1, 22, 59) function-extrapolation-python 1.9337 "BENCH: 1.93370103836" (2012, 5, 25, 1, 23, 22) la-vector-access-cpp 23.4113 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 25, 1, 23, 51) la-vector-assignment-cpp 28.3577 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 26, 1, 11, 10) common-progress-cpp 29.7607 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 26, 1, 11, 40) common-timing-cpp 30.4693 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 26, 1, 11, 50) fem-multicore-cpp 10.0649 "Coloring mesh." (2012, 5, 26, 1, 15, 2) fem-assembly-cpp 192.302 "Assembly for various forms and backends" (2012, 5, 26, 1, 15, 14) fem-convergence-cpp 11.5876 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 26, 1, 15, 15) fem-jit-python 0.000417519 "JIT compilation (in memory cache)" (2012, 5, 26, 1, 20, 28) fem-speedup-cpp 312.653 "Assembly/solve speedup running on 4 processors" (2012, 5, 26, 1, 20, 28) fem-speedup-cpp-assembly 5.34531 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 26, 1, 20, 28) fem-speedup-cpp-solve 2.02419 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 26, 1, 20, 52) mesh-refinement-cpp 22.7937 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 26, 1, 21, 14) mesh-topology-cpp 21.4674 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 26, 1, 21, 36) mesh-unitcube-cpp 21.8767 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 26, 1, 22, 19) mesh-iteration-cpp 40.3903 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 26, 1, 22, 40) function-evaluation-cpp 21.2679 "Evaluations of functions at arbitrary points." (2012, 5, 26, 1, 22, 40) function-evaluation-cpp 21.1869 "Evaluations of functions at arbitrary points." (2012, 5, 26, 1, 22, 47) function-extrapolation-python 6.68463 "BENCH: 1.87658405304" (2012, 5, 26, 1, 22, 47) function-extrapolation-python 1.87658 "BENCH: 1.87658405304" (2012, 5, 26, 1, 23, 9) la-vector-access-cpp 22.4248 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 26, 1, 23, 34) la-vector-assignment-cpp 24.9583 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 27, 1, 11, 6) common-progress-cpp 29.6723 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 27, 1, 11, 36) common-timing-cpp 30.183 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 27, 1, 11, 46) fem-multicore-cpp 10.001 "Coloring mesh." (2012, 5, 27, 1, 14, 58) fem-assembly-cpp 192.08 "Assembly for various forms and backends" (2012, 5, 27, 1, 15, 10) fem-convergence-cpp 11.8371 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 27, 1, 15, 11) fem-jit-python 0.00042069 "JIT compilation (in memory cache)" (2012, 5, 27, 1, 20, 23) fem-speedup-cpp 312.003 "Assembly/solve speedup running on 4 processors" (2012, 5, 27, 1, 20, 23) fem-speedup-cpp-assembly 5.30995 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 27, 1, 20, 23) fem-speedup-cpp-solve 2.02653 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 27, 1, 20, 47) mesh-refinement-cpp 22.6896 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 27, 1, 21, 9) mesh-topology-cpp 21.5698 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 27, 1, 21, 31) mesh-unitcube-cpp 21.9092 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 27, 1, 22, 16) mesh-iteration-cpp 42.8681 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 27, 1, 22, 37) function-evaluation-cpp 21.3879 "Evaluations of functions at arbitrary points." (2012, 5, 27, 1, 22, 37) function-evaluation-cpp 21.3012 "Evaluations of functions at arbitrary points." (2012, 5, 27, 1, 22, 44) function-extrapolation-python 6.88474 "BENCH: 1.92811703682" (2012, 5, 27, 1, 22, 44) function-extrapolation-python 1.92812 "BENCH: 1.92811703682" (2012, 5, 27, 1, 23, 7) la-vector-access-cpp 22.468 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 27, 1, 23, 32) la-vector-assignment-cpp 24.9473 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 28, 1, 11, 13) common-progress-cpp 36.4364 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 28, 1, 11, 43) common-timing-cpp 30.0805 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 28, 1, 11, 53) fem-multicore-cpp 10.1594 "Coloring mesh." (2012, 5, 28, 1, 15, 5) fem-assembly-cpp 191.795 "Assembly for various forms and backends" (2012, 5, 28, 1, 15, 17) fem-convergence-cpp 11.8942 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 28, 1, 15, 18) fem-jit-python 0.00044589 "JIT compilation (in memory cache)" (2012, 5, 28, 1, 20, 29) fem-speedup-cpp 310.854 "Assembly/solve speedup running on 4 processors" (2012, 5, 28, 1, 20, 29) fem-speedup-cpp-assembly 5.31187 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 28, 1, 20, 29) fem-speedup-cpp-solve 2.01725 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 28, 1, 20, 53) mesh-refinement-cpp 22.8342 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 28, 1, 21, 15) mesh-topology-cpp 21.5352 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 28, 1, 21, 37) mesh-unitcube-cpp 22.2483 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 28, 1, 22, 20) mesh-iteration-cpp 40.3942 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 28, 1, 22, 42) function-evaluation-cpp 21.3141 "Evaluations of functions at arbitrary points." (2012, 5, 28, 1, 22, 42) function-evaluation-cpp 21.233 "Evaluations of functions at arbitrary points." (2012, 5, 28, 1, 22, 48) function-extrapolation-python 6.79742 "BENCH: 1.92716479301" (2012, 5, 28, 1, 22, 48) function-extrapolation-python 1.92716 "BENCH: 1.92716479301" (2012, 5, 28, 1, 23, 13) la-vector-access-cpp 24.4848 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 28, 1, 23, 38) la-vector-assignment-cpp 24.9579 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 29, 1, 11, 22) common-progress-cpp 29.5721 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 29, 1, 11, 51) common-timing-cpp 29.353 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 29, 1, 12, 1) fem-multicore-cpp 10.024 "Coloring mesh." (2012, 5, 29, 1, 15, 15) fem-assembly-cpp 194.214 "Assembly for various forms and backends" (2012, 5, 29, 1, 15, 27) fem-convergence-cpp 11.8917 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 29, 1, 15, 28) fem-jit-python 0.000406408 "JIT compilation (in memory cache)" (2012, 5, 29, 1, 20, 41) fem-speedup-cpp 312.617 "Assembly/solve speedup running on 4 processors" (2012, 5, 29, 1, 20, 41) fem-speedup-cpp-assembly 5.34119 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 29, 1, 20, 41) fem-speedup-cpp-solve 2.02083 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 29, 1, 21, 5) mesh-refinement-cpp 22.7366 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 29, 1, 21, 27) mesh-topology-cpp 21.5695 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 29, 1, 21, 48) mesh-unitcube-cpp 21.5538 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 29, 1, 22, 31) mesh-iteration-cpp 40.3848 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 29, 1, 22, 52) function-evaluation-cpp 21.2794 "Evaluations of functions at arbitrary points." (2012, 5, 29, 1, 22, 52) function-evaluation-cpp 21.1984 "Evaluations of functions at arbitrary points." (2012, 5, 29, 1, 22, 59) function-extrapolation-python 6.82393 "BENCH: 1.9122531414" (2012, 5, 29, 1, 22, 59) function-extrapolation-python 1.91225 "BENCH: 1.9122531414" (2012, 5, 29, 1, 23, 22) la-vector-access-cpp 22.9087 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 29, 1, 23, 47) la-vector-assignment-cpp 25.0548 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 30, 1, 11, 7) common-progress-cpp 29.5942 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 30, 1, 11, 36) common-timing-cpp 29.3557 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 30, 1, 11, 46) fem-multicore-cpp 10.0285 "Coloring mesh." (2012, 5, 30, 1, 15, 2) fem-assembly-cpp 195.489 "Assembly for various forms and backends" (2012, 5, 30, 1, 15, 13) fem-convergence-cpp 11.8672 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 30, 1, 15, 15) fem-jit-python 0.000409794 "JIT compilation (in memory cache)" (2012, 5, 30, 1, 20, 25) fem-speedup-cpp 310.344 "Assembly/solve speedup running on 4 processors" (2012, 5, 30, 1, 20, 25) fem-speedup-cpp-assembly 5.31013 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 30, 1, 20, 25) fem-speedup-cpp-solve 2.02744 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 30, 1, 20, 49) mesh-refinement-cpp 22.7933 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 30, 1, 21, 11) mesh-topology-cpp 21.5537 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 30, 1, 21, 33) mesh-unitcube-cpp 21.4803 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 30, 1, 22, 25) mesh-iteration-cpp 50.3892 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 30, 1, 22, 47) function-evaluation-cpp 21.3679 "Evaluations of functions at arbitrary points." (2012, 5, 30, 1, 22, 47) function-evaluation-cpp 21.2867 "Evaluations of functions at arbitrary points." (2012, 5, 30, 1, 22, 54) function-extrapolation-python 6.75319 "BENCH: 1.91392302513" (2012, 5, 30, 1, 22, 54) function-extrapolation-python 1.91392 "BENCH: 1.91392302513" (2012, 5, 30, 1, 23, 16) la-vector-access-cpp 22.8961 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 30, 1, 23, 42) la-vector-assignment-cpp 24.9622 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 5, 31, 1, 11, 15) common-progress-cpp 30.2434 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 5, 31, 1, 11, 45) common-timing-cpp 29.95 "Timing access and registration of timings (10000000 repetitions)" (2012, 5, 31, 1, 11, 56) fem-multicore-cpp 10.1539 "Coloring mesh." (2012, 5, 31, 1, 15, 11) fem-assembly-cpp 195.619 "Assembly for various forms and backends" (2012, 5, 31, 1, 15, 23) fem-convergence-cpp 11.9067 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 5, 31, 1, 15, 24) fem-jit-python 0.000415277 "JIT compilation (in memory cache)" (2012, 5, 31, 1, 20, 35) fem-speedup-cpp 310.523 "Assembly/solve speedup running on 4 processors" (2012, 5, 31, 1, 20, 35) fem-speedup-cpp-assembly 5.35221 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 5, 31, 1, 20, 35) fem-speedup-cpp-solve 2.00606 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 5, 31, 1, 20, 59) mesh-refinement-cpp 22.7502 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 5, 31, 1, 21, 21) mesh-topology-cpp 21.605 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 5, 31, 1, 21, 42) mesh-unitcube-cpp 21.5397 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 5, 31, 1, 22, 25) mesh-iteration-cpp 40.3962 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 5, 31, 1, 22, 47) function-evaluation-cpp 21.3396 "Evaluations of functions at arbitrary points." (2012, 5, 31, 1, 22, 47) function-evaluation-cpp 21.2581 "Evaluations of functions at arbitrary points." (2012, 5, 31, 1, 22, 53) function-extrapolation-python 6.68259 "BENCH: 1.91393995285" (2012, 5, 31, 1, 22, 53) function-extrapolation-python 1.91394 "BENCH: 1.91393995285" (2012, 5, 31, 1, 23, 17) la-vector-access-cpp 23.7996 "Accessing vector of size 10000000 (100 repetitions)" (2012, 5, 31, 1, 23, 42) la-vector-assignment-cpp 25.0495 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 1, 1, 11, 8) common-progress-cpp 29.892 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 1, 1, 11, 38) common-timing-cpp 29.2017 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 1, 1, 11, 48) fem-multicore-cpp 10.0623 "Coloring mesh." (2012, 6, 1, 1, 15, 1) fem-assembly-cpp 193.849 "Assembly for various forms and backends" (2012, 6, 1, 1, 15, 13) fem-convergence-cpp 11.8302 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 1, 1, 15, 14) fem-jit-python 0.000411201 "JIT compilation (in memory cache)" (2012, 6, 1, 1, 20, 26) fem-speedup-cpp 311.968 "Assembly/solve speedup running on 4 processors" (2012, 6, 1, 1, 20, 26) fem-speedup-cpp-assembly 5.33225 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 1, 1, 20, 26) fem-speedup-cpp-solve 1.98457 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 1, 1, 20, 51) mesh-refinement-cpp 22.6667 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 1, 1, 21, 12) mesh-topology-cpp 21.5592 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 1, 1, 21, 34) mesh-unitcube-cpp 21.5331 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 1, 1, 22, 17) mesh-iteration-cpp 40.3761 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 1, 1, 22, 38) function-evaluation-cpp 21.3813 "Evaluations of functions at arbitrary points." (2012, 6, 1, 1, 22, 38) function-evaluation-cpp 21.2632 "Evaluations of functions at arbitrary points." (2012, 6, 1, 1, 22, 45) function-extrapolation-python 6.84335 "BENCH: 1.92669606209" (2012, 6, 1, 1, 22, 45) function-extrapolation-python 1.9267 "BENCH: 1.92669606209" (2012, 6, 1, 1, 23, 8) la-vector-access-cpp 22.8918 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 1, 1, 23, 33) la-vector-assignment-cpp 24.9478 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 2, 1, 11, 26) common-progress-cpp 29.5682 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 2, 1, 11, 55) common-timing-cpp 29.4358 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 2, 1, 12, 6) fem-multicore-cpp 10.1176 "Coloring mesh." (2012, 6, 2, 1, 15, 20) fem-assembly-cpp 194.888 "Assembly for various forms and backends" (2012, 6, 2, 1, 15, 32) fem-convergence-cpp 11.8629 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 2, 1, 15, 33) fem-jit-python 0.000422287 "JIT compilation (in memory cache)" (2012, 6, 2, 1, 20, 46) fem-speedup-cpp 312.141 "Assembly/solve speedup running on 4 processors" (2012, 6, 2, 1, 20, 46) fem-speedup-cpp-assembly 5.42749 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 2, 1, 20, 46) fem-speedup-cpp-solve 2.03296 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 2, 1, 21, 10) mesh-refinement-cpp 22.6487 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 2, 1, 21, 32) mesh-topology-cpp 21.5539 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 2, 1, 21, 53) mesh-unitcube-cpp 21.5304 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 2, 1, 22, 36) mesh-iteration-cpp 40.3734 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 2, 1, 22, 57) function-evaluation-cpp 20.9285 "Evaluations of functions at arbitrary points." (2012, 6, 2, 1, 22, 57) function-evaluation-cpp 20.8105 "Evaluations of functions at arbitrary points." (2012, 6, 2, 1, 23, 4) function-extrapolation-python 6.91056 "BENCH: 1.89626288414" (2012, 6, 2, 1, 23, 4) function-extrapolation-python 1.89626 "BENCH: 1.89626288414" (2012, 6, 2, 1, 23, 27) la-vector-access-cpp 22.8956 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 2, 1, 23, 52) la-vector-assignment-cpp 24.9617 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 3, 1, 11, 6) common-progress-cpp 29.7073 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 3, 1, 11, 36) common-timing-cpp 29.6492 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 3, 1, 11, 46) fem-multicore-cpp 10.1124 "Coloring mesh." (2012, 6, 3, 1, 15, 0) fem-assembly-cpp 193.997 "Assembly for various forms and backends" (2012, 6, 3, 1, 15, 12) fem-convergence-cpp 11.5825 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 3, 1, 15, 13) fem-jit-python 0.000427794 "JIT compilation (in memory cache)" (2012, 6, 3, 1, 20, 30) fem-speedup-cpp 317.088 "Assembly/solve speedup running on 4 processors" (2012, 6, 3, 1, 20, 30) fem-speedup-cpp-assembly 5.36035 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 3, 1, 20, 30) fem-speedup-cpp-solve 1.90454 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 3, 1, 20, 54) mesh-refinement-cpp 22.662 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 3, 1, 21, 16) mesh-topology-cpp 21.5826 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 3, 1, 21, 37) mesh-unitcube-cpp 21.5292 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 3, 1, 22, 20) mesh-iteration-cpp 40.3793 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 3, 1, 22, 41) function-evaluation-cpp 21.331 "Evaluations of functions at arbitrary points." (2012, 6, 3, 1, 22, 41) function-evaluation-cpp 21.2363 "Evaluations of functions at arbitrary points." (2012, 6, 3, 1, 22, 49) function-extrapolation-python 6.98481 "BENCH: 1.92869877815" (2012, 6, 3, 1, 22, 49) function-extrapolation-python 1.9287 "BENCH: 1.92869877815" (2012, 6, 3, 1, 23, 11) la-vector-access-cpp 22.8882 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 3, 1, 23, 43) la-vector-assignment-cpp 31.8781 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 4, 1, 11, 9) common-progress-cpp 29.607 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 4, 1, 11, 40) common-timing-cpp 30.8566 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 4, 1, 11, 50) fem-multicore-cpp 10.1028 "Coloring mesh." (2012, 6, 4, 1, 15, 3) fem-assembly-cpp 193.564 "Assembly for various forms and backends" (2012, 6, 4, 1, 15, 15) fem-convergence-cpp 11.8916 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 4, 1, 15, 16) fem-jit-python 0.000420904 "JIT compilation (in memory cache)" (2012, 6, 4, 1, 20, 28) fem-speedup-cpp 311.697 "Assembly/solve speedup running on 4 processors" (2012, 6, 4, 1, 20, 28) fem-speedup-cpp-assembly 5.3027 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 4, 1, 20, 28) fem-speedup-cpp-solve 2.03463 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 4, 1, 20, 52) mesh-refinement-cpp 22.7172 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 4, 1, 21, 14) mesh-topology-cpp 21.6336 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 4, 1, 21, 35) mesh-unitcube-cpp 21.6053 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 4, 1, 22, 18) mesh-iteration-cpp 40.3822 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 4, 1, 22, 39) function-evaluation-cpp 21.3066 "Evaluations of functions at arbitrary points." (2012, 6, 4, 1, 22, 39) function-evaluation-cpp 21.213 "Evaluations of functions at arbitrary points." (2012, 6, 4, 1, 22, 46) function-extrapolation-python 6.67891 "BENCH: 1.90621995926" (2012, 6, 4, 1, 22, 46) function-extrapolation-python 1.90622 "BENCH: 1.90621995926" (2012, 6, 4, 1, 23, 9) la-vector-access-cpp 22.9162 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 4, 1, 23, 34) la-vector-assignment-cpp 24.9555 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 5, 1, 11, 3) common-progress-cpp 29.6767 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 5, 1, 11, 32) common-timing-cpp 29.4671 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 5, 1, 11, 42) fem-multicore-cpp 10.015 "Coloring mesh." (2012, 6, 5, 1, 14, 56) fem-assembly-cpp 194.016 "Assembly for various forms and backends" (2012, 6, 5, 1, 15, 8) fem-convergence-cpp 11.8499 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 5, 1, 15, 9) fem-jit-python 0.000432396 "JIT compilation (in memory cache)" (2012, 6, 5, 1, 20, 20) fem-speedup-cpp 310.625 "Assembly/solve speedup running on 4 processors" (2012, 6, 5, 1, 20, 20) fem-speedup-cpp-assembly 5.39826 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 5, 1, 20, 20) fem-speedup-cpp-solve 2.0291 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 5, 1, 20, 44) mesh-refinement-cpp 22.6605 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 5, 1, 21, 6) mesh-topology-cpp 21.5928 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 5, 1, 21, 27) mesh-unitcube-cpp 21.5892 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 5, 1, 22, 10) mesh-iteration-cpp 40.3749 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 5, 1, 22, 31) function-evaluation-cpp 21.2994 "Evaluations of functions at arbitrary points." (2012, 6, 5, 1, 22, 31) function-evaluation-cpp 21.1948 "Evaluations of functions at arbitrary points." (2012, 6, 5, 1, 22, 38) function-extrapolation-python 6.72049 "BENCH: 1.9154291153" (2012, 6, 5, 1, 22, 38) function-extrapolation-python 1.91543 "BENCH: 1.9154291153" (2012, 6, 5, 1, 23, 1) la-vector-access-cpp 22.8892 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 5, 1, 23, 26) la-vector-assignment-cpp 24.9787 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 6, 1, 11, 11) common-progress-cpp 36.4362 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 6, 1, 11, 40) common-timing-cpp 29.0998 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 6, 1, 11, 50) fem-multicore-cpp 10.0637 "Coloring mesh." (2012, 6, 6, 1, 15, 4) fem-assembly-cpp 194.366 "Assembly for various forms and backends" (2012, 6, 6, 1, 15, 16) fem-convergence-cpp 11.8895 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 6, 1, 15, 17) fem-jit-python 0.000433302 "JIT compilation (in memory cache)" (2012, 6, 6, 1, 20, 31) fem-speedup-cpp 313.468 "Assembly/solve speedup running on 4 processors" (2012, 6, 6, 1, 20, 31) fem-speedup-cpp-assembly 5.27284 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 6, 1, 20, 31) fem-speedup-cpp-solve 1.99439 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 6, 1, 20, 55) mesh-refinement-cpp 22.7055 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 6, 1, 21, 17) mesh-topology-cpp 21.6391 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 6, 1, 21, 38) mesh-unitcube-cpp 21.5574 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 6, 1, 22, 21) mesh-iteration-cpp 40.3823 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 6, 1, 22, 42) function-evaluation-cpp 21.3322 "Evaluations of functions at arbitrary points." (2012, 6, 6, 1, 22, 42) function-evaluation-cpp 21.2309 "Evaluations of functions at arbitrary points." (2012, 6, 6, 1, 22, 49) function-extrapolation-python 6.88828 "BENCH: 1.94164609909" (2012, 6, 6, 1, 22, 49) function-extrapolation-python 1.94165 "BENCH: 1.94164609909" (2012, 6, 6, 1, 23, 14) la-vector-access-cpp 24.7008 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 6, 1, 23, 42) la-vector-assignment-cpp 27.9355 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 7, 1, 11, 39) common-progress-cpp 29.907 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 7, 1, 12, 9) common-timing-cpp 29.8448 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 7, 1, 12, 19) fem-multicore-cpp 10.1124 "Coloring mesh." (2012, 6, 7, 1, 15, 32) fem-assembly-cpp 192.956 "Assembly for various forms and backends" (2012, 6, 7, 1, 15, 44) fem-convergence-cpp 11.8814 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 7, 1, 15, 45) fem-jit-python 0.000419784 "JIT compilation (in memory cache)" (2012, 6, 7, 1, 20, 54) fem-speedup-cpp 309.291 "Assembly/solve speedup running on 4 processors" (2012, 6, 7, 1, 20, 54) fem-speedup-cpp-assembly 5.55141 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 7, 1, 20, 54) fem-speedup-cpp-solve 2.02218 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 7, 1, 21, 18) mesh-refinement-cpp 22.4169 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 7, 1, 21, 40) mesh-topology-cpp 21.1113 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 7, 1, 22, 1) mesh-unitcube-cpp 21.4645 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 7, 1, 22, 44) mesh-iteration-cpp 40.3754 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 7, 1, 23, 5) function-evaluation-cpp 21.3316 "Evaluations of functions at arbitrary points." (2012, 6, 7, 1, 23, 5) function-evaluation-cpp 21.2343 "Evaluations of functions at arbitrary points." (2012, 6, 7, 1, 23, 12) function-extrapolation-python 6.72874 "BENCH: 1.91428589821" (2012, 6, 7, 1, 23, 12) function-extrapolation-python 1.91429 "BENCH: 1.91428589821" (2012, 6, 7, 1, 23, 34) la-vector-access-cpp 22.4149 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 7, 1, 24, 0) la-vector-assignment-cpp 25.0207 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 8, 1, 11, 6) common-progress-cpp 29.8863 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 8, 1, 11, 36) common-timing-cpp 29.9752 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 8, 1, 11, 46) fem-multicore-cpp 10.1752 "Coloring mesh." (2012, 6, 8, 1, 14, 59) fem-assembly-cpp 192.827 "Assembly for various forms and backends" (2012, 6, 8, 1, 15, 11) fem-convergence-cpp 11.8781 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 8, 1, 15, 12) fem-jit-python 0.000407004 "JIT compilation (in memory cache)" (2012, 6, 8, 1, 20, 25) fem-speedup-cpp 312.744 "Assembly/solve speedup running on 4 processors" (2012, 6, 8, 1, 20, 25) fem-speedup-cpp-assembly 5.51927 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 8, 1, 20, 25) fem-speedup-cpp-solve 1.98713 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 8, 1, 20, 49) mesh-refinement-cpp 22.4902 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 8, 1, 21, 10) mesh-topology-cpp 21.227 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 8, 1, 21, 32) mesh-unitcube-cpp 21.5297 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 8, 1, 22, 14) mesh-iteration-cpp 40.3794 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 8, 1, 22, 36) function-evaluation-cpp 21.3448 "Evaluations of functions at arbitrary points." (2012, 6, 8, 1, 22, 36) function-evaluation-cpp 21.2269 "Evaluations of functions at arbitrary points." (2012, 6, 8, 1, 22, 42) function-extrapolation-python 6.74054 "BENCH: 1.90929389" (2012, 6, 8, 1, 22, 42) function-extrapolation-python 1.90929 "BENCH: 1.90929389" (2012, 6, 8, 1, 23, 5) la-vector-access-cpp 22.414 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 8, 1, 23, 30) la-vector-assignment-cpp 25.1507 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 9, 1, 11, 11) common-progress-cpp 29.6083 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 9, 1, 11, 41) common-timing-cpp 29.9019 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 9, 1, 11, 51) fem-multicore-cpp 10.292 "Coloring mesh." (2012, 6, 9, 1, 15, 4) fem-assembly-cpp 192.929 "Assembly for various forms and backends" (2012, 6, 9, 1, 15, 16) fem-convergence-cpp 11.8579 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 9, 1, 15, 17) fem-jit-python 0.000409293 "JIT compilation (in memory cache)" (2012, 6, 9, 1, 20, 27) fem-speedup-cpp 310.53 "Assembly/solve speedup running on 4 processors" (2012, 6, 9, 1, 20, 27) fem-speedup-cpp-assembly 5.50762 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 9, 1, 20, 27) fem-speedup-cpp-solve 2.02045 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 9, 1, 20, 51) mesh-refinement-cpp 22.3945 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 9, 1, 21, 13) mesh-topology-cpp 21.4554 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 9, 1, 21, 35) mesh-unitcube-cpp 21.5144 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 9, 1, 22, 17) mesh-iteration-cpp 40.3748 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 9, 1, 22, 39) function-evaluation-cpp 21.2983 "Evaluations of functions at arbitrary points." (2012, 6, 9, 1, 22, 39) function-evaluation-cpp 21.1995 "Evaluations of functions at arbitrary points." (2012, 6, 9, 1, 22, 46) function-extrapolation-python 6.91573 "BENCH: 1.91140294075" (2012, 6, 9, 1, 22, 46) function-extrapolation-python 1.9114 "BENCH: 1.91140294075" (2012, 6, 9, 1, 23, 8) la-vector-access-cpp 22.4171 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 9, 1, 23, 33) la-vector-assignment-cpp 24.9578 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 10, 1, 11, 8) common-progress-cpp 29.6028 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 10, 1, 11, 37) common-timing-cpp 29.241 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 10, 1, 11, 47) fem-multicore-cpp 10.2085 "Coloring mesh." (2012, 6, 10, 1, 15, 1) fem-assembly-cpp 193.99 "Assembly for various forms and backends" (2012, 6, 10, 1, 15, 13) fem-convergence-cpp 11.9072 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 10, 1, 15, 14) fem-jit-python 0.000418711 "JIT compilation (in memory cache)" (2012, 6, 10, 1, 20, 30) fem-speedup-cpp 315.755 "Assembly/solve speedup running on 4 processors" (2012, 6, 10, 1, 20, 30) fem-speedup-cpp-assembly 5.5264 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 10, 1, 20, 30) fem-speedup-cpp-solve 1.92734 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 10, 1, 20, 54) mesh-refinement-cpp 22.402 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 10, 1, 21, 15) mesh-topology-cpp 21.1577 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 10, 1, 21, 37) mesh-unitcube-cpp 21.4241 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 10, 1, 22, 19) mesh-iteration-cpp 40.3732 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 10, 1, 22, 41) function-evaluation-cpp 21.5731 "Evaluations of functions at arbitrary points." (2012, 6, 10, 1, 22, 41) function-evaluation-cpp 21.4726 "Evaluations of functions at arbitrary points." (2012, 6, 10, 1, 22, 48) function-extrapolation-python 6.99914 "BENCH: 1.92446279526" (2012, 6, 10, 1, 22, 48) function-extrapolation-python 1.92446 "BENCH: 1.92446279526" (2012, 6, 10, 1, 23, 12) la-vector-access-cpp 23.4081 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 10, 1, 23, 40) la-vector-assignment-cpp 27.8949 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 11, 1, 11, 16) common-progress-cpp 30.1849 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 11, 1, 11, 46) common-timing-cpp 29.6861 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 11, 1, 11, 56) fem-multicore-cpp 10.1629 "Coloring mesh." (2012, 6, 11, 1, 15, 9) fem-assembly-cpp 192.913 "Assembly for various forms and backends" (2012, 6, 11, 1, 15, 21) fem-convergence-cpp 11.8951 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 11, 1, 15, 22) fem-jit-python 0.000427198 "JIT compilation (in memory cache)" (2012, 6, 11, 1, 20, 34) fem-speedup-cpp 311.439 "Assembly/solve speedup running on 4 processors" (2012, 6, 11, 1, 20, 34) fem-speedup-cpp-assembly 5.52724 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 11, 1, 20, 34) fem-speedup-cpp-solve 2.0019 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 11, 1, 20, 58) mesh-refinement-cpp 22.4489 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 11, 1, 21, 19) mesh-topology-cpp 21.1194 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 11, 1, 21, 40) mesh-unitcube-cpp 21.4372 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 11, 1, 22, 23) mesh-iteration-cpp 40.3721 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 11, 1, 22, 45) function-evaluation-cpp 21.3233 "Evaluations of functions at arbitrary points." (2012, 6, 11, 1, 22, 45) function-evaluation-cpp 21.2205 "Evaluations of functions at arbitrary points." (2012, 6, 11, 1, 22, 51) function-extrapolation-python 6.7301 "BENCH: 1.91325688362" (2012, 6, 11, 1, 22, 51) function-extrapolation-python 1.91326 "BENCH: 1.91325688362" (2012, 6, 11, 1, 23, 15) la-vector-access-cpp 23.7871 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 11, 1, 23, 40) la-vector-assignment-cpp 24.9551 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 12, 1, 11, 12) common-progress-cpp 29.6005 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 12, 1, 11, 41) common-timing-cpp 29.3649 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 12, 1, 11, 52) fem-multicore-cpp 10.2365 "Coloring mesh." (2012, 6, 12, 1, 15, 4) fem-assembly-cpp 192.809 "Assembly for various forms and backends" (2012, 6, 12, 1, 15, 16) fem-convergence-cpp 11.902 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 12, 1, 15, 17) fem-jit-python 0.000407386 "JIT compilation (in memory cache)" (2012, 6, 12, 1, 20, 30) fem-speedup-cpp 312.619 "Assembly/solve speedup running on 4 processors" (2012, 6, 12, 1, 20, 30) fem-speedup-cpp-assembly 5.52872 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 12, 1, 20, 30) fem-speedup-cpp-solve 2.00459 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 12, 1, 20, 54) mesh-refinement-cpp 22.4309 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 12, 1, 21, 15) mesh-topology-cpp 21.147 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 12, 1, 21, 37) mesh-unitcube-cpp 21.552 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 12, 1, 22, 20) mesh-iteration-cpp 40.3784 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 12, 1, 22, 41) function-evaluation-cpp 21.3816 "Evaluations of functions at arbitrary points." (2012, 6, 12, 1, 22, 41) function-evaluation-cpp 21.2866 "Evaluations of functions at arbitrary points." (2012, 6, 12, 1, 22, 48) function-extrapolation-python 6.75649 "BENCH: 1.92233991623" (2012, 6, 12, 1, 22, 48) function-extrapolation-python 1.92234 "BENCH: 1.92233991623" (2012, 6, 12, 1, 23, 10) la-vector-access-cpp 22.4226 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 12, 1, 23, 35) la-vector-assignment-cpp 24.9146 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 13, 1, 11, 4) common-progress-cpp 29.8758 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 13, 1, 11, 33) common-timing-cpp 28.8893 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 13, 1, 11, 43) fem-multicore-cpp 10.1614 "Coloring mesh." (2012, 6, 13, 1, 14, 56) fem-assembly-cpp 193.134 "Assembly for various forms and backends" (2012, 6, 13, 1, 15, 8) fem-convergence-cpp 11.8836 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 13, 1, 15, 9) fem-jit-python 0.000417399 "JIT compilation (in memory cache)" (2012, 6, 13, 1, 20, 19) fem-speedup-cpp 309.8 "Assembly/solve speedup running on 4 processors" (2012, 6, 13, 1, 20, 19) fem-speedup-cpp-assembly 5.54182 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 13, 1, 20, 19) fem-speedup-cpp-solve 2.05001 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 13, 1, 20, 43) mesh-refinement-cpp 22.4349 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 13, 1, 21, 4) mesh-topology-cpp 21.1341 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 13, 1, 21, 26) mesh-unitcube-cpp 21.4753 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 13, 1, 22, 9) mesh-iteration-cpp 40.3903 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 13, 1, 22, 30) function-evaluation-cpp 21.3232 "Evaluations of functions at arbitrary points." (2012, 6, 13, 1, 22, 30) function-evaluation-cpp 21.2204 "Evaluations of functions at arbitrary points." (2012, 6, 13, 1, 22, 37) function-extrapolation-python 6.83525 "BENCH: 1.92004990578" (2012, 6, 13, 1, 22, 37) function-extrapolation-python 1.92005 "BENCH: 1.92004990578" (2012, 6, 13, 1, 23, 1) la-vector-access-cpp 24.3973 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 13, 1, 23, 27) la-vector-assignment-cpp 24.9728 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 14, 1, 11, 29) common-progress-cpp 30.4164 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 14, 1, 11, 59) common-timing-cpp 29.5554 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 14, 1, 12, 9) fem-multicore-cpp 10.1626 "Coloring mesh." (2012, 6, 14, 1, 15, 22) fem-assembly-cpp 193.395 "Assembly for various forms and backends" (2012, 6, 14, 1, 15, 34) fem-convergence-cpp 11.9002 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 14, 1, 15, 36) fem-jit-python 0.00041461 "JIT compilation (in memory cache)" (2012, 6, 14, 1, 20, 47) fem-speedup-cpp 310.316 "Assembly/solve speedup running on 4 processors" (2012, 6, 14, 1, 20, 47) fem-speedup-cpp-assembly 5.52806 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 14, 1, 20, 47) fem-speedup-cpp-solve 2.05104 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 14, 1, 21, 10) mesh-refinement-cpp 22.4071 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 14, 1, 21, 31) mesh-topology-cpp 21.2934 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 14, 1, 21, 53) mesh-unitcube-cpp 21.6732 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 14, 1, 22, 36) mesh-iteration-cpp 40.3907 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 14, 1, 22, 57) function-evaluation-cpp 21.1068 "Evaluations of functions at arbitrary points." (2012, 6, 14, 1, 22, 57) function-evaluation-cpp 20.9887 "Evaluations of functions at arbitrary points." (2012, 6, 14, 1, 23, 26) function-extrapolation-python 29.0757 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 6, 14, 1, 23, 26) function-extrapolation-python 1.91098 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 6, 14, 1, 23, 50) la-vector-access-cpp 23.8802 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 14, 1, 24, 15) la-vector-assignment-cpp 24.962 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 15, 1, 11, 19) common-progress-cpp 29.5797 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 15, 1, 11, 49) common-timing-cpp 30.5908 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 15, 1, 12, 0) fem-multicore-cpp 10.1569 "Coloring mesh." (2012, 6, 15, 1, 15, 16) fem-assembly-cpp 196.654 "Assembly for various forms and backends" (2012, 6, 15, 1, 15, 28) fem-convergence-cpp 11.9271 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 15, 1, 15, 29) fem-jit-python 0.000416589 "JIT compilation (in memory cache)" (2012, 6, 15, 1, 20, 40) fem-speedup-cpp 310.93 "Assembly/solve speedup running on 4 processors" (2012, 6, 15, 1, 20, 40) fem-speedup-cpp-assembly 5.49874 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 15, 1, 20, 40) fem-speedup-cpp-solve 2.00135 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 15, 1, 21, 4) mesh-refinement-cpp 22.0645 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 15, 1, 21, 25) mesh-topology-cpp 20.6735 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 15, 1, 21, 46) mesh-unitcube-cpp 21.0208 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 15, 1, 22, 29) mesh-iteration-cpp 40.3737 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 15, 1, 22, 50) function-evaluation-cpp 21.34 "Evaluations of functions at arbitrary points." (2012, 6, 15, 1, 22, 50) function-evaluation-cpp 21.2363 "Evaluations of functions at arbitrary points." (2012, 6, 15, 1, 22, 57) function-extrapolation-python 6.81551 "BENCH: 1.96959495544" (2012, 6, 15, 1, 22, 57) function-extrapolation-python 1.96959 "BENCH: 1.96959495544" (2012, 6, 15, 1, 23, 22) la-vector-access-cpp 25.389 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 15, 1, 23, 47) la-vector-assignment-cpp 24.9487 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 16, 1, 11, 8) common-progress-cpp 29.5048 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 16, 1, 11, 39) common-timing-cpp 30.7238 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 16, 1, 11, 49) fem-multicore-cpp 10.0559 "Coloring mesh." (2012, 6, 16, 1, 15, 6) fem-assembly-cpp 197.068 "Assembly for various forms and backends" (2012, 6, 16, 1, 15, 18) fem-convergence-cpp 11.9068 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 16, 1, 15, 19) fem-jit-python 0.000429916 "JIT compilation (in memory cache)" (2012, 6, 16, 1, 20, 29) fem-speedup-cpp 309.285 "Assembly/solve speedup running on 4 processors" (2012, 6, 16, 1, 20, 29) fem-speedup-cpp-assembly 5.59151 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 16, 1, 20, 29) fem-speedup-cpp-solve 2.0454 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 16, 1, 20, 52) mesh-refinement-cpp 22.1236 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 16, 1, 21, 13) mesh-topology-cpp 20.6117 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 16, 1, 21, 34) mesh-unitcube-cpp 21.0168 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 16, 1, 22, 19) mesh-iteration-cpp 42.8725 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 16, 1, 22, 40) function-evaluation-cpp 20.807 "Evaluations of functions at arbitrary points." (2012, 6, 16, 1, 22, 40) function-evaluation-cpp 20.7038 "Evaluations of functions at arbitrary points." (2012, 6, 16, 1, 22, 47) function-extrapolation-python 6.6858 "BENCH: 1.96168613434" (2012, 6, 16, 1, 22, 47) function-extrapolation-python 1.96169 "BENCH: 1.96168613434" (2012, 6, 16, 1, 23, 12) la-vector-access-cpp 25.3891 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 16, 1, 23, 40) la-vector-assignment-cpp 27.8951 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 17, 1, 11, 9) common-progress-cpp 29.6113 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 17, 1, 11, 40) common-timing-cpp 30.2551 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 17, 1, 11, 50) fem-multicore-cpp 10.1262 "Coloring mesh." (2012, 6, 17, 1, 15, 7) fem-assembly-cpp 197.233 "Assembly for various forms and backends" (2012, 6, 17, 1, 15, 19) fem-convergence-cpp 11.8976 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 17, 1, 15, 20) fem-jit-python 0.000421381 "JIT compilation (in memory cache)" (2012, 6, 17, 1, 20, 30) fem-speedup-cpp 309.934 "Assembly/solve speedup running on 4 processors" (2012, 6, 17, 1, 20, 30) fem-speedup-cpp-assembly 5.59283 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 17, 1, 20, 30) fem-speedup-cpp-solve 2.03595 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 17, 1, 20, 54) mesh-refinement-cpp 22.1048 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 17, 1, 21, 15) mesh-topology-cpp 20.6635 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 17, 1, 21, 36) mesh-unitcube-cpp 20.9857 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 17, 1, 22, 18) mesh-iteration-cpp 40.3724 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 17, 1, 22, 39) function-evaluation-cpp 20.9905 "Evaluations of functions at arbitrary points." (2012, 6, 17, 1, 22, 39) function-evaluation-cpp 20.9089 "Evaluations of functions at arbitrary points." (2012, 6, 17, 1, 22, 46) function-extrapolation-python 6.7089 "BENCH: 1.91786503792" (2012, 6, 17, 1, 22, 46) function-extrapolation-python 1.91787 "BENCH: 1.91786503792" (2012, 6, 17, 1, 23, 12) la-vector-access-cpp 25.3986 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 17, 1, 23, 40) la-vector-assignment-cpp 27.8999 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 18, 1, 11, 4) common-progress-cpp 29.6312 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 18, 1, 11, 34) common-timing-cpp 30.4561 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 18, 1, 11, 44) fem-multicore-cpp 10.1147 "Coloring mesh." (2012, 6, 18, 1, 15, 0) fem-assembly-cpp 196.29 "Assembly for various forms and backends" (2012, 6, 18, 1, 15, 12) fem-convergence-cpp 11.9254 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 18, 1, 15, 13) fem-jit-python 0.000420594 "JIT compilation (in memory cache)" (2012, 6, 18, 1, 20, 26) fem-speedup-cpp 312.323 "Assembly/solve speedup running on 4 processors" (2012, 6, 18, 1, 20, 26) fem-speedup-cpp-assembly 5.57966 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 18, 1, 20, 26) fem-speedup-cpp-solve 2.00593 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 18, 1, 20, 49) mesh-refinement-cpp 22.0531 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 18, 1, 21, 10) mesh-topology-cpp 20.5799 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 18, 1, 21, 31) mesh-unitcube-cpp 20.9718 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 18, 1, 22, 14) mesh-iteration-cpp 40.3808 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 18, 1, 22, 35) function-evaluation-cpp 21.2974 "Evaluations of functions at arbitrary points." (2012, 6, 18, 1, 22, 35) function-evaluation-cpp 21.2158 "Evaluations of functions at arbitrary points." (2012, 6, 18, 1, 22, 42) function-extrapolation-python 6.77056 "BENCH: 1.96496796608" (2012, 6, 18, 1, 22, 42) function-extrapolation-python 1.96497 "BENCH: 1.96496796608" (2012, 6, 18, 1, 23, 8) la-vector-access-cpp 25.3872 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 18, 1, 23, 33) la-vector-assignment-cpp 24.9484 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 19, 1, 11, 21) common-progress-cpp 29.5791 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 19, 1, 11, 51) common-timing-cpp 30.5005 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 19, 1, 12, 1) fem-multicore-cpp 10.062 "Coloring mesh." (2012, 6, 19, 1, 15, 18) fem-assembly-cpp 196.873 "Assembly for various forms and backends" (2012, 6, 19, 1, 15, 30) fem-convergence-cpp 11.905 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 19, 1, 15, 31) fem-jit-python 0.000429606 "JIT compilation (in memory cache)" (2012, 6, 19, 1, 20, 42) fem-speedup-cpp 310.724 "Assembly/solve speedup running on 4 processors" (2012, 6, 19, 1, 20, 42) fem-speedup-cpp-assembly 5.56819 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 19, 1, 20, 42) fem-speedup-cpp-solve 2.00762 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 19, 1, 21, 6) mesh-refinement-cpp 22.0974 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 19, 1, 21, 27) mesh-topology-cpp 20.63 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 19, 1, 21, 48) mesh-unitcube-cpp 20.9931 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 19, 1, 22, 36) mesh-iteration-cpp 46.0181 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 19, 1, 22, 57) function-evaluation-cpp 21.3652 "Evaluations of functions at arbitrary points." (2012, 6, 19, 1, 22, 57) function-evaluation-cpp 21.2063 "Evaluations of functions at arbitrary points." (2012, 6, 19, 1, 23, 4) function-extrapolation-python 6.85452 "BENCH: 1.94724607468" (2012, 6, 19, 1, 23, 4) function-extrapolation-python 1.94725 "BENCH: 1.94724607468" (2012, 6, 19, 1, 23, 30) la-vector-access-cpp 25.3918 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 19, 1, 23, 55) la-vector-assignment-cpp 24.9583 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 20, 1, 11, 32) common-progress-cpp 29.6165 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 20, 1, 12, 2) common-timing-cpp 29.7392 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 20, 1, 12, 12) fem-multicore-cpp 10.2458 "Coloring mesh." (2012, 6, 20, 1, 15, 31) fem-assembly-cpp 198.543 "Assembly for various forms and backends" (2012, 6, 20, 1, 15, 42) fem-convergence-cpp 11.7064 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 20, 1, 15, 44) fem-jit-python 0.000405312 "JIT compilation (in memory cache)" (2012, 6, 20, 1, 20, 55) fem-speedup-cpp 311.85 "Assembly/solve speedup running on 4 processors" (2012, 6, 20, 1, 20, 55) fem-speedup-cpp-assembly 5.48203 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 20, 1, 20, 55) fem-speedup-cpp-solve 2.02044 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 20, 1, 21, 19) mesh-refinement-cpp 22.0618 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 20, 1, 21, 40) mesh-topology-cpp 20.5839 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 20, 1, 22, 1) mesh-unitcube-cpp 21.1712 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 20, 1, 22, 45) mesh-iteration-cpp 41.6332 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 20, 1, 23, 6) function-evaluation-cpp 21.3149 "Evaluations of functions at arbitrary points." (2012, 6, 20, 1, 23, 6) function-evaluation-cpp 21.2203 "Evaluations of functions at arbitrary points." (2012, 6, 20, 1, 23, 13) function-extrapolation-python 6.63328 "BENCH: 1.91113209724" (2012, 6, 20, 1, 23, 13) function-extrapolation-python 1.91113 "BENCH: 1.91113209724" (2012, 6, 20, 1, 23, 38) la-vector-access-cpp 25.3921 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 20, 1, 24, 4) la-vector-assignment-cpp 24.9485 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 21, 1, 11, 9) common-progress-cpp 29.5482 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 21, 1, 11, 39) common-timing-cpp 30.4116 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 21, 1, 11, 49) fem-multicore-cpp 10.2049 "Coloring mesh." (2012, 6, 21, 1, 15, 8) fem-assembly-cpp 198.816 "Assembly for various forms and backends" (2012, 6, 21, 1, 15, 20) fem-convergence-cpp 11.9213 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 21, 1, 15, 21) fem-jit-python 0.000418019 "JIT compilation (in memory cache)" (2012, 6, 21, 1, 20, 34) fem-speedup-cpp 312.465 "Assembly/solve speedup running on 4 processors" (2012, 6, 21, 1, 20, 34) fem-speedup-cpp-assembly 5.50722 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 21, 1, 20, 34) fem-speedup-cpp-solve 2.02664 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 21, 1, 20, 57) mesh-refinement-cpp 22.11 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 21, 1, 21, 18) mesh-topology-cpp 20.644 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 21, 1, 21, 39) mesh-unitcube-cpp 21.0374 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 21, 1, 22, 22) mesh-iteration-cpp 40.3875 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 21, 1, 22, 43) function-evaluation-cpp 21.0824 "Evaluations of functions at arbitrary points." (2012, 6, 21, 1, 22, 43) function-evaluation-cpp 20.9891 "Evaluations of functions at arbitrary points." (2012, 6, 21, 1, 22, 50) function-extrapolation-python 6.75934 "BENCH: 1.9227771759" (2012, 6, 21, 1, 22, 50) function-extrapolation-python 1.92278 "BENCH: 1.9227771759" (2012, 6, 21, 1, 23, 15) la-vector-access-cpp 25.3927 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 21, 1, 23, 40) la-vector-assignment-cpp 24.9591 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 22, 1, 11, 10) common-progress-cpp 29.5883 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 22, 1, 11, 41) common-timing-cpp 30.5781 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 22, 1, 11, 51) fem-multicore-cpp 10.1749 "Coloring mesh." (2012, 6, 22, 1, 15, 10) fem-assembly-cpp 199.092 "Assembly for various forms and backends" (2012, 6, 22, 1, 15, 22) fem-convergence-cpp 11.9102 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 22, 1, 15, 23) fem-jit-python 0.000406694 "JIT compilation (in memory cache)" (2012, 6, 22, 1, 20, 36) fem-speedup-cpp 312.915 "Assembly/solve speedup running on 4 processors" (2012, 6, 22, 1, 20, 36) fem-speedup-cpp-assembly 5.51407 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 22, 1, 20, 36) fem-speedup-cpp-solve 2.01124 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 22, 1, 21, 0) mesh-refinement-cpp 22.0415 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 22, 1, 21, 21) mesh-topology-cpp 20.579 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 22, 1, 21, 42) mesh-unitcube-cpp 21.3379 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 22, 1, 22, 25) mesh-iteration-cpp 40.3935 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 22, 1, 22, 46) function-evaluation-cpp 21.3151 "Evaluations of functions at arbitrary points." (2012, 6, 22, 1, 22, 46) function-evaluation-cpp 21.2194 "Evaluations of functions at arbitrary points." (2012, 6, 22, 1, 22, 53) function-extrapolation-python 6.88405 "BENCH: 1.93112683296" (2012, 6, 22, 1, 22, 53) function-extrapolation-python 1.93113 "BENCH: 1.93112683296" (2012, 6, 22, 1, 23, 18) la-vector-access-cpp 25.3934 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 22, 1, 23, 43) la-vector-assignment-cpp 24.9475 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 23, 1, 11, 28) common-progress-cpp 29.6063 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 23, 1, 11, 58) common-timing-cpp 30.446 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 23, 1, 12, 8) fem-multicore-cpp 10.1256 "Coloring mesh." (2012, 6, 23, 1, 15, 27) fem-assembly-cpp 198.646 "Assembly for various forms and backends" (2012, 6, 23, 1, 15, 39) fem-convergence-cpp 11.9411 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 23, 1, 15, 40) fem-jit-python 0.000417185 "JIT compilation (in memory cache)" (2012, 6, 23, 1, 20, 52) fem-speedup-cpp 311.882 "Assembly/solve speedup running on 4 processors" (2012, 6, 23, 1, 20, 52) fem-speedup-cpp-assembly 5.4743 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 23, 1, 20, 52) fem-speedup-cpp-solve 2.01504 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 23, 1, 21, 16) mesh-refinement-cpp 22.124 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 23, 1, 21, 37) mesh-topology-cpp 20.568 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 23, 1, 21, 58) mesh-unitcube-cpp 21.01 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 23, 1, 22, 42) mesh-iteration-cpp 41.6568 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 23, 1, 23, 3) function-evaluation-cpp 21.5815 "Evaluations of functions at arbitrary points." (2012, 6, 23, 1, 23, 3) function-evaluation-cpp 21.4783 "Evaluations of functions at arbitrary points." (2012, 6, 23, 1, 23, 10) function-extrapolation-python 6.82318 "BENCH: 1.92148900032" (2012, 6, 23, 1, 23, 10) function-extrapolation-python 1.92149 "BENCH: 1.92148900032" (2012, 6, 23, 1, 23, 36) la-vector-access-cpp 25.3911 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 23, 1, 24, 4) la-vector-assignment-cpp 27.8442 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 24, 1, 11, 12) common-progress-cpp 29.573 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 24, 1, 11, 42) common-timing-cpp 30.3033 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 24, 1, 11, 52) fem-multicore-cpp 10.1529 "Coloring mesh." (2012, 6, 24, 1, 15, 12) fem-assembly-cpp 199.243 "Assembly for various forms and backends" (2012, 6, 24, 1, 15, 24) fem-convergence-cpp 11.9021 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 24, 1, 15, 25) fem-jit-python 0.000401711 "JIT compilation (in memory cache)" (2012, 6, 24, 1, 20, 38) fem-speedup-cpp 312.978 "Assembly/solve speedup running on 4 processors" (2012, 6, 24, 1, 20, 38) fem-speedup-cpp-assembly 5.55022 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 24, 1, 20, 38) fem-speedup-cpp-solve 2.03781 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 24, 1, 21, 1) mesh-refinement-cpp 22.1779 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 24, 1, 21, 22) mesh-topology-cpp 20.5895 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 24, 1, 21, 43) mesh-unitcube-cpp 21.0479 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 24, 1, 22, 26) mesh-iteration-cpp 40.3746 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 24, 1, 22, 48) function-evaluation-cpp 22.3893 "Evaluations of functions at arbitrary points." (2012, 6, 24, 1, 22, 48) function-evaluation-cpp 22.2908 "Evaluations of functions at arbitrary points." (2012, 6, 24, 1, 22, 55) function-extrapolation-python 6.85051 "BENCH: 1.9329020977" (2012, 6, 24, 1, 22, 55) function-extrapolation-python 1.9329 "BENCH: 1.9329020977" (2012, 6, 24, 1, 23, 21) la-vector-access-cpp 25.3882 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 24, 1, 23, 46) la-vector-assignment-cpp 24.9473 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 25, 1, 11, 10) common-progress-cpp 29.5366 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 25, 1, 11, 41) common-timing-cpp 31.157 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 25, 1, 11, 51) fem-multicore-cpp 10.1419 "Coloring mesh." (2012, 6, 25, 1, 15, 10) fem-assembly-cpp 198.689 "Assembly for various forms and backends" (2012, 6, 25, 1, 15, 22) fem-convergence-cpp 11.8499 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 25, 1, 15, 23) fem-jit-python 0.0004251 "JIT compilation (in memory cache)" (2012, 6, 25, 1, 20, 36) fem-speedup-cpp 313.241 "Assembly/solve speedup running on 4 processors" (2012, 6, 25, 1, 20, 36) fem-speedup-cpp-assembly 5.59466 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 25, 1, 20, 36) fem-speedup-cpp-solve 2.00567 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 25, 1, 21, 0) mesh-refinement-cpp 22.0802 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 25, 1, 21, 20) mesh-topology-cpp 20.597 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 25, 1, 21, 41) mesh-unitcube-cpp 21.0991 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 25, 1, 22, 24) mesh-iteration-cpp 40.3755 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 25, 1, 22, 45) function-evaluation-cpp 21.3401 "Evaluations of functions at arbitrary points." (2012, 6, 25, 1, 22, 45) function-evaluation-cpp 21.2445 "Evaluations of functions at arbitrary points." (2012, 6, 25, 1, 22, 52) function-extrapolation-python 6.74911 "BENCH: 1.9215118885" (2012, 6, 25, 1, 22, 52) function-extrapolation-python 1.92151 "BENCH: 1.9215118885" (2012, 6, 25, 1, 23, 17) la-vector-access-cpp 25.3874 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 25, 1, 23, 42) la-vector-assignment-cpp 24.9493 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 26, 1, 11, 28) common-progress-cpp 29.6136 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 26, 1, 11, 59) common-timing-cpp 30.5872 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 26, 1, 12, 9) fem-multicore-cpp 10.0909 "Coloring mesh." (2012, 6, 26, 1, 15, 25) fem-assembly-cpp 195.933 "Assembly for various forms and backends" (2012, 6, 26, 1, 15, 37) fem-convergence-cpp 11.9398 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 26, 1, 15, 38) fem-jit-python 0.000399804 "JIT compilation (in memory cache)" (2012, 6, 26, 1, 20, 49) fem-speedup-cpp 310.914 "Assembly/solve speedup running on 4 processors" (2012, 6, 26, 1, 20, 49) fem-speedup-cpp-assembly 5.58617 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 26, 1, 20, 49) fem-speedup-cpp-solve 2.03649 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 26, 1, 21, 12) mesh-refinement-cpp 22.1508 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 26, 1, 21, 33) mesh-topology-cpp 20.5792 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 26, 1, 21, 54) mesh-unitcube-cpp 21.0742 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 26, 1, 22, 38) mesh-iteration-cpp 41.0163 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 26, 1, 22, 59) function-evaluation-cpp 21.315 "Evaluations of functions at arbitrary points." (2012, 6, 26, 1, 22, 59) function-evaluation-cpp 21.219 "Evaluations of functions at arbitrary points." (2012, 6, 26, 1, 23, 6) function-extrapolation-python 6.60352 "BENCH: 1.92566514015" (2012, 6, 26, 1, 23, 6) function-extrapolation-python 1.92567 "BENCH: 1.92566514015" (2012, 6, 26, 1, 23, 31) la-vector-access-cpp 25.3865 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 26, 1, 23, 56) la-vector-assignment-cpp 24.9464 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 27, 1, 11, 25) common-progress-cpp 29.8897 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 27, 1, 11, 56) common-timing-cpp 30.6465 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 27, 1, 12, 6) fem-multicore-cpp 10.2003 "Coloring mesh." (2012, 6, 27, 1, 15, 18) fem-assembly-cpp 191.976 "Assembly for various forms and backends" (2012, 6, 27, 1, 15, 30) fem-convergence-cpp 11.9411 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 27, 1, 15, 31) fem-jit-python 0.000414991 "JIT compilation (in memory cache)" (2012, 6, 27, 1, 20, 43) fem-speedup-cpp 311.98 "Assembly/solve speedup running on 4 processors" (2012, 6, 27, 1, 20, 43) fem-speedup-cpp-assembly 5.60493 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 27, 1, 20, 43) fem-speedup-cpp-solve 1.99835 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 27, 1, 21, 7) mesh-refinement-cpp 22.0564 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 27, 1, 21, 28) mesh-topology-cpp 20.6054 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 27, 1, 21, 50) mesh-unitcube-cpp 21.7215 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 27, 1, 22, 32) mesh-iteration-cpp 40.3773 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 27, 1, 22, 53) function-evaluation-cpp 21.2317 "Evaluations of functions at arbitrary points." (2012, 6, 27, 1, 22, 53) function-evaluation-cpp 21.134 "Evaluations of functions at arbitrary points." (2012, 6, 27, 1, 23, 0) function-extrapolation-python 6.7933 "BENCH: 1.95113587379" (2012, 6, 27, 1, 23, 0) function-extrapolation-python 1.95114 "BENCH: 1.95113587379" (2012, 6, 27, 1, 23, 26) la-vector-access-cpp 25.3915 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 27, 1, 23, 54) la-vector-assignment-cpp 27.8938 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 28, 1, 11, 51) common-progress-cpp 36.4371 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 28, 1, 12, 20) common-timing-cpp 28.9524 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 28, 1, 12, 30) fem-multicore-cpp 10.0163 "Coloring mesh." (2012, 6, 28, 1, 15, 42) fem-assembly-cpp 191.767 "Assembly for various forms and backends" (2012, 6, 28, 1, 15, 54) fem-convergence-cpp 11.9488 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 28, 1, 15, 55) fem-jit-python 0.000433707 "JIT compilation (in memory cache)" (2012, 6, 28, 1, 21, 5) fem-speedup-cpp 310.174 "Assembly/solve speedup running on 4 processors" (2012, 6, 28, 1, 21, 5) fem-speedup-cpp-assembly 5.57693 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 28, 1, 21, 5) fem-speedup-cpp-solve 2.03365 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 28, 1, 21, 29) mesh-refinement-cpp 22.0733 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 28, 1, 21, 49) mesh-topology-cpp 20.4687 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 28, 1, 22, 11) mesh-unitcube-cpp 21.6383 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 28, 1, 22, 54) mesh-iteration-cpp 40.3758 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 28, 1, 23, 15) function-evaluation-cpp 21.3317 "Evaluations of functions at arbitrary points." (2012, 6, 28, 1, 23, 15) function-evaluation-cpp 21.2295 "Evaluations of functions at arbitrary points." (2012, 6, 28, 1, 23, 22) function-extrapolation-python 6.76363 "BENCH: 1.91172289848" (2012, 6, 28, 1, 23, 22) function-extrapolation-python 1.91172 "BENCH: 1.91172289848" (2012, 6, 28, 1, 23, 45) la-vector-access-cpp 22.8985 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 28, 1, 24, 10) la-vector-assignment-cpp 24.9467 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 29, 1, 16, 32) common-progress-cpp 29.6195 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 29, 1, 17, 1) common-timing-cpp 29.1329 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 29, 1, 17, 11) fem-multicore-cpp 10.0964 "Coloring mesh." (2012, 6, 29, 1, 20, 24) fem-assembly-cpp 192.598 "Assembly for various forms and backends" (2012, 6, 29, 1, 20, 36) fem-convergence-cpp 11.9221 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 29, 1, 20, 37) fem-jit-python 0.00043602 "JIT compilation (in memory cache)" (2012, 6, 29, 1, 25, 46) fem-speedup-cpp 308.68 "Assembly/solve speedup running on 4 processors" (2012, 6, 29, 1, 25, 46) fem-speedup-cpp-assembly 5.58399 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 29, 1, 25, 46) fem-speedup-cpp-solve 2.05438 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 29, 1, 26, 9) mesh-refinement-cpp 22.081 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 29, 1, 26, 30) mesh-topology-cpp 20.434 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 29, 1, 26, 52) mesh-unitcube-cpp 21.4899 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 29, 1, 27, 34) mesh-iteration-cpp 40.5043 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 29, 1, 27, 55) function-evaluation-cpp 21.1883 "Evaluations of functions at arbitrary points." (2012, 6, 29, 1, 27, 55) function-evaluation-cpp 21.0855 "Evaluations of functions at arbitrary points." (2012, 6, 29, 1, 28, 2) function-extrapolation-python 6.68353 "BENCH: 1.91109395027" (2012, 6, 29, 1, 28, 2) function-extrapolation-python 1.91109 "BENCH: 1.91109395027" (2012, 6, 29, 1, 28, 25) la-vector-access-cpp 22.8937 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 29, 1, 28, 50) la-vector-assignment-cpp 24.9483 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 6, 30, 1, 15, 40) common-progress-cpp 29.6137 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 6, 30, 1, 16, 9) common-timing-cpp 29.4747 "Timing access and registration of timings (10000000 repetitions)" (2012, 6, 30, 1, 16, 19) fem-multicore-cpp 10.049 "Coloring mesh." (2012, 6, 30, 1, 19, 32) fem-assembly-cpp 193.023 "Assembly for various forms and backends" (2012, 6, 30, 1, 19, 44) fem-convergence-cpp 11.9579 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 6, 30, 1, 19, 45) fem-jit-python 0.000429201 "JIT compilation (in memory cache)" (2012, 6, 30, 1, 25, 11) fem-speedup-cpp 326.068 "Assembly/solve speedup running on 4 processors" (2012, 6, 30, 1, 25, 11) fem-speedup-cpp-assembly 5.60321 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 6, 30, 1, 25, 11) fem-speedup-cpp-solve 1.69883 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 6, 30, 1, 25, 35) mesh-refinement-cpp 22.0917 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 6, 30, 1, 25, 55) mesh-topology-cpp 20.4268 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 6, 30, 1, 26, 17) mesh-unitcube-cpp 21.573 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 6, 30, 1, 27, 0) mesh-iteration-cpp 40.3727 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 6, 30, 1, 27, 21) function-evaluation-cpp 21.3041 "Evaluations of functions at arbitrary points." (2012, 6, 30, 1, 27, 21) function-evaluation-cpp 21.2163 "Evaluations of functions at arbitrary points." (2012, 6, 30, 1, 27, 28) function-extrapolation-python 6.70274 "BENCH: 1.90698099136" (2012, 6, 30, 1, 27, 28) function-extrapolation-python 1.90698 "BENCH: 1.90698099136" (2012, 6, 30, 1, 27, 51) la-vector-access-cpp 22.8911 "Accessing vector of size 10000000 (100 repetitions)" (2012, 6, 30, 1, 28, 16) la-vector-assignment-cpp 24.9591 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 1, 1, 15, 39) common-progress-cpp 29.6486 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 1, 1, 16, 8) common-timing-cpp 29.0547 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 1, 1, 16, 18) fem-multicore-cpp 10.2782 "Coloring mesh." (2012, 7, 1, 1, 19, 29) fem-assembly-cpp 191.057 "Assembly for various forms and backends" (2012, 7, 1, 1, 19, 41) fem-convergence-cpp 11.9412 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 1, 1, 19, 42) fem-jit-python 0.000424194 "JIT compilation (in memory cache)" (2012, 7, 1, 1, 24, 52) fem-speedup-cpp 309.605 "Assembly/solve speedup running on 4 processors" (2012, 7, 1, 1, 24, 52) fem-speedup-cpp-assembly 5.59463 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 1, 1, 24, 52) fem-speedup-cpp-solve 2.02099 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 1, 1, 25, 16) mesh-refinement-cpp 22.058 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 1, 1, 25, 36) mesh-topology-cpp 20.4891 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 1, 1, 25, 58) mesh-unitcube-cpp 21.4736 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 1, 1, 26, 40) mesh-iteration-cpp 40.3786 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 1, 1, 27, 2) function-evaluation-cpp 21.3167 "Evaluations of functions at arbitrary points." (2012, 7, 1, 1, 27, 2) function-evaluation-cpp 21.2348 "Evaluations of functions at arbitrary points." (2012, 7, 1, 1, 27, 8) function-extrapolation-python 6.6622 "BENCH: 1.90865588188" (2012, 7, 1, 1, 27, 8) function-extrapolation-python 1.90866 "BENCH: 1.90865588188" (2012, 7, 1, 1, 27, 33) la-vector-access-cpp 24.7514 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 1, 1, 27, 58) la-vector-assignment-cpp 25.0286 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 2, 1, 15, 45) common-progress-cpp 29.6133 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 2, 1, 16, 14) common-timing-cpp 29.0894 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 2, 1, 16, 24) fem-multicore-cpp 10.2739 "Coloring mesh." (2012, 7, 2, 1, 19, 37) fem-assembly-cpp 192.367 "Assembly for various forms and backends" (2012, 7, 2, 1, 19, 48) fem-convergence-cpp 11.6683 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 2, 1, 19, 49) fem-jit-python 0.000405407 "JIT compilation (in memory cache)" (2012, 7, 2, 1, 25, 4) fem-speedup-cpp 314.726 "Assembly/solve speedup running on 4 processors" (2012, 7, 2, 1, 25, 4) fem-speedup-cpp-assembly 5.63825 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 2, 1, 25, 4) fem-speedup-cpp-solve 1.95124 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 2, 1, 25, 28) mesh-refinement-cpp 22.0579 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 2, 1, 25, 48) mesh-topology-cpp 20.4115 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 2, 1, 26, 10) mesh-unitcube-cpp 21.5577 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 2, 1, 26, 55) mesh-iteration-cpp 42.8509 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 2, 1, 27, 16) function-evaluation-cpp 21.2894 "Evaluations of functions at arbitrary points." (2012, 7, 2, 1, 27, 16) function-evaluation-cpp 21.1915 "Evaluations of functions at arbitrary points." (2012, 7, 2, 1, 27, 23) function-extrapolation-python 6.6945 "BENCH: 1.90479803085" (2012, 7, 2, 1, 27, 23) function-extrapolation-python 1.9048 "BENCH: 1.90479803085" (2012, 7, 2, 1, 27, 46) la-vector-access-cpp 22.8879 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 2, 1, 28, 11) la-vector-assignment-cpp 24.9607 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 3, 1, 11, 26) common-progress-cpp 29.628 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 3, 1, 11, 55) common-timing-cpp 28.1257 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 3, 1, 15, 9) fem-assembly-cpp 194.238 "Assembly for various forms and backends" (2012, 7, 3, 1, 15, 21) fem-convergence-cpp 11.9512 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 3, 1, 15, 22) fem-jit-python 0.000419402 "JIT compilation (in memory cache)" (2012, 7, 3, 1, 20, 40) fem-speedup-cpp 317.628 "Assembly/solve speedup running on 4 processors" (2012, 7, 3, 1, 20, 40) fem-speedup-cpp-assembly 5.6005 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 3, 1, 20, 40) fem-speedup-cpp-solve 1.88693 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 3, 1, 21, 3) mesh-refinement-cpp 22.1633 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 3, 1, 21, 24) mesh-topology-cpp 20.7193 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 3, 1, 21, 46) mesh-unitcube-cpp 21.4555 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 3, 1, 22, 30) mesh-iteration-cpp 41.636 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 3, 1, 22, 51) function-evaluation-cpp 20.8499 "Evaluations of functions at arbitrary points." (2012, 7, 3, 1, 22, 51) function-evaluation-cpp 20.7684 "Evaluations of functions at arbitrary points." (2012, 7, 3, 1, 22, 58) function-extrapolation-python 6.85095 "BENCH: 1.90791702271" (2012, 7, 3, 1, 22, 58) function-extrapolation-python 1.90792 "BENCH: 1.90791702271" (2012, 7, 3, 1, 23, 20) la-vector-access-cpp 22.4229 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 3, 1, 23, 46) la-vector-assignment-cpp 25.3976 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 4, 1, 11, 30) common-progress-cpp 36.4368 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 4, 1, 11, 58) common-timing-cpp 27.9784 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 4, 1, 15, 12) fem-assembly-cpp 193.354 "Assembly for various forms and backends" (2012, 7, 4, 1, 15, 23) fem-convergence-cpp 11.9229 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 4, 1, 15, 25) fem-jit-python 0.00042851 "JIT compilation (in memory cache)" (2012, 7, 4, 1, 20, 35) fem-speedup-cpp 310.733 "Assembly/solve speedup running on 4 processors" (2012, 7, 4, 1, 20, 35) fem-speedup-cpp-assembly 5.5576 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 4, 1, 20, 35) fem-speedup-cpp-solve 2.02502 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 4, 1, 20, 59) mesh-refinement-cpp 22.0479 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 4, 1, 21, 20) mesh-topology-cpp 20.5564 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 4, 1, 21, 41) mesh-unitcube-cpp 21.4302 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 4, 1, 22, 24) mesh-iteration-cpp 40.3744 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 4, 1, 22, 45) function-evaluation-cpp 21.379 "Evaluations of functions at arbitrary points." (2012, 7, 4, 1, 22, 45) function-evaluation-cpp 21.2979 "Evaluations of functions at arbitrary points." (2012, 7, 4, 1, 22, 52) function-extrapolation-python 6.58007 "BENCH: 1.86557984352" (2012, 7, 4, 1, 22, 52) function-extrapolation-python 1.86558 "BENCH: 1.86557984352" (2012, 7, 4, 1, 23, 14) la-vector-access-cpp 22.4098 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 4, 1, 23, 40) la-vector-assignment-cpp 25.4512 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 5, 1, 11, 10) common-progress-cpp 29.7995 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 5, 1, 11, 38) common-timing-cpp 28.1751 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 5, 1, 14, 53) fem-assembly-cpp 194.588 "Assembly for various forms and backends" (2012, 7, 5, 1, 15, 5) fem-convergence-cpp 11.9151 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 5, 1, 15, 6) fem-jit-python 0.000421095 "JIT compilation (in memory cache)" (2012, 7, 5, 1, 20, 17) fem-speedup-cpp 310.645 "Assembly/solve speedup running on 4 processors" (2012, 7, 5, 1, 20, 17) fem-speedup-cpp-assembly 5.5981 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 5, 1, 20, 17) fem-speedup-cpp-solve 2.03443 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 5, 1, 20, 41) mesh-refinement-cpp 22.1465 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 5, 1, 21, 2) mesh-topology-cpp 20.6106 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 5, 1, 21, 23) mesh-unitcube-cpp 21.5178 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 5, 1, 22, 6) mesh-iteration-cpp 40.3804 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 5, 1, 22, 27) function-evaluation-cpp 21.0924 "Evaluations of functions at arbitrary points." (2012, 7, 5, 1, 22, 27) function-evaluation-cpp 21.0063 "Evaluations of functions at arbitrary points." (2012, 7, 5, 1, 22, 34) function-extrapolation-python 6.72323 "BENCH: 1.92064619064" (2012, 7, 5, 1, 22, 34) function-extrapolation-python 1.92065 "BENCH: 1.92064619064" (2012, 7, 5, 1, 22, 56) la-vector-access-cpp 22.4236 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 5, 1, 23, 22) la-vector-assignment-cpp 25.4492 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 6, 1, 11, 24) common-progress-cpp 29.6113 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 6, 1, 11, 51) common-timing-cpp 27.6632 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 6, 1, 15, 5) fem-assembly-cpp 193.551 "Assembly for various forms and backends" (2012, 7, 6, 1, 15, 17) fem-convergence-cpp 11.4544 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 6, 1, 15, 18) fem-jit-python 0.000411701 "JIT compilation (in memory cache)" (2012, 7, 6, 1, 20, 28) fem-speedup-cpp 309.882 "Assembly/solve speedup running on 4 processors" (2012, 7, 6, 1, 20, 28) fem-speedup-cpp-assembly 5.58177 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 6, 1, 20, 28) fem-speedup-cpp-solve 1.99716 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 6, 1, 20, 51) mesh-refinement-cpp 22.2273 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 6, 1, 21, 12) mesh-topology-cpp 20.6234 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 6, 1, 21, 34) mesh-unitcube-cpp 21.4828 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 6, 1, 22, 17) mesh-iteration-cpp 40.3755 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 6, 1, 22, 38) function-evaluation-cpp 20.9144 "Evaluations of functions at arbitrary points." (2012, 7, 6, 1, 22, 38) function-evaluation-cpp 20.8334 "Evaluations of functions at arbitrary points." (2012, 7, 6, 1, 22, 44) function-extrapolation-python 6.73101 "BENCH: 1.90335488319" (2012, 7, 6, 1, 22, 44) function-extrapolation-python 1.90335 "BENCH: 1.90335488319" (2012, 7, 6, 1, 23, 10) la-vector-access-cpp 25.4003 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 6, 1, 23, 35) la-vector-assignment-cpp 25.4528 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 7, 1, 14, 24) common-progress-cpp 36.4364 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 7, 1, 14, 53) common-timing-cpp 28.9885 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 7, 1, 18, 7) fem-assembly-cpp 193.739 "Assembly for various forms and backends" (2012, 7, 7, 1, 18, 19) fem-convergence-cpp 11.9366 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 7, 1, 18, 20) fem-jit-python 0.000412583 "JIT compilation (in memory cache)" (2012, 7, 7, 1, 23, 30) fem-speedup-cpp 310.244 "Assembly/solve speedup running on 4 processors" (2012, 7, 7, 1, 23, 30) fem-speedup-cpp-assembly 5.5773 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 7, 1, 23, 30) fem-speedup-cpp-solve 2.02537 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 7, 1, 23, 54) mesh-refinement-cpp 22.1877 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 7, 1, 24, 15) mesh-topology-cpp 20.5021 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 7, 1, 24, 36) mesh-unitcube-cpp 21.2574 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 7, 1, 25, 25) mesh-iteration-cpp 46.0096 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 7, 1, 25, 49) function-evaluation-cpp 24.1302 "Evaluations of functions at arbitrary points." (2012, 7, 7, 1, 25, 49) function-evaluation-cpp 24.0496 "Evaluations of functions at arbitrary points." (2012, 7, 7, 1, 25, 56) function-extrapolation-python 6.88995 "BENCH: 1.90162992477" (2012, 7, 7, 1, 25, 56) function-extrapolation-python 1.90163 "BENCH: 1.90162992477" (2012, 7, 7, 1, 26, 20) la-vector-access-cpp 24.4814 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 7, 1, 26, 46) la-vector-assignment-cpp 25.4047 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 8, 1, 13, 15) common-progress-cpp 29.6378 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 8, 1, 13, 44) common-timing-cpp 28.9003 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 8, 1, 16, 57) fem-assembly-cpp 192.965 "Assembly for various forms and backends" (2012, 7, 8, 1, 17, 8) fem-convergence-cpp 11.4697 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 8, 1, 17, 9) fem-jit-python 0.000409007 "JIT compilation (in memory cache)" (2012, 7, 8, 1, 22, 21) fem-speedup-cpp 311.156 "Assembly/solve speedup running on 4 processors" (2012, 7, 8, 1, 22, 21) fem-speedup-cpp-assembly 5.57145 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 8, 1, 22, 21) fem-speedup-cpp-solve 1.99761 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 8, 1, 22, 44) mesh-refinement-cpp 22.0935 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 8, 1, 23, 5) mesh-topology-cpp 20.5707 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 8, 1, 23, 26) mesh-unitcube-cpp 21.279 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 8, 1, 24, 9) mesh-iteration-cpp 40.376 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 8, 1, 24, 30) function-evaluation-cpp 21.2841 "Evaluations of functions at arbitrary points." (2012, 7, 8, 1, 24, 30) function-evaluation-cpp 21.2034 "Evaluations of functions at arbitrary points." (2012, 7, 8, 1, 24, 37) function-extrapolation-python 6.76327 "BENCH: 1.9202029705" (2012, 7, 8, 1, 24, 37) function-extrapolation-python 1.9202 "BENCH: 1.9202029705" (2012, 7, 8, 1, 25, 0) la-vector-access-cpp 22.42 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 8, 1, 25, 25) la-vector-assignment-cpp 25.4584 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 9, 1, 13, 19) common-progress-cpp 29.5748 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 9, 1, 13, 48) common-timing-cpp 28.6257 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 9, 1, 17, 1) fem-assembly-cpp 192.955 "Assembly for various forms and backends" (2012, 7, 9, 1, 17, 13) fem-convergence-cpp 11.9453 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 9, 1, 17, 14) fem-jit-python 0.00041399 "JIT compilation (in memory cache)" (2012, 7, 9, 1, 22, 26) fem-speedup-cpp 311.295 "Assembly/solve speedup running on 4 processors" (2012, 7, 9, 1, 22, 26) fem-speedup-cpp-assembly 5.58353 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 9, 1, 22, 26) fem-speedup-cpp-solve 2.02437 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 9, 1, 22, 49) mesh-refinement-cpp 22.1555 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 9, 1, 23, 10) mesh-topology-cpp 20.5953 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 9, 1, 23, 32) mesh-unitcube-cpp 21.3128 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 9, 1, 24, 14) mesh-iteration-cpp 40.4215 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 9, 1, 24, 36) function-evaluation-cpp 21.5272 "Evaluations of functions at arbitrary points." (2012, 7, 9, 1, 24, 36) function-evaluation-cpp 21.4467 "Evaluations of functions at arbitrary points." (2012, 7, 9, 1, 24, 43) function-extrapolation-python 6.78775 "BENCH: 1.91103196144" (2012, 7, 9, 1, 24, 43) function-extrapolation-python 1.91103 "BENCH: 1.91103196144" (2012, 7, 9, 1, 25, 6) la-vector-access-cpp 23.6291 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 9, 1, 25, 34) la-vector-assignment-cpp 27.892 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 10, 1, 14, 38) common-progress-cpp 29.5893 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 10, 1, 15, 7) common-timing-cpp 29.1217 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 10, 1, 18, 22) fem-assembly-cpp 194.469 "Assembly for various forms and backends" (2012, 7, 10, 1, 18, 34) fem-convergence-cpp 11.9089 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 10, 1, 18, 35) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2012, 7, 10, 1, 23, 44) fem-speedup-cpp 309.423 "Assembly/solve speedup running on 4 processors" (2012, 7, 10, 1, 23, 44) fem-speedup-cpp-assembly 5.66613 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 10, 1, 23, 44) fem-speedup-cpp-solve 2.03236 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 10, 1, 24, 8) mesh-refinement-cpp 22.3689 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 10, 1, 24, 29) mesh-topology-cpp 20.554 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 10, 1, 24, 50) mesh-unitcube-cpp 20.9391 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 10, 1, 25, 33) mesh-iteration-cpp 40.3767 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 10, 1, 25, 54) function-evaluation-cpp 21.2844 "Evaluations of functions at arbitrary points." (2012, 7, 10, 1, 25, 54) function-evaluation-cpp 21.2033 "Evaluations of functions at arbitrary points." (2012, 7, 10, 1, 26, 1) function-extrapolation-python 6.67263 "BENCH: 1.9172949791" (2012, 7, 10, 1, 26, 1) function-extrapolation-python 1.91729 "BENCH: 1.9172949791" (2012, 7, 10, 1, 26, 23) la-vector-access-cpp 22.427 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 10, 1, 26, 51) la-vector-assignment-cpp 27.9069 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 11, 1, 11, 47) common-progress-cpp 29.8045 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 11, 1, 12, 17) common-timing-cpp 30.0524 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 11, 1, 15, 31) fem-assembly-cpp 194.012 "Assembly for various forms and backends" (2012, 7, 11, 1, 15, 43) fem-convergence-cpp 11.9505 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 11, 1, 15, 44) fem-jit-python 0.000429821 "JIT compilation (in memory cache)" (2012, 7, 11, 1, 20, 56) fem-speedup-cpp 311.849 "Assembly/solve speedup running on 4 processors" (2012, 7, 11, 1, 20, 56) fem-speedup-cpp-assembly 5.6531 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 11, 1, 20, 56) fem-speedup-cpp-solve 2.00829 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 11, 1, 21, 20) mesh-refinement-cpp 22.3421 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 11, 1, 21, 41) mesh-topology-cpp 20.6441 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 11, 1, 22, 2) mesh-unitcube-cpp 20.9552 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 11, 1, 22, 44) mesh-iteration-cpp 40.3828 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 11, 1, 23, 6) function-evaluation-cpp 21.9723 "Evaluations of functions at arbitrary points." (2012, 7, 11, 1, 23, 6) function-evaluation-cpp 21.8829 "Evaluations of functions at arbitrary points." (2012, 7, 11, 1, 23, 13) function-extrapolation-python 6.75829 "BENCH: 1.90943789482" (2012, 7, 11, 1, 23, 13) function-extrapolation-python 1.90944 "BENCH: 1.90943789482" (2012, 7, 11, 1, 23, 38) la-vector-access-cpp 24.7412 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 11, 1, 24, 3) la-vector-assignment-cpp 25.4111 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 12, 1, 11, 53) common-progress-cpp 36.4373 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 12, 1, 12, 21) common-timing-cpp 28.5086 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 12, 1, 15, 36) fem-assembly-cpp 194.434 "Assembly for various forms and backends" (2012, 7, 12, 1, 15, 48) fem-convergence-cpp 11.5306 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 12, 1, 15, 49) fem-jit-python 0.000412893 "JIT compilation (in memory cache)" (2012, 7, 12, 1, 20, 57) fem-speedup-cpp 308.792 "Assembly/solve speedup running on 4 processors" (2012, 7, 12, 1, 20, 57) fem-speedup-cpp-assembly 5.60959 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 12, 1, 20, 57) fem-speedup-cpp-solve 2.0193 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 12, 1, 21, 21) mesh-refinement-cpp 22.4121 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 12, 1, 21, 42) mesh-topology-cpp 20.5736 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 12, 1, 22, 3) mesh-unitcube-cpp 20.93 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 12, 1, 22, 46) mesh-iteration-cpp 40.3743 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 12, 1, 23, 7) function-evaluation-cpp 21.2894 "Evaluations of functions at arbitrary points." (2012, 7, 12, 1, 23, 7) function-evaluation-cpp 21.2081 "Evaluations of functions at arbitrary points." (2012, 7, 12, 1, 23, 14) function-extrapolation-python 6.67532 "BENCH: 1.91668891907" (2012, 7, 12, 1, 23, 14) function-extrapolation-python 1.91669 "BENCH: 1.91668891907" (2012, 7, 12, 1, 23, 38) la-vector-access-cpp 23.6359 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 12, 1, 24, 3) la-vector-assignment-cpp 25.4436 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 13, 1, 11, 28) common-progress-cpp 29.6488 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 13, 1, 11, 59) common-timing-cpp 30.083 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 13, 1, 12, 9) fem-multicore-cpp 10.0839 "Coloring mesh." (2012, 7, 13, 1, 15, 22) fem-assembly-cpp 193.626 "Assembly for various forms and backends" (2012, 7, 13, 1, 15, 34) fem-convergence-cpp 11.9086 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 13, 1, 15, 35) fem-jit-python 0.000427198 "JIT compilation (in memory cache)" (2012, 7, 13, 1, 20, 45) fem-speedup-cpp 309.717 "Assembly/solve speedup running on 4 processors" (2012, 7, 13, 1, 20, 45) fem-speedup-cpp-assembly 5.63184 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 13, 1, 20, 45) fem-speedup-cpp-solve 2.04214 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 13, 1, 21, 9) mesh-refinement-cpp 22.153 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 13, 1, 21, 30) mesh-topology-cpp 20.7313 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 13, 1, 21, 51) mesh-unitcube-cpp 21.4905 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 13, 1, 22, 35) mesh-iteration-cpp 41.634 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 13, 1, 22, 56) function-evaluation-cpp 21.2933 "Evaluations of functions at arbitrary points." (2012, 7, 13, 1, 22, 56) function-evaluation-cpp 21.2119 "Evaluations of functions at arbitrary points." (2012, 7, 13, 1, 23, 3) function-extrapolation-python 6.8248 "BENCH: 1.9243979454" (2012, 7, 13, 1, 23, 3) function-extrapolation-python 1.9244 "BENCH: 1.9243979454" (2012, 7, 13, 1, 23, 26) la-vector-access-cpp 22.4081 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 13, 1, 23, 51) la-vector-assignment-cpp 25.4809 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 14, 1, 11, 14) common-progress-cpp 38.9434 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 14, 1, 11, 43) common-timing-cpp 29.3379 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 14, 1, 11, 53) fem-multicore-cpp 10.0772 "Coloring mesh." (2012, 7, 14, 1, 15, 6) fem-assembly-cpp 193.142 "Assembly for various forms and backends" (2012, 7, 14, 1, 15, 18) fem-convergence-cpp 11.8946 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 14, 1, 15, 19) fem-jit-python 0.000407195 "JIT compilation (in memory cache)" (2012, 7, 14, 1, 20, 29) fem-speedup-cpp 310.363 "Assembly/solve speedup running on 4 processors" (2012, 7, 14, 1, 20, 29) fem-speedup-cpp-assembly 5.55063 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 14, 1, 20, 29) fem-speedup-cpp-solve 2.02214 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 14, 1, 20, 53) mesh-refinement-cpp 22.1168 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 14, 1, 21, 14) mesh-topology-cpp 20.7844 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 14, 1, 21, 36) mesh-unitcube-cpp 21.3481 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 14, 1, 22, 18) mesh-iteration-cpp 40.3815 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 14, 1, 22, 40) function-evaluation-cpp 21.9608 "Evaluations of functions at arbitrary points." (2012, 7, 14, 1, 22, 40) function-evaluation-cpp 21.8798 "Evaluations of functions at arbitrary points." (2012, 7, 14, 1, 22, 47) function-extrapolation-python 6.8243 "BENCH: 1.92809700966" (2012, 7, 14, 1, 22, 47) function-extrapolation-python 1.9281 "BENCH: 1.92809700966" (2012, 7, 14, 1, 23, 10) la-vector-access-cpp 22.4038 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 14, 1, 23, 35) la-vector-assignment-cpp 25.5905 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 15, 1, 11, 14) common-progress-cpp 38.9439 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 15, 1, 11, 45) common-timing-cpp 30.8212 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 15, 1, 11, 55) fem-multicore-cpp 10.1311 "Coloring mesh." (2012, 7, 15, 1, 15, 10) fem-assembly-cpp 194.769 "Assembly for various forms and backends" (2012, 7, 15, 1, 15, 21) fem-convergence-cpp 11.8522 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 15, 1, 15, 22) fem-jit-python 0.000414014 "JIT compilation (in memory cache)" (2012, 7, 15, 1, 20, 34) fem-speedup-cpp 311.408 "Assembly/solve speedup running on 4 processors" (2012, 7, 15, 1, 20, 34) fem-speedup-cpp-assembly 5.62431 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 15, 1, 20, 34) fem-speedup-cpp-solve 2.02487 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 15, 1, 20, 58) mesh-refinement-cpp 22.0856 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 15, 1, 21, 18) mesh-topology-cpp 20.6847 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 15, 1, 21, 40) mesh-unitcube-cpp 21.4524 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 15, 1, 22, 29) mesh-iteration-cpp 46.2753 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 15, 1, 22, 50) function-evaluation-cpp 21.2861 "Evaluations of functions at arbitrary points." (2012, 7, 15, 1, 22, 50) function-evaluation-cpp 21.2044 "Evaluations of functions at arbitrary points." (2012, 7, 15, 1, 22, 57) function-extrapolation-python 6.77093 "BENCH: 1.92303419113" (2012, 7, 15, 1, 22, 57) function-extrapolation-python 1.92303 "BENCH: 1.92303419113" (2012, 7, 15, 1, 23, 22) la-vector-access-cpp 25.3831 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 15, 1, 23, 48) la-vector-assignment-cpp 25.4531 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 16, 1, 11, 11) common-progress-cpp 29.5795 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 16, 1, 11, 41) common-timing-cpp 29.7445 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 16, 1, 11, 51) fem-multicore-cpp 9.94738 "Coloring mesh." (2012, 7, 16, 1, 15, 5) fem-assembly-cpp 194.098 "Assembly for various forms and backends" (2012, 7, 16, 1, 15, 17) fem-convergence-cpp 11.9348 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 16, 1, 15, 18) fem-jit-python 0.000427079 "JIT compilation (in memory cache)" (2012, 7, 16, 1, 20, 27) fem-speedup-cpp 308.865 "Assembly/solve speedup running on 4 processors" (2012, 7, 16, 1, 20, 27) fem-speedup-cpp-assembly 5.60095 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 16, 1, 20, 27) fem-speedup-cpp-solve 2.02497 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 16, 1, 20, 50) mesh-refinement-cpp 22.1093 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 16, 1, 21, 11) mesh-topology-cpp 20.8478 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 16, 1, 21, 33) mesh-unitcube-cpp 21.4882 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 16, 1, 22, 16) mesh-iteration-cpp 40.3822 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 16, 1, 22, 37) function-evaluation-cpp 20.9776 "Evaluations of functions at arbitrary points." (2012, 7, 16, 1, 22, 37) function-evaluation-cpp 20.8962 "Evaluations of functions at arbitrary points." (2012, 7, 16, 1, 22, 43) function-extrapolation-python 6.72694 "BENCH: 1.93575787544" (2012, 7, 16, 1, 22, 43) function-extrapolation-python 1.93576 "BENCH: 1.93575787544" (2012, 7, 16, 1, 23, 6) la-vector-access-cpp 22.409 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 16, 1, 23, 31) la-vector-assignment-cpp 25.4432 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 17, 1, 11, 31) common-progress-cpp 29.6357 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 17, 1, 12, 2) common-timing-cpp 30.6584 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 17, 1, 12, 12) fem-multicore-cpp 10.0469 "Coloring mesh." (2012, 7, 17, 1, 15, 26) fem-assembly-cpp 194.112 "Assembly for various forms and backends" (2012, 7, 17, 1, 15, 38) fem-convergence-cpp 11.9217 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 17, 1, 15, 39) fem-jit-python 0.000420213 "JIT compilation (in memory cache)" (2012, 7, 17, 1, 20, 50) fem-speedup-cpp 310.945 "Assembly/solve speedup running on 4 processors" (2012, 7, 17, 1, 20, 50) fem-speedup-cpp-assembly 5.57088 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 17, 1, 20, 50) fem-speedup-cpp-solve 2.03844 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 17, 1, 21, 14) mesh-refinement-cpp 22.1577 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 17, 1, 21, 35) mesh-topology-cpp 20.764 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 17, 1, 21, 56) mesh-unitcube-cpp 21.3822 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 17, 1, 22, 39) mesh-iteration-cpp 40.3758 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 17, 1, 23, 1) function-evaluation-cpp 21.2812 "Evaluations of functions at arbitrary points." (2012, 7, 17, 1, 23, 1) function-evaluation-cpp 21.2001 "Evaluations of functions at arbitrary points." (2012, 7, 17, 1, 23, 7) function-extrapolation-python 6.7999 "BENCH: 1.92372608185" (2012, 7, 17, 1, 23, 7) function-extrapolation-python 1.92373 "BENCH: 1.92372608185" (2012, 7, 17, 1, 23, 32) la-vector-access-cpp 24.7897 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 17, 1, 23, 58) la-vector-assignment-cpp 25.4068 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 19, 1, 11, 9) common-progress-cpp 29.7868 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 19, 1, 11, 38) common-timing-cpp 28.8395 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 19, 1, 11, 48) fem-multicore-cpp 10.2752 "Coloring mesh." (2012, 7, 19, 1, 15, 3) fem-assembly-cpp 194.947 "Assembly for various forms and backends" (2012, 7, 19, 1, 15, 15) fem-convergence-cpp 11.8983 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 19, 1, 15, 16) fem-jit-python 0.000419402 "JIT compilation (in memory cache)" (2012, 7, 19, 1, 20, 25) fem-speedup-cpp 308.963 "Assembly/solve speedup running on 4 processors" (2012, 7, 19, 1, 20, 25) fem-speedup-cpp-assembly 5.60969 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 19, 1, 20, 25) fem-speedup-cpp-solve 2.03868 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 19, 1, 20, 49) mesh-refinement-cpp 22.4129 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 19, 1, 21, 10) mesh-topology-cpp 20.761 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 19, 1, 21, 32) mesh-unitcube-cpp 21.5611 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 19, 1, 22, 25) mesh-iteration-cpp 51.0275 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 19, 1, 22, 47) function-evaluation-cpp 21.5729 "Evaluations of functions at arbitrary points." (2012, 7, 19, 1, 22, 47) function-evaluation-cpp 21.4917 "Evaluations of functions at arbitrary points." (2012, 7, 19, 1, 22, 54) function-extrapolation-python 6.68494 "BENCH: 1.89506697655" (2012, 7, 19, 1, 22, 54) function-extrapolation-python 1.89507 "BENCH: 1.89506697655" (2012, 7, 19, 1, 23, 16) la-vector-access-cpp 22.4159 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 19, 1, 23, 41) la-vector-assignment-cpp 25.399 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 20, 1, 11, 8) common-progress-cpp 29.0914 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 20, 1, 11, 37) common-timing-cpp 29.2537 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 20, 1, 11, 47) fem-multicore-cpp 10.1507 "Coloring mesh." (2012, 7, 20, 1, 15, 4) fem-assembly-cpp 196.471 "Assembly for various forms and backends" (2012, 7, 20, 1, 15, 16) fem-convergence-cpp 11.8827 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 20, 1, 15, 17) fem-jit-python 0.000411892 "JIT compilation (in memory cache)" (2012, 7, 20, 1, 20, 29) fem-speedup-cpp 312.336 "Assembly/solve speedup running on 4 processors" (2012, 7, 20, 1, 20, 29) fem-speedup-cpp-assembly 5.58828 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 20, 1, 20, 29) fem-speedup-cpp-solve 2.0176 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 20, 1, 20, 53) mesh-refinement-cpp 22.4186 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 20, 1, 21, 14) mesh-topology-cpp 20.6485 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 20, 1, 21, 36) mesh-unitcube-cpp 21.7139 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 20, 1, 22, 18) mesh-iteration-cpp 40.3752 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 20, 1, 22, 40) function-evaluation-cpp 21.2835 "Evaluations of functions at arbitrary points." (2012, 7, 20, 1, 22, 40) function-evaluation-cpp 21.2025 "Evaluations of functions at arbitrary points." (2012, 7, 20, 1, 22, 47) function-extrapolation-python 6.79721 "BENCH: 1.89754605293" (2012, 7, 20, 1, 22, 47) function-extrapolation-python 1.89755 "BENCH: 1.89754605293" (2012, 7, 20, 1, 23, 11) la-vector-access-cpp 23.9353 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 20, 1, 23, 36) la-vector-assignment-cpp 25.3965 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 21, 1, 11, 32) common-progress-cpp 29.6363 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 21, 1, 12, 2) common-timing-cpp 29.8686 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 21, 1, 12, 12) fem-multicore-cpp 9.95786 "Coloring mesh." (2012, 7, 21, 1, 15, 26) fem-assembly-cpp 193.425 "Assembly for various forms and backends" (2012, 7, 21, 1, 15, 37) fem-convergence-cpp 11.9171 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 21, 1, 15, 39) fem-jit-python 0.000430417 "JIT compilation (in memory cache)" (2012, 7, 21, 1, 20, 48) fem-speedup-cpp 308.931 "Assembly/solve speedup running on 4 processors" (2012, 7, 21, 1, 20, 48) fem-speedup-cpp-assembly 5.5555 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 21, 1, 20, 48) fem-speedup-cpp-solve 2.05058 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 21, 1, 21, 11) mesh-refinement-cpp 22.3758 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 21, 1, 21, 32) mesh-topology-cpp 20.6305 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 21, 1, 21, 55) mesh-unitcube-cpp 22.3498 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 21, 1, 22, 41) mesh-iteration-cpp 43.5146 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 21, 1, 23, 2) function-evaluation-cpp 20.8254 "Evaluations of functions at arbitrary points." (2012, 7, 21, 1, 23, 2) function-evaluation-cpp 20.7446 "Evaluations of functions at arbitrary points." (2012, 7, 21, 1, 23, 8) function-extrapolation-python 6.78721 "BENCH: 1.91753196716" (2012, 7, 21, 1, 23, 8) function-extrapolation-python 1.91753 "BENCH: 1.91753196716" (2012, 7, 21, 1, 23, 31) la-vector-access-cpp 22.4287 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 21, 1, 23, 56) la-vector-assignment-cpp 25.4559 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 22, 1, 11, 31) common-progress-cpp 47.72 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 22, 1, 12, 1) common-timing-cpp 29.4317 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 22, 1, 12, 11) fem-multicore-cpp 9.94623 "Coloring mesh." (2012, 7, 22, 1, 15, 26) fem-assembly-cpp 194.897 "Assembly for various forms and backends" (2012, 7, 22, 1, 15, 37) fem-convergence-cpp 11.8542 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 22, 1, 15, 39) fem-jit-python 0.000412416 "JIT compilation (in memory cache)" (2012, 7, 22, 1, 20, 49) fem-speedup-cpp 310.132 "Assembly/solve speedup running on 4 processors" (2012, 7, 22, 1, 20, 49) fem-speedup-cpp-assembly 5.54072 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 22, 1, 20, 49) fem-speedup-cpp-solve 2.03657 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 22, 1, 21, 13) mesh-refinement-cpp 22.4339 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 22, 1, 21, 34) mesh-topology-cpp 20.6921 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 22, 1, 21, 56) mesh-unitcube-cpp 22.3722 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 22, 1, 22, 40) mesh-iteration-cpp 41.7626 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 22, 1, 23, 1) function-evaluation-cpp 20.7944 "Evaluations of functions at arbitrary points." (2012, 7, 22, 1, 23, 1) function-evaluation-cpp 20.7068 "Evaluations of functions at arbitrary points." (2012, 7, 22, 1, 23, 8) function-extrapolation-python 6.84596 "BENCH: 1.90588784218" (2012, 7, 22, 1, 23, 8) function-extrapolation-python 1.90589 "BENCH: 1.90588784218" (2012, 7, 22, 1, 23, 33) la-vector-access-cpp 25.41 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 22, 1, 23, 59) la-vector-assignment-cpp 25.4635 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 23, 1, 11, 6) common-progress-cpp 29.6032 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 23, 1, 11, 36) common-timing-cpp 29.9432 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 23, 1, 11, 46) fem-multicore-cpp 9.90192 "Coloring mesh." (2012, 7, 23, 1, 14, 59) fem-assembly-cpp 193.564 "Assembly for various forms and backends" (2012, 7, 23, 1, 15, 11) fem-convergence-cpp 11.9282 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 23, 1, 15, 12) fem-jit-python 0.000425696 "JIT compilation (in memory cache)" (2012, 7, 23, 1, 20, 23) fem-speedup-cpp 310.915 "Assembly/solve speedup running on 4 processors" (2012, 7, 23, 1, 20, 23) fem-speedup-cpp-assembly 5.57585 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 23, 1, 20, 23) fem-speedup-cpp-solve 2.00888 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 23, 1, 20, 47) mesh-refinement-cpp 22.3715 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 23, 1, 21, 8) mesh-topology-cpp 20.6325 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 23, 1, 21, 31) mesh-unitcube-cpp 22.4316 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 23, 1, 22, 14) mesh-iteration-cpp 41.0185 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 23, 1, 22, 35) function-evaluation-cpp 21.3319 "Evaluations of functions at arbitrary points." (2012, 7, 23, 1, 22, 35) function-evaluation-cpp 21.2447 "Evaluations of functions at arbitrary points." (2012, 7, 23, 1, 22, 42) function-extrapolation-python 6.82343 "BENCH: 1.93197798729" (2012, 7, 23, 1, 22, 42) function-extrapolation-python 1.93198 "BENCH: 1.93197798729" (2012, 7, 23, 1, 23, 8) la-vector-access-cpp 25.3912 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 23, 1, 23, 36) la-vector-assignment-cpp 27.9007 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 24, 1, 11, 11) common-progress-cpp 29.0819 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 24, 1, 11, 41) common-timing-cpp 29.3601 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 24, 1, 11, 51) fem-multicore-cpp 9.95028 "Coloring mesh." (2012, 7, 24, 1, 15, 5) fem-assembly-cpp 194.265 "Assembly for various forms and backends" (2012, 7, 24, 1, 15, 17) fem-convergence-cpp 11.9279 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 24, 1, 15, 18) fem-jit-python 0.000419378 "JIT compilation (in memory cache)" (2012, 7, 24, 1, 20, 30) fem-speedup-cpp 311.658 "Assembly/solve speedup running on 4 processors" (2012, 7, 24, 1, 20, 30) fem-speedup-cpp-assembly 5.49909 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 24, 1, 20, 30) fem-speedup-cpp-solve 2.05009 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 24, 1, 20, 54) mesh-refinement-cpp 22.4222 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 24, 1, 21, 15) mesh-topology-cpp 20.6787 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 24, 1, 21, 37) mesh-unitcube-cpp 22.4159 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 24, 1, 22, 25) mesh-iteration-cpp 46.0234 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 24, 1, 22, 47) function-evaluation-cpp 21.2977 "Evaluations of functions at arbitrary points." (2012, 7, 24, 1, 22, 47) function-evaluation-cpp 21.2007 "Evaluations of functions at arbitrary points." (2012, 7, 24, 1, 22, 53) function-extrapolation-python 6.86221 "BENCH: 1.92128801346" (2012, 7, 24, 1, 22, 53) function-extrapolation-python 1.92129 "BENCH: 1.92128801346" (2012, 7, 24, 1, 23, 18) la-vector-access-cpp 24.7522 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 24, 1, 23, 46) la-vector-assignment-cpp 27.8409 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 25, 1, 11, 14) common-progress-cpp 36.4356 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 25, 1, 11, 43) common-timing-cpp 29.6528 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 25, 1, 11, 53) fem-multicore-cpp 9.98029 "Coloring mesh." (2012, 7, 25, 1, 15, 7) fem-assembly-cpp 193.57 "Assembly for various forms and backends" (2012, 7, 25, 1, 15, 19) fem-convergence-cpp 11.9259 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 25, 1, 15, 20) fem-jit-python 0.000426006 "JIT compilation (in memory cache)" (2012, 7, 25, 1, 20, 31) fem-speedup-cpp 310.625 "Assembly/solve speedup running on 4 processors" (2012, 7, 25, 1, 20, 31) fem-speedup-cpp-assembly 5.55859 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 25, 1, 20, 31) fem-speedup-cpp-solve 1.99905 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 25, 1, 20, 55) mesh-refinement-cpp 22.4398 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 25, 1, 21, 15) mesh-topology-cpp 20.6706 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 25, 1, 21, 38) mesh-unitcube-cpp 22.3091 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 25, 1, 22, 22) mesh-iteration-cpp 41.6074 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 25, 1, 22, 43) function-evaluation-cpp 21.2907 "Evaluations of functions at arbitrary points." (2012, 7, 25, 1, 22, 43) function-evaluation-cpp 21.2097 "Evaluations of functions at arbitrary points." (2012, 7, 25, 1, 22, 50) function-extrapolation-python 6.70363 "BENCH: 1.9204351902" (2012, 7, 25, 1, 22, 50) function-extrapolation-python 1.92044 "BENCH: 1.9204351902" (2012, 7, 25, 1, 23, 12) la-vector-access-cpp 22.4167 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 25, 1, 23, 38) la-vector-assignment-cpp 25.3947 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 27, 1, 11, 26) common-progress-cpp 37.6901 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 27, 1, 11, 56) common-timing-cpp 30.1764 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 27, 1, 12, 6) fem-multicore-cpp 9.98826 "Coloring mesh." (2012, 7, 27, 1, 15, 19) fem-assembly-cpp 193.644 "Assembly for various forms and backends" (2012, 7, 27, 1, 15, 31) fem-convergence-cpp 11.8717 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 27, 1, 15, 32) fem-jit-python 0.00041101 "JIT compilation (in memory cache)" (2012, 7, 27, 1, 20, 42) fem-speedup-cpp 309.846 "Assembly/solve speedup running on 4 processors" (2012, 7, 27, 1, 20, 42) fem-speedup-cpp-assembly 5.65637 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 27, 1, 20, 42) fem-speedup-cpp-solve 2.04842 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 27, 1, 21, 6) mesh-refinement-cpp 22.3369 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 27, 1, 21, 27) mesh-topology-cpp 20.7088 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 27, 1, 21, 50) mesh-unitcube-cpp 22.4545 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 27, 1, 22, 32) mesh-iteration-cpp 40.3789 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 27, 1, 22, 54) function-evaluation-cpp 21.9869 "Evaluations of functions at arbitrary points." (2012, 7, 27, 1, 22, 54) function-evaluation-cpp 21.8999 "Evaluations of functions at arbitrary points." (2012, 7, 27, 1, 23, 1) function-extrapolation-python 6.73873 "BENCH: 1.90853095055" (2012, 7, 27, 1, 23, 1) function-extrapolation-python 1.90853 "BENCH: 1.90853095055" (2012, 7, 27, 1, 23, 24) la-vector-access-cpp 22.4537 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 27, 1, 23, 49) la-vector-assignment-cpp 24.9493 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 29, 1, 11, 13) common-progress-cpp 29.7298 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 29, 1, 11, 44) common-timing-cpp 30.7616 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 29, 1, 11, 54) fem-multicore-cpp 10.0131 "Coloring mesh." (2012, 7, 29, 1, 15, 7) fem-assembly-cpp 193.53 "Assembly for various forms and backends" (2012, 7, 29, 1, 15, 19) fem-convergence-cpp 11.426 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 29, 1, 15, 20) fem-jit-python 0.000416112 "JIT compilation (in memory cache)" (2012, 7, 29, 1, 20, 31) fem-speedup-cpp 311.399 "Assembly/solve speedup running on 4 processors" (2012, 7, 29, 1, 20, 31) fem-speedup-cpp-assembly 5.64124 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 29, 1, 20, 31) fem-speedup-cpp-solve 2.00606 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 29, 1, 20, 55) mesh-refinement-cpp 22.3373 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 29, 1, 21, 16) mesh-topology-cpp 20.6986 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 29, 1, 21, 38) mesh-unitcube-cpp 21.8388 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 29, 1, 22, 21) mesh-iteration-cpp 40.3855 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 29, 1, 22, 42) function-evaluation-cpp 21.3017 "Evaluations of functions at arbitrary points." (2012, 7, 29, 1, 22, 42) function-evaluation-cpp 21.2214 "Evaluations of functions at arbitrary points." (2012, 7, 29, 1, 22, 49) function-extrapolation-python 6.69555 "BENCH: 1.89014196396" (2012, 7, 29, 1, 22, 49) function-extrapolation-python 1.89014 "BENCH: 1.89014196396" (2012, 7, 29, 1, 23, 12) la-vector-access-cpp 22.4472 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 29, 1, 23, 40) la-vector-assignment-cpp 27.9015 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 30, 1, 11, 16) common-progress-cpp 29.6569 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 30, 1, 11, 47) common-timing-cpp 30.2102 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 30, 1, 11, 57) fem-multicore-cpp 9.89728 "Coloring mesh." (2012, 7, 30, 1, 15, 10) fem-assembly-cpp 193.385 "Assembly for various forms and backends" (2012, 7, 30, 1, 15, 22) fem-convergence-cpp 11.9149 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 30, 1, 15, 23) fem-jit-python 0.000411415 "JIT compilation (in memory cache)" (2012, 7, 30, 1, 20, 34) fem-speedup-cpp 310.68 "Assembly/solve speedup running on 4 processors" (2012, 7, 30, 1, 20, 34) fem-speedup-cpp-assembly 5.68593 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 30, 1, 20, 34) fem-speedup-cpp-solve 2.04506 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 30, 1, 20, 58) mesh-refinement-cpp 22.3722 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 30, 1, 21, 19) mesh-topology-cpp 20.7445 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 30, 1, 21, 40) mesh-unitcube-cpp 21.8393 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 30, 1, 22, 23) mesh-iteration-cpp 40.3795 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 30, 1, 22, 45) function-evaluation-cpp 21.3273 "Evaluations of functions at arbitrary points." (2012, 7, 30, 1, 22, 45) function-evaluation-cpp 21.2424 "Evaluations of functions at arbitrary points." (2012, 7, 30, 1, 22, 51) function-extrapolation-python 6.76534 "BENCH: 1.95725488663" (2012, 7, 30, 1, 22, 51) function-extrapolation-python 1.95725 "BENCH: 1.95725488663" (2012, 7, 30, 1, 23, 17) la-vector-access-cpp 25.4715 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 30, 1, 23, 42) la-vector-assignment-cpp 24.9598 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 7, 31, 1, 11, 28) common-progress-cpp 29.5893 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 7, 31, 1, 11, 58) common-timing-cpp 30.1016 "Timing access and registration of timings (10000000 repetitions)" (2012, 7, 31, 1, 12, 8) fem-multicore-cpp 9.93331 "Coloring mesh." (2012, 7, 31, 1, 15, 19) fem-assembly-cpp 190.548 "Assembly for various forms and backends" (2012, 7, 31, 1, 15, 31) fem-convergence-cpp 11.9473 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 7, 31, 1, 15, 32) fem-jit-python 0.000434399 "JIT compilation (in memory cache)" (2012, 7, 31, 1, 20, 42) fem-speedup-cpp 310.112 "Assembly/solve speedup running on 4 processors" (2012, 7, 31, 1, 20, 42) fem-speedup-cpp-assembly 5.56953 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 7, 31, 1, 20, 42) fem-speedup-cpp-solve 2.02464 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 7, 31, 1, 21, 6) mesh-refinement-cpp 22.5539 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 7, 31, 1, 21, 27) mesh-topology-cpp 20.7692 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 7, 31, 1, 21, 51) mesh-unitcube-cpp 23.7833 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 7, 31, 1, 22, 40) mesh-iteration-cpp 46.0126 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 7, 31, 1, 23, 1) function-evaluation-cpp 21.3054 "Evaluations of functions at arbitrary points." (2012, 7, 31, 1, 23, 1) function-evaluation-cpp 21.2248 "Evaluations of functions at arbitrary points." (2012, 7, 31, 1, 23, 8) function-extrapolation-python 6.78106 "BENCH: 1.90696597099" (2012, 7, 31, 1, 23, 8) function-extrapolation-python 1.90697 "BENCH: 1.90696597099" (2012, 7, 31, 1, 23, 37) la-vector-access-cpp 29.4313 "Accessing vector of size 10000000 (100 repetitions)" (2012, 7, 31, 1, 24, 2) la-vector-assignment-cpp 24.955 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 1, 1, 11, 17) common-progress-cpp 29.5766 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 1, 1, 11, 47) common-timing-cpp 30.4901 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 1, 1, 11, 57) fem-multicore-cpp 9.94622 "Coloring mesh." (2012, 8, 1, 1, 15, 8) fem-assembly-cpp 190.876 "Assembly for various forms and backends" (2012, 8, 1, 1, 15, 20) fem-convergence-cpp 11.8958 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 1, 1, 15, 21) fem-jit-python 0.000432014 "JIT compilation (in memory cache)" (2012, 8, 1, 1, 20, 32) fem-speedup-cpp 311.034 "Assembly/solve speedup running on 4 processors" (2012, 8, 1, 1, 20, 32) fem-speedup-cpp-assembly 5.59269 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 1, 1, 20, 32) fem-speedup-cpp-solve 2.03693 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 1, 1, 20, 56) mesh-refinement-cpp 22.598 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 1, 1, 21, 18) mesh-topology-cpp 20.8268 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 1, 1, 21, 41) mesh-unitcube-cpp 23.7219 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 1, 1, 22, 26) mesh-iteration-cpp 41.6373 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 1, 1, 22, 47) function-evaluation-cpp 21.3215 "Evaluations of functions at arbitrary points." (2012, 8, 1, 1, 22, 47) function-evaluation-cpp 21.2352 "Evaluations of functions at arbitrary points." (2012, 8, 1, 1, 22, 54) function-extrapolation-python 6.78113 "BENCH: 1.93070411682" (2012, 8, 1, 1, 22, 54) function-extrapolation-python 1.9307 "BENCH: 1.93070411682" (2012, 8, 1, 1, 23, 19) la-vector-access-cpp 25.4321 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 1, 1, 23, 47) la-vector-assignment-cpp 27.9015 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 4, 1, 11, 8) common-progress-cpp 29.5677 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 4, 1, 11, 39) common-timing-cpp 30.7567 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 4, 1, 11, 49) fem-multicore-cpp 10.0697 "Coloring mesh." (2012, 8, 4, 1, 15, 3) fem-assembly-cpp 194.446 "Assembly for various forms and backends" (2012, 8, 4, 1, 15, 15) fem-convergence-cpp 11.6303 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 4, 1, 15, 16) fem-jit-python 0.0004107 "JIT compilation (in memory cache)" (2012, 8, 4, 1, 20, 26) fem-speedup-cpp 310.251 "Assembly/solve speedup running on 4 processors" (2012, 8, 4, 1, 20, 26) fem-speedup-cpp-assembly 5.47256 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 4, 1, 20, 26) fem-speedup-cpp-solve 2.01621 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 4, 1, 20, 50) mesh-refinement-cpp 22.653 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 4, 1, 21, 11) mesh-topology-cpp 20.7198 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 4, 1, 21, 34) mesh-unitcube-cpp 22.6232 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 4, 1, 22, 17) mesh-iteration-cpp 40.3965 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 4, 1, 22, 38) function-evaluation-cpp 21.2694 "Evaluations of functions at arbitrary points." (2012, 8, 4, 1, 22, 38) function-evaluation-cpp 21.1881 "Evaluations of functions at arbitrary points." (2012, 8, 4, 1, 22, 45) function-extrapolation-python 6.82189 "BENCH: 1.91672205925" (2012, 8, 4, 1, 22, 45) function-extrapolation-python 1.91672 "BENCH: 1.91672205925" (2012, 8, 4, 1, 23, 11) la-vector-access-cpp 25.5452 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 4, 1, 23, 39) la-vector-assignment-cpp 27.9509 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 5, 1, 11, 18) common-progress-cpp 29.6033 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 5, 1, 11, 48) common-timing-cpp 30.2034 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 5, 1, 11, 58) fem-multicore-cpp 9.93131 "Coloring mesh." (2012, 8, 5, 1, 15, 12) fem-assembly-cpp 193.977 "Assembly for various forms and backends" (2012, 8, 5, 1, 15, 24) fem-convergence-cpp 11.9058 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 5, 1, 15, 25) fem-jit-python 0.000437999 "JIT compilation (in memory cache)" (2012, 8, 5, 1, 20, 36) fem-speedup-cpp 311.152 "Assembly/solve speedup running on 4 processors" (2012, 8, 5, 1, 20, 36) fem-speedup-cpp-assembly 5.60511 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 5, 1, 20, 36) fem-speedup-cpp-solve 2.02208 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 5, 1, 21, 1) mesh-refinement-cpp 22.6587 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 5, 1, 21, 22) mesh-topology-cpp 20.7138 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 5, 1, 21, 44) mesh-unitcube-cpp 22.6397 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 5, 1, 22, 27) mesh-iteration-cpp 40.3847 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 5, 1, 22, 48) function-evaluation-cpp 21.3067 "Evaluations of functions at arbitrary points." (2012, 8, 5, 1, 22, 48) function-evaluation-cpp 21.2124 "Evaluations of functions at arbitrary points." (2012, 8, 5, 1, 22, 55) function-extrapolation-python 6.80332 "BENCH: 1.91370081902" (2012, 8, 5, 1, 22, 55) function-extrapolation-python 1.9137 "BENCH: 1.91370081902" (2012, 8, 5, 1, 23, 21) la-vector-access-cpp 25.4307 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 5, 1, 23, 49) la-vector-assignment-cpp 27.9586 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 6, 1, 11, 17) common-progress-cpp 29.5685 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 6, 1, 11, 47) common-timing-cpp 29.9062 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 6, 1, 11, 57) fem-multicore-cpp 9.99407 "Coloring mesh." (2012, 8, 6, 1, 15, 10) fem-assembly-cpp 193.681 "Assembly for various forms and backends" (2012, 8, 6, 1, 15, 22) fem-convergence-cpp 11.9636 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 6, 1, 15, 24) fem-jit-python 0.000430202 "JIT compilation (in memory cache)" (2012, 8, 6, 1, 20, 34) fem-speedup-cpp 310.882 "Assembly/solve speedup running on 4 processors" (2012, 8, 6, 1, 20, 34) fem-speedup-cpp-assembly 5.53369 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 6, 1, 20, 34) fem-speedup-cpp-solve 2.02864 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 6, 1, 20, 59) mesh-refinement-cpp 22.7181 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 6, 1, 21, 20) mesh-topology-cpp 20.722 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 6, 1, 21, 42) mesh-unitcube-cpp 22.6194 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 6, 1, 22, 25) mesh-iteration-cpp 40.3834 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 6, 1, 22, 46) function-evaluation-cpp 21.0041 "Evaluations of functions at arbitrary points." (2012, 8, 6, 1, 22, 46) function-evaluation-cpp 20.9226 "Evaluations of functions at arbitrary points." (2012, 8, 6, 1, 22, 53) function-extrapolation-python 6.84373 "BENCH: 1.9204390049" (2012, 8, 6, 1, 22, 53) function-extrapolation-python 1.92044 "BENCH: 1.9204390049" (2012, 8, 6, 1, 23, 20) la-vector-access-cpp 27.4338 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 6, 1, 23, 48) la-vector-assignment-cpp 27.9573 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 7, 1, 11, 34) common-progress-cpp 29.6532 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 7, 1, 12, 4) common-timing-cpp 30.5249 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 7, 1, 12, 14) fem-multicore-cpp 10.0167 "Coloring mesh." (2012, 8, 7, 1, 15, 29) fem-assembly-cpp 194.051 "Assembly for various forms and backends" (2012, 8, 7, 1, 15, 40) fem-convergence-cpp 11.9458 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 7, 1, 15, 42) fem-jit-python 0.000429392 "JIT compilation (in memory cache)" (2012, 8, 7, 1, 20, 51) fem-speedup-cpp 309.81 "Assembly/solve speedup running on 4 processors" (2012, 8, 7, 1, 20, 51) fem-speedup-cpp-assembly 5.52202 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 7, 1, 20, 51) fem-speedup-cpp-solve 2.03811 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 7, 1, 21, 16) mesh-refinement-cpp 22.5951 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 7, 1, 21, 36) mesh-topology-cpp 20.7318 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 7, 1, 21, 59) mesh-unitcube-cpp 22.6861 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 7, 1, 22, 42) mesh-iteration-cpp 40.3973 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 7, 1, 23, 3) function-evaluation-cpp 20.9564 "Evaluations of functions at arbitrary points." (2012, 8, 7, 1, 23, 3) function-evaluation-cpp 20.8654 "Evaluations of functions at arbitrary points." (2012, 8, 7, 1, 23, 10) function-extrapolation-python 6.78835 "BENCH: 1.91855502129" (2012, 8, 7, 1, 23, 10) function-extrapolation-python 1.91856 "BENCH: 1.91855502129" (2012, 8, 7, 1, 23, 38) la-vector-access-cpp 28.4729 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 7, 1, 24, 6) la-vector-assignment-cpp 27.9488 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 8, 1, 11, 18) common-progress-cpp 29.6504 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 8, 1, 11, 48) common-timing-cpp 29.8586 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 8, 1, 11, 58) fem-multicore-cpp 9.92846 "Coloring mesh." (2012, 8, 8, 1, 15, 12) fem-assembly-cpp 194.148 "Assembly for various forms and backends" (2012, 8, 8, 1, 15, 24) fem-convergence-cpp 11.9317 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 8, 1, 15, 25) fem-jit-python 0.000427699 "JIT compilation (in memory cache)" (2012, 8, 8, 1, 20, 36) fem-speedup-cpp 311.619 "Assembly/solve speedup running on 4 processors" (2012, 8, 8, 1, 20, 36) fem-speedup-cpp-assembly 5.56895 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 8, 1, 20, 36) fem-speedup-cpp-solve 2.01393 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 8, 1, 21, 1) mesh-refinement-cpp 22.6399 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 8, 1, 21, 22) mesh-topology-cpp 20.7521 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 8, 1, 21, 44) mesh-unitcube-cpp 22.5742 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 8, 1, 22, 27) mesh-iteration-cpp 40.3871 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 8, 1, 22, 48) function-evaluation-cpp 21.1572 "Evaluations of functions at arbitrary points." (2012, 8, 8, 1, 22, 48) function-evaluation-cpp 21.0703 "Evaluations of functions at arbitrary points." (2012, 8, 8, 1, 22, 55) function-extrapolation-python 6.75318 "BENCH: 1.91586899757" (2012, 8, 8, 1, 22, 55) function-extrapolation-python 1.91587 "BENCH: 1.91586899757" (2012, 8, 8, 1, 23, 23) la-vector-access-cpp 27.4304 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 8, 1, 23, 51) la-vector-assignment-cpp 28.0375 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 9, 1, 11, 32) common-progress-cpp 29.1688 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 9, 1, 12, 1) common-timing-cpp 29.1207 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 9, 1, 12, 11) fem-multicore-cpp 10.0195 "Coloring mesh." (2012, 8, 9, 1, 15, 24) fem-assembly-cpp 192.693 "Assembly for various forms and backends" (2012, 8, 9, 1, 15, 36) fem-convergence-cpp 11.9155 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 9, 1, 15, 37) fem-jit-python 0.000408816 "JIT compilation (in memory cache)" (2012, 8, 9, 1, 20, 47) fem-speedup-cpp 310.15 "Assembly/solve speedup running on 4 processors" (2012, 8, 9, 1, 20, 47) fem-speedup-cpp-assembly 5.67568 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 9, 1, 20, 47) fem-speedup-cpp-solve 2.03949 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 9, 1, 21, 11) mesh-refinement-cpp 22.3792 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 9, 1, 21, 32) mesh-topology-cpp 20.7918 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 9, 1, 21, 54) mesh-unitcube-cpp 21.6439 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 9, 1, 22, 36) mesh-iteration-cpp 40.4397 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 9, 1, 22, 58) function-evaluation-cpp 21.4014 "Evaluations of functions at arbitrary points." (2012, 8, 9, 1, 22, 58) function-evaluation-cpp 21.3149 "Evaluations of functions at arbitrary points." (2012, 8, 9, 1, 23, 5) function-extrapolation-python 6.76052 "BENCH: 1.9006588459" (2012, 8, 9, 1, 23, 5) function-extrapolation-python 1.90066 "BENCH: 1.9006588459" (2012, 8, 9, 1, 23, 29) la-vector-access-cpp 23.8692 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 9, 1, 23, 54) la-vector-assignment-cpp 24.9677 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 10, 1, 11, 18) common-progress-cpp 29.5915 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 10, 1, 11, 45) common-timing-cpp 27.8588 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 10, 1, 11, 55) fem-multicore-cpp 9.97277 "Coloring mesh." (2012, 8, 10, 1, 15, 9) fem-assembly-cpp 193.462 "Assembly for various forms and backends" (2012, 8, 10, 1, 15, 21) fem-convergence-cpp 11.9182 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 10, 1, 15, 22) fem-jit-python 0.000425386 "JIT compilation (in memory cache)" (2012, 8, 10, 1, 20, 33) fem-speedup-cpp 311.223 "Assembly/solve speedup running on 4 processors" (2012, 8, 10, 1, 20, 33) fem-speedup-cpp-assembly 5.55217 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 10, 1, 20, 33) fem-speedup-cpp-solve 2.00544 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 10, 1, 20, 57) mesh-refinement-cpp 22.3538 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 10, 1, 21, 18) mesh-topology-cpp 20.7157 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 10, 1, 21, 40) mesh-unitcube-cpp 21.6796 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 10, 1, 22, 22) mesh-iteration-cpp 40.4225 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 10, 1, 22, 44) function-evaluation-cpp 21.3058 "Evaluations of functions at arbitrary points." (2012, 8, 10, 1, 22, 44) function-evaluation-cpp 21.2198 "Evaluations of functions at arbitrary points." (2012, 8, 10, 1, 22, 51) function-extrapolation-python 6.70799 "BENCH: 1.86585593224" (2012, 8, 10, 1, 22, 51) function-extrapolation-python 1.86586 "BENCH: 1.86585593224" (2012, 8, 10, 1, 23, 15) la-vector-access-cpp 24.0826 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 10, 1, 23, 43) la-vector-assignment-cpp 27.9036 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 11, 1, 11, 37) common-progress-cpp 29.6069 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 11, 1, 12, 7) common-timing-cpp 29.5002 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 11, 1, 12, 17) fem-multicore-cpp 9.94934 "Coloring mesh." (2012, 8, 11, 1, 15, 29) fem-assembly-cpp 192.373 "Assembly for various forms and backends" (2012, 8, 11, 1, 15, 41) fem-convergence-cpp 11.8973 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 11, 1, 15, 42) fem-jit-python 0.000414801 "JIT compilation (in memory cache)" (2012, 8, 11, 1, 20, 54) fem-speedup-cpp 311.356 "Assembly/solve speedup running on 4 processors" (2012, 8, 11, 1, 20, 54) fem-speedup-cpp-assembly 5.59887 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 11, 1, 20, 54) fem-speedup-cpp-solve 2.00801 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 11, 1, 21, 17) mesh-refinement-cpp 22.2398 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 11, 1, 21, 38) mesh-topology-cpp 20.7689 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 11, 1, 22, 0) mesh-unitcube-cpp 21.4631 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 11, 1, 22, 43) mesh-iteration-cpp 40.371 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 11, 1, 23, 4) function-evaluation-cpp 21.3375 "Evaluations of functions at arbitrary points." (2012, 8, 11, 1, 23, 4) function-evaluation-cpp 21.2513 "Evaluations of functions at arbitrary points." (2012, 8, 11, 1, 23, 11) function-extrapolation-python 6.60068 "BENCH: 1.86741900444" (2012, 8, 11, 1, 23, 11) function-extrapolation-python 1.86742 "BENCH: 1.86741900444" (2012, 8, 11, 1, 23, 33) la-vector-access-cpp 22.4522 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 11, 1, 23, 58) la-vector-assignment-cpp 24.9455 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 12, 1, 11, 24) common-progress-cpp 36.4359 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 12, 1, 11, 53) common-timing-cpp 29.4811 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 12, 1, 12, 3) fem-multicore-cpp 10.004 "Coloring mesh." (2012, 8, 12, 1, 15, 16) fem-assembly-cpp 192.329 "Assembly for various forms and backends" (2012, 8, 12, 1, 15, 28) fem-convergence-cpp 11.9107 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 12, 1, 15, 29) fem-jit-python 0.000414395 "JIT compilation (in memory cache)" (2012, 8, 12, 1, 20, 39) fem-speedup-cpp 310.181 "Assembly/solve speedup running on 4 processors" (2012, 8, 12, 1, 20, 39) fem-speedup-cpp-assembly 5.57826 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 12, 1, 20, 39) fem-speedup-cpp-solve 2.04047 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 12, 1, 21, 3) mesh-refinement-cpp 22.2584 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 12, 1, 21, 24) mesh-topology-cpp 20.7387 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 12, 1, 21, 45) mesh-unitcube-cpp 21.4504 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 12, 1, 22, 28) mesh-iteration-cpp 40.3731 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 12, 1, 22, 49) function-evaluation-cpp 21.3378 "Evaluations of functions at arbitrary points." (2012, 8, 12, 1, 22, 49) function-evaluation-cpp 21.2573 "Evaluations of functions at arbitrary points." (2012, 8, 12, 1, 22, 56) function-extrapolation-python 6.74439 "BENCH: 1.90518307686" (2012, 8, 12, 1, 22, 56) function-extrapolation-python 1.90518 "BENCH: 1.90518307686" (2012, 8, 12, 1, 23, 21) la-vector-access-cpp 25.4743 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 12, 1, 23, 46) la-vector-assignment-cpp 24.9611 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 13, 1, 11, 21) common-progress-cpp 29.6003 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 13, 1, 11, 50) common-timing-cpp 29.0404 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 13, 1, 12, 0) fem-multicore-cpp 9.9726 "Coloring mesh." (2012, 8, 13, 1, 15, 13) fem-assembly-cpp 192.972 "Assembly for various forms and backends" (2012, 8, 13, 1, 15, 25) fem-convergence-cpp 11.92 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 13, 1, 15, 26) fem-jit-python 0.000420594 "JIT compilation (in memory cache)" (2012, 8, 13, 1, 20, 36) fem-speedup-cpp 309.958 "Assembly/solve speedup running on 4 processors" (2012, 8, 13, 1, 20, 36) fem-speedup-cpp-assembly 5.61779 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 13, 1, 20, 36) fem-speedup-cpp-solve 2.0242 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 13, 1, 21, 0) mesh-refinement-cpp 22.2323 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 13, 1, 21, 21) mesh-topology-cpp 20.7578 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 13, 1, 21, 43) mesh-unitcube-cpp 21.5205 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 13, 1, 22, 34) mesh-iteration-cpp 48.5982 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 13, 1, 22, 55) function-evaluation-cpp 21.3066 "Evaluations of functions at arbitrary points." (2012, 8, 13, 1, 22, 55) function-evaluation-cpp 21.2036 "Evaluations of functions at arbitrary points." (2012, 8, 13, 1, 23, 2) function-extrapolation-python 6.74164 "BENCH: 1.91136407852" (2012, 8, 13, 1, 23, 2) function-extrapolation-python 1.91136 "BENCH: 1.91136407852" (2012, 8, 13, 1, 23, 24) la-vector-access-cpp 22.4569 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 13, 1, 23, 52) la-vector-assignment-cpp 27.8951 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 14, 1, 11, 22) common-progress-cpp 29.8172 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 14, 1, 11, 51) common-timing-cpp 29.0471 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 14, 1, 12, 1) fem-multicore-cpp 10.0125 "Coloring mesh." (2012, 8, 14, 1, 15, 13) fem-assembly-cpp 192.687 "Assembly for various forms and backends" (2012, 8, 14, 1, 15, 25) fem-convergence-cpp 11.8924 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 14, 1, 15, 26) fem-jit-python 0.000396609 "JIT compilation (in memory cache)" (2012, 8, 14, 1, 20, 35) fem-speedup-cpp 308.327 "Assembly/solve speedup running on 4 processors" (2012, 8, 14, 1, 20, 35) fem-speedup-cpp-assembly 5.6104 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 14, 1, 20, 35) fem-speedup-cpp-solve 2.04878 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 14, 1, 20, 59) mesh-refinement-cpp 22.2217 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 14, 1, 21, 19) mesh-topology-cpp 20.5416 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 14, 1, 21, 41) mesh-unitcube-cpp 21.506 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 14, 1, 22, 26) mesh-iteration-cpp 42.5484 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 14, 1, 22, 47) function-evaluation-cpp 21.3132 "Evaluations of functions at arbitrary points." (2012, 8, 14, 1, 22, 47) function-evaluation-cpp 21.2102 "Evaluations of functions at arbitrary points." (2012, 8, 14, 1, 23, 2) function-extrapolation-python 15.1869 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 8, 14, 1, 23, 2) function-extrapolation-python 1.92276 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 8, 14, 1, 23, 25) la-vector-access-cpp 22.4531 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 14, 1, 23, 50) la-vector-assignment-cpp 24.8936 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 15, 1, 11, 11) common-progress-cpp 29.8187 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 15, 1, 11, 39) common-timing-cpp 27.9404 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 15, 1, 11, 49) fem-multicore-cpp 9.91794 "Coloring mesh." (2012, 8, 15, 1, 15, 1) fem-assembly-cpp 192.054 "Assembly for various forms and backends" (2012, 8, 15, 1, 15, 13) fem-convergence-cpp 11.9179 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 15, 1, 15, 14) fem-jit-python 0.000404501 "JIT compilation (in memory cache)" (2012, 8, 15, 1, 20, 35) fem-speedup-cpp 320.661 "Assembly/solve speedup running on 4 processors" (2012, 8, 15, 1, 20, 35) fem-speedup-cpp-assembly 5.64051 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 15, 1, 20, 35) fem-speedup-cpp-solve 1.80935 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 15, 1, 20, 59) mesh-refinement-cpp 22.2428 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 15, 1, 21, 20) mesh-topology-cpp 20.637 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 15, 1, 21, 41) mesh-unitcube-cpp 21.498 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 15, 1, 22, 30) mesh-iteration-cpp 46.0084 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 15, 1, 22, 51) function-evaluation-cpp 21.4559 "Evaluations of functions at arbitrary points." (2012, 8, 15, 1, 22, 51) function-evaluation-cpp 21.3534 "Evaluations of functions at arbitrary points." (2012, 8, 15, 1, 22, 58) function-extrapolation-python 6.69634 "BENCH: 1.90821099281" (2012, 8, 15, 1, 22, 58) function-extrapolation-python 1.90821 "BENCH: 1.90821099281" (2012, 8, 15, 1, 23, 20) la-vector-access-cpp 22.4478 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 15, 1, 23, 48) la-vector-assignment-cpp 27.9062 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 16, 1, 11, 13) common-progress-cpp 29.5439 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 16, 1, 11, 43) common-timing-cpp 29.4157 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 16, 1, 11, 52) fem-multicore-cpp 9.91404 "Coloring mesh." (2012, 8, 16, 1, 15, 5) fem-assembly-cpp 192.963 "Assembly for various forms and backends" (2012, 8, 16, 1, 15, 17) fem-convergence-cpp 11.895 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 16, 1, 15, 18) fem-jit-python 0.0004107 "JIT compilation (in memory cache)" (2012, 8, 16, 1, 20, 38) fem-speedup-cpp 319.618 "Assembly/solve speedup running on 4 processors" (2012, 8, 16, 1, 20, 38) fem-speedup-cpp-assembly 5.57104 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 16, 1, 20, 38) fem-speedup-cpp-solve 1.839 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 16, 1, 21, 2) mesh-refinement-cpp 22.1943 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 16, 1, 21, 23) mesh-topology-cpp 20.5452 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 16, 1, 21, 44) mesh-unitcube-cpp 20.9311 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 16, 1, 22, 26) mesh-iteration-cpp 40.3767 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 16, 1, 22, 48) function-evaluation-cpp 21.3144 "Evaluations of functions at arbitrary points." (2012, 8, 16, 1, 22, 48) function-evaluation-cpp 21.2126 "Evaluations of functions at arbitrary points." (2012, 8, 16, 1, 22, 54) function-extrapolation-python 6.81123 "BENCH: 1.90908384323" (2012, 8, 16, 1, 22, 54) function-extrapolation-python 1.90908 "BENCH: 1.90908384323" (2012, 8, 16, 1, 23, 17) la-vector-access-cpp 22.4566 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 16, 1, 23, 42) la-vector-assignment-cpp 24.9612 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 17, 1, 11, 16) common-progress-cpp 29.6005 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 17, 1, 11, 45) common-timing-cpp 29.2083 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 17, 1, 11, 55) fem-multicore-cpp 10.0308 "Coloring mesh." (2012, 8, 17, 1, 15, 7) fem-assembly-cpp 191.725 "Assembly for various forms and backends" (2012, 8, 17, 1, 15, 19) fem-convergence-cpp 11.8967 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 17, 1, 15, 20) fem-jit-python 0.000408387 "JIT compilation (in memory cache)" (2012, 8, 17, 1, 20, 39) fem-speedup-cpp 319.603 "Assembly/solve speedup running on 4 processors" (2012, 8, 17, 1, 20, 39) fem-speedup-cpp-assembly 5.57295 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 17, 1, 20, 39) fem-speedup-cpp-solve 1.83149 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 17, 1, 21, 3) mesh-refinement-cpp 22.1609 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 17, 1, 21, 24) mesh-topology-cpp 20.6038 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 17, 1, 21, 45) mesh-unitcube-cpp 20.8285 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 17, 1, 22, 31) mesh-iteration-cpp 43.4951 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 17, 1, 22, 52) function-evaluation-cpp 21.3142 "Evaluations of functions at arbitrary points." (2012, 8, 17, 1, 22, 52) function-evaluation-cpp 21.2279 "Evaluations of functions at arbitrary points." (2012, 8, 17, 1, 22, 59) function-extrapolation-python 6.89417 "BENCH: 1.92462897301" (2012, 8, 17, 1, 22, 59) function-extrapolation-python 1.92463 "BENCH: 1.92462897301" (2012, 8, 17, 1, 23, 24) la-vector-access-cpp 25.4594 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 17, 1, 23, 49) la-vector-assignment-cpp 24.9556 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 24, 1, 11, 1) common-progress-cpp 29.8743 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 24, 1, 11, 30) common-timing-cpp 28.658 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 24, 4, 6, 34) fem-multicore-cpp 10504.5 "Coloring mesh." (2012, 8, 24, 4, 9, 48) fem-assembly-cpp 193.646 "Assembly for various forms and backends" (2012, 8, 24, 4, 10, 0) fem-convergence-cpp 11.7719 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 24, 4, 10, 5) fem-jit-python 0.000407386 "JIT compilation (in memory cache)" (2012, 8, 24, 4, 15, 23) fem-speedup-cpp 317.976 "Assembly/solve speedup running on 4 processors" (2012, 8, 24, 4, 15, 23) fem-speedup-cpp-assembly 5.44423 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 24, 4, 15, 23) fem-speedup-cpp-solve 1.91317 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 24, 4, 15, 47) mesh-refinement-cpp 22.2461 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 24, 4, 16, 8) mesh-topology-cpp 20.7809 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 24, 4, 16, 29) mesh-unitcube-cpp 21.0413 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 24, 4, 17, 12) mesh-iteration-cpp 41.641 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 24, 4, 17, 34) function-evaluation-cpp 21.5348 "Evaluations of functions at arbitrary points." (2012, 8, 24, 4, 17, 34) function-evaluation-cpp 21.4538 "Evaluations of functions at arbitrary points." (2012, 8, 24, 4, 17, 40) function-extrapolation-python 6.50722 "BENCH: 1.90129494667" (2012, 8, 24, 4, 17, 40) function-extrapolation-python 1.90129 "BENCH: 1.90129494667" (2012, 8, 24, 4, 18, 4) la-vector-access-cpp 23.8915 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 24, 4, 18, 32) la-vector-assignment-cpp 27.9114 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 25, 1, 11, 21) common-progress-cpp 29.5834 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 25, 1, 11, 50) common-timing-cpp 29.3365 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 25, 3, 58, 20) fem-multicore-cpp 9989.49 "Coloring mesh." (2012, 8, 25, 4, 1, 36) fem-assembly-cpp 195.508 "Assembly for various forms and backends" (2012, 8, 25, 4, 1, 48) fem-convergence-cpp 11.8139 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 25, 4, 1, 53) fem-jit-python 0.000408888 "JIT compilation (in memory cache)" (2012, 8, 25, 4, 7, 9) fem-speedup-cpp 316.274 "Assembly/solve speedup running on 4 processors" (2012, 8, 25, 4, 7, 9) fem-speedup-cpp-assembly 5.47493 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 25, 4, 7, 9) fem-speedup-cpp-solve 1.91709 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 25, 4, 7, 33) mesh-refinement-cpp 22.4666 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 25, 4, 7, 54) mesh-topology-cpp 20.9077 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 25, 4, 8, 15) mesh-unitcube-cpp 21.3295 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 25, 4, 8, 58) mesh-iteration-cpp 40.5254 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 25, 4, 9, 20) function-evaluation-cpp 21.1887 "Evaluations of functions at arbitrary points." (2012, 8, 25, 4, 9, 20) function-evaluation-cpp 21.1076 "Evaluations of functions at arbitrary points." (2012, 8, 25, 4, 9, 26) function-extrapolation-python 6.45974 "BENCH: 1.93025588989" (2012, 8, 25, 4, 9, 26) function-extrapolation-python 1.93026 "BENCH: 1.93025588989" (2012, 8, 25, 4, 9, 49) la-vector-access-cpp 22.4612 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 25, 4, 10, 17) la-vector-assignment-cpp 27.9046 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 26, 1, 10, 58) common-progress-cpp 29.578 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 26, 1, 11, 26) common-timing-cpp 28.554 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 26, 4, 29, 28) fem-multicore-cpp 11882.1 "Coloring mesh." (2012, 8, 26, 4, 32, 43) fem-assembly-cpp 195.024 "Assembly for various forms and backends" (2012, 8, 26, 4, 32, 55) fem-convergence-cpp 11.769 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 26, 4, 33, 0) fem-jit-python 0.000400996 "JIT compilation (in memory cache)" (2012, 8, 26, 4, 38, 28) fem-speedup-cpp 328.448 "Assembly/solve speedup running on 4 processors" (2012, 8, 26, 4, 38, 28) fem-speedup-cpp-assembly 5.46016 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 26, 4, 38, 28) fem-speedup-cpp-solve 1.67566 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 26, 4, 38, 52) mesh-refinement-cpp 22.4752 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 26, 4, 39, 13) mesh-topology-cpp 20.8396 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 26, 4, 39, 35) mesh-unitcube-cpp 21.3037 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 26, 4, 40, 17) mesh-iteration-cpp 40.3935 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 26, 4, 40, 39) function-evaluation-cpp 21.3049 "Evaluations of functions at arbitrary points." (2012, 8, 26, 4, 40, 39) function-evaluation-cpp 21.2185 "Evaluations of functions at arbitrary points." (2012, 8, 26, 4, 40, 45) function-extrapolation-python 6.57617 "BENCH: 1.90819191933" (2012, 8, 26, 4, 40, 45) function-extrapolation-python 1.90819 "BENCH: 1.90819191933" (2012, 8, 26, 4, 41, 9) la-vector-access-cpp 23.8171 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 26, 4, 41, 34) la-vector-assignment-cpp 24.9598 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 27, 1, 11, 22) common-progress-cpp 29.5425 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 27, 1, 11, 51) common-timing-cpp 28.8016 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 27, 4, 15, 43) fem-multicore-cpp 11032.2 "Coloring mesh." (2012, 8, 27, 4, 18, 59) fem-assembly-cpp 195.105 "Assembly for various forms and backends" (2012, 8, 27, 4, 19, 10) fem-convergence-cpp 11.7484 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 27, 4, 19, 15) fem-jit-python 0.000409412 "JIT compilation (in memory cache)" (2012, 8, 27, 4, 24, 31) fem-speedup-cpp 315.887 "Assembly/solve speedup running on 4 processors" (2012, 8, 27, 4, 24, 31) fem-speedup-cpp-assembly 5.48086 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 27, 4, 24, 31) fem-speedup-cpp-solve 1.91503 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 27, 4, 24, 55) mesh-refinement-cpp 22.1121 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 27, 4, 25, 16) mesh-topology-cpp 20.5943 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 27, 4, 25, 38) mesh-unitcube-cpp 21.4914 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 27, 4, 26, 20) mesh-iteration-cpp 40.3717 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 27, 4, 26, 42) function-evaluation-cpp 21.4769 "Evaluations of functions at arbitrary points." (2012, 8, 27, 4, 26, 42) function-evaluation-cpp 21.3843 "Evaluations of functions at arbitrary points." (2012, 8, 27, 4, 26, 48) function-extrapolation-python 5.95758 "BENCH: 1.89759898186" (2012, 8, 27, 4, 26, 48) function-extrapolation-python 1.8976 "BENCH: 1.89759898186" (2012, 8, 27, 4, 27, 11) la-vector-access-cpp 23.7317 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 27, 4, 27, 36) la-vector-assignment-cpp 24.9449 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 28, 1, 11, 2) common-progress-cpp 29.1471 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 28, 1, 11, 32) common-timing-cpp 29.5819 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 28, 4, 34, 44) fem-multicore-cpp 12192.2 "Coloring mesh." (2012, 8, 28, 4, 37, 58) fem-assembly-cpp 193.658 "Assembly for various forms and backends" (2012, 8, 28, 4, 38, 9) fem-convergence-cpp 11.7615 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 28, 4, 38, 14) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2012, 8, 28, 4, 43, 31) fem-speedup-cpp 316.501 "Assembly/solve speedup running on 4 processors" (2012, 8, 28, 4, 43, 31) fem-speedup-cpp-assembly 5.5541 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 28, 4, 43, 31) fem-speedup-cpp-solve 1.90491 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 28, 4, 43, 54) mesh-refinement-cpp 22.0557 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 28, 4, 44, 15) mesh-topology-cpp 20.5836 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 28, 4, 44, 37) mesh-unitcube-cpp 21.3962 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 28, 4, 45, 20) mesh-iteration-cpp 40.4135 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 28, 4, 45, 41) function-evaluation-cpp 21.6928 "Evaluations of functions at arbitrary points." (2012, 8, 28, 4, 45, 41) function-evaluation-cpp 21.5991 "Evaluations of functions at arbitrary points." (2012, 8, 28, 4, 45, 52) function-extrapolation-python 11.0376 "BENCH: 2.02043700218" (2012, 8, 28, 4, 45, 52) function-extrapolation-python 2.02044 "BENCH: 2.02043700218" (2012, 8, 28, 4, 46, 16) la-vector-access-cpp 23.7492 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 28, 4, 46, 41) la-vector-assignment-cpp 24.9605 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 29, 1, 10, 56) common-progress-cpp 29.5577 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 29, 1, 11, 25) common-timing-cpp 28.878 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 29, 4, 9, 22) fem-multicore-cpp 10676.2 "Coloring mesh." (2012, 8, 29, 4, 12, 36) fem-assembly-cpp 193.966 "Assembly for various forms and backends" (2012, 8, 29, 4, 12, 48) fem-convergence-cpp 11.7888 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 29, 4, 12, 53) fem-jit-python 0.000405383 "JIT compilation (in memory cache)" (2012, 8, 29, 4, 18, 9) fem-speedup-cpp 316.449 "Assembly/solve speedup running on 4 processors" (2012, 8, 29, 4, 18, 9) fem-speedup-cpp-assembly 5.53233 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 29, 4, 18, 9) fem-speedup-cpp-solve 1.93681 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 29, 4, 18, 33) mesh-refinement-cpp 22.1238 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 29, 4, 18, 53) mesh-topology-cpp 20.5463 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 29, 4, 19, 15) mesh-unitcube-cpp 21.4682 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 29, 4, 19, 58) mesh-iteration-cpp 40.3799 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 29, 4, 20, 19) function-evaluation-cpp 21.3564 "Evaluations of functions at arbitrary points." (2012, 8, 29, 4, 20, 19) function-evaluation-cpp 21.2693 "Evaluations of functions at arbitrary points." (2012, 8, 29, 4, 20, 26) function-extrapolation-python 6.59316 "BENCH: 1.92814803123" (2012, 8, 29, 4, 20, 26) function-extrapolation-python 1.92815 "BENCH: 1.92814803123" (2012, 8, 29, 4, 20, 48) la-vector-access-cpp 22.453 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 29, 4, 21, 13) la-vector-assignment-cpp 24.9591 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 30, 1, 11, 25) common-progress-cpp 29.6086 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 30, 1, 11, 55) common-timing-cpp 30.4986 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 30, 19, 31, 31) fem-multicore-cpp 65975.9 "Coloring mesh." (2012, 8, 30, 19, 37, 30) fem-assembly-cpp 358.629 "Assembly for various forms and backends" (2012, 8, 30, 19, 37, 43) fem-convergence-cpp 13.3816 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 30, 19, 37, 47) fem-jit-python 0.000408697 "JIT compilation (in memory cache)" (2012, 8, 30, 19, 42, 52) fem-speedup-cpp 305.02 "Assembly/solve speedup running on 4 processors" (2012, 8, 30, 19, 42, 52) fem-speedup-cpp-assembly 5.77223 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 30, 19, 42, 52) fem-speedup-cpp-solve 1.655 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 30, 19, 43, 15) mesh-refinement-cpp 22.0642 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 30, 19, 43, 36) mesh-topology-cpp 20.6893 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 30, 19, 43, 57) mesh-unitcube-cpp 20.6617 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 30, 19, 44, 40) mesh-iteration-cpp 40.3913 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 30, 19, 45, 2) function-evaluation-cpp 21.8022 "Evaluations of functions at arbitrary points." (2012, 8, 30, 19, 45, 2) function-evaluation-cpp 21.7156 "Evaluations of functions at arbitrary points." (2012, 8, 30, 19, 45, 9) function-extrapolation-python 7.47366 "BENCH: 1.97645187378" (2012, 8, 30, 19, 45, 9) function-extrapolation-python 1.97645 "BENCH: 1.97645187378" (2012, 8, 30, 19, 45, 32) la-vector-access-cpp 22.4584 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 30, 19, 46, 0) la-vector-assignment-cpp 27.9069 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 8, 31, 1, 11, 19) common-progress-cpp 30.0397 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 8, 31, 1, 11, 49) common-timing-cpp 30.3872 "Timing access and registration of timings (10000000 repetitions)" (2012, 8, 31, 19, 34, 39) fem-multicore-cpp 66170.3 "Coloring mesh." (2012, 8, 31, 19, 40, 32) fem-assembly-cpp 352.912 "Assembly for various forms and backends" (2012, 8, 31, 19, 40, 45) fem-convergence-cpp 13.1759 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 8, 31, 19, 40, 49) fem-jit-python 0.000409317 "JIT compilation (in memory cache)" (2012, 8, 31, 19, 45, 56) fem-speedup-cpp 306.6 "Assembly/solve speedup running on 4 processors" (2012, 8, 31, 19, 45, 56) fem-speedup-cpp-assembly 5.89598 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 8, 31, 19, 45, 56) fem-speedup-cpp-solve 1.62596 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 8, 31, 19, 46, 19) mesh-refinement-cpp 22.1125 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 8, 31, 19, 46, 40) mesh-topology-cpp 20.6376 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 8, 31, 19, 47, 1) mesh-unitcube-cpp 20.6487 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 8, 31, 19, 47, 43) mesh-iteration-cpp 40.3864 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 8, 31, 19, 48, 5) function-evaluation-cpp 21.5704 "Evaluations of functions at arbitrary points." (2012, 8, 31, 19, 48, 5) function-evaluation-cpp 21.4837 "Evaluations of functions at arbitrary points." (2012, 8, 31, 19, 48, 12) function-extrapolation-python 7.25649 "BENCH: 1.97002291679" (2012, 8, 31, 19, 48, 12) function-extrapolation-python 1.97002 "BENCH: 1.97002291679" (2012, 8, 31, 19, 48, 36) la-vector-access-cpp 23.3603 "Accessing vector of size 10000000 (100 repetitions)" (2012, 8, 31, 19, 49, 1) la-vector-assignment-cpp 24.956 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 1, 1, 11, 40) common-progress-cpp 36.435 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 1, 1, 12, 11) common-timing-cpp 30.6524 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 1, 19, 20, 50) fem-multicore-cpp 65318.7 "Coloring mesh." (2012, 9, 1, 19, 26, 41) fem-assembly-cpp 350.995 "Assembly for various forms and backends" (2012, 9, 1, 19, 26, 54) fem-convergence-cpp 13.2139 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 1, 19, 26, 58) fem-jit-python 0.000410318 "JIT compilation (in memory cache)" (2012, 9, 1, 19, 32, 6) fem-speedup-cpp 308.201 "Assembly/solve speedup running on 4 processors" (2012, 9, 1, 19, 32, 6) fem-speedup-cpp-assembly 5.8024 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 1, 19, 32, 6) fem-speedup-cpp-solve 1.61389 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 1, 19, 32, 30) mesh-refinement-cpp 22.1571 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 1, 19, 32, 50) mesh-topology-cpp 20.6384 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 1, 19, 33, 11) mesh-unitcube-cpp 20.6526 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 1, 19, 33, 54) mesh-iteration-cpp 40.3768 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 1, 19, 34, 16) function-evaluation-cpp 21.926 "Evaluations of functions at arbitrary points." (2012, 9, 1, 19, 34, 16) function-evaluation-cpp 21.8449 "Evaluations of functions at arbitrary points." (2012, 9, 1, 19, 34, 23) function-extrapolation-python 7.32387 "BENCH: 1.97256088257" (2012, 9, 1, 19, 34, 23) function-extrapolation-python 1.97256 "BENCH: 1.97256088257" (2012, 9, 1, 19, 34, 46) la-vector-access-cpp 22.4532 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 1, 19, 35, 11) la-vector-assignment-cpp 24.9643 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 2, 1, 11, 25) common-progress-cpp 37.6895 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 2, 1, 11, 55) common-timing-cpp 30.4091 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 2, 19, 10, 21) fem-multicore-cpp 64705.6 "Coloring mesh." (2012, 9, 2, 19, 16, 14) fem-assembly-cpp 353.478 "Assembly for various forms and backends" (2012, 9, 2, 19, 16, 27) fem-convergence-cpp 13.1566 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 2, 19, 16, 30) fem-jit-python 0.000413704 "JIT compilation (in memory cache)" (2012, 9, 2, 19, 21, 34) fem-speedup-cpp 304.89 "Assembly/solve speedup running on 4 processors" (2012, 9, 2, 19, 21, 34) fem-speedup-cpp-assembly 5.84812 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 2, 19, 21, 34) fem-speedup-cpp-solve 1.67032 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 2, 19, 21, 57) mesh-refinement-cpp 22.1585 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 2, 19, 22, 18) mesh-topology-cpp 20.6684 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 2, 19, 22, 39) mesh-unitcube-cpp 20.8423 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 2, 19, 23, 22) mesh-iteration-cpp 40.3766 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 2, 19, 23, 43) function-evaluation-cpp 21.4348 "Evaluations of functions at arbitrary points." (2012, 9, 2, 19, 23, 43) function-evaluation-cpp 21.3481 "Evaluations of functions at arbitrary points." (2012, 9, 2, 19, 23, 49) function-extrapolation-python 5.35787 "BENCH: 1.97291898727" (2012, 9, 2, 19, 23, 49) function-extrapolation-python 1.97292 "BENCH: 1.97291898727" (2012, 9, 2, 19, 24, 13) la-vector-access-cpp 23.9989 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 2, 19, 24, 38) la-vector-assignment-cpp 24.9542 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 3, 1, 11, 1) common-progress-cpp 29.6154 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 3, 1, 11, 32) common-timing-cpp 30.8066 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 3, 19, 37, 53) fem-multicore-cpp 66381.2 "Coloring mesh." (2012, 9, 3, 19, 43, 47) fem-assembly-cpp 353.906 "Assembly for various forms and backends" (2012, 9, 3, 19, 44, 0) fem-convergence-cpp 13.204 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 3, 19, 44, 3) fem-jit-python 0.000414205 "JIT compilation (in memory cache)" (2012, 9, 3, 19, 49, 9) fem-speedup-cpp 306.308 "Assembly/solve speedup running on 4 processors" (2012, 9, 3, 19, 49, 9) fem-speedup-cpp-assembly 5.77531 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 3, 19, 49, 9) fem-speedup-cpp-solve 1.63016 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 3, 19, 49, 32) mesh-refinement-cpp 22.1092 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 3, 19, 49, 54) mesh-topology-cpp 21.4351 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 3, 19, 50, 14) mesh-unitcube-cpp 20.7103 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 3, 19, 50, 57) mesh-iteration-cpp 40.3736 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 3, 19, 51, 19) function-evaluation-cpp 21.6735 "Evaluations of functions at arbitrary points." (2012, 9, 3, 19, 51, 19) function-evaluation-cpp 21.5859 "Evaluations of functions at arbitrary points." (2012, 9, 3, 19, 51, 24) function-extrapolation-python 5.38296 "BENCH: 1.98295307159" (2012, 9, 3, 19, 51, 24) function-extrapolation-python 1.98295 "BENCH: 1.98295307159" (2012, 9, 3, 19, 51, 47) la-vector-access-cpp 22.4489 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 3, 19, 52, 12) la-vector-assignment-cpp 24.9559 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 4, 1, 11, 18) common-progress-cpp 29.555 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 4, 1, 11, 48) common-timing-cpp 30.352 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 4, 19, 40, 57) fem-multicore-cpp 66549.2 "Coloring mesh." (2012, 9, 4, 19, 47, 9) fem-assembly-cpp 371.179 "Assembly for various forms and backends" (2012, 9, 4, 19, 47, 22) fem-convergence-cpp 13.4013 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 4, 19, 47, 24) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2012, 9, 4, 19, 52, 31) fem-speedup-cpp 306.795 "Assembly/solve speedup running on 4 processors" (2012, 9, 4, 19, 52, 31) fem-speedup-cpp-assembly 5.91365 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 4, 19, 52, 31) fem-speedup-cpp-solve 1.64665 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 4, 19, 52, 54) mesh-refinement-cpp 22.3169 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 4, 19, 53, 15) mesh-topology-cpp 21.0624 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 4, 19, 53, 37) mesh-unitcube-cpp 21.0063 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 4, 19, 54, 19) mesh-iteration-cpp 40.3747 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 4, 19, 54, 41) function-evaluation-cpp 21.9393 "Evaluations of functions at arbitrary points." (2012, 9, 4, 19, 54, 41) function-evaluation-cpp 21.8525 "Evaluations of functions at arbitrary points." (2012, 9, 4, 19, 54, 47) function-extrapolation-python 5.19274 "BENCH: 1.96293091774" (2012, 9, 4, 19, 54, 47) function-extrapolation-python 1.96293 "BENCH: 1.96293091774" (2012, 9, 4, 19, 55, 10) la-vector-access-cpp 23.5033 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 4, 19, 55, 38) la-vector-assignment-cpp 27.9047 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 5, 1, 11, 23) common-progress-cpp 29.5939 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 5, 1, 11, 55) common-timing-cpp 31.1492 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 5, 19, 48, 33) fem-multicore-cpp 66998.1 "Coloring mesh." (2012, 9, 5, 19, 54, 42) fem-assembly-cpp 369.477 "Assembly for various forms and backends" (2012, 9, 5, 19, 54, 56) fem-convergence-cpp 13.4173 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 5, 19, 54, 58) fem-jit-python 0.000405693 "JIT compilation (in memory cache)" (2012, 9, 5, 20, 0, 11) fem-speedup-cpp 313.094 "Assembly/solve speedup running on 4 processors" (2012, 9, 5, 20, 0, 11) fem-speedup-cpp-assembly 5.76646 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 5, 20, 0, 11) fem-speedup-cpp-solve 1.55733 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 5, 20, 0, 34) mesh-refinement-cpp 22.3776 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 5, 20, 0, 55) mesh-topology-cpp 21.028 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 5, 20, 1, 17) mesh-unitcube-cpp 20.9815 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 5, 20, 1, 59) mesh-iteration-cpp 40.3801 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 5, 20, 2, 21) function-evaluation-cpp 21.9014 "Evaluations of functions at arbitrary points." (2012, 9, 5, 20, 2, 21) function-evaluation-cpp 21.8147 "Evaluations of functions at arbitrary points." (2012, 9, 5, 20, 2, 27) function-extrapolation-python 5.39935 "BENCH: 1.95831203461" (2012, 9, 5, 20, 2, 27) function-extrapolation-python 1.95831 "BENCH: 1.95831203461" (2012, 9, 5, 20, 2, 51) la-vector-access-cpp 24.4459 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 5, 20, 3, 23) la-vector-assignment-cpp 31.8966 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 6, 1, 11, 24) common-progress-cpp 29.5608 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 6, 1, 11, 53) common-timing-cpp 29.7331 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 6, 19, 48, 58) fem-multicore-cpp 67024.4 "Coloring mesh." (2012, 9, 6, 19, 55, 8) fem-assembly-cpp 370.287 "Assembly for various forms and backends" (2012, 9, 6, 19, 55, 22) fem-convergence-cpp 13.4429 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 6, 19, 55, 24) fem-jit-python 0.000417709 "JIT compilation (in memory cache)" (2012, 9, 6, 20, 0, 31) fem-speedup-cpp 307.13 "Assembly/solve speedup running on 4 processors" (2012, 9, 6, 20, 0, 31) fem-speedup-cpp-assembly 5.86936 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 6, 20, 0, 31) fem-speedup-cpp-solve 1.63583 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 6, 20, 0, 54) mesh-refinement-cpp 22.3903 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 6, 20, 1, 15) mesh-topology-cpp 20.8413 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 6, 20, 1, 37) mesh-unitcube-cpp 21.2655 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 6, 20, 2, 22) mesh-iteration-cpp 42.5653 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 6, 20, 2, 44) function-evaluation-cpp 21.9231 "Evaluations of functions at arbitrary points." (2012, 9, 6, 20, 2, 44) function-evaluation-cpp 21.8363 "Evaluations of functions at arbitrary points." (2012, 9, 6, 20, 2, 49) function-extrapolation-python 5.36616 "BENCH: 1.96219110489" (2012, 9, 6, 20, 2, 49) function-extrapolation-python 1.96219 "BENCH: 1.96219110489" (2012, 9, 6, 20, 3, 12) la-vector-access-cpp 22.4555 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 6, 20, 3, 40) la-vector-assignment-cpp 27.9026 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 7, 1, 11, 23) common-progress-cpp 29.1164 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 7, 1, 11, 53) common-timing-cpp 29.8478 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 7, 12, 55, 46) fem-multicore-cpp 42233.4 "Coloring mesh." (2012, 9, 7, 13, 1, 36) fem-assembly-cpp 349.136 "Assembly for various forms and backends" (2012, 9, 7, 13, 1, 49) fem-convergence-cpp 13.2804 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 7, 13, 1, 51) fem-jit-python 0.0004035 "JIT compilation (in memory cache)" (2012, 9, 7, 13, 8, 13) fem-speedup-cpp 381.55 "Assembly/solve speedup running on 4 processors" (2012, 9, 7, 13, 8, 13) fem-speedup-cpp-assembly 6.10032 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 7, 13, 8, 13) fem-speedup-cpp-solve 1.57736 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 7, 13, 8, 36) mesh-refinement-cpp 22.1586 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 7, 13, 8, 57) mesh-topology-cpp 20.6734 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 7, 13, 9, 18) mesh-unitcube-cpp 21.2095 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 7, 13, 10, 7) mesh-iteration-cpp 46.0039 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 7, 13, 10, 29) function-evaluation-cpp 21.8716 "Evaluations of functions at arbitrary points." (2012, 9, 7, 13, 10, 29) function-evaluation-cpp 21.7906 "Evaluations of functions at arbitrary points." (2012, 9, 7, 13, 10, 34) function-extrapolation-python 5.39313 "BENCH: 1.92531085014" (2012, 9, 7, 13, 10, 34) function-extrapolation-python 1.92531 "BENCH: 1.92531085014" (2012, 9, 7, 13, 10, 57) la-vector-access-cpp 22.4554 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 7, 13, 11, 22) la-vector-assignment-cpp 24.9557 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 8, 1, 11, 24) common-progress-cpp 29.648 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 8, 1, 11, 55) common-timing-cpp 30.8156 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 8, 13, 7, 35) fem-multicore-cpp 42940.6 "Coloring mesh." (2012, 9, 8, 13, 13, 24) fem-assembly-cpp 348.849 "Assembly for various forms and backends" (2012, 9, 8, 13, 13, 37) fem-convergence-cpp 13.1329 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 8, 13, 13, 40) fem-jit-python 0.000404501 "JIT compilation (in memory cache)" (2012, 9, 8, 13, 20, 2) fem-speedup-cpp 382.047 "Assembly/solve speedup running on 4 processors" (2012, 9, 8, 13, 20, 2) fem-speedup-cpp-assembly 6.08771 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 8, 13, 20, 2) fem-speedup-cpp-solve 1.60074 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 8, 13, 20, 25) mesh-refinement-cpp 22.0717 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 8, 13, 20, 46) mesh-topology-cpp 20.7544 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 8, 13, 21, 7) mesh-unitcube-cpp 21.4244 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 8, 13, 21, 50) mesh-iteration-cpp 40.3868 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 8, 13, 22, 12) function-evaluation-cpp 21.8589 "Evaluations of functions at arbitrary points." (2012, 9, 8, 13, 22, 12) function-evaluation-cpp 21.7517 "Evaluations of functions at arbitrary points." (2012, 9, 8, 13, 22, 27) function-extrapolation-python 14.4207 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 9, 8, 13, 22, 27) function-extrapolation-python 1.96067 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2012, 9, 8, 13, 22, 49) la-vector-access-cpp 22.8787 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 8, 13, 23, 15) la-vector-assignment-cpp 24.9518 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 9, 1, 11, 37) common-progress-cpp 29.8691 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 9, 1, 12, 7) common-timing-cpp 30.3262 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 9, 12, 47, 13) fem-assembly-cpp 349.715 "Assembly for various forms and backends" (2012, 9, 9, 12, 47, 26) fem-convergence-cpp 13.2086 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 9, 12, 47, 28) fem-jit-python 0.000411987 "JIT compilation (in memory cache)" (2012, 9, 9, 12, 53, 53) fem-speedup-cpp 384.017 "Assembly/solve speedup running on 4 processors" (2012, 9, 9, 12, 53, 53) fem-speedup-cpp-assembly 6.05459 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 9, 12, 53, 53) fem-speedup-cpp-solve 1.55812 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 9, 12, 54, 16) mesh-refinement-cpp 22.1192 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 9, 12, 54, 37) mesh-topology-cpp 20.8795 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 9, 12, 54, 59) mesh-unitcube-cpp 21.2642 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 9, 12, 55, 41) mesh-iteration-cpp 40.3734 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 9, 12, 56, 3) function-evaluation-cpp 21.8774 "Evaluations of functions at arbitrary points." (2012, 9, 9, 12, 56, 3) function-evaluation-cpp 21.7966 "Evaluations of functions at arbitrary points." (2012, 9, 9, 12, 56, 9) function-extrapolation-python 5.29122 "BENCH: 1.87799406052" (2012, 9, 9, 12, 56, 9) function-extrapolation-python 1.87799 "BENCH: 1.87799406052" (2012, 9, 9, 12, 56, 31) la-vector-access-cpp 22.4534 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 9, 12, 56, 56) la-vector-assignment-cpp 24.9631 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 10, 1, 11, 41) common-progress-cpp 29.5617 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 10, 1, 12, 10) common-timing-cpp 29.8504 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 10, 12, 45, 4) fem-assembly-cpp 347.319 "Assembly for various forms and backends" (2012, 9, 10, 12, 45, 18) fem-convergence-cpp 13.2249 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 10, 12, 45, 20) fem-jit-python 0.000414491 "JIT compilation (in memory cache)" (2012, 9, 10, 12, 51, 42) fem-speedup-cpp 382.666 "Assembly/solve speedup running on 4 processors" (2012, 9, 10, 12, 51, 42) fem-speedup-cpp-assembly 6.10554 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 10, 12, 51, 42) fem-speedup-cpp-solve 1.57108 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 10, 12, 52, 6) mesh-refinement-cpp 22.0961 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 10, 12, 52, 27) mesh-topology-cpp 20.7155 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 10, 12, 52, 48) mesh-unitcube-cpp 21.1334 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 10, 12, 53, 31) mesh-iteration-cpp 40.3921 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 10, 12, 53, 53) function-evaluation-cpp 21.878 "Evaluations of functions at arbitrary points." (2012, 9, 10, 12, 53, 53) function-evaluation-cpp 21.7911 "Evaluations of functions at arbitrary points." (2012, 9, 10, 12, 53, 58) function-extrapolation-python 5.31745 "BENCH: 1.89025998116" (2012, 9, 10, 12, 53, 58) function-extrapolation-python 1.89026 "BENCH: 1.89025998116" (2012, 9, 10, 12, 54, 21) la-vector-access-cpp 22.4589 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 10, 12, 54, 46) la-vector-assignment-cpp 25.1076 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 11, 1, 11, 55) common-progress-cpp 29.6292 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 11, 1, 12, 25) common-timing-cpp 30.1381 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 11, 12, 43, 19) fem-assembly-cpp 347.635 "Assembly for various forms and backends" (2012, 9, 11, 12, 43, 32) fem-convergence-cpp 13.3449 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 11, 12, 43, 34) fem-jit-python 0.000408792 "JIT compilation (in memory cache)" (2012, 9, 11, 12, 50, 5) fem-speedup-cpp 390.856 "Assembly/solve speedup running on 4 processors" (2012, 9, 11, 12, 50, 5) fem-speedup-cpp-assembly 6.11155 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 11, 12, 50, 5) fem-speedup-cpp-solve 1.48925 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 11, 12, 50, 29) mesh-refinement-cpp 22.1867 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 11, 12, 50, 50) mesh-topology-cpp 20.8785 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 11, 12, 51, 11) mesh-unitcube-cpp 21.1004 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 11, 12, 51, 54) mesh-iteration-cpp 40.3758 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 11, 12, 52, 16) function-evaluation-cpp 21.6863 "Evaluations of functions at arbitrary points." (2012, 9, 11, 12, 52, 16) function-evaluation-cpp 21.6053 "Evaluations of functions at arbitrary points." (2012, 9, 11, 12, 52, 21) function-extrapolation-python 5.38411 "BENCH: 1.94400215149" (2012, 9, 11, 12, 52, 21) function-extrapolation-python 1.944 "BENCH: 1.94400215149" (2012, 9, 11, 12, 52, 44) la-vector-access-cpp 22.4543 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 11, 12, 53, 9) la-vector-assignment-cpp 24.9595 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 12, 1, 11, 32) common-progress-cpp 36.4371 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 12, 1, 12, 1) common-timing-cpp 29.5084 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 12, 12, 41, 1) fem-assembly-cpp 347.333 "Assembly for various forms and backends" (2012, 9, 12, 12, 41, 14) fem-convergence-cpp 13.3065 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 12, 12, 41, 17) fem-jit-python 0.000404406 "JIT compilation (in memory cache)" (2012, 9, 12, 12, 47, 39) fem-speedup-cpp 382.711 "Assembly/solve speedup running on 4 processors" (2012, 9, 12, 12, 47, 39) fem-speedup-cpp-assembly 6.07984 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 12, 12, 47, 39) fem-speedup-cpp-solve 1.58246 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 12, 12, 48, 3) mesh-refinement-cpp 22.185 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 12, 12, 48, 24) mesh-topology-cpp 20.8243 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 12, 12, 48, 45) mesh-unitcube-cpp 21.0921 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 12, 12, 49, 28) mesh-iteration-cpp 40.3826 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 12, 12, 49, 50) function-evaluation-cpp 21.9126 "Evaluations of functions at arbitrary points." (2012, 9, 12, 12, 49, 50) function-evaluation-cpp 21.8315 "Evaluations of functions at arbitrary points." (2012, 9, 12, 12, 49, 55) function-extrapolation-python 5.56267 "BENCH: 1.95282721519" (2012, 9, 12, 12, 49, 55) function-extrapolation-python 1.95283 "BENCH: 1.95282721519" (2012, 9, 12, 12, 50, 18) la-vector-access-cpp 22.518 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 12, 12, 50, 43) la-vector-assignment-cpp 24.8598 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 13, 1, 11, 23) common-progress-cpp 29.5793 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 13, 1, 11, 53) common-timing-cpp 29.8039 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 13, 12, 48, 27) fem-assembly-cpp 346.829 "Assembly for various forms and backends" (2012, 9, 13, 12, 48, 40) fem-convergence-cpp 13.3287 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 13, 12, 48, 43) fem-jit-python 0.000405312 "JIT compilation (in memory cache)" (2012, 9, 13, 12, 55, 12) fem-speedup-cpp 389.505 "Assembly/solve speedup running on 4 processors" (2012, 9, 13, 12, 55, 12) fem-speedup-cpp-assembly 6.06103 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 13, 12, 55, 12) fem-speedup-cpp-solve 1.51599 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 13, 12, 55, 36) mesh-refinement-cpp 22.166 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 13, 12, 55, 57) mesh-topology-cpp 20.8705 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 13, 12, 56, 18) mesh-unitcube-cpp 21.0782 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 13, 12, 57, 1) mesh-iteration-cpp 40.3775 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 13, 12, 57, 23) function-evaluation-cpp 21.8964 "Evaluations of functions at arbitrary points." (2012, 9, 13, 12, 57, 23) function-evaluation-cpp 21.815 "Evaluations of functions at arbitrary points." (2012, 9, 13, 12, 57, 29) function-extrapolation-python 5.50112 "BENCH: 1.9168510437" (2012, 9, 13, 12, 57, 29) function-extrapolation-python 1.91685 "BENCH: 1.9168510437" (2012, 9, 13, 12, 57, 51) la-vector-access-cpp 22.4541 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 13, 12, 58, 16) la-vector-assignment-cpp 24.9638 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 14, 1, 11, 39) common-progress-cpp 36.4364 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 14, 1, 12, 10) common-timing-cpp 30.2412 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 14, 12, 25, 43) fem-assembly-cpp 347.315 "Assembly for various forms and backends" (2012, 9, 14, 12, 25, 56) fem-convergence-cpp 13.3531 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 14, 12, 25, 58) fem-jit-python 0.000406313 "JIT compilation (in memory cache)" (2012, 9, 14, 12, 32, 29) fem-speedup-cpp 390.186 "Assembly/solve speedup running on 4 processors" (2012, 9, 14, 12, 32, 29) fem-speedup-cpp-assembly 6.10476 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 14, 12, 32, 29) fem-speedup-cpp-solve 1.49782 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 14, 12, 32, 52) mesh-refinement-cpp 22.1111 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 14, 12, 33, 13) mesh-topology-cpp 20.6805 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 14, 12, 33, 34) mesh-unitcube-cpp 21.0993 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 14, 12, 34, 17) mesh-iteration-cpp 40.3802 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 14, 12, 34, 39) function-evaluation-cpp 21.9003 "Evaluations of functions at arbitrary points." (2012, 9, 14, 12, 34, 39) function-evaluation-cpp 21.8196 "Evaluations of functions at arbitrary points." (2012, 9, 14, 12, 34, 45) function-extrapolation-python 5.40911 "BENCH: 1.89039516449" (2012, 9, 14, 12, 34, 45) function-extrapolation-python 1.8904 "BENCH: 1.89039516449" (2012, 9, 14, 12, 35, 9) la-vector-access-cpp 23.8229 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 14, 12, 35, 34) la-vector-assignment-cpp 24.962 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 15, 1, 11, 28) common-progress-cpp 29.5854 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 15, 1, 11, 57) common-timing-cpp 28.7927 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 15, 12, 28, 50) fem-convergence-cpp 13.0818 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 15, 12, 28, 52) fem-jit-python 0.000412393 "JIT compilation (in memory cache)" (2012, 9, 15, 12, 35, 27) fem-speedup-cpp 394.561 "Assembly/solve speedup running on 4 processors" (2012, 9, 15, 12, 35, 27) fem-speedup-cpp-assembly 6.09929 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 15, 12, 35, 27) fem-speedup-cpp-solve 1.44758 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 15, 12, 35, 51) mesh-refinement-cpp 22.4542 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 15, 12, 36, 12) mesh-topology-cpp 20.901 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 15, 12, 36, 36) mesh-unitcube-cpp 23.5594 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 15, 12, 37, 18) mesh-iteration-cpp 40.3736 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 15, 12, 37, 40) function-evaluation-cpp 21.815 "Evaluations of functions at arbitrary points." (2012, 9, 15, 12, 37, 40) function-evaluation-cpp 21.7257 "Evaluations of functions at arbitrary points." (2012, 9, 15, 12, 37, 46) function-extrapolation-python 5.43882 "BENCH: 1.89907884598" (2012, 9, 15, 12, 37, 46) function-extrapolation-python 1.89908 "BENCH: 1.89907884598" (2012, 9, 15, 12, 38, 9) la-vector-access-cpp 23.3205 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 15, 12, 38, 35) la-vector-assignment-cpp 25.5206 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 16, 1, 11, 16) common-progress-cpp 38.9439 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 16, 1, 11, 45) common-timing-cpp 28.9383 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 16, 13, 9, 30) fem-multicore-cpp 43065.4 "Coloring mesh." (2012, 9, 16, 13, 9, 45) fem-convergence-cpp 13.0918 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 16, 13, 9, 48) fem-jit-python 0.000410509 "JIT compilation (in memory cache)" (2012, 9, 16, 13, 16, 19) fem-speedup-cpp 391.508 "Assembly/solve speedup running on 4 processors" (2012, 9, 16, 13, 16, 19) fem-speedup-cpp-assembly 6.06307 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 16, 13, 16, 19) fem-speedup-cpp-solve 1.47197 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 16, 13, 16, 43) mesh-refinement-cpp 22.49 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 16, 13, 17, 4) mesh-topology-cpp 20.86 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 16, 13, 17, 28) mesh-unitcube-cpp 23.5676 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 16, 13, 18, 11) mesh-iteration-cpp 40.3725 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 16, 13, 18, 33) function-evaluation-cpp 21.8604 "Evaluations of functions at arbitrary points." (2012, 9, 16, 13, 18, 33) function-evaluation-cpp 21.7796 "Evaluations of functions at arbitrary points." (2012, 9, 16, 13, 18, 38) function-extrapolation-python 5.20525 "BENCH: 1.89735102654" (2012, 9, 16, 13, 18, 38) function-extrapolation-python 1.89735 "BENCH: 1.89735102654" (2012, 9, 16, 13, 19, 1) la-vector-access-cpp 22.3997 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 16, 13, 19, 26) la-vector-assignment-cpp 25.5192 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 17, 1, 10, 46) common-progress-cpp 29.612 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 17, 1, 11, 15) common-timing-cpp 28.7437 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 17, 13, 24, 34) fem-multicore-cpp 43998.9 "Coloring mesh." (2012, 9, 17, 13, 24, 49) fem-convergence-cpp 13.1166 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 17, 13, 24, 52) fem-jit-python 0.000408792 "JIT compilation (in memory cache)" (2012, 9, 17, 13, 31, 26) fem-speedup-cpp 394.534 "Assembly/solve speedup running on 4 processors" (2012, 9, 17, 13, 31, 26) fem-speedup-cpp-assembly 6.11943 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 17, 13, 31, 26) fem-speedup-cpp-solve 1.45052 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 17, 13, 31, 50) mesh-refinement-cpp 22.5091 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 17, 13, 32, 11) mesh-topology-cpp 20.8864 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 17, 13, 32, 35) mesh-unitcube-cpp 23.6286 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 17, 13, 33, 18) mesh-iteration-cpp 40.3785 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 17, 13, 33, 41) function-evaluation-cpp 22.9586 "Evaluations of functions at arbitrary points." (2012, 9, 17, 13, 33, 41) function-evaluation-cpp 22.8698 "Evaluations of functions at arbitrary points." (2012, 9, 17, 13, 33, 47) function-extrapolation-python 5.3996 "BENCH: 1.89168787003" (2012, 9, 17, 13, 33, 47) function-extrapolation-python 1.89169 "BENCH: 1.89168787003" (2012, 9, 17, 13, 34, 15) la-vector-access-cpp 27.8828 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 17, 13, 34, 40) la-vector-assignment-cpp 25.5082 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 18, 1, 10, 49) common-progress-cpp 29.5931 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 18, 1, 11, 17) common-timing-cpp 28.1017 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 18, 12, 49, 11) fem-multicore-cpp 41874.5 "Coloring mesh." (2012, 9, 18, 12, 49, 26) fem-convergence-cpp 13.1149 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 18, 12, 49, 28) fem-jit-python 0.000406289 "JIT compilation (in memory cache)" (2012, 9, 18, 12, 56, 1) fem-speedup-cpp 392.847 "Assembly/solve speedup running on 4 processors" (2012, 9, 18, 12, 56, 1) fem-speedup-cpp-assembly 6.04611 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 18, 12, 56, 1) fem-speedup-cpp-solve 1.48035 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 18, 12, 56, 26) mesh-refinement-cpp 22.5223 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 18, 12, 56, 47) mesh-topology-cpp 20.8932 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 18, 12, 57, 10) mesh-unitcube-cpp 23.5504 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 18, 12, 57, 53) mesh-iteration-cpp 40.3742 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 18, 12, 58, 15) function-evaluation-cpp 21.881 "Evaluations of functions at arbitrary points." (2012, 9, 18, 12, 58, 15) function-evaluation-cpp 21.7839 "Evaluations of functions at arbitrary points." (2012, 9, 18, 12, 58, 21) function-extrapolation-python 5.30175 "BENCH: 1.90063285828" (2012, 9, 18, 12, 58, 21) function-extrapolation-python 1.90063 "BENCH: 1.90063285828" (2012, 9, 18, 12, 58, 45) la-vector-access-cpp 24.4174 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 18, 12, 59, 13) la-vector-assignment-cpp 27.8988 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 19, 1, 11, 8) common-progress-cpp 29.8735 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 19, 1, 11, 37) common-timing-cpp 29.1151 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 19, 13, 25, 15) fem-multicore-cpp 44018.3 "Coloring mesh." (2012, 9, 19, 13, 25, 30) fem-convergence-cpp 13.2066 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 19, 13, 25, 32) fem-jit-python 0.000416398 "JIT compilation (in memory cache)" (2012, 9, 19, 13, 31, 56) fem-speedup-cpp 383.872 "Assembly/solve speedup running on 4 processors" (2012, 9, 19, 13, 31, 56) fem-speedup-cpp-assembly 6.10301 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 19, 13, 31, 56) fem-speedup-cpp-solve 1.56911 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 19, 13, 32, 20) mesh-refinement-cpp 22.3385 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 19, 13, 32, 41) mesh-topology-cpp 20.4917 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 19, 13, 33, 4) mesh-unitcube-cpp 22.4845 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 19, 13, 33, 48) mesh-iteration-cpp 41.6145 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 19, 13, 34, 10) function-evaluation-cpp 21.9973 "Evaluations of functions at arbitrary points." (2012, 9, 19, 13, 34, 10) function-evaluation-cpp 21.9161 "Evaluations of functions at arbitrary points." (2012, 9, 19, 13, 34, 15) function-extrapolation-python 5.26828 "BENCH: 1.89837098122" (2012, 9, 19, 13, 34, 15) function-extrapolation-python 1.89837 "BENCH: 1.89837098122" (2012, 9, 19, 13, 34, 38) la-vector-access-cpp 22.4024 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 19, 13, 35, 3) la-vector-assignment-cpp 25.514 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 20, 1, 11, 5) common-progress-cpp 29.7306 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 20, 1, 11, 34) common-timing-cpp 29.1986 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 20, 13, 20, 37) fem-multicore-cpp 43742.7 "Coloring mesh." (2012, 9, 20, 13, 20, 52) fem-convergence-cpp 13.2042 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 20, 13, 20, 54) fem-jit-python 0.000415611 "JIT compilation (in memory cache)" (2012, 9, 20, 13, 27, 17) fem-speedup-cpp 382.221 "Assembly/solve speedup running on 4 processors" (2012, 9, 20, 13, 27, 17) fem-speedup-cpp-assembly 6.11515 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 20, 13, 27, 17) fem-speedup-cpp-solve 1.59161 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 20, 13, 27, 41) mesh-refinement-cpp 22.3458 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 20, 13, 28, 1) mesh-topology-cpp 20.4703 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 20, 13, 28, 24) mesh-unitcube-cpp 22.5939 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 20, 13, 29, 7) mesh-iteration-cpp 40.377 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 20, 13, 29, 29) function-evaluation-cpp 21.8748 "Evaluations of functions at arbitrary points." (2012, 9, 20, 13, 29, 29) function-evaluation-cpp 21.7941 "Evaluations of functions at arbitrary points." (2012, 9, 20, 13, 29, 34) function-extrapolation-python 5.24601 "BENCH: 1.89654994011" (2012, 9, 20, 13, 29, 34) function-extrapolation-python 1.89655 "BENCH: 1.89654994011" (2012, 9, 20, 13, 29, 56) la-vector-access-cpp 22.4008 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 20, 13, 30, 22) la-vector-assignment-cpp 25.5189 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 21, 1, 11, 12) common-progress-cpp 29.6577 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 21, 1, 11, 41) common-timing-cpp 29.1631 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 21, 9, 7, 39) common-progress-cpp 29.6845 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 21, 9, 8, 8) common-timing-cpp 29.4578 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 21, 10, 24, 25) fem-jit-python 0.000410795 "JIT compilation (in memory cache)" (2012, 9, 21, 10, 27, 13) function-extrapolation-python 3.39918 "BENCH: 1.87466597557" (2012, 9, 21, 10, 27, 13) function-extrapolation-python 1.87467 "BENCH: 1.87466597557" (2012, 9, 22, 1, 11, 19) common-progress-cpp 29.1781 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 22, 1, 11, 48) common-timing-cpp 29.5232 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 22, 1, 13, 36) fem-multicore-cpp 107.78 "Coloring mesh." (2012, 9, 22, 1, 13, 51) fem-convergence-cpp 13.1441 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 22, 1, 13, 51) fem-jit-python 0.000403094 "JIT compilation (in memory cache)" (2012, 9, 22, 1, 20, 27) fem-speedup-cpp 395.787 "Assembly/solve speedup running on 4 processors" (2012, 9, 22, 1, 20, 27) fem-speedup-cpp-assembly 6.05911 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 22, 1, 20, 27) fem-speedup-cpp-solve 1.44451 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 22, 1, 21, 1) mesh-refinement-cpp 31.5896 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 22, 1, 21, 22) mesh-topology-cpp 20.8219 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 22, 1, 21, 43) mesh-unitcube-cpp 21.7527 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 22, 1, 22, 47) mesh-iteration-cpp 61.0734 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 22, 1, 23, 9) function-evaluation-cpp 21.8743 "Evaluations of functions at arbitrary points." (2012, 9, 22, 1, 23, 9) function-evaluation-cpp 21.7859 "Evaluations of functions at arbitrary points." (2012, 9, 22, 1, 23, 15) function-extrapolation-python 5.58182 "BENCH: 1.90315103531" (2012, 9, 22, 1, 23, 15) function-extrapolation-python 1.90315 "BENCH: 1.90315103531" (2012, 9, 22, 1, 23, 40) la-vector-access-cpp 24.9702 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 22, 1, 24, 5) la-vector-assignment-cpp 25.5096 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 23, 1, 11, 0) common-progress-cpp 30.7373 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 23, 1, 11, 28) common-timing-cpp 28.1362 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 23, 1, 13, 15) fem-multicore-cpp 107.745 "Coloring mesh." (2012, 9, 23, 1, 13, 30) fem-convergence-cpp 13.3992 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 23, 1, 13, 31) fem-jit-python 0.000411797 "JIT compilation (in memory cache)" (2012, 9, 23, 1, 20, 9) fem-speedup-cpp 398.523 "Assembly/solve speedup running on 4 processors" (2012, 9, 23, 1, 20, 9) fem-speedup-cpp-assembly 6.18453 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 23, 1, 20, 9) fem-speedup-cpp-solve 1.39178 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 23, 1, 20, 43) mesh-refinement-cpp 31.5799 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 23, 1, 21, 4) mesh-topology-cpp 20.8693 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 23, 1, 21, 26) mesh-unitcube-cpp 21.8442 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 23, 1, 22, 10) mesh-iteration-cpp 41.6302 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 23, 1, 22, 32) function-evaluation-cpp 21.8793 "Evaluations of functions at arbitrary points." (2012, 9, 23, 1, 22, 32) function-evaluation-cpp 21.7983 "Evaluations of functions at arbitrary points." (2012, 9, 23, 1, 22, 37) function-extrapolation-python 5.56562 "BENCH: 1.9037539959" (2012, 9, 23, 1, 22, 37) function-extrapolation-python 1.90375 "BENCH: 1.9037539959" (2012, 9, 23, 1, 23, 0) la-vector-access-cpp 22.3991 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 23, 1, 23, 28) la-vector-assignment-cpp 28.3515 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 24, 1, 11, 1) common-progress-cpp 29.5841 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 24, 1, 11, 30) common-timing-cpp 29.0484 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 24, 1, 13, 19) fem-multicore-cpp 108.684 "Coloring mesh." (2012, 9, 24, 1, 13, 33) fem-convergence-cpp 13.4175 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 24, 1, 13, 34) fem-jit-python 0.000411797 "JIT compilation (in memory cache)" (2012, 9, 24, 1, 19, 42) fem-speedup-cpp 367.845 "Assembly/solve speedup running on 4 processors" (2012, 9, 24, 1, 19, 42) fem-speedup-cpp-assembly 6.07892 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 24, 1, 19, 42) fem-speedup-cpp-solve 1.80876 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 24, 1, 20, 15) mesh-refinement-cpp 31.6335 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 24, 1, 20, 36) mesh-topology-cpp 20.9318 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 24, 1, 20, 58) mesh-unitcube-cpp 21.8601 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 24, 1, 21, 42) mesh-iteration-cpp 41.5928 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 24, 1, 22, 4) function-evaluation-cpp 21.9059 "Evaluations of functions at arbitrary points." (2012, 9, 24, 1, 22, 4) function-evaluation-cpp 21.8099 "Evaluations of functions at arbitrary points." (2012, 9, 24, 1, 22, 10) function-extrapolation-python 5.5134 "BENCH: 1.92673611641" (2012, 9, 24, 1, 22, 10) function-extrapolation-python 1.92674 "BENCH: 1.92673611641" (2012, 9, 24, 1, 22, 32) la-vector-access-cpp 22.3992 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 24, 1, 22, 58) la-vector-assignment-cpp 25.4026 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 25, 1, 11, 24) common-progress-cpp 48.2572 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 25, 1, 11, 54) common-timing-cpp 29.7911 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 25, 1, 13, 42) fem-multicore-cpp 108.482 "Coloring mesh." (2012, 9, 25, 1, 16, 6) fem-assembly-cpp 143.666 "Assembly for various forms and backends" (2012, 9, 25, 1, 16, 19) fem-convergence-cpp 13.3206 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 25, 1, 16, 20) fem-jit-python 0.000407314 "JIT compilation (in memory cache)" (2012, 9, 25, 1, 23, 0) fem-speedup-cpp 400.125 "Assembly/solve speedup running on 4 processors" (2012, 9, 25, 1, 23, 0) fem-speedup-cpp-assembly 6.09379 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 25, 1, 23, 0) fem-speedup-cpp-solve 1.36736 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 25, 1, 23, 25) mesh-refinement-cpp 23.5491 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 25, 1, 23, 46) mesh-topology-cpp 20.5739 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 25, 1, 24, 8) mesh-unitcube-cpp 21.9915 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 25, 1, 24, 51) mesh-iteration-cpp 41.0121 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 25, 1, 25, 13) function-evaluation-cpp 21.8873 "Evaluations of functions at arbitrary points." (2012, 9, 25, 1, 25, 13) function-evaluation-cpp 21.806 "Evaluations of functions at arbitrary points." (2012, 9, 25, 1, 25, 19) function-extrapolation-python 5.54546 "BENCH: 1.89376592636" (2012, 9, 25, 1, 25, 19) function-extrapolation-python 1.89377 "BENCH: 1.89376592636" (2012, 9, 25, 1, 25, 41) la-vector-access-cpp 22.4 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 25, 1, 26, 7) la-vector-assignment-cpp 25.5236 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 26, 1, 11, 38) common-progress-cpp 29.6016 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 26, 1, 12, 8) common-timing-cpp 29.4257 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 26, 1, 13, 56) fem-multicore-cpp 108.321 "Coloring mesh." (2012, 9, 26, 1, 16, 22) fem-assembly-cpp 145.668 "Assembly for various forms and backends" (2012, 9, 26, 1, 16, 35) fem-convergence-cpp 13.4098 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 26, 1, 16, 36) fem-jit-python 0.000411701 "JIT compilation (in memory cache)" (2012, 9, 26, 1, 22, 47) fem-speedup-cpp 370.705 "Assembly/solve speedup running on 4 processors" (2012, 9, 26, 1, 22, 47) fem-speedup-cpp-assembly 6.08716 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 26, 1, 22, 47) fem-speedup-cpp-solve 1.7315 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 26, 1, 23, 11) mesh-refinement-cpp 23.4647 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 26, 1, 23, 32) mesh-topology-cpp 20.6221 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 26, 1, 23, 54) mesh-unitcube-cpp 21.877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 26, 1, 24, 40) mesh-iteration-cpp 43.5017 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 26, 1, 25, 2) function-evaluation-cpp 21.5565 "Evaluations of functions at arbitrary points." (2012, 9, 26, 1, 25, 2) function-evaluation-cpp 21.4753 "Evaluations of functions at arbitrary points." (2012, 9, 26, 1, 25, 7) function-extrapolation-python 5.58725 "BENCH: 1.94169616699" (2012, 9, 26, 1, 25, 7) function-extrapolation-python 1.9417 "BENCH: 1.94169616699" (2012, 9, 26, 1, 25, 33) la-vector-access-cpp 25.1789 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 26, 1, 25, 58) la-vector-assignment-cpp 25.518 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 27, 1, 10, 49) common-progress-cpp 29.0637 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 27, 1, 11, 19) common-timing-cpp 29.6664 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 27, 1, 13, 8) fem-multicore-cpp 109.065 "Coloring mesh." (2012, 9, 27, 1, 15, 34) fem-assembly-cpp 146.163 "Assembly for various forms and backends" (2012, 9, 27, 1, 15, 48) fem-convergence-cpp 13.3473 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 27, 1, 15, 48) fem-jit-python 0.000416493 "JIT compilation (in memory cache)" (2012, 9, 27, 1, 22, 5) fem-speedup-cpp 376.931 "Assembly/solve speedup running on 4 processors" (2012, 9, 27, 1, 22, 5) fem-speedup-cpp-assembly 6.25234 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 27, 1, 22, 5) fem-speedup-cpp-solve 1.65077 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 27, 1, 22, 30) mesh-refinement-cpp 23.6467 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 27, 1, 22, 51) mesh-topology-cpp 20.5443 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 27, 1, 23, 13) mesh-unitcube-cpp 21.8913 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 27, 1, 23, 57) mesh-iteration-cpp 41.0244 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 27, 1, 24, 19) function-evaluation-cpp 21.9048 "Evaluations of functions at arbitrary points." (2012, 9, 27, 1, 24, 19) function-evaluation-cpp 21.8233 "Evaluations of functions at arbitrary points." (2012, 9, 27, 1, 24, 24) function-extrapolation-python 5.54644 "BENCH: 1.94915890694" (2012, 9, 27, 1, 24, 24) function-extrapolation-python 1.94916 "BENCH: 1.94915890694" (2012, 9, 27, 1, 24, 47) la-vector-access-cpp 22.5069 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 27, 1, 25, 12) la-vector-assignment-cpp 25.5253 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 28, 1, 11, 13) common-progress-cpp 29.6133 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 28, 1, 11, 42) common-timing-cpp 29.0405 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 28, 1, 13, 30) fem-multicore-cpp 107.814 "Coloring mesh." (2012, 9, 28, 1, 15, 52) fem-assembly-cpp 142.62 "Assembly for various forms and backends" (2012, 9, 28, 1, 16, 6) fem-convergence-cpp 13.3901 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 28, 1, 16, 6) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2012, 9, 28, 1, 22, 26) fem-speedup-cpp 379.907 "Assembly/solve speedup running on 4 processors" (2012, 9, 28, 1, 22, 26) fem-speedup-cpp-assembly 6.04427 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 28, 1, 22, 26) fem-speedup-cpp-solve 1.61463 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 28, 1, 22, 52) mesh-refinement-cpp 24.0284 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 28, 1, 23, 13) mesh-topology-cpp 20.7403 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 28, 1, 23, 36) mesh-unitcube-cpp 22.8326 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 28, 1, 24, 19) mesh-iteration-cpp 41.0062 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 28, 1, 24, 42) function-evaluation-cpp 21.9311 "Evaluations of functions at arbitrary points." (2012, 9, 28, 1, 24, 42) function-evaluation-cpp 21.8367 "Evaluations of functions at arbitrary points." (2012, 9, 28, 1, 24, 47) function-extrapolation-python 5.49925 "BENCH: 1.93289494514" (2012, 9, 28, 1, 24, 47) function-extrapolation-python 1.93289 "BENCH: 1.93289494514" (2012, 9, 28, 1, 25, 12) la-vector-access-cpp 24.8691 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 28, 1, 25, 40) la-vector-assignment-cpp 27.9045 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 29, 1, 11, 31) common-progress-cpp 47.7193 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 29, 1, 12, 0) common-timing-cpp 28.5082 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 29, 1, 13, 48) fem-multicore-cpp 107.933 "Coloring mesh." (2012, 9, 29, 1, 16, 11) fem-assembly-cpp 143.145 "Assembly for various forms and backends" (2012, 9, 29, 1, 16, 24) fem-convergence-cpp 13.3756 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 29, 1, 16, 25) fem-jit-python 0.000413704 "JIT compilation (in memory cache)" (2012, 9, 29, 1, 22, 42) fem-speedup-cpp 376.965 "Assembly/solve speedup running on 4 processors" (2012, 9, 29, 1, 22, 42) fem-speedup-cpp-assembly 6.23284 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 29, 1, 22, 42) fem-speedup-cpp-solve 1.65074 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 29, 1, 23, 8) mesh-refinement-cpp 24.0957 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 29, 1, 23, 29) mesh-topology-cpp 20.771 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 29, 1, 23, 52) mesh-unitcube-cpp 22.8637 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 29, 1, 24, 42) mesh-iteration-cpp 47.9873 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 29, 1, 25, 4) function-evaluation-cpp 21.9068 "Evaluations of functions at arbitrary points." (2012, 9, 29, 1, 25, 4) function-evaluation-cpp 21.8096 "Evaluations of functions at arbitrary points." (2012, 9, 29, 1, 25, 10) function-extrapolation-python 5.53809 "BENCH: 1.93129992485" (2012, 9, 29, 1, 25, 10) function-extrapolation-python 1.9313 "BENCH: 1.93129992485" (2012, 9, 29, 1, 25, 33) la-vector-access-cpp 23.0662 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 29, 1, 25, 58) la-vector-assignment-cpp 25.5173 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 9, 30, 1, 11, 8) common-progress-cpp 29.5861 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 9, 30, 1, 11, 37) common-timing-cpp 28.4111 "Timing access and registration of timings (10000000 repetitions)" (2012, 9, 30, 1, 13, 25) fem-multicore-cpp 108.645 "Coloring mesh." (2012, 9, 30, 1, 15, 48) fem-assembly-cpp 142.402 "Assembly for various forms and backends" (2012, 9, 30, 1, 16, 1) fem-convergence-cpp 13.3853 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 9, 30, 1, 16, 2) fem-jit-python 0.000404596 "JIT compilation (in memory cache)" (2012, 9, 30, 1, 22, 5) fem-speedup-cpp 362.844 "Assembly/solve speedup running on 4 processors" (2012, 9, 30, 1, 22, 5) fem-speedup-cpp-assembly 5.97461 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 9, 30, 1, 22, 5) fem-speedup-cpp-solve 1.88495 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 9, 30, 1, 22, 30) mesh-refinement-cpp 23.9759 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 9, 30, 1, 22, 52) mesh-topology-cpp 20.7914 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 9, 30, 1, 23, 14) mesh-unitcube-cpp 22.8583 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 9, 30, 1, 23, 58) mesh-iteration-cpp 41.0752 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 9, 30, 1, 24, 20) function-evaluation-cpp 21.881 "Evaluations of functions at arbitrary points." (2012, 9, 30, 1, 24, 20) function-evaluation-cpp 21.8001 "Evaluations of functions at arbitrary points." (2012, 9, 30, 1, 24, 25) function-extrapolation-python 5.35302 "BENCH: 1.89962601662" (2012, 9, 30, 1, 24, 25) function-extrapolation-python 1.89963 "BENCH: 1.89962601662" (2012, 9, 30, 1, 24, 49) la-vector-access-cpp 23.6877 "Accessing vector of size 10000000 (100 repetitions)" (2012, 9, 30, 1, 25, 15) la-vector-assignment-cpp 25.5145 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 1, 1, 14, 26) common-progress-cpp 29.7977 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 1, 1, 14, 55) common-timing-cpp 28.9869 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 1, 1, 16, 43) fem-multicore-cpp 107.883 "Coloring mesh." (2012, 10, 1, 1, 19, 6) fem-assembly-cpp 142.334 "Assembly for various forms and backends" (2012, 10, 1, 1, 19, 19) fem-convergence-cpp 13.3669 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 1, 1, 19, 20) fem-jit-python 0.000411797 "JIT compilation (in memory cache)" (2012, 10, 1, 1, 25, 44) fem-speedup-cpp 384.676 "Assembly/solve speedup running on 4 processors" (2012, 10, 1, 1, 25, 44) fem-speedup-cpp-assembly 6.21876 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 1, 1, 25, 44) fem-speedup-cpp-solve 1.55803 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 1, 1, 26, 10) mesh-refinement-cpp 24.001 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 1, 1, 26, 31) mesh-topology-cpp 20.7638 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 1, 1, 26, 54) mesh-unitcube-cpp 22.8602 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 1, 1, 27, 37) mesh-iteration-cpp 41.0101 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 1, 1, 27, 59) function-evaluation-cpp 21.5396 "Evaluations of functions at arbitrary points." (2012, 10, 1, 1, 27, 59) function-evaluation-cpp 21.4428 "Evaluations of functions at arbitrary points." (2012, 10, 1, 1, 28, 4) function-extrapolation-python 5.29918 "BENCH: 1.90193295479" (2012, 10, 1, 1, 28, 4) function-extrapolation-python 1.90193 "BENCH: 1.90193295479" (2012, 10, 1, 1, 28, 26) la-vector-access-cpp 22.248 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 1, 1, 28, 52) la-vector-assignment-cpp 25.519 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 2, 1, 11, 10) common-progress-cpp 29.6006 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 2, 1, 11, 39) common-timing-cpp 28.3973 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 2, 1, 13, 28) fem-multicore-cpp 108.952 "Coloring mesh." (2012, 10, 2, 1, 15, 52) fem-assembly-cpp 143.9 "Assembly for various forms and backends" (2012, 10, 2, 1, 16, 5) fem-convergence-cpp 13.3715 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 2, 1, 16, 6) fem-jit-python 0.000425506 "JIT compilation (in memory cache)" (2012, 10, 2, 1, 22, 32) fem-speedup-cpp 386.403 "Assembly/solve speedup running on 4 processors" (2012, 10, 2, 1, 22, 32) fem-speedup-cpp-assembly 6.12962 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 2, 1, 22, 32) fem-speedup-cpp-solve 1.53724 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 2, 1, 22, 58) mesh-refinement-cpp 24.0623 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 2, 1, 23, 19) mesh-topology-cpp 20.7278 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 2, 1, 23, 42) mesh-unitcube-cpp 22.8369 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 2, 1, 24, 25) mesh-iteration-cpp 41.0071 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 2, 1, 24, 47) function-evaluation-cpp 21.8894 "Evaluations of functions at arbitrary points." (2012, 10, 2, 1, 24, 47) function-evaluation-cpp 21.794 "Evaluations of functions at arbitrary points." (2012, 10, 2, 1, 24, 53) function-extrapolation-python 5.35678 "BENCH: 1.90628290176" (2012, 10, 2, 1, 24, 53) function-extrapolation-python 1.90628 "BENCH: 1.90628290176" (2012, 10, 2, 1, 25, 15) la-vector-access-cpp 22.2436 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 2, 1, 25, 41) la-vector-assignment-cpp 25.5693 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 3, 1, 11, 17) common-progress-cpp 29.569 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 3, 1, 11, 45) common-timing-cpp 28.3248 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 3, 1, 13, 34) fem-multicore-cpp 109.109 "Coloring mesh." (2012, 10, 3, 1, 15, 57) fem-assembly-cpp 142.903 "Assembly for various forms and backends" (2012, 10, 3, 1, 16, 10) fem-convergence-cpp 13.384 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 3, 1, 16, 11) fem-jit-python 0.000418591 "JIT compilation (in memory cache)" (2012, 10, 3, 1, 22, 26) fem-speedup-cpp 374.484 "Assembly/solve speedup running on 4 processors" (2012, 10, 3, 1, 22, 26) fem-speedup-cpp-assembly 6.09382 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 3, 1, 22, 26) fem-speedup-cpp-solve 1.70573 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 3, 1, 22, 51) mesh-refinement-cpp 23.7131 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 3, 1, 23, 12) mesh-topology-cpp 20.7221 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 3, 1, 23, 34) mesh-unitcube-cpp 21.9531 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 3, 1, 24, 21) mesh-iteration-cpp 44.4199 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 3, 1, 24, 43) function-evaluation-cpp 21.82 "Evaluations of functions at arbitrary points." (2012, 10, 3, 1, 24, 43) function-evaluation-cpp 21.7338 "Evaluations of functions at arbitrary points." (2012, 10, 3, 1, 24, 48) function-extrapolation-python 5.53245 "BENCH: 1.93266105652" (2012, 10, 3, 1, 24, 48) function-extrapolation-python 1.93266 "BENCH: 1.93266105652" (2012, 10, 3, 1, 25, 13) la-vector-access-cpp 24.8894 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 3, 1, 25, 39) la-vector-assignment-cpp 25.5064 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 4, 1, 11, 11) common-progress-cpp 36.4362 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 4, 1, 11, 41) common-timing-cpp 29.8187 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 4, 1, 13, 29) fem-multicore-cpp 108.076 "Coloring mesh." (2012, 10, 4, 1, 15, 52) fem-assembly-cpp 143.135 "Assembly for various forms and backends" (2012, 10, 4, 1, 16, 6) fem-convergence-cpp 13.3825 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 4, 1, 16, 7) fem-jit-python 0.000425911 "JIT compilation (in memory cache)" (2012, 10, 4, 1, 22, 14) fem-speedup-cpp 367.408 "Assembly/solve speedup running on 4 processors" (2012, 10, 4, 1, 22, 14) fem-speedup-cpp-assembly 6.25707 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 4, 1, 22, 14) fem-speedup-cpp-solve 1.82569 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 4, 1, 22, 39) mesh-refinement-cpp 23.6219 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 4, 1, 23, 0) mesh-topology-cpp 20.9927 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 4, 1, 23, 22) mesh-unitcube-cpp 21.5831 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 4, 1, 24, 4) mesh-iteration-cpp 39.8708 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 4, 1, 24, 26) function-evaluation-cpp 21.9227 "Evaluations of functions at arbitrary points." (2012, 10, 4, 1, 24, 26) function-evaluation-cpp 21.8203 "Evaluations of functions at arbitrary points." (2012, 10, 4, 1, 24, 32) function-extrapolation-python 5.44318 "BENCH: 1.94250607491" (2012, 10, 4, 1, 24, 32) function-extrapolation-python 1.94251 "BENCH: 1.94250607491" (2012, 10, 4, 1, 24, 57) la-vector-access-cpp 24.9693 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 4, 1, 25, 25) la-vector-assignment-cpp 28.3925 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 5, 1, 10, 47) common-progress-cpp 29.6076 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 5, 1, 11, 17) common-timing-cpp 29.8419 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 5, 1, 13, 5) fem-multicore-cpp 108.098 "Coloring mesh." (2012, 10, 5, 1, 15, 29) fem-assembly-cpp 143.573 "Assembly for various forms and backends" (2012, 10, 5, 1, 15, 42) fem-convergence-cpp 13.3563 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 5, 1, 15, 43) fem-jit-python 0.000414705 "JIT compilation (in memory cache)" (2012, 10, 5, 1, 22, 10) fem-speedup-cpp 386.838 "Assembly/solve speedup running on 4 processors" (2012, 10, 5, 1, 22, 10) fem-speedup-cpp-assembly 6.18296 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 5, 1, 22, 10) fem-speedup-cpp-solve 1.55 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 5, 1, 22, 35) mesh-refinement-cpp 23.6266 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 5, 1, 22, 56) mesh-topology-cpp 21.036 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 5, 1, 23, 18) mesh-unitcube-cpp 21.9407 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 5, 1, 24, 0) mesh-iteration-cpp 39.8735 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 5, 1, 24, 22) function-evaluation-cpp 21.9317 "Evaluations of functions at arbitrary points." (2012, 10, 5, 1, 24, 22) function-evaluation-cpp 21.8358 "Evaluations of functions at arbitrary points." (2012, 10, 5, 1, 24, 28) function-extrapolation-python 5.52398 "BENCH: 1.90278792381" (2012, 10, 5, 1, 24, 28) function-extrapolation-python 1.90279 "BENCH: 1.90278792381" (2012, 10, 5, 1, 24, 56) la-vector-access-cpp 27.8847 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 5, 1, 25, 21) la-vector-assignment-cpp 25.5232 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 6, 1, 11, 4) common-progress-cpp 29.5893 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 6, 1, 11, 33) common-timing-cpp 29.3947 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 6, 1, 13, 48) fem-multicore-cpp 134.171 "Coloring mesh." (2012, 10, 6, 1, 20, 49) fem-assembly-cpp 421.039 "Assembly for various forms and backends" (2012, 10, 6, 1, 21, 2) fem-convergence-cpp 13.0996 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 6, 1, 21, 2) fem-jit-python 0.000415993 "JIT compilation (in memory cache)" (2012, 10, 6, 2, 16, 7) fem-speedup-cpp 3304.04 "Assembly/solve speedup running on 4 processors" (2012, 10, 6, 2, 16, 7) fem-speedup-cpp-assembly 6.22398 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 6, 2, 16, 7) fem-speedup-cpp-solve 1.92808 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 6, 2, 16, 32) mesh-refinement-cpp 23.9863 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 6, 2, 16, 53) mesh-topology-cpp 20.7132 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 6, 2, 17, 17) mesh-unitcube-cpp 24.2534 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 6, 2, 18, 0) mesh-iteration-cpp 39.8714 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 6, 2, 18, 28) function-evaluation-cpp 28.4574 "Evaluations of functions at arbitrary points." (2012, 10, 6, 2, 18, 28) function-evaluation-cpp 28.3718 "Evaluations of functions at arbitrary points." (2012, 10, 6, 2, 18, 34) function-extrapolation-python 5.49477 "BENCH: 1.94015908241" (2012, 10, 6, 2, 18, 34) function-extrapolation-python 1.94016 "BENCH: 1.94015908241" (2012, 10, 6, 2, 18, 59) la-vector-access-cpp 24.8462 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 6, 2, 19, 24) la-vector-assignment-cpp 25.5061 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 7, 1, 11, 3) common-progress-cpp 29.8116 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 7, 1, 11, 31) common-timing-cpp 28.1932 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 7, 1, 13, 47) fem-multicore-cpp 135.999 "Coloring mesh." (2012, 10, 7, 1, 20, 51) fem-assembly-cpp 424.349 "Assembly for various forms and backends" (2012, 10, 7, 1, 21, 4) fem-convergence-cpp 13.2273 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 7, 1, 21, 5) fem-jit-python 0.00043571 "JIT compilation (in memory cache)" (2012, 10, 7, 2, 16, 28) fem-speedup-cpp 3323.09 "Assembly/solve speedup running on 4 processors" (2012, 10, 7, 2, 16, 28) fem-speedup-cpp-assembly 6.27355 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 7, 2, 16, 28) fem-speedup-cpp-solve 1.53843 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 7, 2, 16, 54) mesh-refinement-cpp 23.8286 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 7, 2, 17, 15) mesh-topology-cpp 20.826 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 7, 2, 17, 39) mesh-unitcube-cpp 23.9602 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 7, 2, 18, 27) mesh-iteration-cpp 46.0029 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 7, 2, 18, 56) function-evaluation-cpp 28.4519 "Evaluations of functions at arbitrary points." (2012, 10, 7, 2, 18, 56) function-evaluation-cpp 28.3571 "Evaluations of functions at arbitrary points." (2012, 10, 7, 2, 19, 2) function-extrapolation-python 5.54058 "BENCH: 1.9537229538" (2012, 10, 7, 2, 19, 2) function-extrapolation-python 1.95372 "BENCH: 1.9537229538" (2012, 10, 7, 2, 19, 24) la-vector-access-cpp 22.4965 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 7, 2, 19, 50) la-vector-assignment-cpp 25.4159 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 8, 1, 11, 7) common-progress-cpp 36.4363 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 8, 1, 11, 35) common-timing-cpp 28.1186 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 8, 1, 13, 50) fem-multicore-cpp 134.317 "Coloring mesh." (2012, 10, 8, 1, 20, 57) fem-assembly-cpp 426.917 "Assembly for various forms and backends" (2012, 10, 8, 1, 21, 10) fem-convergence-cpp 13.2095 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 8, 1, 21, 11) fem-jit-python 0.000414491 "JIT compilation (in memory cache)" (2012, 10, 8, 2, 16, 35) fem-speedup-cpp 3324.54 "Assembly/solve speedup running on 4 processors" (2012, 10, 8, 2, 16, 35) fem-speedup-cpp-assembly 6.07838 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 8, 2, 16, 35) fem-speedup-cpp-solve 1.86639 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 8, 2, 17, 0) mesh-refinement-cpp 23.8644 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 8, 2, 17, 21) mesh-topology-cpp 20.7884 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 8, 2, 17, 46) mesh-unitcube-cpp 24.7006 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 8, 2, 18, 28) mesh-iteration-cpp 39.877 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 8, 2, 18, 57) function-evaluation-cpp 28.4609 "Evaluations of functions at arbitrary points." (2012, 10, 8, 2, 18, 57) function-evaluation-cpp 28.3395 "Evaluations of functions at arbitrary points." (2012, 10, 8, 2, 19, 2) function-extrapolation-python 4.85098 "BENCH: 1.88601994514" (2012, 10, 8, 2, 19, 2) function-extrapolation-python 1.88602 "BENCH: 1.88601994514" (2012, 10, 8, 2, 19, 27) la-vector-access-cpp 24.9781 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 8, 2, 19, 52) la-vector-assignment-cpp 25.5121 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 10, 1, 10, 55) common-progress-cpp 29.6756 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 10, 1, 11, 26) common-timing-cpp 31.2842 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 10, 1, 13, 15) fem-multicore-cpp 108.393 "Coloring mesh." (2012, 10, 10, 1, 15, 40) fem-assembly-cpp 145.062 "Assembly for various forms and backends" (2012, 10, 10, 1, 15, 53) fem-convergence-cpp 12.8455 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 10, 1, 15, 53) fem-jit-python 0.000422287 "JIT compilation (in memory cache)" (2012, 10, 10, 1, 22, 16) fem-speedup-cpp 382.598 "Assembly/solve speedup running on 4 processors" (2012, 10, 10, 1, 22, 16) fem-speedup-cpp-assembly 6.27907 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 10, 1, 22, 16) fem-speedup-cpp-solve 1.60051 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 10, 1, 22, 42) mesh-refinement-cpp 23.8081 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 10, 1, 23, 2) mesh-topology-cpp 20.4471 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 10, 1, 23, 28) mesh-unitcube-cpp 25.2329 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 10, 1, 24, 10) mesh-iteration-cpp 39.8649 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 10, 1, 24, 32) function-evaluation-cpp 21.9984 "Evaluations of functions at arbitrary points." (2012, 10, 10, 1, 24, 32) function-evaluation-cpp 21.8963 "Evaluations of functions at arbitrary points." (2012, 10, 10, 1, 24, 38) function-extrapolation-python 5.44042 "BENCH: 1.89774489403" (2012, 10, 10, 1, 24, 38) function-extrapolation-python 1.89774 "BENCH: 1.89774489403" (2012, 10, 10, 1, 25, 3) la-vector-access-cpp 24.9716 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 10, 1, 25, 31) la-vector-assignment-cpp 27.8934 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 11, 1, 11, 9) common-progress-cpp 29.7959 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 11, 1, 11, 38) common-timing-cpp 29.7389 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 11, 1, 13, 26) fem-multicore-cpp 107.618 "Coloring mesh." (2012, 10, 11, 1, 15, 50) fem-assembly-cpp 143.99 "Assembly for various forms and backends" (2012, 10, 11, 1, 16, 3) fem-convergence-cpp 13.283 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 11, 1, 16, 4) fem-jit-python 0.000419879 "JIT compilation (in memory cache)" (2012, 10, 11, 1, 22, 10) fem-speedup-cpp 366.102 "Assembly/solve speedup running on 4 processors" (2012, 10, 11, 1, 22, 10) fem-speedup-cpp-assembly 6.16601 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 11, 1, 22, 10) fem-speedup-cpp-solve 1.88006 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 11, 1, 22, 36) mesh-refinement-cpp 23.9996 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 11, 1, 22, 57) mesh-topology-cpp 20.6914 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 11, 1, 23, 22) mesh-unitcube-cpp 25.1739 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 11, 1, 24, 7) mesh-iteration-cpp 41.7616 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 11, 1, 24, 28) function-evaluation-cpp 21.7646 "Evaluations of functions at arbitrary points." (2012, 10, 11, 1, 24, 28) function-evaluation-cpp 21.6625 "Evaluations of functions at arbitrary points." (2012, 10, 11, 1, 24, 34) function-extrapolation-python 5.38501 "BENCH: 1.8960211277" (2012, 10, 11, 1, 24, 34) function-extrapolation-python 1.89602 "BENCH: 1.8960211277" (2012, 10, 11, 1, 24, 59) la-vector-access-cpp 24.997 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 11, 1, 25, 27) la-vector-assignment-cpp 27.8964 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 12, 1, 11, 4) common-progress-cpp 29.6314 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 12, 1, 11, 34) common-timing-cpp 30.112 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 12, 1, 13, 21) fem-multicore-cpp 107.016 "Coloring mesh." (2012, 10, 12, 1, 15, 44) fem-assembly-cpp 143.37 "Assembly for various forms and backends" (2012, 10, 12, 1, 15, 57) fem-convergence-cpp 13.0292 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 12, 1, 15, 58) fem-jit-python 0.000414109 "JIT compilation (in memory cache)" (2012, 10, 12, 1, 22, 28) fem-speedup-cpp 389.83 "Assembly/solve speedup running on 4 processors" (2012, 10, 12, 1, 22, 28) fem-speedup-cpp-assembly 6.15052 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 12, 1, 22, 28) fem-speedup-cpp-solve 1.51194 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 12, 1, 22, 53) mesh-refinement-cpp 23.8275 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 12, 1, 23, 14) mesh-topology-cpp 20.6546 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 12, 1, 23, 39) mesh-unitcube-cpp 25.149 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 12, 1, 24, 22) mesh-iteration-cpp 39.8918 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 12, 1, 24, 44) function-evaluation-cpp 21.8857 "Evaluations of functions at arbitrary points." (2012, 10, 12, 1, 24, 44) function-evaluation-cpp 21.7849 "Evaluations of functions at arbitrary points." (2012, 10, 12, 1, 24, 50) function-extrapolation-python 5.70246 "BENCH: 1.89557099342" (2012, 10, 12, 1, 24, 50) function-extrapolation-python 1.89557 "BENCH: 1.89557099342" (2012, 10, 12, 1, 25, 18) la-vector-access-cpp 27.885 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 12, 1, 25, 50) la-vector-assignment-cpp 31.9626 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 13, 1, 11, 6) common-progress-cpp 29.7911 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 13, 1, 11, 34) common-timing-cpp 28.1414 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 13, 1, 13, 21) fem-multicore-cpp 107.134 "Coloring mesh." (2012, 10, 13, 1, 15, 46) fem-assembly-cpp 145.19 "Assembly for various forms and backends" (2012, 10, 13, 1, 16, 0) fem-convergence-cpp 13.1017 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 13, 1, 16, 0) fem-jit-python 0.000406003 "JIT compilation (in memory cache)" (2012, 10, 13, 1, 22, 4) fem-speedup-cpp 363.206 "Assembly/solve speedup running on 4 processors" (2012, 10, 13, 1, 22, 4) fem-speedup-cpp-assembly 6.16716 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 13, 1, 22, 4) fem-speedup-cpp-solve 1.89728 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 13, 1, 22, 29) mesh-refinement-cpp 23.6697 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 13, 1, 22, 49) mesh-topology-cpp 20.3828 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 13, 1, 23, 15) mesh-unitcube-cpp 25.1925 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 13, 1, 23, 59) mesh-iteration-cpp 42.1989 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 13, 1, 24, 21) function-evaluation-cpp 21.8454 "Evaluations of functions at arbitrary points." (2012, 10, 13, 1, 24, 21) function-evaluation-cpp 21.7607 "Evaluations of functions at arbitrary points." (2012, 10, 13, 1, 24, 27) function-extrapolation-python 5.42938 "BENCH: 1.89672780037" (2012, 10, 13, 1, 24, 27) function-extrapolation-python 1.89673 "BENCH: 1.89672780037" (2012, 10, 13, 1, 24, 52) la-vector-access-cpp 25.0082 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 13, 1, 25, 20) la-vector-assignment-cpp 27.8997 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 14, 1, 10, 59) common-progress-cpp 29.6104 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 14, 1, 11, 28) common-timing-cpp 29.303 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 14, 1, 13, 17) fem-multicore-cpp 108.286 "Coloring mesh." (2012, 10, 14, 1, 15, 42) fem-assembly-cpp 145.013 "Assembly for various forms and backends" (2012, 10, 14, 1, 15, 55) fem-convergence-cpp 13.1318 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 14, 1, 15, 56) fem-jit-python 0.000409698 "JIT compilation (in memory cache)" (2012, 10, 14, 1, 22, 5) fem-speedup-cpp 369.518 "Assembly/solve speedup running on 4 processors" (2012, 10, 14, 1, 22, 5) fem-speedup-cpp-assembly 6.18168 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 14, 1, 22, 5) fem-speedup-cpp-solve 1.78852 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 14, 1, 22, 30) mesh-refinement-cpp 23.6548 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 14, 1, 22, 51) mesh-topology-cpp 20.4598 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 14, 1, 23, 16) mesh-unitcube-cpp 25.1253 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 14, 1, 23, 59) mesh-iteration-cpp 39.8827 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 14, 1, 24, 21) function-evaluation-cpp 21.9072 "Evaluations of functions at arbitrary points." (2012, 10, 14, 1, 24, 21) function-evaluation-cpp 21.8176 "Evaluations of functions at arbitrary points." (2012, 10, 14, 1, 24, 26) function-extrapolation-python 5.48543 "BENCH: 1.89035010338" (2012, 10, 14, 1, 24, 26) function-extrapolation-python 1.89035 "BENCH: 1.89035010338" (2012, 10, 14, 1, 24, 54) la-vector-access-cpp 27.896 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 14, 1, 25, 22) la-vector-assignment-cpp 27.9296 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 15, 1, 11, 3) common-progress-cpp 29.6303 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 15, 1, 11, 31) common-timing-cpp 28.7557 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 15, 1, 13, 18) fem-multicore-cpp 106.775 "Coloring mesh." (2012, 10, 15, 1, 15, 42) fem-assembly-cpp 143.434 "Assembly for various forms and backends" (2012, 10, 15, 1, 15, 55) fem-convergence-cpp 13.1809 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 15, 1, 15, 56) fem-jit-python 0.000412297 "JIT compilation (in memory cache)" (2012, 10, 15, 1, 22, 2) fem-speedup-cpp 365.924 "Assembly/solve speedup running on 4 processors" (2012, 10, 15, 1, 22, 2) fem-speedup-cpp-assembly 6.21584 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 15, 1, 22, 2) fem-speedup-cpp-solve 1.84441 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 15, 1, 22, 27) mesh-refinement-cpp 23.7086 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 15, 1, 22, 48) mesh-topology-cpp 20.4438 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 15, 1, 23, 13) mesh-unitcube-cpp 24.9571 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 15, 1, 23, 55) mesh-iteration-cpp 39.8855 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 15, 1, 24, 17) function-evaluation-cpp 22.0873 "Evaluations of functions at arbitrary points." (2012, 10, 15, 1, 24, 17) function-evaluation-cpp 21.9876 "Evaluations of functions at arbitrary points." (2012, 10, 15, 1, 24, 23) function-extrapolation-python 5.46758 "BENCH: 1.88941311836" (2012, 10, 15, 1, 24, 23) function-extrapolation-python 1.88941 "BENCH: 1.88941311836" (2012, 10, 15, 1, 24, 48) la-vector-access-cpp 25.0158 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 15, 1, 25, 18) la-vector-assignment-cpp 29.8982 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 16, 1, 11, 2) common-progress-cpp 29.6326 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 16, 1, 11, 31) common-timing-cpp 28.9816 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 16, 1, 13, 18) fem-multicore-cpp 107.339 "Coloring mesh." (2012, 10, 16, 1, 15, 42) fem-assembly-cpp 144.256 "Assembly for various forms and backends" (2012, 10, 16, 1, 15, 56) fem-convergence-cpp 13.0873 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 16, 1, 15, 56) fem-jit-python 0.00041759 "JIT compilation (in memory cache)" (2012, 10, 16, 1, 22, 20) fem-speedup-cpp 383.173 "Assembly/solve speedup running on 4 processors" (2012, 10, 16, 1, 22, 20) fem-speedup-cpp-assembly 6.16102 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 16, 1, 22, 20) fem-speedup-cpp-solve 1.58601 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 16, 1, 22, 45) mesh-refinement-cpp 23.7392 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 16, 1, 23, 6) mesh-topology-cpp 20.4203 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 16, 1, 23, 31) mesh-unitcube-cpp 24.9546 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 16, 1, 24, 13) mesh-iteration-cpp 39.8789 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 16, 1, 24, 35) function-evaluation-cpp 21.9034 "Evaluations of functions at arbitrary points." (2012, 10, 16, 1, 24, 35) function-evaluation-cpp 21.8018 "Evaluations of functions at arbitrary points." (2012, 10, 16, 1, 24, 41) function-extrapolation-python 5.57063 "BENCH: 1.88705778122" (2012, 10, 16, 1, 24, 41) function-extrapolation-python 1.88706 "BENCH: 1.88705778122" (2012, 10, 16, 1, 25, 9) la-vector-access-cpp 27.881 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 16, 1, 25, 37) la-vector-assignment-cpp 27.8991 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 17, 1, 11, 23) common-progress-cpp 47.7146 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 17, 1, 11, 53) common-timing-cpp 29.3424 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 17, 1, 13, 40) fem-multicore-cpp 107.024 "Coloring mesh." (2012, 10, 17, 1, 16, 3) fem-assembly-cpp 143.514 "Assembly for various forms and backends" (2012, 10, 17, 1, 16, 16) fem-convergence-cpp 13.2208 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 17, 1, 16, 17) fem-jit-python 0.000418711 "JIT compilation (in memory cache)" (2012, 10, 17, 1, 22, 20) fem-speedup-cpp 362.632 "Assembly/solve speedup running on 4 processors" (2012, 10, 17, 1, 22, 20) fem-speedup-cpp-assembly 6.15154 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 17, 1, 22, 20) fem-speedup-cpp-solve 1.88051 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 17, 1, 22, 45) mesh-refinement-cpp 23.7093 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 17, 1, 23, 6) mesh-topology-cpp 20.4665 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 17, 1, 23, 31) mesh-unitcube-cpp 24.9678 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 17, 1, 24, 13) mesh-iteration-cpp 39.8805 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 17, 1, 24, 35) function-evaluation-cpp 21.9202 "Evaluations of functions at arbitrary points." (2012, 10, 17, 1, 24, 35) function-evaluation-cpp 21.8163 "Evaluations of functions at arbitrary points." (2012, 10, 17, 1, 24, 41) function-extrapolation-python 5.50883 "BENCH: 1.90085911751" (2012, 10, 17, 1, 24, 41) function-extrapolation-python 1.90086 "BENCH: 1.90085911751" (2012, 10, 17, 1, 25, 9) la-vector-access-cpp 27.9921 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 17, 1, 25, 37) la-vector-assignment-cpp 27.9122 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 18, 1, 10, 57) common-progress-cpp 37.6863 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 18, 1, 11, 26) common-timing-cpp 28.8341 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 18, 1, 13, 13) fem-multicore-cpp 106.985 "Coloring mesh." (2012, 10, 18, 1, 15, 36) fem-assembly-cpp 143.382 "Assembly for various forms and backends" (2012, 10, 18, 1, 15, 49) fem-convergence-cpp 13.1261 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 18, 1, 15, 50) fem-jit-python 0.000414801 "JIT compilation (in memory cache)" (2012, 10, 18, 1, 22, 4) fem-speedup-cpp 373.573 "Assembly/solve speedup running on 4 processors" (2012, 10, 18, 1, 22, 4) fem-speedup-cpp-assembly 6.39121 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 18, 1, 22, 4) fem-speedup-cpp-solve 1.705 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 18, 1, 22, 29) mesh-refinement-cpp 23.7853 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 18, 1, 22, 50) mesh-topology-cpp 20.4528 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 18, 1, 23, 15) mesh-unitcube-cpp 24.9561 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 18, 1, 23, 59) mesh-iteration-cpp 41.6841 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 18, 1, 24, 21) function-evaluation-cpp 21.9286 "Evaluations of functions at arbitrary points." (2012, 10, 18, 1, 24, 21) function-evaluation-cpp 21.8291 "Evaluations of functions at arbitrary points." (2012, 10, 18, 1, 24, 27) function-extrapolation-python 5.50077 "BENCH: 1.90567708015" (2012, 10, 18, 1, 24, 27) function-extrapolation-python 1.90568 "BENCH: 1.90567708015" (2012, 10, 18, 1, 24, 52) la-vector-access-cpp 25.0288 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 18, 1, 25, 24) la-vector-assignment-cpp 31.9189 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 10, 19, 1, 11, 9) common-progress-cpp 29.7909 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 10, 19, 1, 11, 39) common-timing-cpp 29.2514 "Timing access and registration of timings (10000000 repetitions)" (2012, 10, 19, 1, 13, 28) fem-multicore-cpp 109.284 "Coloring mesh." (2012, 10, 19, 1, 15, 51) fem-assembly-cpp 143.255 "Assembly for various forms and backends" (2012, 10, 19, 1, 16, 4) fem-convergence-cpp 13.1273 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 10, 19, 1, 16, 5) fem-jit-python 0.000416088 "JIT compilation (in memory cache)" (2012, 10, 19, 1, 22, 28) fem-speedup-cpp 383.027 "Assembly/solve speedup running on 4 processors" (2012, 10, 19, 1, 22, 28) fem-speedup-cpp-assembly 6.22418 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 10, 19, 1, 22, 28) fem-speedup-cpp-solve 1.57998 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 10, 19, 1, 22, 53) mesh-refinement-cpp 23.7088 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 10, 19, 1, 23, 14) mesh-topology-cpp 20.4493 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 10, 19, 1, 23, 39) mesh-unitcube-cpp 25.0553 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 10, 19, 1, 24, 28) mesh-iteration-cpp 46.0101 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 10, 19, 1, 24, 50) function-evaluation-cpp 21.9119 "Evaluations of functions at arbitrary points." (2012, 10, 19, 1, 24, 50) function-evaluation-cpp 21.8117 "Evaluations of functions at arbitrary points." (2012, 10, 19, 1, 24, 56) function-extrapolation-python 5.75036 "BENCH: 1.90998411179" (2012, 10, 19, 1, 24, 56) function-extrapolation-python 1.90998 "BENCH: 1.90998411179" (2012, 10, 19, 1, 25, 21) la-vector-access-cpp 24.9921 "Accessing vector of size 10000000 (100 repetitions)" (2012, 10, 19, 1, 25, 49) la-vector-assignment-cpp 27.8993 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 1, 15, 5, 58) common-progress-cpp 36.4445 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 1, 15, 6, 26) common-timing-cpp 27.9173 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 1, 15, 8, 14) fem-multicore-cpp 107.797 "Coloring mesh." (2012, 11, 1, 15, 10, 38) fem-assembly-cpp 144.005 "Assembly for various forms and backends" (2012, 11, 1, 15, 10, 49) fem-convergence-cpp 11.4147 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 1, 15, 10, 50) fem-jit-python 0.000419116 "JIT compilation (in memory cache)" (2012, 11, 1, 15, 16, 13) fem-speedup-cpp 322.674 "Assembly/solve speedup running on 4 processors" (2012, 11, 1, 15, 16, 13) fem-speedup-cpp-assembly 6.36108 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 1, 15, 16, 13) fem-speedup-cpp-solve 2.18473 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 1, 15, 16, 39) mesh-refinement-cpp 24.2369 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 1, 15, 17, 0) mesh-topology-cpp 20.8887 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 1, 15, 17, 28) mesh-unitcube-cpp 27.4108 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 1, 15, 18, 11) mesh-iteration-cpp 39.8901 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 1, 15, 18, 32) function-evaluation-cpp 21.7326 "Evaluations of functions at arbitrary points." (2012, 11, 1, 15, 18, 32) function-evaluation-cpp 21.6272 "Evaluations of functions at arbitrary points." (2012, 11, 1, 15, 18, 38) function-extrapolation-python 5.16388 "BENCH: 1.91285610199" (2012, 11, 1, 15, 18, 38) function-extrapolation-python 1.91286 "BENCH: 1.91285610199" (2012, 11, 1, 15, 19, 2) la-vector-access-cpp 24.0428 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 1, 15, 19, 29) la-vector-assignment-cpp 27.5389 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 2, 2, 11, 51) common-progress-cpp 29.6003 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 2, 2, 12, 17) common-timing-cpp 26.192 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 2, 2, 14, 5) fem-multicore-cpp 107.897 "Coloring mesh." (2012, 11, 2, 2, 16, 27) fem-assembly-cpp 142.676 "Assembly for various forms and backends" (2012, 11, 2, 2, 16, 39) fem-convergence-cpp 11.4203 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 2, 2, 16, 40) fem-jit-python 0.000414681 "JIT compilation (in memory cache)" (2012, 11, 2, 2, 22, 34) fem-speedup-cpp 354.373 "Assembly/solve speedup running on 4 processors" (2012, 11, 2, 2, 22, 34) fem-speedup-cpp-assembly 6.4215 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 2, 2, 22, 34) fem-speedup-cpp-solve 1.55178 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 2, 2, 23, 0) mesh-refinement-cpp 23.9968 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 2, 2, 23, 21) mesh-topology-cpp 20.6611 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 2, 2, 23, 48) mesh-unitcube-cpp 27.3273 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 2, 2, 24, 31) mesh-iteration-cpp 39.8803 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 2, 2, 24, 52) function-evaluation-cpp 21.2047 "Evaluations of functions at arbitrary points." (2012, 11, 2, 2, 24, 52) function-evaluation-cpp 21.1056 "Evaluations of functions at arbitrary points." (2012, 11, 2, 2, 24, 58) function-extrapolation-python 5.29053 "BENCH: 1.87143492699" (2012, 11, 2, 2, 24, 58) function-extrapolation-python 1.87143 "BENCH: 1.87143492699" (2012, 11, 2, 2, 25, 21) la-vector-access-cpp 23.2768 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 2, 2, 25, 49) la-vector-assignment-cpp 27.4323 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 3, 2, 11, 42) common-progress-cpp 28.9295 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 3, 2, 12, 10) common-timing-cpp 27.4472 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 3, 2, 13, 58) fem-multicore-cpp 108.795 "Coloring mesh." (2012, 11, 3, 2, 16, 22) fem-assembly-cpp 143.373 "Assembly for various forms and backends" (2012, 11, 3, 2, 16, 33) fem-convergence-cpp 11.4252 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 3, 2, 16, 34) fem-jit-python 0.00041132 "JIT compilation (in memory cache)" (2012, 11, 3, 2, 21, 50) fem-speedup-cpp 315.672 "Assembly/solve speedup running on 4 processors" (2012, 11, 3, 2, 21, 50) fem-speedup-cpp-assembly 6.45748 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 3, 2, 21, 50) fem-speedup-cpp-solve 2.37984 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 3, 2, 22, 16) mesh-refinement-cpp 24.1271 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 3, 2, 22, 37) mesh-topology-cpp 20.7534 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 3, 2, 23, 4) mesh-unitcube-cpp 27.6688 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 3, 2, 23, 53) mesh-iteration-cpp 46.1058 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 3, 2, 24, 15) function-evaluation-cpp 21.681 "Evaluations of functions at arbitrary points." (2012, 11, 3, 2, 24, 15) function-evaluation-cpp 21.5906 "Evaluations of functions at arbitrary points." (2012, 11, 3, 2, 24, 20) function-extrapolation-python 5.27907 "BENCH: 1.85399603844" (2012, 11, 3, 2, 24, 20) function-extrapolation-python 1.854 "BENCH: 1.85399603844" (2012, 11, 3, 2, 24, 46) la-vector-access-cpp 25.4366 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 3, 2, 25, 13) la-vector-assignment-cpp 27.4319 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 4, 2, 11, 32) common-progress-cpp 28.9459 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 4, 2, 11, 59) common-timing-cpp 26.7289 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 4, 2, 13, 48) fem-multicore-cpp 109.168 "Coloring mesh." (2012, 11, 4, 2, 16, 12) fem-assembly-cpp 143.575 "Assembly for various forms and backends" (2012, 11, 4, 2, 16, 23) fem-convergence-cpp 11.3999 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 4, 2, 16, 24) fem-jit-python 0.000411105 "JIT compilation (in memory cache)" (2012, 11, 4, 2, 21, 41) fem-speedup-cpp 317.117 "Assembly/solve speedup running on 4 processors" (2012, 11, 4, 2, 21, 41) fem-speedup-cpp-assembly 6.4321 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 4, 2, 21, 41) fem-speedup-cpp-solve 2.33182 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 4, 2, 22, 7) mesh-refinement-cpp 24.173 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 4, 2, 22, 28) mesh-topology-cpp 20.6735 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 4, 2, 22, 56) mesh-unitcube-cpp 27.6971 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 4, 2, 23, 38) mesh-iteration-cpp 39.883 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 4, 2, 24, 0) function-evaluation-cpp 21.6981 "Evaluations of functions at arbitrary points." (2012, 11, 4, 2, 24, 0) function-evaluation-cpp 21.6002 "Evaluations of functions at arbitrary points." (2012, 11, 4, 2, 24, 6) function-extrapolation-python 5.19064 "BENCH: 1.86858487129" (2012, 11, 4, 2, 24, 6) function-extrapolation-python 1.86858 "BENCH: 1.86858487129" (2012, 11, 4, 2, 24, 31) la-vector-access-cpp 25.412 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 4, 2, 24, 59) la-vector-assignment-cpp 27.922 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 5, 2, 16, 33) common-progress-cpp 28.9358 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 5, 2, 17, 0) common-timing-cpp 26.9958 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 5, 2, 18, 49) fem-multicore-cpp 108.871 "Coloring mesh." (2012, 11, 5, 2, 21, 13) fem-assembly-cpp 143.36 "Assembly for various forms and backends" (2012, 11, 5, 2, 21, 24) fem-convergence-cpp 11.4351 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 5, 2, 21, 25) fem-jit-python 0.000419998 "JIT compilation (in memory cache)" (2012, 11, 5, 2, 26, 43) fem-speedup-cpp 318.145 "Assembly/solve speedup running on 4 processors" (2012, 11, 5, 2, 26, 43) fem-speedup-cpp-assembly 6.43513 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 5, 2, 26, 43) fem-speedup-cpp-solve 2.31065 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 5, 2, 27, 9) mesh-refinement-cpp 24.1595 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 5, 2, 27, 30) mesh-topology-cpp 20.6874 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 5, 2, 27, 58) mesh-unitcube-cpp 27.6708 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 5, 2, 28, 47) mesh-iteration-cpp 46.1245 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 5, 2, 29, 9) function-evaluation-cpp 21.7343 "Evaluations of functions at arbitrary points." (2012, 11, 5, 2, 29, 9) function-evaluation-cpp 21.6329 "Evaluations of functions at arbitrary points." (2012, 11, 5, 2, 29, 14) function-extrapolation-python 5.40821 "BENCH: 1.85706400871" (2012, 11, 5, 2, 29, 14) function-extrapolation-python 1.85706 "BENCH: 1.85706400871" (2012, 11, 5, 2, 29, 40) la-vector-access-cpp 25.4278 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 5, 2, 30, 7) la-vector-assignment-cpp 27.5069 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 6, 2, 11, 54) common-progress-cpp 28.9825 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 6, 2, 12, 21) common-timing-cpp 26.9318 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 6, 2, 14, 5) fem-multicore-cpp 104.376 "Coloring mesh." (2012, 11, 6, 2, 16, 29) fem-assembly-cpp 143.59 "Assembly for various forms and backends" (2012, 11, 6, 2, 16, 40) fem-convergence-cpp 11.428 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 6, 2, 16, 41) fem-jit-python 0.000420594 "JIT compilation (in memory cache)" (2012, 11, 6, 2, 21, 58) fem-speedup-cpp 316.873 "Assembly/solve speedup running on 4 processors" (2012, 11, 6, 2, 21, 58) fem-speedup-cpp-assembly 6.44359 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 6, 2, 21, 58) fem-speedup-cpp-solve 2.33874 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 6, 2, 22, 24) mesh-refinement-cpp 24.095 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 6, 2, 22, 45) mesh-topology-cpp 20.7545 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 6, 2, 23, 13) mesh-unitcube-cpp 27.4974 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 6, 2, 24, 7) mesh-iteration-cpp 51.0524 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 6, 2, 24, 29) function-evaluation-cpp 21.704 "Evaluations of functions at arbitrary points." (2012, 11, 6, 2, 24, 29) function-evaluation-cpp 21.6003 "Evaluations of functions at arbitrary points." (2012, 11, 6, 2, 24, 34) function-extrapolation-python 5.48166 "BENCH: 1.91927194595" (2012, 11, 6, 2, 24, 34) function-extrapolation-python 1.91927 "BENCH: 1.91927194595" (2012, 11, 6, 2, 24, 58) la-vector-access-cpp 24.0551 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 6, 2, 25, 24) la-vector-assignment-cpp 26.0356 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 7, 2, 11, 45) common-progress-cpp 28.9308 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 7, 2, 12, 11) common-timing-cpp 26.381 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 7, 2, 13, 55) fem-multicore-cpp 104.198 "Coloring mesh." (2012, 11, 7, 2, 16, 19) fem-assembly-cpp 144.06 "Assembly for various forms and backends" (2012, 11, 7, 2, 16, 31) fem-convergence-cpp 11.4373 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 7, 2, 16, 32) fem-jit-python 0.000416589 "JIT compilation (in memory cache)" (2012, 11, 7, 2, 21, 48) fem-speedup-cpp 316.653 "Assembly/solve speedup running on 4 processors" (2012, 11, 7, 2, 21, 48) fem-speedup-cpp-assembly 6.38083 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 7, 2, 21, 48) fem-speedup-cpp-solve 2.3388 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 7, 2, 22, 14) mesh-refinement-cpp 24.0422 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 7, 2, 22, 35) mesh-topology-cpp 20.8434 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 7, 2, 23, 3) mesh-unitcube-cpp 27.504 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 7, 2, 23, 49) mesh-iteration-cpp 43.097 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 7, 2, 24, 11) function-evaluation-cpp 21.7229 "Evaluations of functions at arbitrary points." (2012, 11, 7, 2, 24, 11) function-evaluation-cpp 21.6206 "Evaluations of functions at arbitrary points." (2012, 11, 7, 2, 24, 16) function-extrapolation-python 5.34945 "BENCH: 1.92649912834" (2012, 11, 7, 2, 24, 16) function-extrapolation-python 1.9265 "BENCH: 1.92649912834" (2012, 11, 7, 2, 24, 41) la-vector-access-cpp 25.4098 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 7, 2, 25, 8) la-vector-assignment-cpp 26.0462 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 8, 2, 11, 43) common-progress-cpp 29.0081 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 8, 2, 12, 10) common-timing-cpp 27.3438 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 8, 2, 13, 56) fem-multicore-cpp 105.21 "Coloring mesh." (2012, 11, 8, 2, 16, 21) fem-assembly-cpp 144.998 "Assembly for various forms and backends" (2012, 11, 8, 2, 16, 32) fem-convergence-cpp 11.3915 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 8, 2, 16, 33) fem-jit-python 0.000414896 "JIT compilation (in memory cache)" (2012, 11, 8, 2, 21, 48) fem-speedup-cpp 314.792 "Assembly/solve speedup running on 4 processors" (2012, 11, 8, 2, 21, 48) fem-speedup-cpp-assembly 6.32696 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 8, 2, 21, 48) fem-speedup-cpp-solve 2.39419 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 8, 2, 22, 14) mesh-refinement-cpp 24.1881 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 8, 2, 22, 35) mesh-topology-cpp 20.9319 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 8, 2, 23, 1) mesh-unitcube-cpp 26.4599 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 8, 2, 23, 47) mesh-iteration-cpp 42.6353 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 8, 2, 24, 9) function-evaluation-cpp 21.5761 "Evaluations of functions at arbitrary points." (2012, 11, 8, 2, 24, 9) function-evaluation-cpp 21.4752 "Evaluations of functions at arbitrary points." (2012, 11, 8, 2, 24, 14) function-extrapolation-python 5.40031 "BENCH: 1.85234689713" (2012, 11, 8, 2, 24, 14) function-extrapolation-python 1.85235 "BENCH: 1.85234689713" (2012, 11, 8, 2, 24, 37) la-vector-access-cpp 23.4463 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 8, 2, 25, 5) la-vector-assignment-cpp 27.4914 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 10, 2, 11, 56) common-progress-cpp 28.9608 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 10, 2, 12, 23) common-timing-cpp 27.3722 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 10, 2, 14, 7) fem-multicore-cpp 104.169 "Coloring mesh." (2012, 11, 10, 2, 16, 33) fem-assembly-cpp 145.387 "Assembly for various forms and backends" (2012, 11, 10, 2, 16, 44) fem-convergence-cpp 11.493 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 10, 2, 16, 45) fem-jit-python 0.000420904 "JIT compilation (in memory cache)" (2012, 11, 10, 2, 22, 2) fem-speedup-cpp 317.019 "Assembly/solve speedup running on 4 processors" (2012, 11, 10, 2, 22, 2) fem-speedup-cpp-assembly 6.41965 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 10, 2, 22, 2) fem-speedup-cpp-solve 2.29975 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 10, 2, 22, 28) mesh-refinement-cpp 24.1195 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 10, 2, 22, 49) mesh-topology-cpp 20.697 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 10, 2, 23, 17) mesh-unitcube-cpp 27.503 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 10, 2, 24, 5) mesh-iteration-cpp 45.5578 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 10, 2, 24, 27) function-evaluation-cpp 21.7149 "Evaluations of functions at arbitrary points." (2012, 11, 10, 2, 24, 27) function-evaluation-cpp 21.6137 "Evaluations of functions at arbitrary points." (2012, 11, 10, 2, 24, 32) function-extrapolation-python 5.16611 "BENCH: 1.83399105072" (2012, 11, 10, 2, 24, 32) function-extrapolation-python 1.83399 "BENCH: 1.83399105072" (2012, 11, 10, 2, 24, 56) la-vector-access-cpp 23.9919 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 10, 2, 25, 24) la-vector-assignment-cpp 27.9097 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 11, 2, 12, 32) common-progress-cpp 28.9619 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 11, 2, 13, 0) common-timing-cpp 27.348 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 11, 2, 14, 45) fem-multicore-cpp 105.465 "Coloring mesh." (2012, 11, 11, 2, 17, 11) fem-assembly-cpp 146.202 "Assembly for various forms and backends" (2012, 11, 11, 2, 17, 23) fem-convergence-cpp 11.4787 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 11, 2, 17, 24) fem-jit-python 0.000419784 "JIT compilation (in memory cache)" (2012, 11, 11, 2, 22, 40) fem-speedup-cpp 316.689 "Assembly/solve speedup running on 4 processors" (2012, 11, 11, 2, 22, 40) fem-speedup-cpp-assembly 6.39714 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 11, 2, 22, 40) fem-speedup-cpp-solve 2.36122 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 11, 2, 23, 7) mesh-refinement-cpp 24.9192 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 11, 2, 23, 28) mesh-topology-cpp 20.9472 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 11, 2, 24, 0) mesh-unitcube-cpp 31.6438 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 11, 2, 24, 43) mesh-iteration-cpp 39.882 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 11, 2, 25, 5) function-evaluation-cpp 21.7498 "Evaluations of functions at arbitrary points." (2012, 11, 11, 2, 25, 5) function-evaluation-cpp 21.6475 "Evaluations of functions at arbitrary points." (2012, 11, 11, 2, 25, 10) function-extrapolation-python 5.22367 "BENCH: 1.87814593315" (2012, 11, 11, 2, 25, 10) function-extrapolation-python 1.87815 "BENCH: 1.87814593315" (2012, 11, 11, 2, 25, 35) la-vector-access-cpp 24.9081 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 11, 2, 26, 3) la-vector-assignment-cpp 27.4879 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 12, 2, 11, 58) common-progress-cpp 28.9458 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 12, 2, 12, 26) common-timing-cpp 28.0505 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 12, 2, 14, 12) fem-multicore-cpp 105.863 "Coloring mesh." (2012, 11, 12, 2, 16, 38) fem-assembly-cpp 146.921 "Assembly for various forms and backends" (2012, 11, 12, 2, 16, 50) fem-convergence-cpp 11.5374 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 12, 2, 16, 51) fem-jit-python 0.000414801 "JIT compilation (in memory cache)" (2012, 11, 12, 2, 22, 8) fem-speedup-cpp 317.01 "Assembly/solve speedup running on 4 processors" (2012, 11, 12, 2, 22, 8) fem-speedup-cpp-assembly 6.30255 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 12, 2, 22, 8) fem-speedup-cpp-solve 2.35125 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 12, 2, 22, 35) mesh-refinement-cpp 24.8949 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 12, 2, 22, 56) mesh-topology-cpp 20.9926 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 12, 2, 23, 28) mesh-unitcube-cpp 31.5892 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 12, 2, 24, 11) mesh-iteration-cpp 39.9205 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 12, 2, 24, 33) function-evaluation-cpp 21.7417 "Evaluations of functions at arbitrary points." (2012, 11, 12, 2, 24, 33) function-evaluation-cpp 21.6408 "Evaluations of functions at arbitrary points." (2012, 11, 12, 2, 24, 38) function-extrapolation-python 5.37756 "BENCH: 1.92436099052" (2012, 11, 12, 2, 24, 38) function-extrapolation-python 1.92436 "BENCH: 1.92436099052" (2012, 11, 12, 2, 25, 1) la-vector-access-cpp 23.253 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 12, 2, 25, 27) la-vector-assignment-cpp 26.0218 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 13, 2, 12, 31) common-progress-cpp 28.9718 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 13, 2, 12, 59) common-timing-cpp 28.1378 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 13, 2, 14, 44) fem-multicore-cpp 104.446 "Coloring mesh." (2012, 11, 13, 2, 17, 8) fem-assembly-cpp 144.153 "Assembly for various forms and backends" (2012, 11, 13, 2, 17, 20) fem-convergence-cpp 11.4939 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 13, 2, 17, 20) fem-jit-python 0.000418997 "JIT compilation (in memory cache)" (2012, 11, 13, 2, 22, 38) fem-speedup-cpp 317.377 "Assembly/solve speedup running on 4 processors" (2012, 11, 13, 2, 22, 38) fem-speedup-cpp-assembly 6.32971 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 13, 2, 22, 38) fem-speedup-cpp-solve 2.35113 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 13, 2, 23, 5) mesh-refinement-cpp 24.855 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 13, 2, 23, 26) mesh-topology-cpp 20.9461 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 13, 2, 23, 57) mesh-unitcube-cpp 31.4813 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 13, 2, 24, 40) mesh-iteration-cpp 39.8781 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 13, 2, 25, 2) function-evaluation-cpp 21.7166 "Evaluations of functions at arbitrary points." (2012, 11, 13, 2, 25, 2) function-evaluation-cpp 21.6188 "Evaluations of functions at arbitrary points." (2012, 11, 13, 2, 25, 7) function-extrapolation-python 5.29317 "BENCH: 1.90870881081" (2012, 11, 13, 2, 25, 7) function-extrapolation-python 1.90871 "BENCH: 1.90870881081" (2012, 11, 13, 2, 25, 31) la-vector-access-cpp 23.6758 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 13, 2, 25, 57) la-vector-assignment-cpp 26.014 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 14, 2, 11, 44) common-progress-cpp 29.0845 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 14, 2, 12, 12) common-timing-cpp 28.0741 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 14, 2, 13, 57) fem-multicore-cpp 104.757 "Coloring mesh." (2012, 11, 14, 2, 16, 21) fem-assembly-cpp 143.982 "Assembly for various forms and backends" (2012, 11, 14, 2, 16, 32) fem-convergence-cpp 11.4462 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 14, 2, 16, 33) fem-jit-python 0.000419021 "JIT compilation (in memory cache)" (2012, 11, 14, 2, 22, 14) fem-speedup-cpp 340.992 "Assembly/solve speedup running on 4 processors" (2012, 11, 14, 2, 22, 14) fem-speedup-cpp-assembly 6.07228 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 14, 2, 22, 14) fem-speedup-cpp-solve 1.7922 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 14, 2, 22, 41) mesh-refinement-cpp 24.7302 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 14, 2, 23, 2) mesh-topology-cpp 21.0199 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 14, 2, 23, 34) mesh-unitcube-cpp 31.4853 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 14, 2, 24, 17) mesh-iteration-cpp 39.8702 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 14, 2, 24, 39) function-evaluation-cpp 21.7129 "Evaluations of functions at arbitrary points." (2012, 11, 14, 2, 24, 39) function-evaluation-cpp 21.6124 "Evaluations of functions at arbitrary points." (2012, 11, 14, 2, 24, 44) function-extrapolation-python 5.33034 "BENCH: 1.8638241291" (2012, 11, 14, 2, 24, 44) function-extrapolation-python 1.86382 "BENCH: 1.8638241291" (2012, 11, 14, 2, 25, 9) la-vector-access-cpp 24.9088 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 14, 2, 25, 35) la-vector-assignment-cpp 26.0161 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 28, 10, 45, 39) common-progress-cpp 29.8699 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 28, 10, 46, 6) common-timing-cpp 27.3613 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 28, 10, 47, 55) fem-multicore-cpp 109.027 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 28, 10, 50, 25) fem-assembly-cpp 149.446 "Assembly for various forms and backends" (2012, 11, 28, 10, 50, 36) fem-convergence-cpp 11.6192 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 28, 10, 50, 37) fem-jit-python 0.000410485 "JIT compilation (in memory cache)" (2012, 11, 28, 10, 56, 1) fem-speedup-cpp 324.372 "Assembly/solve speedup running on 4 processors" (2012, 11, 28, 10, 56, 1) fem-speedup-cpp-assembly 6.36426 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 28, 10, 56, 1) fem-speedup-cpp-solve 2.21717 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 28, 10, 56, 29) mesh-refinement-cpp 24.9411 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 28, 10, 56, 50) mesh-topology-cpp 21.5957 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 28, 10, 57, 17) mesh-unitcube-cpp 27.1692 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 28, 10, 58, 6) mesh-iteration-cpp 46.0245 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 28, 10, 58, 28) function-evaluation-cpp 21.7517 "Evaluations of functions at arbitrary points." (2012, 11, 28, 10, 58, 28) function-evaluation-cpp 21.6487 "Evaluations of functions at arbitrary points." (2012, 11, 28, 10, 58, 33) function-extrapolation-python 5.11629 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 28, 10, 58, 33) function-extrapolation-python 1.85061 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 28, 10, 58, 57) la-vector-access-cpp 23.6232 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 28, 10, 59, 32) la-vector-assignment-cpp 35.5079 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 29, 2, 13, 32) common-progress-cpp 30.9797 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 29, 2, 14, 0) common-timing-cpp 27.3327 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 29, 2, 15, 48) fem-multicore-cpp 108.347 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 29, 2, 18, 15) fem-assembly-cpp 146.68 "Assembly for various forms and backends" (2012, 11, 29, 2, 18, 27) fem-convergence-cpp 11.6503 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 29, 2, 18, 28) fem-jit-python 0.000407696 "JIT compilation (in memory cache)" (2012, 11, 29, 2, 23, 51) fem-speedup-cpp 322.737 "Assembly/solve speedup running on 4 processors" (2012, 11, 29, 2, 23, 51) fem-speedup-cpp-assembly 6.2628 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 29, 2, 23, 51) fem-speedup-cpp-solve 2.21315 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 29, 2, 24, 18) mesh-refinement-cpp 25.1911 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 29, 2, 24, 40) mesh-topology-cpp 21.7557 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 29, 2, 25, 8) mesh-unitcube-cpp 27.827 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 29, 2, 25, 56) mesh-iteration-cpp 44.6855 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 29, 2, 26, 17) function-evaluation-cpp 21.2149 "Evaluations of functions at arbitrary points." (2012, 11, 29, 2, 26, 17) function-evaluation-cpp 21.1175 "Evaluations of functions at arbitrary points." (2012, 11, 29, 2, 26, 22) function-extrapolation-python 4.89231 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 29, 2, 26, 22) function-extrapolation-python 1.85643 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 29, 2, 26, 45) la-vector-access-cpp 23.0024 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 29, 2, 27, 16) la-vector-assignment-cpp 31.4937 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 11, 30, 2, 13, 28) common-progress-cpp 31.0549 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 11, 30, 2, 13, 56) common-timing-cpp 27.8077 "Timing access and registration of timings (10000000 repetitions)" (2012, 11, 30, 2, 15, 45) fem-multicore-cpp 108.963 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 30, 2, 18, 13) fem-assembly-cpp 147.799 "Assembly for various forms and backends" (2012, 11, 30, 2, 18, 24) fem-convergence-cpp 11.6782 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 11, 30, 2, 18, 26) fem-jit-python 0.000415087 "JIT compilation (in memory cache)" (2012, 11, 30, 2, 23, 48) fem-speedup-cpp 322.268 "Assembly/solve speedup running on 4 processors" (2012, 11, 30, 2, 23, 48) fem-speedup-cpp-assembly 6.17554 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 11, 30, 2, 23, 48) fem-speedup-cpp-solve 2.23146 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 11, 30, 2, 24, 16) mesh-refinement-cpp 25.1416 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 11, 30, 2, 24, 38) mesh-topology-cpp 21.799 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 11, 30, 2, 25, 5) mesh-unitcube-cpp 27.8141 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 11, 30, 2, 25, 53) mesh-iteration-cpp 44.677 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 11, 30, 2, 26, 15) function-evaluation-cpp 21.7458 "Evaluations of functions at arbitrary points." (2012, 11, 30, 2, 26, 15) function-evaluation-cpp 21.6485 "Evaluations of functions at arbitrary points." (2012, 11, 30, 2, 26, 20) function-extrapolation-python 5.01753 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 30, 2, 26, 20) function-extrapolation-python 1.85042 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 11, 30, 2, 26, 43) la-vector-access-cpp 23.0474 "Accessing vector of size 10000000 (100 repetitions)" (2012, 11, 30, 2, 27, 10) la-vector-assignment-cpp 26.9439 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 1, 2, 13, 24) common-progress-cpp 30.8381 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 1, 2, 13, 51) common-timing-cpp 27.3641 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 1, 2, 15, 40) fem-multicore-cpp 108.48 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 1, 2, 18, 7) fem-assembly-cpp 147.143 "Assembly for various forms and backends" (2012, 12, 1, 2, 18, 19) fem-convergence-cpp 11.6838 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 1, 2, 18, 20) fem-jit-python 0.000421095 "JIT compilation (in memory cache)" (2012, 12, 1, 2, 23, 41) fem-speedup-cpp 320.362 "Assembly/solve speedup running on 4 processors" (2012, 12, 1, 2, 23, 41) fem-speedup-cpp-assembly 6.07905 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 1, 2, 23, 41) fem-speedup-cpp-solve 2.28325 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 1, 2, 24, 8) mesh-refinement-cpp 25.2071 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 1, 2, 24, 30) mesh-topology-cpp 21.8705 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 1, 2, 24, 58) mesh-unitcube-cpp 27.8679 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 1, 2, 25, 45) mesh-iteration-cpp 44.1876 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 1, 2, 26, 7) function-evaluation-cpp 21.7473 "Evaluations of functions at arbitrary points." (2012, 12, 1, 2, 26, 7) function-evaluation-cpp 21.6479 "Evaluations of functions at arbitrary points." (2012, 12, 1, 2, 26, 12) function-extrapolation-python 4.98174 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 1, 2, 26, 12) function-extrapolation-python 1.92596 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 1, 2, 26, 36) la-vector-access-cpp 23.6385 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 1, 2, 27, 3) la-vector-assignment-cpp 26.9472 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 2, 2, 13, 37) common-progress-cpp 31.0547 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 2, 2, 14, 5) common-timing-cpp 27.2938 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 2, 2, 15, 53) fem-multicore-cpp 108.191 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 2, 2, 18, 21) fem-assembly-cpp 148.078 "Assembly for various forms and backends" (2012, 12, 2, 2, 18, 33) fem-convergence-cpp 11.6612 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 2, 2, 18, 35) fem-jit-python 0.000414801 "JIT compilation (in memory cache)" (2012, 12, 2, 2, 23, 57) fem-speedup-cpp 321.856 "Assembly/solve speedup running on 4 processors" (2012, 12, 2, 2, 23, 57) fem-speedup-cpp-assembly 6.21593 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 2, 2, 23, 57) fem-speedup-cpp-solve 2.25051 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 2, 2, 24, 24) mesh-refinement-cpp 25.0493 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 2, 2, 24, 46) mesh-topology-cpp 21.7952 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 2, 2, 25, 14) mesh-unitcube-cpp 27.9996 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 2, 2, 26, 1) mesh-iteration-cpp 44.6613 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 2, 2, 26, 23) function-evaluation-cpp 21.8016 "Evaluations of functions at arbitrary points." (2012, 12, 2, 2, 26, 23) function-evaluation-cpp 21.6906 "Evaluations of functions at arbitrary points." (2012, 12, 2, 2, 26, 28) function-extrapolation-python 5.11694 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 2, 2, 26, 28) function-extrapolation-python 1.88872 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 2, 2, 26, 54) la-vector-access-cpp 25.5805 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 2, 2, 27, 21) la-vector-assignment-cpp 26.9355 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 3, 2, 13, 28) common-progress-cpp 37.6836 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 3, 2, 13, 57) common-timing-cpp 28.5344 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 3, 2, 15, 46) fem-multicore-cpp 109.156 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 3, 2, 18, 15) fem-assembly-cpp 149.058 "Assembly for various forms and backends" (2012, 12, 3, 2, 18, 27) fem-convergence-cpp 11.6717 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 3, 2, 18, 29) fem-jit-python 0.000430393 "JIT compilation (in memory cache)" (2012, 12, 3, 2, 23, 57) fem-speedup-cpp 328.098 "Assembly/solve speedup running on 4 processors" (2012, 12, 3, 2, 23, 57) fem-speedup-cpp-assembly 6.24401 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 3, 2, 23, 57) fem-speedup-cpp-solve 2.0813 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 3, 2, 24, 24) mesh-refinement-cpp 25.0092 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 3, 2, 24, 46) mesh-topology-cpp 21.983 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 3, 2, 25, 14) mesh-unitcube-cpp 28.0109 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 3, 2, 26, 2) mesh-iteration-cpp 44.6116 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 3, 2, 26, 23) function-evaluation-cpp 21.4359 "Evaluations of functions at arbitrary points." (2012, 12, 3, 2, 26, 23) function-evaluation-cpp 21.3245 "Evaluations of functions at arbitrary points." (2012, 12, 3, 2, 26, 28) function-extrapolation-python 5.03537 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 3, 2, 26, 28) function-extrapolation-python 1.89278 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 3, 2, 26, 51) la-vector-access-cpp 23.0156 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 3, 2, 27, 24) la-vector-assignment-cpp 32.9353 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 4, 2, 13, 35) common-progress-cpp 37.6919 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 4, 2, 14, 2) common-timing-cpp 26.6364 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 4, 2, 15, 50) fem-multicore-cpp 107.982 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 4, 2, 18, 18) fem-assembly-cpp 148.019 "Assembly for various forms and backends" (2012, 12, 4, 2, 18, 30) fem-convergence-cpp 11.6783 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 4, 2, 18, 32) fem-jit-python 0.000423789 "JIT compilation (in memory cache)" (2012, 12, 4, 2, 23, 54) fem-speedup-cpp 322.32 "Assembly/solve speedup running on 4 processors" (2012, 12, 4, 2, 23, 54) fem-speedup-cpp-assembly 6.20075 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 4, 2, 23, 54) fem-speedup-cpp-solve 2.26538 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 4, 2, 24, 22) mesh-refinement-cpp 25.6088 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 4, 2, 24, 44) mesh-topology-cpp 21.6699 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 4, 2, 25, 17) mesh-unitcube-cpp 33.442 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 4, 2, 26, 5) mesh-iteration-cpp 44.6827 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 4, 2, 26, 27) function-evaluation-cpp 21.7768 "Evaluations of functions at arbitrary points." (2012, 12, 4, 2, 26, 27) function-evaluation-cpp 21.6651 "Evaluations of functions at arbitrary points." (2012, 12, 4, 2, 26, 32) function-extrapolation-python 4.97931 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 4, 2, 26, 32) function-extrapolation-python 1.9061 "*** Warning: UnitCube is deprecated. Use UnitCubeMesh" (2012, 12, 4, 2, 26, 56) la-vector-access-cpp 24.3218 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 4, 2, 27, 22) la-vector-assignment-cpp 26.0215 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 5, 2, 14, 4) common-progress-cpp 29.1975 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 5, 2, 14, 32) common-timing-cpp 27.6865 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 5, 2, 16, 59) fem-assembly-cpp 146.982 "Assembly for various forms and backends" (2012, 12, 5, 2, 17, 11) fem-convergence-cpp 11.6838 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 5, 2, 17, 12) fem-jit-python 0.000422406 "JIT compilation (in memory cache)" (2012, 12, 5, 2, 22, 37) fem-speedup-cpp 324.082 "Assembly/solve speedup running on 4 processors" (2012, 12, 5, 2, 22, 37) fem-speedup-cpp-assembly 6.20012 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 5, 2, 22, 37) fem-speedup-cpp-solve 2.18646 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 5, 2, 23, 3) mesh-refinement-cpp 24.9222 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 5, 2, 23, 26) mesh-topology-cpp 21.9294 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 5, 2, 23, 53) mesh-unitcube-cpp 27.0426 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 5, 2, 24, 38) mesh-iteration-cpp 42.5934 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 5, 2, 25, 6) la-vector-access-cpp 24.3764 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 5, 2, 25, 32) la-vector-assignment-cpp 26.0256 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 6, 2, 13, 33) common-progress-cpp 28.9727 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 6, 2, 14, 0) common-timing-cpp 26.922 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 6, 2, 15, 48) fem-multicore-cpp 107.778 "Coloring mesh." (2012, 12, 6, 2, 18, 15) fem-assembly-cpp 147.517 "Assembly for various forms and backends" (2012, 12, 6, 2, 18, 27) fem-convergence-cpp 11.6778 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 6, 2, 18, 29) fem-jit-python 0.000414801 "JIT compilation (in memory cache)" (2012, 12, 6, 2, 23, 52) fem-speedup-cpp 323.501 "Assembly/solve speedup running on 4 processors" (2012, 12, 6, 2, 23, 52) fem-speedup-cpp-assembly 6.13647 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 6, 2, 23, 52) fem-speedup-cpp-solve 2.21196 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 6, 2, 24, 20) mesh-refinement-cpp 25.2882 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 6, 2, 24, 41) mesh-topology-cpp 21.5749 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 6, 2, 25, 8) mesh-unitcube-cpp 26.4855 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 6, 2, 25, 53) mesh-iteration-cpp 41.876 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 6, 2, 26, 14) function-evaluation-cpp 21.6652 "Evaluations of functions at arbitrary points." (2012, 12, 6, 2, 26, 14) function-evaluation-cpp 21.5614 "Evaluations of functions at arbitrary points." (2012, 12, 6, 2, 26, 40) la-vector-access-cpp 23.0849 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 6, 2, 27, 6) la-vector-assignment-cpp 26.0251 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 7, 2, 13, 29) common-progress-cpp 28.9728 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 7, 2, 13, 56) common-timing-cpp 26.7469 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 7, 2, 15, 44) fem-multicore-cpp 107.907 "Coloring mesh." (2012, 12, 7, 2, 18, 11) fem-assembly-cpp 147.177 "Assembly for various forms and backends" (2012, 12, 7, 2, 18, 22) fem-convergence-cpp 11.6811 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 7, 2, 18, 24) fem-jit-python 0.00041101 "JIT compilation (in memory cache)" (2012, 12, 7, 2, 23, 47) fem-speedup-cpp 322.171 "Assembly/solve speedup running on 4 processors" (2012, 12, 7, 2, 23, 47) fem-speedup-cpp-assembly 6.20805 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 7, 2, 23, 47) fem-speedup-cpp-solve 2.23711 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 7, 2, 24, 14) mesh-refinement-cpp 25.431 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 7, 2, 24, 36) mesh-topology-cpp 21.5766 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 7, 2, 25, 2) mesh-unitcube-cpp 26.4238 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 7, 2, 25, 45) mesh-iteration-cpp 40.3383 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 7, 2, 26, 7) function-evaluation-cpp 21.6979 "Evaluations of functions at arbitrary points." (2012, 12, 7, 2, 26, 7) function-evaluation-cpp 21.5938 "Evaluations of functions at arbitrary points." (2012, 12, 7, 2, 26, 35) la-vector-access-cpp 24.3346 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 7, 2, 27, 1) la-vector-assignment-cpp 26.0214 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 8, 2, 13, 21) common-progress-cpp 28.9727 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 8, 2, 13, 48) common-timing-cpp 26.9482 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 8, 2, 15, 36) fem-multicore-cpp 108.174 "Coloring mesh." (2012, 12, 8, 2, 18, 3) fem-assembly-cpp 146.566 "Assembly for various forms and backends" (2012, 12, 8, 2, 18, 15) fem-convergence-cpp 11.7335 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 8, 2, 18, 17) fem-jit-python 0.000417399 "JIT compilation (in memory cache)" (2012, 12, 8, 2, 23, 45) fem-speedup-cpp 328.415 "Assembly/solve speedup running on 4 processors" (2012, 12, 8, 2, 23, 45) fem-speedup-cpp-assembly 6.2053 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 8, 2, 23, 45) fem-speedup-cpp-solve 2.07078 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 8, 2, 24, 12) mesh-refinement-cpp 24.8384 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 8, 2, 24, 34) mesh-topology-cpp 21.7294 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 8, 2, 25, 1) mesh-unitcube-cpp 27.6182 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 8, 2, 25, 45) mesh-iteration-cpp 40.2858 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 8, 2, 26, 6) function-evaluation-cpp 21.6586 "Evaluations of functions at arbitrary points." (2012, 12, 8, 2, 26, 6) function-evaluation-cpp 21.556 "Evaluations of functions at arbitrary points." (2012, 12, 8, 2, 26, 34) la-vector-access-cpp 24.3336 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 8, 2, 27, 0) la-vector-assignment-cpp 25.9746 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 9, 2, 13, 27) common-progress-cpp 29.0143 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 9, 2, 13, 55) common-timing-cpp 28.2108 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 9, 2, 15, 44) fem-multicore-cpp 108.241 "Coloring mesh." (2012, 12, 9, 2, 18, 10) fem-assembly-cpp 146.471 "Assembly for various forms and backends" (2012, 12, 9, 2, 18, 22) fem-convergence-cpp 11.715 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 9, 2, 18, 24) fem-jit-python 0.000421 "JIT compilation (in memory cache)" (2012, 12, 9, 2, 23, 48) fem-speedup-cpp 324.711 "Assembly/solve speedup running on 4 processors" (2012, 12, 9, 2, 23, 48) fem-speedup-cpp-assembly 6.31489 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 9, 2, 23, 48) fem-speedup-cpp-solve 2.08223 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 9, 2, 24, 15) mesh-refinement-cpp 24.9089 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 9, 2, 24, 37) mesh-topology-cpp 21.8068 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 9, 2, 25, 4) mesh-unitcube-cpp 27.4638 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 9, 2, 25, 54) mesh-iteration-cpp 46.2157 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 9, 2, 26, 15) function-evaluation-cpp 21.6875 "Evaluations of functions at arbitrary points." (2012, 12, 9, 2, 26, 15) function-evaluation-cpp 21.5542 "Evaluations of functions at arbitrary points." (2012, 12, 9, 2, 26, 43) la-vector-access-cpp 24.0787 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 9, 2, 27, 11) la-vector-assignment-cpp 28.0499 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 10, 2, 13, 22) common-progress-cpp 29.1393 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 10, 2, 13, 50) common-timing-cpp 27.2842 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 10, 2, 15, 37) fem-multicore-cpp 107.596 "Coloring mesh." (2012, 12, 10, 2, 18, 6) fem-assembly-cpp 148.379 "Assembly for various forms and backends" (2012, 12, 10, 2, 18, 17) fem-convergence-cpp 11.6703 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 10, 2, 18, 19) fem-jit-python 0.000418091 "JIT compilation (in memory cache)" (2012, 12, 10, 2, 23, 49) fem-speedup-cpp 330.092 "Assembly/solve speedup running on 4 processors" (2012, 12, 10, 2, 23, 49) fem-speedup-cpp-assembly 6.29587 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 10, 2, 23, 49) fem-speedup-cpp-solve 1.95925 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 10, 2, 24, 16) mesh-refinement-cpp 24.8545 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 10, 2, 24, 38) mesh-topology-cpp 21.664 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 10, 2, 25, 6) mesh-unitcube-cpp 27.6158 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 10, 2, 25, 49) mesh-iteration-cpp 40.2808 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 10, 2, 26, 11) function-evaluation-cpp 21.6777 "Evaluations of functions at arbitrary points." (2012, 12, 10, 2, 26, 11) function-evaluation-cpp 21.5682 "Evaluations of functions at arbitrary points." (2012, 12, 10, 2, 26, 39) la-vector-access-cpp 24.9206 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 10, 2, 27, 5) la-vector-assignment-cpp 26.0242 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 11, 2, 13, 13) common-progress-cpp 29.0144 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 11, 2, 13, 40) common-timing-cpp 26.8327 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 11, 2, 15, 28) fem-multicore-cpp 107.576 "Coloring mesh." (2012, 12, 11, 2, 17, 56) fem-assembly-cpp 147.83 "Assembly for various forms and backends" (2012, 12, 11, 2, 18, 7) fem-convergence-cpp 11.6604 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 11, 2, 18, 9) fem-jit-python 0.000420809 "JIT compilation (in memory cache)" (2012, 12, 11, 2, 23, 35) fem-speedup-cpp 325.251 "Assembly/solve speedup running on 4 processors" (2012, 12, 11, 2, 23, 35) fem-speedup-cpp-assembly 6.23278 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 11, 2, 23, 35) fem-speedup-cpp-solve 2.07781 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 11, 2, 24, 1) mesh-refinement-cpp 24.853 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 11, 2, 24, 23) mesh-topology-cpp 21.6676 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 11, 2, 24, 51) mesh-unitcube-cpp 27.6461 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 11, 2, 25, 34) mesh-iteration-cpp 40.3338 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 11, 2, 25, 56) function-evaluation-cpp 21.6709 "Evaluations of functions at arbitrary points." (2012, 12, 11, 2, 25, 56) function-evaluation-cpp 21.524 "Evaluations of functions at arbitrary points." (2012, 12, 11, 2, 26, 23) la-vector-access-cpp 24.34 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 11, 2, 26, 49) la-vector-assignment-cpp 25.9889 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 12, 2, 13, 39) common-progress-cpp 36.5011 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 12, 2, 14, 6) common-timing-cpp 26.6948 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 12, 2, 15, 55) fem-multicore-cpp 108.8 "Coloring mesh." (2012, 12, 12, 2, 18, 22) fem-assembly-cpp 146.779 "Assembly for various forms and backends" (2012, 12, 12, 2, 18, 33) fem-convergence-cpp 11.7195 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 12, 2, 18, 35) fem-jit-python 0.000428104 "JIT compilation (in memory cache)" (2012, 12, 12, 2, 23, 57) fem-speedup-cpp 322.113 "Assembly/solve speedup running on 4 processors" (2012, 12, 12, 2, 23, 57) fem-speedup-cpp-assembly 6.1429 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 12, 2, 23, 57) fem-speedup-cpp-solve 2.11719 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 12, 2, 24, 24) mesh-refinement-cpp 24.8416 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 12, 2, 24, 45) mesh-topology-cpp 21.5376 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 12, 2, 25, 13) mesh-unitcube-cpp 27.4487 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 12, 2, 25, 56) mesh-iteration-cpp 40.3285 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 12, 2, 26, 18) function-evaluation-cpp 21.7355 "Evaluations of functions at arbitrary points." (2012, 12, 12, 2, 26, 18) function-evaluation-cpp 21.5837 "Evaluations of functions at arbitrary points." (2012, 12, 12, 2, 26, 45) la-vector-access-cpp 24.3411 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 12, 2, 27, 12) la-vector-assignment-cpp 26.9404 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 13, 2, 13, 36) common-progress-cpp 28.9477 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 13, 2, 14, 3) common-timing-cpp 27.2035 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 13, 2, 15, 52) fem-multicore-cpp 109.355 "Coloring mesh." (2012, 12, 13, 2, 18, 20) fem-assembly-cpp 147.36 "Assembly for various forms and backends" (2012, 12, 13, 2, 18, 31) fem-convergence-cpp 11.6826 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 13, 2, 18, 33) fem-jit-python 0.000417089 "JIT compilation (in memory cache)" (2012, 12, 13, 2, 23, 57) fem-speedup-cpp 323.46 "Assembly/solve speedup running on 4 processors" (2012, 12, 13, 2, 23, 57) fem-speedup-cpp-assembly 6.31413 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 13, 2, 23, 57) fem-speedup-cpp-solve 2.10175 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 13, 2, 24, 23) mesh-refinement-cpp 24.8889 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 13, 2, 24, 45) mesh-topology-cpp 21.9512 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 13, 2, 25, 13) mesh-unitcube-cpp 27.7404 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 13, 2, 25, 59) mesh-iteration-cpp 43.2183 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 13, 2, 26, 21) function-evaluation-cpp 21.7209 "Evaluations of functions at arbitrary points." (2012, 12, 13, 2, 26, 21) function-evaluation-cpp 21.5806 "Evaluations of functions at arbitrary points." (2012, 12, 13, 2, 26, 49) la-vector-access-cpp 24.3415 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 13, 2, 27, 15) la-vector-assignment-cpp 26.0252 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 14, 2, 13, 30) common-progress-cpp 29.0323 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 14, 2, 13, 58) common-timing-cpp 27.2585 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 14, 2, 15, 47) fem-multicore-cpp 109.32 "Coloring mesh." (2012, 12, 14, 2, 18, 16) fem-assembly-cpp 148.463 "Assembly for various forms and backends" (2012, 12, 14, 2, 18, 27) fem-convergence-cpp 11.6121 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 14, 2, 18, 29) fem-jit-python 0.000419402 "JIT compilation (in memory cache)" (2012, 12, 14, 2, 23, 52) fem-speedup-cpp 322.701 "Assembly/solve speedup running on 4 processors" (2012, 12, 14, 2, 23, 52) fem-speedup-cpp-assembly 6.24069 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 14, 2, 23, 52) fem-speedup-cpp-solve 2.12094 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 14, 2, 24, 18) mesh-refinement-cpp 24.8999 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 14, 2, 24, 40) mesh-topology-cpp 21.9843 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 14, 2, 25, 8) mesh-unitcube-cpp 27.8451 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 14, 2, 25, 56) mesh-iteration-cpp 45.2509 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 14, 2, 26, 18) function-evaluation-cpp 21.7323 "Evaluations of functions at arbitrary points." (2012, 12, 14, 2, 26, 18) function-evaluation-cpp 21.5954 "Evaluations of functions at arbitrary points." (2012, 12, 14, 2, 26, 46) la-vector-access-cpp 24.0774 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 14, 2, 27, 12) la-vector-assignment-cpp 26.0304 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 15, 2, 13, 28) common-progress-cpp 29.2071 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 15, 2, 13, 55) common-timing-cpp 26.9454 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 15, 2, 15, 44) fem-multicore-cpp 109.106 "Coloring mesh." (2012, 12, 15, 2, 18, 13) fem-assembly-cpp 149.112 "Assembly for various forms and backends" (2012, 12, 15, 2, 18, 25) fem-convergence-cpp 11.6841 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 15, 2, 18, 27) fem-jit-python 0.000422287 "JIT compilation (in memory cache)" (2012, 12, 15, 2, 23, 50) fem-speedup-cpp 322.967 "Assembly/solve speedup running on 4 processors" (2012, 12, 15, 2, 23, 50) fem-speedup-cpp-assembly 6.32278 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 15, 2, 23, 50) fem-speedup-cpp-solve 2.1039 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 15, 2, 24, 16) mesh-refinement-cpp 24.8879 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 15, 2, 24, 38) mesh-topology-cpp 22.0019 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 15, 2, 25, 6) mesh-unitcube-cpp 27.9895 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 15, 2, 25, 52) mesh-iteration-cpp 43.1356 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 15, 2, 26, 14) function-evaluation-cpp 21.7075 "Evaluations of functions at arbitrary points." (2012, 12, 15, 2, 26, 14) function-evaluation-cpp 21.5679 "Evaluations of functions at arbitrary points." (2012, 12, 15, 2, 26, 42) la-vector-access-cpp 24.3325 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 15, 2, 27, 9) la-vector-assignment-cpp 27.4288 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 16, 2, 13, 6) common-progress-cpp 29.0322 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 16, 2, 13, 33) common-timing-cpp 26.9458 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 16, 2, 15, 22) fem-multicore-cpp 109.062 "Coloring mesh." (2012, 12, 16, 2, 17, 51) fem-assembly-cpp 149.133 "Assembly for various forms and backends" (2012, 12, 16, 2, 18, 3) fem-convergence-cpp 11.6778 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 16, 2, 18, 5) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2012, 12, 16, 2, 23, 34) fem-speedup-cpp 329.319 "Assembly/solve speedup running on 4 processors" (2012, 12, 16, 2, 23, 34) fem-speedup-cpp-assembly 6.29477 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 16, 2, 23, 34) fem-speedup-cpp-solve 1.9898 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 16, 2, 24, 1) mesh-refinement-cpp 24.8575 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 16, 2, 24, 23) mesh-topology-cpp 22.0094 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 16, 2, 24, 51) mesh-unitcube-cpp 27.7353 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 16, 2, 25, 40) mesh-iteration-cpp 45.9221 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 16, 2, 26, 1) function-evaluation-cpp 21.7257 "Evaluations of functions at arbitrary points." (2012, 12, 16, 2, 26, 1) function-evaluation-cpp 21.6219 "Evaluations of functions at arbitrary points." (2012, 12, 16, 2, 26, 29) la-vector-access-cpp 24.3184 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 16, 2, 26, 55) la-vector-assignment-cpp 25.8787 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 17, 2, 13, 4) common-progress-cpp 29.0322 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 17, 2, 13, 31) common-timing-cpp 26.6655 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 17, 2, 15, 20) fem-multicore-cpp 109.022 "Coloring mesh." (2012, 12, 17, 2, 17, 49) fem-assembly-cpp 148.84 "Assembly for various forms and backends" (2012, 12, 17, 2, 18, 1) fem-convergence-cpp 11.6696 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 17, 2, 18, 3) fem-jit-python 0.000425291 "JIT compilation (in memory cache)" (2012, 12, 17, 2, 23, 27) fem-speedup-cpp 324.706 "Assembly/solve speedup running on 4 processors" (2012, 12, 17, 2, 23, 27) fem-speedup-cpp-assembly 6.24436 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 17, 2, 23, 27) fem-speedup-cpp-solve 2.08727 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 17, 2, 23, 54) mesh-refinement-cpp 24.9221 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 17, 2, 24, 17) mesh-topology-cpp 22.1276 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 17, 2, 24, 44) mesh-unitcube-cpp 27.7595 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 17, 2, 25, 30) mesh-iteration-cpp 42.8699 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 17, 2, 25, 52) function-evaluation-cpp 21.7213 "Evaluations of functions at arbitrary points." (2012, 12, 17, 2, 25, 52) function-evaluation-cpp 21.6154 "Evaluations of functions at arbitrary points." (2012, 12, 17, 2, 26, 19) la-vector-access-cpp 24.3298 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 17, 2, 26, 45) la-vector-assignment-cpp 26.0138 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 18, 2, 13, 31) common-progress-cpp 29.0239 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 18, 2, 13, 58) common-timing-cpp 27.1075 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 18, 2, 15, 48) fem-multicore-cpp 109.763 "Coloring mesh." (2012, 12, 18, 2, 18, 13) fem-assembly-cpp 145.7 "Assembly for various forms and backends" (2012, 12, 18, 2, 18, 25) fem-convergence-cpp 11.6877 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 18, 2, 18, 27) fem-jit-python 0.000414085 "JIT compilation (in memory cache)" (2012, 12, 18, 2, 23, 51) fem-speedup-cpp 323.823 "Assembly/solve speedup running on 4 processors" (2012, 12, 18, 2, 23, 51) fem-speedup-cpp-assembly 6.16698 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 18, 2, 23, 51) fem-speedup-cpp-solve 2.08549 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 18, 2, 24, 17) mesh-refinement-cpp 24.8653 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 18, 2, 24, 39) mesh-topology-cpp 22.0175 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 18, 2, 25, 7) mesh-unitcube-cpp 27.8598 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 18, 2, 25, 53) mesh-iteration-cpp 42.878 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 18, 2, 26, 15) function-evaluation-cpp 21.7492 "Evaluations of functions at arbitrary points." (2012, 12, 18, 2, 26, 15) function-evaluation-cpp 21.6077 "Evaluations of functions at arbitrary points." (2012, 12, 18, 2, 26, 43) la-vector-access-cpp 25.4171 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 18, 2, 27, 11) la-vector-assignment-cpp 27.4802 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 19, 2, 13, 32) common-progress-cpp 29.0489 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 19, 2, 14, 0) common-timing-cpp 27.1396 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 19, 2, 15, 49) fem-multicore-cpp 109.052 "Coloring mesh." (2012, 12, 19, 2, 18, 14) fem-assembly-cpp 145.112 "Assembly for various forms and backends" (2012, 12, 19, 2, 18, 25) fem-convergence-cpp 11.6985 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 19, 2, 18, 27) fem-jit-python 0.000419688 "JIT compilation (in memory cache)" (2012, 12, 19, 2, 23, 52) fem-speedup-cpp 324.61 "Assembly/solve speedup running on 4 processors" (2012, 12, 19, 2, 23, 52) fem-speedup-cpp-assembly 6.23634 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 19, 2, 23, 52) fem-speedup-cpp-solve 2.06688 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 19, 2, 24, 18) mesh-refinement-cpp 24.8315 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 19, 2, 24, 41) mesh-topology-cpp 22.0915 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 19, 2, 25, 9) mesh-unitcube-cpp 27.7826 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 19, 2, 25, 55) mesh-iteration-cpp 43.0979 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 19, 2, 26, 19) function-evaluation-cpp 24.1554 "Evaluations of functions at arbitrary points." (2012, 12, 19, 2, 26, 19) function-evaluation-cpp 24.0283 "Evaluations of functions at arbitrary points." (2012, 12, 19, 2, 26, 46) la-vector-access-cpp 24.3283 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 19, 2, 27, 12) la-vector-assignment-cpp 26.0187 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 20, 2, 13, 57) common-progress-cpp 29.1488 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 20, 2, 14, 25) common-timing-cpp 27.6833 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 20, 2, 16, 13) fem-multicore-cpp 108.924 "Coloring mesh." (2012, 12, 20, 2, 18, 41) fem-assembly-cpp 147.147 "Assembly for various forms and backends" (2012, 12, 20, 2, 18, 52) fem-convergence-cpp 11.6702 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 20, 2, 18, 54) fem-jit-python 0.000423098 "JIT compilation (in memory cache)" (2012, 12, 20, 2, 24, 18) fem-speedup-cpp 323.5 "Assembly/solve speedup running on 4 processors" (2012, 12, 20, 2, 24, 18) fem-speedup-cpp-assembly 6.22749 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 20, 2, 24, 18) fem-speedup-cpp-solve 2.08634 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 20, 2, 24, 45) mesh-refinement-cpp 25.1577 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 20, 2, 25, 7) mesh-topology-cpp 22.0001 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 20, 2, 25, 34) mesh-unitcube-cpp 27.1674 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 20, 2, 26, 20) mesh-iteration-cpp 43.7318 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 20, 2, 26, 42) function-evaluation-cpp 21.7056 "Evaluations of functions at arbitrary points." (2012, 12, 20, 2, 26, 42) function-evaluation-cpp 21.5613 "Evaluations of functions at arbitrary points." (2012, 12, 20, 2, 27, 8) la-vector-access-cpp 23.0751 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 20, 2, 27, 34) la-vector-assignment-cpp 26.0183 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 21, 2, 13, 27) common-progress-cpp 29.0239 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 21, 2, 13, 53) common-timing-cpp 26.1405 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 21, 2, 15, 41) fem-multicore-cpp 108.325 "Coloring mesh." (2012, 12, 21, 2, 18, 10) fem-assembly-cpp 148.394 "Assembly for various forms and backends" (2012, 12, 21, 2, 18, 21) fem-convergence-cpp 11.6802 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 21, 2, 18, 23) fem-jit-python 0.000420713 "JIT compilation (in memory cache)" (2012, 12, 21, 2, 23, 45) fem-speedup-cpp 321.903 "Assembly/solve speedup running on 4 processors" (2012, 12, 21, 2, 23, 45) fem-speedup-cpp-assembly 6.32324 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 21, 2, 23, 45) fem-speedup-cpp-solve 2.12434 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 21, 2, 24, 12) mesh-refinement-cpp 24.8268 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 21, 2, 24, 33) mesh-topology-cpp 21.785 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 21, 2, 25, 1) mesh-unitcube-cpp 27.2246 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 21, 2, 25, 44) mesh-iteration-cpp 40.2766 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 21, 2, 26, 6) function-evaluation-cpp 21.725 "Evaluations of functions at arbitrary points." (2012, 12, 21, 2, 26, 6) function-evaluation-cpp 21.5773 "Evaluations of functions at arbitrary points." (2012, 12, 21, 2, 26, 32) la-vector-access-cpp 23.4319 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 21, 2, 26, 58) la-vector-assignment-cpp 26.0252 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 22, 2, 13, 13) common-progress-cpp 28.9739 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 22, 2, 13, 39) common-timing-cpp 26.0747 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 22, 2, 15, 26) fem-multicore-cpp 107.704 "Coloring mesh." (2012, 12, 22, 2, 17, 55) fem-assembly-cpp 148.472 "Assembly for various forms and backends" (2012, 12, 22, 2, 18, 7) fem-convergence-cpp 11.7415 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 22, 2, 18, 9) fem-jit-python 0.000417686 "JIT compilation (in memory cache)" (2012, 12, 22, 2, 23, 35) fem-speedup-cpp 326.017 "Assembly/solve speedup running on 4 processors" (2012, 12, 22, 2, 23, 35) fem-speedup-cpp-assembly 6.29701 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 22, 2, 23, 35) fem-speedup-cpp-solve 2.0374 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 22, 2, 24, 2) mesh-refinement-cpp 24.9012 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 22, 2, 24, 23) mesh-topology-cpp 21.7896 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 22, 2, 24, 51) mesh-unitcube-cpp 27.1716 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 22, 2, 25, 40) mesh-iteration-cpp 46.0368 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 22, 2, 26, 1) function-evaluation-cpp 21.752 "Evaluations of functions at arbitrary points." (2012, 12, 22, 2, 26, 1) function-evaluation-cpp 21.6145 "Evaluations of functions at arbitrary points." (2012, 12, 22, 2, 26, 28) la-vector-access-cpp 23.0926 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 22, 2, 26, 54) la-vector-assignment-cpp 26.0175 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 23, 2, 13, 21) common-progress-cpp 29.0822 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 23, 2, 13, 46) common-timing-cpp 25.7393 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 23, 2, 15, 35) fem-multicore-cpp 108.785 "Coloring mesh." (2012, 12, 23, 2, 18, 4) fem-assembly-cpp 148.926 "Assembly for various forms and backends" (2012, 12, 23, 2, 18, 16) fem-convergence-cpp 11.7111 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 23, 2, 18, 18) fem-jit-python 0.000428796 "JIT compilation (in memory cache)" (2012, 12, 23, 2, 23, 47) fem-speedup-cpp 329.65 "Assembly/solve speedup running on 4 processors" (2012, 12, 23, 2, 23, 47) fem-speedup-cpp-assembly 6.28928 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 23, 2, 23, 47) fem-speedup-cpp-solve 1.96131 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 23, 2, 24, 14) mesh-refinement-cpp 24.8607 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 23, 2, 24, 36) mesh-topology-cpp 21.801 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 23, 2, 25, 3) mesh-unitcube-cpp 27.0871 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 23, 2, 25, 47) mesh-iteration-cpp 40.2912 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 23, 2, 26, 8) function-evaluation-cpp 21.7183 "Evaluations of functions at arbitrary points." (2012, 12, 23, 2, 26, 8) function-evaluation-cpp 21.6116 "Evaluations of functions at arbitrary points." (2012, 12, 23, 2, 26, 36) la-vector-access-cpp 24.8538 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 23, 2, 27, 2) la-vector-assignment-cpp 26.023 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 24, 2, 13, 39) common-progress-cpp 28.9573 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 24, 2, 14, 5) common-timing-cpp 26.8616 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 24, 2, 15, 54) fem-multicore-cpp 108.985 "Coloring mesh." (2012, 12, 24, 2, 18, 23) fem-assembly-cpp 148.074 "Assembly for various forms and backends" (2012, 12, 24, 2, 18, 34) fem-convergence-cpp 11.6873 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 24, 2, 18, 36) fem-jit-python 0.000423598 "JIT compilation (in memory cache)" (2012, 12, 24, 2, 24, 7) fem-speedup-cpp 330.902 "Assembly/solve speedup running on 4 processors" (2012, 12, 24, 2, 24, 7) fem-speedup-cpp-assembly 6.21077 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 24, 2, 24, 7) fem-speedup-cpp-solve 1.97674 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 24, 2, 24, 34) mesh-refinement-cpp 25.236 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 24, 2, 24, 56) mesh-topology-cpp 21.7018 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 24, 2, 25, 24) mesh-unitcube-cpp 27.4367 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 24, 2, 26, 7) mesh-iteration-cpp 40.2467 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 24, 2, 26, 29) function-evaluation-cpp 21.7405 "Evaluations of functions at arbitrary points." (2012, 12, 24, 2, 26, 29) function-evaluation-cpp 21.628 "Evaluations of functions at arbitrary points." (2012, 12, 24, 2, 26, 55) la-vector-access-cpp 22.9861 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 24, 2, 27, 21) la-vector-assignment-cpp 26.0143 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 25, 2, 13, 30) common-progress-cpp 29.0073 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 25, 2, 13, 57) common-timing-cpp 26.8355 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 25, 2, 15, 45) fem-multicore-cpp 108.254 "Coloring mesh." (2012, 12, 25, 2, 18, 13) fem-assembly-cpp 148.426 "Assembly for various forms and backends" (2012, 12, 25, 2, 18, 25) fem-convergence-cpp 11.6963 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 25, 2, 18, 27) fem-jit-python 0.000414491 "JIT compilation (in memory cache)" (2012, 12, 25, 2, 23, 52) fem-speedup-cpp 324.822 "Assembly/solve speedup running on 4 processors" (2012, 12, 25, 2, 23, 52) fem-speedup-cpp-assembly 6.3266 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 25, 2, 23, 52) fem-speedup-cpp-solve 2.10992 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 25, 2, 24, 19) mesh-refinement-cpp 25.318 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 25, 2, 24, 41) mesh-topology-cpp 21.6827 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 25, 2, 25, 8) mesh-unitcube-cpp 27.4621 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 25, 2, 25, 51) mesh-iteration-cpp 40.2768 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 25, 2, 26, 13) function-evaluation-cpp 21.7806 "Evaluations of functions at arbitrary points." (2012, 12, 25, 2, 26, 13) function-evaluation-cpp 21.5986 "Evaluations of functions at arbitrary points." (2012, 12, 25, 2, 26, 39) la-vector-access-cpp 23.0233 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 25, 2, 27, 8) la-vector-assignment-cpp 28.0347 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 26, 2, 13, 9) common-progress-cpp 29.0405 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 26, 2, 13, 36) common-timing-cpp 26.9821 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 26, 2, 15, 24) fem-multicore-cpp 108.168 "Coloring mesh." (2012, 12, 26, 2, 17, 52) fem-assembly-cpp 148.114 "Assembly for various forms and backends" (2012, 12, 26, 2, 18, 4) fem-convergence-cpp 11.6671 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 26, 2, 18, 6) fem-jit-python 0.000422621 "JIT compilation (in memory cache)" (2012, 12, 26, 2, 23, 39) fem-speedup-cpp 333.372 "Assembly/solve speedup running on 4 processors" (2012, 12, 26, 2, 23, 39) fem-speedup-cpp-assembly 6.29044 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 26, 2, 23, 39) fem-speedup-cpp-solve 1.92494 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 26, 2, 24, 6) mesh-refinement-cpp 25.1923 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 26, 2, 24, 28) mesh-topology-cpp 21.6682 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 26, 2, 24, 55) mesh-unitcube-cpp 27.5047 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 26, 2, 25, 39) mesh-iteration-cpp 40.3036 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 26, 2, 26, 0) function-evaluation-cpp 21.7269 "Evaluations of functions at arbitrary points." (2012, 12, 26, 2, 26, 0) function-evaluation-cpp 21.6199 "Evaluations of functions at arbitrary points." (2012, 12, 26, 2, 26, 27) la-vector-access-cpp 22.9979 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 26, 2, 26, 54) la-vector-assignment-cpp 27.4878 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 27, 2, 13, 27) common-progress-cpp 28.9991 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 27, 2, 13, 55) common-timing-cpp 27.1153 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 27, 2, 15, 43) fem-multicore-cpp 108.197 "Coloring mesh." (2012, 12, 27, 2, 18, 10) fem-assembly-cpp 147.47 "Assembly for various forms and backends" (2012, 12, 27, 2, 18, 22) fem-convergence-cpp 11.7034 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 27, 2, 18, 24) fem-jit-python 0.000424385 "JIT compilation (in memory cache)" (2012, 12, 27, 2, 23, 50) fem-speedup-cpp 326.475 "Assembly/solve speedup running on 4 processors" (2012, 12, 27, 2, 23, 50) fem-speedup-cpp-assembly 6.3998 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 27, 2, 23, 50) fem-speedup-cpp-solve 2.07613 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 27, 2, 24, 17) mesh-refinement-cpp 25.2119 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 27, 2, 24, 39) mesh-topology-cpp 21.6611 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 27, 2, 25, 7) mesh-unitcube-cpp 27.6063 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 27, 2, 25, 50) mesh-iteration-cpp 40.2987 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 27, 2, 26, 12) function-evaluation-cpp 21.9805 "Evaluations of functions at arbitrary points." (2012, 12, 27, 2, 26, 12) function-evaluation-cpp 21.8329 "Evaluations of functions at arbitrary points." (2012, 12, 27, 2, 26, 41) la-vector-access-cpp 25.4526 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 27, 2, 27, 7) la-vector-assignment-cpp 26.0238 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 28, 2, 13, 32) common-progress-cpp 29.0655 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 28, 2, 13, 58) common-timing-cpp 26.238 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 28, 2, 15, 48) fem-multicore-cpp 109.167 "Coloring mesh." (2012, 12, 28, 2, 18, 15) fem-assembly-cpp 147.683 "Assembly for various forms and backends" (2012, 12, 28, 2, 18, 27) fem-convergence-cpp 11.7358 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 28, 2, 18, 29) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2012, 12, 28, 2, 24, 1) fem-speedup-cpp 332.376 "Assembly/solve speedup running on 4 processors" (2012, 12, 28, 2, 24, 1) fem-speedup-cpp-assembly 6.24272 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 28, 2, 24, 1) fem-speedup-cpp-solve 1.95932 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 28, 2, 24, 29) mesh-refinement-cpp 24.9065 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 28, 2, 24, 51) mesh-topology-cpp 21.8203 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 28, 2, 25, 20) mesh-unitcube-cpp 28.6299 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 28, 2, 26, 3) mesh-iteration-cpp 40.2737 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 28, 2, 26, 24) function-evaluation-cpp 21.1953 "Evaluations of functions at arbitrary points." (2012, 12, 28, 2, 26, 24) function-evaluation-cpp 21.0886 "Evaluations of functions at arbitrary points." (2012, 12, 28, 2, 26, 52) la-vector-access-cpp 24.3344 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 28, 2, 27, 18) la-vector-assignment-cpp 26.0212 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 30, 2, 13, 50) common-progress-cpp 46.6583 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 30, 2, 14, 17) common-timing-cpp 26.896 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 30, 2, 16, 6) fem-multicore-cpp 108.83 "Coloring mesh." (2012, 12, 30, 2, 18, 34) fem-assembly-cpp 147.589 "Assembly for various forms and backends" (2012, 12, 30, 2, 18, 46) fem-convergence-cpp 11.7084 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 30, 2, 18, 48) fem-jit-python 0.000419688 "JIT compilation (in memory cache)" (2012, 12, 30, 2, 24, 10) fem-speedup-cpp 322.443 "Assembly/solve speedup running on 4 processors" (2012, 12, 30, 2, 24, 10) fem-speedup-cpp-assembly 6.32365 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 30, 2, 24, 10) fem-speedup-cpp-solve 2.08285 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 30, 2, 24, 37) mesh-refinement-cpp 24.9664 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 30, 2, 24, 59) mesh-topology-cpp 21.7461 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 30, 2, 25, 26) mesh-unitcube-cpp 27.4331 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 30, 2, 26, 9) mesh-iteration-cpp 40.2772 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 30, 2, 26, 31) function-evaluation-cpp 21.6977 "Evaluations of functions at arbitrary points." (2012, 12, 30, 2, 26, 31) function-evaluation-cpp 21.5547 "Evaluations of functions at arbitrary points." (2012, 12, 30, 2, 26, 58) la-vector-access-cpp 24.3215 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 30, 2, 27, 25) la-vector-assignment-cpp 26.9333 "Assigning to vector of size 10000000 (100 repetitions)" (2012, 12, 31, 2, 13, 28) common-progress-cpp 29.1655 "Creating progress bar with 500000000 steps (5 repetitions)" (2012, 12, 31, 2, 13, 56) common-timing-cpp 28.0255 "Timing access and registration of timings (10000000 repetitions)" (2012, 12, 31, 2, 15, 45) fem-multicore-cpp 108.873 "Coloring mesh." (2012, 12, 31, 2, 18, 12) fem-assembly-cpp 147.631 "Assembly for various forms and backends" (2012, 12, 31, 2, 18, 24) fem-convergence-cpp 11.6496 "Solving Poisson's equation in 2D for q = 1, n = 2." (2012, 12, 31, 2, 18, 26) fem-jit-python 0.000419092 "JIT compilation (in memory cache)" (2012, 12, 31, 2, 23, 48) fem-speedup-cpp 322.078 "Assembly/solve speedup running on 4 processors" (2012, 12, 31, 2, 23, 48) fem-speedup-cpp-assembly 6.31242 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2012, 12, 31, 2, 23, 48) fem-speedup-cpp-solve 2.10099 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2012, 12, 31, 2, 24, 15) mesh-refinement-cpp 24.9202 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2012, 12, 31, 2, 24, 37) mesh-topology-cpp 21.7964 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2012, 12, 31, 2, 25, 4) mesh-unitcube-cpp 27.3034 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2012, 12, 31, 2, 25, 47) mesh-iteration-cpp 40.2757 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2012, 12, 31, 2, 26, 9) function-evaluation-cpp 21.5395 "Evaluations of functions at arbitrary points." (2012, 12, 31, 2, 26, 9) function-evaluation-cpp 21.376 "Evaluations of functions at arbitrary points." (2012, 12, 31, 2, 26, 36) la-vector-access-cpp 24.3255 "Accessing vector of size 10000000 (100 repetitions)" (2012, 12, 31, 2, 27, 3) la-vector-assignment-cpp 26.9392 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 1, 2, 13, 38) common-progress-cpp 29.1904 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 1, 2, 14, 6) common-timing-cpp 27.4852 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 1, 2, 15, 54) fem-multicore-cpp 108.066 "Coloring mesh." (2013, 1, 1, 2, 18, 21) fem-assembly-cpp 147.773 "Assembly for various forms and backends" (2013, 1, 1, 2, 18, 33) fem-convergence-cpp 11.6448 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 1, 2, 18, 35) fem-jit-python 0.000428605 "JIT compilation (in memory cache)" (2013, 1, 1, 2, 23, 55) fem-speedup-cpp 320.02 "Assembly/solve speedup running on 4 processors" (2013, 1, 1, 2, 23, 55) fem-speedup-cpp-assembly 6.30526 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 1, 2, 23, 55) fem-speedup-cpp-solve 2.14649 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 1, 2, 24, 22) mesh-refinement-cpp 25.0549 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 1, 2, 24, 44) mesh-topology-cpp 21.9906 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 1, 2, 25, 14) mesh-unitcube-cpp 29.9711 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 1, 2, 25, 57) mesh-iteration-cpp 40.2668 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 1, 2, 26, 19) function-evaluation-cpp 21.7586 "Evaluations of functions at arbitrary points." (2013, 1, 1, 2, 26, 19) function-evaluation-cpp 21.6251 "Evaluations of functions at arbitrary points." (2013, 1, 1, 2, 26, 47) la-vector-access-cpp 24.3313 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 1, 2, 27, 13) la-vector-assignment-cpp 26.0209 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 2, 2, 13, 22) common-progress-cpp 29.0827 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 2, 2, 13, 51) common-timing-cpp 28.3639 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 2, 2, 15, 39) fem-multicore-cpp 108.285 "Coloring mesh." (2013, 1, 2, 2, 18, 7) fem-assembly-cpp 147.852 "Assembly for various forms and backends" (2013, 1, 2, 2, 18, 19) fem-convergence-cpp 11.6661 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 2, 2, 18, 20) fem-jit-python 0.000412893 "JIT compilation (in memory cache)" (2013, 1, 2, 2, 23, 44) fem-speedup-cpp 323.195 "Assembly/solve speedup running on 4 processors" (2013, 1, 2, 2, 23, 44) fem-speedup-cpp-assembly 6.31078 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 2, 2, 23, 44) fem-speedup-cpp-solve 2.07754 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 2, 2, 24, 11) mesh-refinement-cpp 25.0994 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 2, 2, 24, 33) mesh-topology-cpp 22.0951 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 2, 2, 25, 3) mesh-unitcube-cpp 29.9758 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 2, 2, 25, 50) mesh-iteration-cpp 43.6582 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 2, 2, 26, 12) function-evaluation-cpp 21.983 "Evaluations of functions at arbitrary points." (2013, 1, 2, 2, 26, 12) function-evaluation-cpp 21.8297 "Evaluations of functions at arbitrary points." (2013, 1, 2, 2, 26, 39) la-vector-access-cpp 24.3228 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 2, 2, 27, 5) la-vector-assignment-cpp 26.0199 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 3, 2, 13, 20) common-progress-cpp 29.0572 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 3, 2, 13, 48) common-timing-cpp 27.4562 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 3, 2, 15, 36) fem-multicore-cpp 108.144 "Coloring mesh." (2013, 1, 3, 2, 18, 4) fem-assembly-cpp 148.32 "Assembly for various forms and backends" (2013, 1, 3, 2, 18, 16) fem-convergence-cpp 11.6262 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 3, 2, 18, 18) fem-jit-python 0.000415707 "JIT compilation (in memory cache)" (2013, 1, 3, 2, 23, 37) fem-speedup-cpp 319.496 "Assembly/solve speedup running on 4 processors" (2013, 1, 3, 2, 23, 37) fem-speedup-cpp-assembly 6.27728 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 3, 2, 23, 37) fem-speedup-cpp-solve 2.15972 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 3, 2, 24, 4) mesh-refinement-cpp 25.0932 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 3, 2, 24, 26) mesh-topology-cpp 22.0119 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 3, 2, 24, 56) mesh-unitcube-cpp 29.9568 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 3, 2, 25, 50) mesh-iteration-cpp 50.8641 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 3, 2, 26, 12) function-evaluation-cpp 21.7498 "Evaluations of functions at arbitrary points." (2013, 1, 3, 2, 26, 12) function-evaluation-cpp 21.5963 "Evaluations of functions at arbitrary points." (2013, 1, 3, 2, 26, 39) la-vector-access-cpp 24.33 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 3, 2, 27, 5) la-vector-assignment-cpp 26.0178 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 4, 2, 14, 3) common-progress-cpp 29.0405 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 4, 2, 14, 29) common-timing-cpp 25.7598 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 4, 2, 16, 17) fem-multicore-cpp 108.493 "Coloring mesh." (2013, 1, 4, 2, 18, 46) fem-assembly-cpp 148.97 "Assembly for various forms and backends" (2013, 1, 4, 2, 18, 58) fem-convergence-cpp 11.6567 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 4, 2, 19, 0) fem-jit-python 0.000427198 "JIT compilation (in memory cache)" (2013, 1, 4, 2, 24, 28) fem-speedup-cpp 328.273 "Assembly/solve speedup running on 4 processors" (2013, 1, 4, 2, 24, 28) fem-speedup-cpp-assembly 6.24089 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 4, 2, 24, 28) fem-speedup-cpp-solve 2.06369 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 4, 2, 24, 56) mesh-refinement-cpp 25.7528 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 4, 2, 25, 19) mesh-topology-cpp 22.8493 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 4, 2, 25, 48) mesh-unitcube-cpp 29.8246 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 4, 2, 26, 32) mesh-iteration-cpp 40.266 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 4, 2, 26, 53) function-evaluation-cpp 21.5245 "Evaluations of functions at arbitrary points." (2013, 1, 4, 2, 26, 53) function-evaluation-cpp 21.4111 "Evaluations of functions at arbitrary points." (2013, 1, 4, 2, 27, 22) la-vector-access-cpp 25.408 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 4, 2, 27, 53) la-vector-assignment-cpp 31.488 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 5, 2, 13, 47) common-progress-cpp 28.974 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 5, 2, 14, 14) common-timing-cpp 26.2999 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 5, 2, 16, 2) fem-multicore-cpp 107.946 "Coloring mesh." (2013, 1, 5, 2, 18, 30) fem-assembly-cpp 147.991 "Assembly for various forms and backends" (2013, 1, 5, 2, 18, 41) fem-convergence-cpp 11.6166 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 5, 2, 18, 43) fem-jit-python 0.000426292 "JIT compilation (in memory cache)" (2013, 1, 5, 2, 24, 12) fem-speedup-cpp 328.557 "Assembly/solve speedup running on 4 processors" (2013, 1, 5, 2, 24, 12) fem-speedup-cpp-assembly 6.22563 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 5, 2, 24, 12) fem-speedup-cpp-solve 2.03482 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 5, 2, 24, 39) mesh-refinement-cpp 25.4168 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 5, 2, 25, 2) mesh-topology-cpp 22.3457 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 5, 2, 25, 32) mesh-unitcube-cpp 29.7962 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 5, 2, 26, 15) mesh-iteration-cpp 40.2716 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 5, 2, 26, 37) function-evaluation-cpp 21.5918 "Evaluations of functions at arbitrary points." (2013, 1, 5, 2, 26, 37) function-evaluation-cpp 21.4536 "Evaluations of functions at arbitrary points." (2013, 1, 5, 2, 27, 3) la-vector-access-cpp 23.0904 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 5, 2, 27, 29) la-vector-assignment-cpp 26.0253 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 6, 2, 13, 46) common-progress-cpp 29.0073 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 6, 2, 14, 12) common-timing-cpp 25.9913 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 6, 2, 16, 0) fem-multicore-cpp 107.69 "Coloring mesh." (2013, 1, 6, 2, 18, 26) fem-assembly-cpp 146.227 "Assembly for various forms and backends" (2013, 1, 6, 2, 18, 38) fem-convergence-cpp 11.6923 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 6, 2, 18, 40) fem-jit-python 0.000419903 "JIT compilation (in memory cache)" (2013, 1, 6, 2, 24, 5) fem-speedup-cpp 325.15 "Assembly/solve speedup running on 4 processors" (2013, 1, 6, 2, 24, 5) fem-speedup-cpp-assembly 6.2811 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 6, 2, 24, 5) fem-speedup-cpp-solve 2.10139 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 6, 2, 24, 32) mesh-refinement-cpp 25.5182 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 6, 2, 24, 55) mesh-topology-cpp 22.5053 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 6, 2, 25, 25) mesh-unitcube-cpp 29.8467 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 6, 2, 26, 10) mesh-iteration-cpp 41.4966 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 6, 2, 26, 31) function-evaluation-cpp 21.6417 "Evaluations of functions at arbitrary points." (2013, 1, 6, 2, 26, 31) function-evaluation-cpp 21.4913 "Evaluations of functions at arbitrary points." (2013, 1, 6, 2, 26, 58) la-vector-access-cpp 23.422 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 6, 2, 27, 26) la-vector-assignment-cpp 28.0429 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 7, 2, 13, 26) common-progress-cpp 29.064 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 7, 2, 13, 52) common-timing-cpp 26.4392 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 7, 2, 15, 40) fem-multicore-cpp 107.793 "Coloring mesh." (2013, 1, 7, 2, 18, 6) fem-assembly-cpp 145.698 "Assembly for various forms and backends" (2013, 1, 7, 2, 18, 17) fem-convergence-cpp 11.6308 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 7, 2, 18, 20) fem-jit-python 0.000425911 "JIT compilation (in memory cache)" (2013, 1, 7, 2, 23, 53) fem-speedup-cpp 333.605 "Assembly/solve speedup running on 4 processors" (2013, 1, 7, 2, 23, 53) fem-speedup-cpp-assembly 6.32009 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 7, 2, 23, 53) fem-speedup-cpp-solve 1.94115 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 7, 2, 24, 21) mesh-refinement-cpp 25.4597 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 7, 2, 24, 43) mesh-topology-cpp 22.3211 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 7, 2, 25, 13) mesh-unitcube-cpp 29.8543 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 7, 2, 25, 56) mesh-iteration-cpp 40.304 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 7, 2, 26, 18) function-evaluation-cpp 21.6466 "Evaluations of functions at arbitrary points." (2013, 1, 7, 2, 26, 18) function-evaluation-cpp 21.5327 "Evaluations of functions at arbitrary points." (2013, 1, 7, 2, 26, 45) la-vector-access-cpp 23.2755 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 7, 2, 27, 11) la-vector-assignment-cpp 26.0323 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 8, 9, 30, 3) common-progress-cpp 27.6769 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 8, 9, 30, 31) common-timing-cpp 27.89 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 8, 9, 32, 19) fem-multicore-cpp 108.086 "Coloring mesh." (2013, 1, 8, 9, 34, 48) fem-assembly-cpp 148.336 "Assembly for various forms and backends" (2013, 1, 8, 9, 34, 59) fem-convergence-cpp 11.5748 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 8, 9, 35, 0) fem-jit-python 0.000421596 "JIT compilation (in memory cache)" (2013, 1, 8, 9, 40, 29) fem-speedup-cpp 329.284 "Assembly/solve speedup running on 4 processors" (2013, 1, 8, 9, 40, 29) fem-speedup-cpp-assembly 6.44639 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 8, 9, 40, 29) fem-speedup-cpp-solve 2.04301 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 8, 9, 40, 57) mesh-refinement-cpp 25.4305 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 8, 9, 41, 20) mesh-topology-cpp 22.7566 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 8, 9, 41, 50) mesh-unitcube-cpp 30.018 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 8, 9, 42, 39) mesh-iteration-cpp 45.9287 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 8, 9, 43, 3) function-evaluation-cpp 24.6349 "Evaluations of functions at arbitrary points." (2013, 1, 8, 9, 43, 3) function-evaluation-cpp 24.4969 "Evaluations of functions at arbitrary points." (2013, 1, 8, 9, 43, 9) function-extrapolation-python 5.06534 "*** -------------------------------------------------------------------------" (2013, 1, 8, 9, 43, 9) function-extrapolation-python 1.89934 "*** -------------------------------------------------------------------------" (2013, 1, 8, 9, 43, 34) la-vector-access-cpp 25.4216 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 8, 9, 44, 0) la-vector-assignment-cpp 26.0434 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 10, 2, 14, 15) common-progress-cpp 46.5251 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 10, 2, 14, 41) common-timing-cpp 26.03 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 10, 2, 17, 38) fem-multicore-cpp 176.271 "Coloring mesh." (2013, 1, 10, 2, 21, 8) fem-assembly-cpp 210.527 "Assembly for various forms and backends" (2013, 1, 10, 2, 21, 21) fem-convergence-cpp 13.1854 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 10, 2, 26, 53) fem-speedup-cpp 329.794 "Assembly/solve speedup running on 4 processors" (2013, 1, 10, 2, 26, 53) fem-speedup-cpp-assembly 6.65393 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 10, 2, 26, 53) fem-speedup-cpp-solve 2.10296 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 10, 2, 27, 20) mesh-refinement-cpp 25.0142 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 10, 2, 27, 42) mesh-topology-cpp 21.9036 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 10, 2, 28, 10) mesh-unitcube-cpp 27.6654 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 10, 2, 28, 58) mesh-iteration-cpp 45.2356 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 10, 2, 29, 19) function-evaluation-cpp 21.6253 "Evaluations of functions at arbitrary points." (2013, 1, 10, 2, 29, 19) function-evaluation-cpp 21.4886 "Evaluations of functions at arbitrary points." (2013, 1, 10, 2, 29, 47) la-vector-access-cpp 25.4046 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 10, 2, 30, 13) la-vector-assignment-cpp 26.0207 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 11, 2, 14, 1) common-progress-cpp 28.9075 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 11, 2, 14, 29) common-timing-cpp 27.7615 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 11, 2, 17, 25) fem-multicore-cpp 176.202 "Coloring mesh." (2013, 1, 11, 2, 20, 53) fem-assembly-cpp 207.36 "Assembly for various forms and backends" (2013, 1, 11, 2, 21, 5) fem-convergence-cpp 12.9138 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 11, 2, 26, 43) fem-speedup-cpp 327.716 "Assembly/solve speedup running on 4 processors" (2013, 1, 11, 2, 26, 43) fem-speedup-cpp-assembly 6.74337 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 11, 2, 26, 43) fem-speedup-cpp-solve 2.13362 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 11, 2, 27, 10) mesh-refinement-cpp 25.579 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 11, 2, 27, 33) mesh-topology-cpp 22.4433 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 11, 2, 28, 3) mesh-unitcube-cpp 29.9766 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 11, 2, 28, 48) mesh-iteration-cpp 41.9984 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 11, 2, 29, 9) function-evaluation-cpp 21.6899 "Evaluations of functions at arbitrary points." (2013, 1, 11, 2, 29, 9) function-evaluation-cpp 21.5237 "Evaluations of functions at arbitrary points." (2013, 1, 11, 2, 30, 0) function-extrapolation-python 50.6551 "*** -------------------------------------------------------------------------" (2013, 1, 11, 2, 30, 0) function-extrapolation-python 1.88481 "*** -------------------------------------------------------------------------" (2013, 1, 11, 2, 30, 26) la-vector-access-cpp 25.9293 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 11, 2, 30, 54) la-vector-assignment-cpp 27.4855 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 12, 2, 13, 45) common-progress-cpp 29.0638 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 12, 2, 14, 13) common-timing-cpp 28.4146 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 12, 2, 17, 9) fem-multicore-cpp 175.394 "Coloring mesh." (2013, 1, 12, 2, 17, 23) fem-convergence-cpp 12.8391 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 12, 2, 17, 36) fem-jit-python 0.000464296 "JIT compilation (in memory cache)" (2013, 1, 12, 2, 22, 55) fem-speedup-cpp 319.498 "Assembly/solve speedup running on 4 processors" (2013, 1, 12, 2, 22, 55) fem-speedup-cpp-assembly 6.66774 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 12, 2, 22, 55) fem-speedup-cpp-solve 2.33399 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 12, 2, 23, 22) mesh-refinement-cpp 25.0449 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 12, 2, 23, 44) mesh-topology-cpp 22.1335 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 12, 2, 24, 12) mesh-unitcube-cpp 27.9635 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 12, 2, 24, 55) mesh-iteration-cpp 40.2816 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 12, 2, 25, 17) function-evaluation-cpp 21.6981 "Evaluations of functions at arbitrary points." (2013, 1, 12, 2, 25, 17) function-evaluation-cpp 21.5212 "Evaluations of functions at arbitrary points." (2013, 1, 12, 2, 26, 2) function-extrapolation-python 44.8762 "*** -------------------------------------------------------------------------" (2013, 1, 12, 2, 26, 2) function-extrapolation-python 1.88083 "*** -------------------------------------------------------------------------" (2013, 1, 12, 2, 26, 25) la-vector-access-cpp 23.0557 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 12, 2, 26, 53) la-vector-assignment-cpp 28.1005 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 13, 2, 13, 29) common-progress-cpp 29.1072 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 13, 2, 13, 55) common-timing-cpp 26.8199 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 13, 2, 16, 51) fem-multicore-cpp 175.762 "Coloring mesh." (2013, 1, 13, 2, 17, 5) fem-convergence-cpp 12.8878 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 13, 2, 17, 7) fem-jit-python 0.000425696 "JIT compilation (in memory cache)" (2013, 1, 13, 2, 22, 27) fem-speedup-cpp 319.732 "Assembly/solve speedup running on 4 processors" (2013, 1, 13, 2, 22, 27) fem-speedup-cpp-assembly 6.59921 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 13, 2, 22, 27) fem-speedup-cpp-solve 2.32908 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 13, 2, 22, 54) mesh-refinement-cpp 25.1064 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 13, 2, 23, 16) mesh-topology-cpp 22.0354 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 13, 2, 23, 45) mesh-unitcube-cpp 28.7885 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 13, 2, 24, 28) mesh-iteration-cpp 40.2882 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 13, 2, 24, 49) function-evaluation-cpp 21.4172 "Evaluations of functions at arbitrary points." (2013, 1, 13, 2, 24, 49) function-evaluation-cpp 21.2329 "Evaluations of functions at arbitrary points." (2013, 1, 13, 2, 24, 55) function-extrapolation-python 5.10637 "*** -------------------------------------------------------------------------" (2013, 1, 13, 2, 24, 55) function-extrapolation-python 1.87679 "*** -------------------------------------------------------------------------" (2013, 1, 13, 2, 25, 20) la-vector-access-cpp 24.9473 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 13, 2, 25, 46) la-vector-assignment-cpp 26.0215 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 14, 2, 13, 40) common-progress-cpp 29.1072 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 14, 2, 14, 8) common-timing-cpp 28.3639 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 14, 2, 17, 4) fem-multicore-cpp 175.802 "Coloring mesh." (2013, 1, 14, 2, 17, 18) fem-convergence-cpp 12.7995 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 14, 2, 17, 28) fem-jit-python 0.000466394 "JIT compilation (in memory cache)" (2013, 1, 14, 2, 22, 48) fem-speedup-cpp 320.547 "Assembly/solve speedup running on 4 processors" (2013, 1, 14, 2, 22, 48) fem-speedup-cpp-assembly 6.57529 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 14, 2, 22, 48) fem-speedup-cpp-solve 2.30587 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 14, 2, 23, 15) mesh-refinement-cpp 25.1114 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 14, 2, 23, 37) mesh-topology-cpp 22.037 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 14, 2, 24, 6) mesh-unitcube-cpp 28.7315 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 14, 2, 24, 49) mesh-iteration-cpp 40.2851 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 14, 2, 25, 10) function-evaluation-cpp 21.1488 "Evaluations of functions at arbitrary points." (2013, 1, 14, 2, 25, 10) function-evaluation-cpp 20.9846 "Evaluations of functions at arbitrary points." (2013, 1, 14, 2, 25, 51) function-extrapolation-python 40.5416 "*** -------------------------------------------------------------------------" (2013, 1, 14, 2, 25, 51) function-extrapolation-python 1.85788 "*** -------------------------------------------------------------------------" (2013, 1, 14, 2, 26, 15) la-vector-access-cpp 24.3184 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 14, 2, 26, 43) la-vector-assignment-cpp 27.4852 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 15, 2, 13, 27) common-progress-cpp 29.332 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 15, 2, 13, 55) common-timing-cpp 27.2501 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 15, 2, 16, 51) fem-multicore-cpp 176.051 "Coloring mesh." (2013, 1, 15, 2, 17, 5) fem-convergence-cpp 12.8666 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 15, 2, 17, 7) fem-jit-python 0.000440693 "JIT compilation (in memory cache)" (2013, 1, 15, 2, 22, 28) fem-speedup-cpp 321.63 "Assembly/solve speedup running on 4 processors" (2013, 1, 15, 2, 22, 28) fem-speedup-cpp-assembly 6.58088 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 15, 2, 22, 28) fem-speedup-cpp-solve 2.27925 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 15, 2, 22, 55) mesh-refinement-cpp 25.2067 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 15, 2, 23, 17) mesh-topology-cpp 21.9983 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 15, 2, 23, 46) mesh-unitcube-cpp 28.6831 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 15, 2, 24, 29) mesh-iteration-cpp 40.2741 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 15, 2, 24, 51) function-evaluation-cpp 21.7253 "Evaluations of functions at arbitrary points." (2013, 1, 15, 2, 24, 51) function-evaluation-cpp 21.5417 "Evaluations of functions at arbitrary points." (2013, 1, 15, 2, 24, 56) function-extrapolation-python 5.14986 "*** -------------------------------------------------------------------------" (2013, 1, 15, 2, 24, 56) function-extrapolation-python 1.87687 "*** -------------------------------------------------------------------------" (2013, 1, 15, 2, 25, 21) la-vector-access-cpp 24.3784 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 15, 2, 25, 47) la-vector-assignment-cpp 26.0258 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 16, 2, 13, 30) common-progress-cpp 29.0156 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 16, 2, 13, 57) common-timing-cpp 27.5074 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 16, 2, 16, 53) fem-multicore-cpp 175.747 "Coloring mesh." (2013, 1, 16, 2, 17, 7) fem-convergence-cpp 12.7917 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 16, 2, 17, 13) fem-jit-python 0.000468087 "JIT compilation (in memory cache)" (2013, 1, 16, 2, 22, 35) fem-speedup-cpp 321.892 "Assembly/solve speedup running on 4 processors" (2013, 1, 16, 2, 22, 35) fem-speedup-cpp-assembly 6.62603 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 16, 2, 22, 35) fem-speedup-cpp-solve 2.26544 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 16, 2, 23, 2) mesh-refinement-cpp 25.1595 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 16, 2, 23, 24) mesh-topology-cpp 22.1158 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 16, 2, 23, 53) mesh-unitcube-cpp 28.6837 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 16, 2, 24, 36) mesh-iteration-cpp 40.2749 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 16, 2, 24, 58) function-evaluation-cpp 21.5979 "Evaluations of functions at arbitrary points." (2013, 1, 16, 2, 24, 58) function-evaluation-cpp 21.4564 "Evaluations of functions at arbitrary points." (2013, 1, 16, 2, 25, 3) function-extrapolation-python 5.07854 "*** -------------------------------------------------------------------------" (2013, 1, 16, 2, 25, 3) function-extrapolation-python 1.85513 "*** -------------------------------------------------------------------------" (2013, 1, 16, 2, 25, 27) la-vector-access-cpp 23.8834 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 16, 2, 25, 53) la-vector-assignment-cpp 26.0283 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 17, 2, 13, 41) common-progress-cpp 29.0073 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 17, 2, 14, 9) common-timing-cpp 27.9297 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 17, 2, 17, 5) fem-multicore-cpp 175.821 "Coloring mesh." (2013, 1, 17, 2, 17, 19) fem-convergence-cpp 12.8058 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 17, 2, 17, 21) fem-jit-python 0.000441289 "JIT compilation (in memory cache)" (2013, 1, 17, 2, 22, 41) fem-speedup-cpp 320.424 "Assembly/solve speedup running on 4 processors" (2013, 1, 17, 2, 22, 41) fem-speedup-cpp-assembly 6.58347 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 17, 2, 22, 41) fem-speedup-cpp-solve 2.31455 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 17, 2, 23, 8) mesh-refinement-cpp 25.1426 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 17, 2, 23, 30) mesh-topology-cpp 22.0589 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 17, 2, 23, 59) mesh-unitcube-cpp 28.5793 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 17, 2, 24, 44) mesh-iteration-cpp 42.7842 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 17, 2, 25, 6) function-evaluation-cpp 21.6734 "Evaluations of functions at arbitrary points." (2013, 1, 17, 2, 25, 6) function-evaluation-cpp 21.4883 "Evaluations of functions at arbitrary points." (2013, 1, 17, 2, 25, 11) function-extrapolation-python 5.18334 "*** -------------------------------------------------------------------------" (2013, 1, 17, 2, 25, 11) function-extrapolation-python 1.85616 "*** -------------------------------------------------------------------------" (2013, 1, 17, 2, 25, 36) la-vector-access-cpp 24.3091 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 17, 2, 26, 2) la-vector-assignment-cpp 26.1076 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 18, 2, 13, 38) common-progress-cpp 28.9989 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 18, 2, 14, 8) common-timing-cpp 29.693 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 18, 2, 17, 4) fem-multicore-cpp 175.731 "Coloring mesh." (2013, 1, 18, 2, 17, 18) fem-convergence-cpp 12.9016 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 18, 2, 17, 20) fem-jit-python 0.000437999 "JIT compilation (in memory cache)" (2013, 1, 18, 2, 22, 43) fem-speedup-cpp 323.569 "Assembly/solve speedup running on 4 processors" (2013, 1, 18, 2, 22, 43) fem-speedup-cpp-assembly 6.5989 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 18, 2, 22, 43) fem-speedup-cpp-solve 2.26139 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 18, 2, 23, 10) mesh-refinement-cpp 24.8542 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 18, 2, 23, 32) mesh-topology-cpp 21.9163 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 18, 2, 23, 59) mesh-unitcube-cpp 27.4605 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 18, 2, 24, 43) mesh-iteration-cpp 40.3387 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 18, 2, 25, 4) function-evaluation-cpp 21.6172 "Evaluations of functions at arbitrary points." (2013, 1, 18, 2, 25, 4) function-evaluation-cpp 21.4665 "Evaluations of functions at arbitrary points." (2013, 1, 18, 2, 25, 10) function-extrapolation-python 5.15149 "*** -------------------------------------------------------------------------" (2013, 1, 18, 2, 25, 10) function-extrapolation-python 1.85093 "*** -------------------------------------------------------------------------" (2013, 1, 18, 2, 25, 35) la-vector-access-cpp 25.7341 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 18, 2, 26, 3) la-vector-assignment-cpp 27.9165 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 19, 2, 13, 33) common-progress-cpp 29.0406 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 19, 2, 14, 2) common-timing-cpp 28.4299 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 19, 2, 16, 57) fem-multicore-cpp 175.758 "Coloring mesh." (2013, 1, 19, 2, 17, 11) fem-convergence-cpp 12.8436 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 19, 2, 17, 13) fem-jit-python 0.000450706 "JIT compilation (in memory cache)" (2013, 1, 19, 2, 22, 34) fem-speedup-cpp 320.408 "Assembly/solve speedup running on 4 processors" (2013, 1, 19, 2, 22, 34) fem-speedup-cpp-assembly 6.61059 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 19, 2, 22, 34) fem-speedup-cpp-solve 2.34127 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 19, 2, 23, 0) mesh-refinement-cpp 24.8787 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 19, 2, 23, 22) mesh-topology-cpp 22.0097 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 19, 2, 23, 50) mesh-unitcube-cpp 27.3828 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 19, 2, 24, 33) mesh-iteration-cpp 40.2712 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 19, 2, 24, 57) function-evaluation-cpp 24.4473 "Evaluations of functions at arbitrary points." (2013, 1, 19, 2, 24, 57) function-evaluation-cpp 24.2817 "Evaluations of functions at arbitrary points." (2013, 1, 19, 2, 25, 3) function-extrapolation-python 5.02378 "*** -------------------------------------------------------------------------" (2013, 1, 19, 2, 25, 3) function-extrapolation-python 1.883 "*** -------------------------------------------------------------------------" (2013, 1, 19, 2, 25, 29) la-vector-access-cpp 25.9917 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 19, 2, 25, 55) la-vector-assignment-cpp 26.0252 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 20, 2, 13, 42) common-progress-cpp 28.9823 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 20, 2, 14, 11) common-timing-cpp 28.42 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 20, 2, 17, 8) fem-multicore-cpp 176.585 "Coloring mesh." (2013, 1, 20, 2, 17, 22) fem-convergence-cpp 12.9216 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 20, 2, 17, 24) fem-jit-python 0.00043211 "JIT compilation (in memory cache)" (2013, 1, 20, 2, 22, 45) fem-speedup-cpp 321.325 "Assembly/solve speedup running on 4 processors" (2013, 1, 20, 2, 22, 45) fem-speedup-cpp-assembly 6.59784 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 20, 2, 22, 45) fem-speedup-cpp-solve 2.32001 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 20, 2, 23, 12) mesh-refinement-cpp 24.974 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 20, 2, 23, 34) mesh-topology-cpp 22.0486 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 20, 2, 24, 2) mesh-unitcube-cpp 27.9062 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 20, 2, 24, 45) mesh-iteration-cpp 40.265 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 20, 2, 25, 6) function-evaluation-cpp 21.509 "Evaluations of functions at arbitrary points." (2013, 1, 20, 2, 25, 6) function-evaluation-cpp 21.338 "Evaluations of functions at arbitrary points." (2013, 1, 20, 2, 25, 12) function-extrapolation-python 5.12828 "*** -------------------------------------------------------------------------" (2013, 1, 20, 2, 25, 12) function-extrapolation-python 1.88845 "*** -------------------------------------------------------------------------" (2013, 1, 20, 2, 25, 38) la-vector-access-cpp 25.9707 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 20, 2, 26, 4) la-vector-assignment-cpp 26.0248 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 21, 2, 13, 50) common-progress-cpp 36.6006 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 21, 2, 14, 19) common-timing-cpp 28.448 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 21, 2, 17, 15) fem-multicore-cpp 176.479 "Coloring mesh." (2013, 1, 21, 2, 17, 29) fem-convergence-cpp 12.9281 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 21, 2, 17, 35) fem-jit-python 0.000461888 "JIT compilation (in memory cache)" (2013, 1, 21, 2, 22, 56) fem-speedup-cpp 321.418 "Assembly/solve speedup running on 4 processors" (2013, 1, 21, 2, 22, 56) fem-speedup-cpp-assembly 6.60954 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 21, 2, 22, 56) fem-speedup-cpp-solve 2.30787 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 21, 2, 23, 23) mesh-refinement-cpp 24.8547 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 21, 2, 23, 45) mesh-topology-cpp 21.9757 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 21, 2, 24, 13) mesh-unitcube-cpp 27.8767 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 21, 2, 24, 56) mesh-iteration-cpp 40.3027 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 21, 2, 25, 18) function-evaluation-cpp 21.6614 "Evaluations of functions at arbitrary points." (2013, 1, 21, 2, 25, 18) function-evaluation-cpp 21.5169 "Evaluations of functions at arbitrary points." (2013, 1, 21, 2, 25, 23) function-extrapolation-python 4.94182 "*** -------------------------------------------------------------------------" (2013, 1, 21, 2, 25, 23) function-extrapolation-python 1.84695 "*** -------------------------------------------------------------------------" (2013, 1, 21, 2, 25, 49) la-vector-access-cpp 25.9738 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 21, 2, 26, 15) la-vector-assignment-cpp 26.0201 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 22, 2, 13, 48) common-progress-cpp 28.9574 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 22, 2, 14, 16) common-timing-cpp 28.3909 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 22, 2, 17, 14) fem-multicore-cpp 177.196 "Coloring mesh." (2013, 1, 22, 2, 17, 28) fem-convergence-cpp 12.9342 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 22, 2, 17, 30) fem-jit-python 0.000439119 "JIT compilation (in memory cache)" (2013, 1, 22, 2, 22, 52) fem-speedup-cpp 321.926 "Assembly/solve speedup running on 4 processors" (2013, 1, 22, 2, 22, 52) fem-speedup-cpp-assembly 6.58873 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 22, 2, 22, 52) fem-speedup-cpp-solve 2.29602 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 22, 2, 23, 18) mesh-refinement-cpp 24.9235 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 22, 2, 23, 40) mesh-topology-cpp 21.9956 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 22, 2, 24, 8) mesh-unitcube-cpp 27.9028 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 22, 2, 24, 52) mesh-iteration-cpp 40.3414 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 22, 2, 25, 13) function-evaluation-cpp 21.607 "Evaluations of functions at arbitrary points." (2013, 1, 22, 2, 25, 13) function-evaluation-cpp 21.4252 "Evaluations of functions at arbitrary points." (2013, 1, 22, 2, 25, 18) function-extrapolation-python 5.16426 "*** -------------------------------------------------------------------------" (2013, 1, 22, 2, 25, 18) function-extrapolation-python 1.8926 "*** -------------------------------------------------------------------------" (2013, 1, 22, 2, 25, 44) la-vector-access-cpp 25.407 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 22, 2, 26, 10) la-vector-assignment-cpp 26.0217 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 23, 2, 14, 1) common-progress-cpp 29.0323 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 23, 2, 14, 32) common-timing-cpp 30.8028 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 23, 2, 17, 28) fem-multicore-cpp 176.407 "Coloring mesh." (2013, 1, 23, 2, 17, 42) fem-convergence-cpp 12.7902 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 23, 2, 17, 55) fem-jit-python 0.000463915 "JIT compilation (in memory cache)" (2013, 1, 23, 2, 23, 22) fem-speedup-cpp 326.326 "Assembly/solve speedup running on 4 processors" (2013, 1, 23, 2, 23, 22) fem-speedup-cpp-assembly 6.46845 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 23, 2, 23, 22) fem-speedup-cpp-solve 2.18454 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 23, 2, 23, 49) mesh-refinement-cpp 24.895 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 23, 2, 24, 11) mesh-topology-cpp 21.9758 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 23, 2, 24, 39) mesh-unitcube-cpp 27.8992 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 23, 2, 25, 24) mesh-iteration-cpp 42.8175 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 23, 2, 25, 46) function-evaluation-cpp 21.6573 "Evaluations of functions at arbitrary points." (2013, 1, 23, 2, 25, 46) function-evaluation-cpp 21.5382 "Evaluations of functions at arbitrary points." (2013, 1, 23, 2, 26, 30) function-extrapolation-python 44.3454 "*** -------------------------------------------------------------------------" (2013, 1, 23, 2, 26, 30) function-extrapolation-python 1.89657 "*** -------------------------------------------------------------------------" (2013, 1, 23, 2, 26, 56) la-vector-access-cpp 25.9762 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 23, 2, 27, 22) la-vector-assignment-cpp 26.0193 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 24, 2, 14, 9) common-progress-cpp 28.974 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 24, 2, 14, 37) common-timing-cpp 27.2276 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 24, 2, 17, 33) fem-multicore-cpp 175.999 "Coloring mesh." (2013, 1, 24, 2, 17, 47) fem-convergence-cpp 12.7795 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 24, 2, 17, 49) fem-jit-python 0.00043149 "JIT compilation (in memory cache)" (2013, 1, 24, 2, 23, 9) fem-speedup-cpp 320.158 "Assembly/solve speedup running on 4 processors" (2013, 1, 24, 2, 23, 9) fem-speedup-cpp-assembly 6.61103 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 24, 2, 23, 9) fem-speedup-cpp-solve 2.31415 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 24, 2, 23, 35) mesh-refinement-cpp 24.7524 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 24, 2, 23, 57) mesh-topology-cpp 21.7797 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 24, 2, 24, 25) mesh-unitcube-cpp 27.6775 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 24, 2, 25, 8) mesh-iteration-cpp 40.2959 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 24, 2, 25, 30) function-evaluation-cpp 21.7424 "Evaluations of functions at arbitrary points." (2013, 1, 24, 2, 25, 30) function-evaluation-cpp 21.586 "Evaluations of functions at arbitrary points." (2013, 1, 24, 2, 25, 35) function-extrapolation-python 5.09456 "*** -------------------------------------------------------------------------" (2013, 1, 24, 2, 25, 35) function-extrapolation-python 1.89557 "*** -------------------------------------------------------------------------" (2013, 1, 24, 2, 25, 59) la-vector-access-cpp 24.3083 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 24, 2, 26, 25) la-vector-assignment-cpp 25.9697 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 25, 2, 13, 36) common-progress-cpp 46.6334 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 25, 2, 14, 3) common-timing-cpp 27.5028 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 25, 2, 17, 0) fem-multicore-cpp 176.666 "Coloring mesh." (2013, 1, 25, 2, 17, 14) fem-convergence-cpp 12.8285 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 25, 2, 17, 27) fem-jit-python 0.00124471 "JIT compilation (in memory cache)" (2013, 1, 25, 2, 22, 53) fem-speedup-cpp 326.365 "Assembly/solve speedup running on 4 processors" (2013, 1, 25, 2, 22, 53) fem-speedup-cpp-assembly 6.65954 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 25, 2, 22, 53) fem-speedup-cpp-solve 2.1487 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 25, 2, 23, 20) mesh-refinement-cpp 24.732 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 25, 2, 23, 42) mesh-topology-cpp 21.7758 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 25, 2, 24, 10) mesh-unitcube-cpp 27.5992 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 25, 2, 24, 54) mesh-iteration-cpp 41.6061 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 25, 2, 25, 16) function-evaluation-cpp 21.7214 "Evaluations of functions at arbitrary points." (2013, 1, 25, 2, 25, 16) function-evaluation-cpp 21.5959 "Evaluations of functions at arbitrary points." (2013, 1, 25, 2, 26, 0) function-extrapolation-python 44.2916 "*** -------------------------------------------------------------------------" (2013, 1, 25, 2, 26, 0) function-extrapolation-python 1.8612 "*** -------------------------------------------------------------------------" (2013, 1, 25, 2, 26, 25) la-vector-access-cpp 24.3241 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 25, 2, 26, 51) la-vector-assignment-cpp 26.0231 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 26, 2, 13, 41) common-progress-cpp 29.0572 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 26, 2, 14, 9) common-timing-cpp 27.3754 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 26, 2, 17, 4) fem-multicore-cpp 175.443 "Coloring mesh." (2013, 1, 26, 2, 17, 18) fem-convergence-cpp 12.8325 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 26, 2, 17, 20) fem-jit-python 0.0011827 "JIT compilation (in memory cache)" (2013, 1, 26, 2, 22, 42) fem-speedup-cpp 322.163 "Assembly/solve speedup running on 4 processors" (2013, 1, 26, 2, 22, 42) fem-speedup-cpp-assembly 6.68567 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 26, 2, 22, 42) fem-speedup-cpp-solve 2.26771 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 26, 2, 23, 9) mesh-refinement-cpp 24.8247 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 26, 2, 23, 31) mesh-topology-cpp 21.8361 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 26, 2, 23, 59) mesh-unitcube-cpp 27.6278 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 26, 2, 24, 42) mesh-iteration-cpp 40.2689 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 26, 2, 25, 3) function-evaluation-cpp 21.4792 "Evaluations of functions at arbitrary points." (2013, 1, 26, 2, 25, 3) function-evaluation-cpp 21.3553 "Evaluations of functions at arbitrary points." (2013, 1, 26, 2, 25, 8) function-extrapolation-python 4.92343 "*** -------------------------------------------------------------------------" (2013, 1, 26, 2, 25, 8) function-extrapolation-python 1.85815 "*** -------------------------------------------------------------------------" (2013, 1, 26, 2, 25, 32) la-vector-access-cpp 23.4097 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 26, 2, 25, 58) la-vector-assignment-cpp 26.0248 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 27, 2, 13, 45) common-progress-cpp 36.5507 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 27, 2, 14, 12) common-timing-cpp 27.355 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 27, 2, 17, 8) fem-multicore-cpp 175.584 "Coloring mesh." (2013, 1, 27, 2, 17, 22) fem-convergence-cpp 12.8384 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 27, 2, 17, 24) fem-jit-python 0.0011826 "JIT compilation (in memory cache)" (2013, 1, 27, 2, 22, 46) fem-speedup-cpp 321.761 "Assembly/solve speedup running on 4 processors" (2013, 1, 27, 2, 22, 46) fem-speedup-cpp-assembly 6.61098 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 27, 2, 22, 46) fem-speedup-cpp-solve 2.27064 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 27, 2, 23, 12) mesh-refinement-cpp 24.7441 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 27, 2, 23, 34) mesh-topology-cpp 21.7775 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 27, 2, 24, 2) mesh-unitcube-cpp 27.6418 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 27, 2, 24, 45) mesh-iteration-cpp 40.272 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 27, 2, 25, 7) function-evaluation-cpp 21.7653 "Evaluations of functions at arbitrary points." (2013, 1, 27, 2, 25, 7) function-evaluation-cpp 21.5784 "Evaluations of functions at arbitrary points." (2013, 1, 27, 2, 25, 12) function-extrapolation-python 5.04005 "*** -------------------------------------------------------------------------" (2013, 1, 27, 2, 25, 12) function-extrapolation-python 1.84921 "*** -------------------------------------------------------------------------" (2013, 1, 27, 2, 25, 36) la-vector-access-cpp 24.3332 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 27, 2, 26, 2) la-vector-assignment-cpp 26.0227 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 28, 2, 13, 31) common-progress-cpp 29.0906 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 28, 2, 13, 59) common-timing-cpp 27.7402 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 28, 2, 16, 56) fem-multicore-cpp 176.709 "Coloring mesh." (2013, 1, 28, 2, 17, 10) fem-convergence-cpp 12.8045 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 28, 2, 17, 12) fem-jit-python 0.00118959 "JIT compilation (in memory cache)" (2013, 1, 28, 2, 22, 31) fem-speedup-cpp 319.714 "Assembly/solve speedup running on 4 processors" (2013, 1, 28, 2, 22, 31) fem-speedup-cpp-assembly 6.63927 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 28, 2, 22, 31) fem-speedup-cpp-solve 2.33265 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 28, 2, 22, 58) mesh-refinement-cpp 24.7539 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 28, 2, 23, 20) mesh-topology-cpp 21.7714 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 28, 2, 23, 47) mesh-unitcube-cpp 27.6728 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 28, 2, 24, 30) mesh-iteration-cpp 40.2776 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 28, 2, 24, 52) function-evaluation-cpp 21.7903 "Evaluations of functions at arbitrary points." (2013, 1, 28, 2, 24, 52) function-evaluation-cpp 21.609 "Evaluations of functions at arbitrary points." (2013, 1, 28, 2, 24, 57) function-extrapolation-python 5.11035 "*** -------------------------------------------------------------------------" (2013, 1, 28, 2, 24, 57) function-extrapolation-python 1.8778 "*** -------------------------------------------------------------------------" (2013, 1, 28, 2, 25, 22) la-vector-access-cpp 24.3376 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 28, 2, 25, 49) la-vector-assignment-cpp 27.4268 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 29, 2, 13, 43) common-progress-cpp 29.2905 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 29, 2, 14, 10) common-timing-cpp 27.4955 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 29, 2, 17, 7) fem-multicore-cpp 176.159 "Coloring mesh." (2013, 1, 29, 2, 17, 20) fem-convergence-cpp 12.8013 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 29, 2, 17, 23) fem-jit-python 0.0011946 "JIT compilation (in memory cache)" (2013, 1, 29, 2, 22, 47) fem-speedup-cpp 324.311 "Assembly/solve speedup running on 4 processors" (2013, 1, 29, 2, 22, 47) fem-speedup-cpp-assembly 6.59535 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 29, 2, 22, 47) fem-speedup-cpp-solve 2.20879 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 29, 2, 23, 14) mesh-refinement-cpp 24.6256 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 29, 2, 23, 35) mesh-topology-cpp 21.7591 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 29, 2, 24, 3) mesh-unitcube-cpp 27.8751 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 29, 2, 24, 47) mesh-iteration-cpp 40.2807 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 29, 2, 25, 9) function-evaluation-cpp 22.4213 "Evaluations of functions at arbitrary points." (2013, 1, 29, 2, 25, 9) function-evaluation-cpp 22.3029 "Evaluations of functions at arbitrary points." (2013, 1, 29, 2, 25, 14) function-extrapolation-python 5.16509 "*** -------------------------------------------------------------------------" (2013, 1, 29, 2, 25, 14) function-extrapolation-python 1.8694 "*** -------------------------------------------------------------------------" (2013, 1, 29, 2, 25, 38) la-vector-access-cpp 24.326 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 29, 2, 26, 5) la-vector-assignment-cpp 26.0185 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 30, 2, 14, 30) common-progress-cpp 28.9739 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 30, 2, 14, 58) common-timing-cpp 27.7129 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 30, 2, 17, 54) fem-multicore-cpp 175.873 "Coloring mesh." (2013, 1, 30, 2, 18, 8) fem-convergence-cpp 12.7941 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 30, 2, 18, 21) fem-jit-python 0.00127661 "JIT compilation (in memory cache)" (2013, 1, 30, 2, 23, 42) fem-speedup-cpp 321.313 "Assembly/solve speedup running on 4 processors" (2013, 1, 30, 2, 23, 42) fem-speedup-cpp-assembly 6.65346 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 30, 2, 23, 42) fem-speedup-cpp-solve 2.28961 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 30, 2, 24, 9) mesh-refinement-cpp 24.7683 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 30, 2, 24, 31) mesh-topology-cpp 21.7878 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 30, 2, 24, 58) mesh-unitcube-cpp 27.3436 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 30, 2, 25, 41) mesh-iteration-cpp 40.2682 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 30, 2, 26, 3) function-evaluation-cpp 21.6926 "Evaluations of functions at arbitrary points." (2013, 1, 30, 2, 26, 3) function-evaluation-cpp 21.5498 "Evaluations of functions at arbitrary points." (2013, 1, 30, 2, 26, 48) function-extrapolation-python 44.675 "*** -------------------------------------------------------------------------" (2013, 1, 30, 2, 26, 48) function-extrapolation-python 1.85632 "*** -------------------------------------------------------------------------" (2013, 1, 30, 2, 27, 11) la-vector-access-cpp 23.0839 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 30, 2, 27, 37) la-vector-assignment-cpp 26.0244 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 1, 31, 2, 13, 43) common-progress-cpp 29.0323 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 1, 31, 2, 14, 11) common-timing-cpp 28.0397 "Timing access and registration of timings (10000000 repetitions)" (2013, 1, 31, 2, 17, 6) fem-multicore-cpp 175.468 "Coloring mesh." (2013, 1, 31, 2, 17, 20) fem-convergence-cpp 12.8566 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 1, 31, 2, 17, 22) fem-jit-python 0.0012038 "JIT compilation (in memory cache)" (2013, 1, 31, 2, 22, 42) fem-speedup-cpp 319.394 "Assembly/solve speedup running on 4 processors" (2013, 1, 31, 2, 22, 42) fem-speedup-cpp-assembly 6.78627 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 1, 31, 2, 22, 42) fem-speedup-cpp-solve 2.21678 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 1, 31, 2, 23, 8) mesh-refinement-cpp 24.7231 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 1, 31, 2, 23, 30) mesh-topology-cpp 21.8377 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 1, 31, 2, 23, 58) mesh-unitcube-cpp 27.4743 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 1, 31, 2, 24, 42) mesh-iteration-cpp 40.9686 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 1, 31, 2, 25, 3) function-evaluation-cpp 21.6549 "Evaluations of functions at arbitrary points." (2013, 1, 31, 2, 25, 3) function-evaluation-cpp 21.5415 "Evaluations of functions at arbitrary points." (2013, 1, 31, 2, 25, 8) function-extrapolation-python 5.02747 "*** -------------------------------------------------------------------------" (2013, 1, 31, 2, 25, 8) function-extrapolation-python 1.85629 "*** -------------------------------------------------------------------------" (2013, 1, 31, 2, 25, 32) la-vector-access-cpp 23.0452 "Accessing vector of size 10000000 (100 repetitions)" (2013, 1, 31, 2, 25, 59) la-vector-assignment-cpp 27.3739 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 1, 2, 13, 38) common-progress-cpp 28.949 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 1, 2, 14, 7) common-timing-cpp 28.6266 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 1, 2, 17, 3) fem-multicore-cpp 175.707 "Coloring mesh." (2013, 2, 1, 2, 17, 17) fem-convergence-cpp 12.9295 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 1, 2, 17, 19) fem-jit-python 0.00121191 "JIT compilation (in memory cache)" (2013, 2, 1, 2, 22, 35) fem-speedup-cpp 316.106 "Assembly/solve speedup running on 4 processors" (2013, 2, 1, 2, 22, 35) fem-speedup-cpp-assembly 6.79646 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 1, 2, 22, 35) fem-speedup-cpp-solve 2.331 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 1, 2, 23, 2) mesh-refinement-cpp 24.7623 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 1, 2, 23, 24) mesh-topology-cpp 21.9673 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 1, 2, 23, 52) mesh-unitcube-cpp 28.0743 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 1, 2, 24, 38) mesh-iteration-cpp 42.8807 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 1, 2, 24, 59) function-evaluation-cpp 21.7134 "Evaluations of functions at arbitrary points." (2013, 2, 1, 2, 24, 59) function-evaluation-cpp 21.5891 "Evaluations of functions at arbitrary points." (2013, 2, 1, 2, 25, 5) function-extrapolation-python 5.04747 "*** -------------------------------------------------------------------------" (2013, 2, 1, 2, 25, 5) function-extrapolation-python 1.84771 "*** -------------------------------------------------------------------------" (2013, 2, 1, 2, 25, 29) la-vector-access-cpp 24.3275 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 1, 2, 25, 55) la-vector-assignment-cpp 26.0251 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 2, 2, 14, 5) common-progress-cpp 29.0558 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 2, 2, 14, 33) common-timing-cpp 27.8623 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 2, 2, 16, 20) fem-multicore-cpp 107.325 "Coloring mesh." (2013, 2, 2, 2, 16, 33) fem-convergence-cpp 11.6857 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 2, 2, 16, 35) fem-jit-python 0.00123742 "JIT compilation (in memory cache)" (2013, 2, 2, 2, 21, 46) fem-speedup-cpp 311.211 "Assembly/solve speedup running on 4 processors" (2013, 2, 2, 2, 21, 46) fem-speedup-cpp-assembly 6.47385 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 2, 2, 21, 46) fem-speedup-cpp-solve 2.35899 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 2, 2, 22, 13) mesh-refinement-cpp 24.7819 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 2, 2, 22, 35) mesh-topology-cpp 22.058 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 2, 2, 23, 2) mesh-unitcube-cpp 27.4631 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 2, 2, 23, 45) mesh-iteration-cpp 40.2504 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 2, 2, 24, 7) function-evaluation-cpp 21.6428 "Evaluations of functions at arbitrary points." (2013, 2, 2, 2, 24, 7) function-evaluation-cpp 21.5019 "Evaluations of functions at arbitrary points." (2013, 2, 2, 2, 24, 12) function-extrapolation-python 5.03068 "*** -------------------------------------------------------------------------" (2013, 2, 2, 2, 24, 12) function-extrapolation-python 1.85362 "*** -------------------------------------------------------------------------" (2013, 2, 2, 2, 24, 37) la-vector-access-cpp 24.3377 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 2, 2, 25, 3) la-vector-assignment-cpp 26.024 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 3, 2, 13, 47) common-progress-cpp 29.0573 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 3, 2, 14, 16) common-timing-cpp 28.2761 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 3, 2, 16, 4) fem-multicore-cpp 108.034 "Coloring mesh." (2013, 2, 3, 2, 16, 16) fem-convergence-cpp 11.7451 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 3, 2, 16, 18) fem-jit-python 0.00121939 "JIT compilation (in memory cache)" (2013, 2, 3, 2, 21, 23) fem-speedup-cpp 304.801 "Assembly/solve speedup running on 4 processors" (2013, 2, 3, 2, 21, 23) fem-speedup-cpp-assembly 6.5549 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 3, 2, 21, 23) fem-speedup-cpp-solve 2.47267 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 3, 2, 21, 50) mesh-refinement-cpp 25.2302 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 3, 2, 22, 12) mesh-topology-cpp 21.9697 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 3, 2, 22, 40) mesh-unitcube-cpp 27.522 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 3, 2, 23, 23) mesh-iteration-cpp 40.2736 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 3, 2, 23, 45) function-evaluation-cpp 21.7926 "Evaluations of functions at arbitrary points." (2013, 2, 3, 2, 23, 45) function-evaluation-cpp 21.6351 "Evaluations of functions at arbitrary points." (2013, 2, 3, 2, 23, 50) function-extrapolation-python 5.20108 "*** -------------------------------------------------------------------------" (2013, 2, 3, 2, 23, 50) function-extrapolation-python 1.90171 "*** -------------------------------------------------------------------------" (2013, 2, 3, 2, 24, 13) la-vector-access-cpp 23.0619 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 3, 2, 24, 41) la-vector-assignment-cpp 27.6175 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 4, 2, 13, 43) common-progress-cpp 29.0656 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 4, 2, 14, 12) common-timing-cpp 28.9802 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 4, 2, 16, 0) fem-multicore-cpp 108.145 "Coloring mesh." (2013, 2, 4, 2, 16, 13) fem-convergence-cpp 11.8229 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 4, 2, 16, 15) fem-jit-python 0.00121241 "JIT compilation (in memory cache)" (2013, 2, 4, 2, 21, 22) fem-speedup-cpp 307.635 "Assembly/solve speedup running on 4 processors" (2013, 2, 4, 2, 21, 22) fem-speedup-cpp-assembly 6.43624 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 4, 2, 21, 22) fem-speedup-cpp-solve 2.40658 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 4, 2, 21, 49) mesh-refinement-cpp 24.9727 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 4, 2, 22, 11) mesh-topology-cpp 21.8537 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 4, 2, 22, 38) mesh-unitcube-cpp 27.0644 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 4, 2, 23, 23) mesh-iteration-cpp 41.8261 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 4, 2, 23, 45) function-evaluation-cpp 21.7448 "Evaluations of functions at arbitrary points." (2013, 2, 4, 2, 23, 45) function-evaluation-cpp 21.6173 "Evaluations of functions at arbitrary points." (2013, 2, 4, 2, 23, 50) function-extrapolation-python 4.96734 "*** -------------------------------------------------------------------------" (2013, 2, 4, 2, 23, 50) function-extrapolation-python 1.86512 "*** -------------------------------------------------------------------------" (2013, 2, 4, 2, 24, 14) la-vector-access-cpp 24.3338 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 4, 2, 24, 40) la-vector-assignment-cpp 26.0144 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 5, 2, 14, 46) common-progress-cpp 28.9574 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 5, 2, 15, 15) common-timing-cpp 28.4751 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 5, 2, 17, 4) fem-multicore-cpp 109.332 "Coloring mesh." (2013, 2, 5, 2, 17, 17) fem-convergence-cpp 11.8202 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 5, 2, 17, 34) fem-jit-python 0.00128171 "JIT compilation (in memory cache)" (2013, 2, 5, 2, 22, 39) fem-speedup-cpp 305.471 "Assembly/solve speedup running on 4 processors" (2013, 2, 5, 2, 22, 39) fem-speedup-cpp-assembly 6.4724 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 5, 2, 22, 39) fem-speedup-cpp-solve 2.43799 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 5, 2, 23, 6) mesh-refinement-cpp 25.0061 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 5, 2, 23, 28) mesh-topology-cpp 21.9141 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 5, 2, 23, 55) mesh-unitcube-cpp 27.1391 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 5, 2, 24, 38) mesh-iteration-cpp 40.3617 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 5, 2, 25, 0) function-evaluation-cpp 21.7322 "Evaluations of functions at arbitrary points." (2013, 2, 5, 2, 25, 0) function-evaluation-cpp 21.5795 "Evaluations of functions at arbitrary points." (2013, 2, 5, 2, 25, 49) function-extrapolation-python 49.0225 "*** -------------------------------------------------------------------------" (2013, 2, 5, 2, 25, 49) function-extrapolation-python 1.87354 "*** -------------------------------------------------------------------------" (2013, 2, 5, 2, 26, 14) la-vector-access-cpp 24.9135 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 5, 2, 26, 40) la-vector-assignment-cpp 26.0214 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 6, 2, 14, 3) common-progress-cpp 29.024 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 6, 2, 14, 32) common-timing-cpp 28.1353 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 6, 2, 16, 20) fem-multicore-cpp 108.128 "Coloring mesh." (2013, 2, 6, 2, 16, 32) fem-convergence-cpp 11.8088 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 6, 2, 16, 49) fem-jit-python 0.00132279 "JIT compilation (in memory cache)" (2013, 2, 6, 2, 21, 55) fem-speedup-cpp 305.848 "Assembly/solve speedup running on 4 processors" (2013, 2, 6, 2, 21, 55) fem-speedup-cpp-assembly 6.32375 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 6, 2, 21, 55) fem-speedup-cpp-solve 2.42394 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 6, 2, 22, 22) mesh-refinement-cpp 25.0894 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 6, 2, 22, 44) mesh-topology-cpp 21.8889 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 6, 2, 23, 11) mesh-unitcube-cpp 27.1583 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 6, 2, 23, 54) mesh-iteration-cpp 40.3066 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 6, 2, 24, 16) function-evaluation-cpp 21.7427 "Evaluations of functions at arbitrary points." (2013, 2, 6, 2, 24, 16) function-evaluation-cpp 21.5884 "Evaluations of functions at arbitrary points." (2013, 2, 6, 2, 25, 5) function-extrapolation-python 49.2393 "*** -------------------------------------------------------------------------" (2013, 2, 6, 2, 25, 5) function-extrapolation-python 1.88775 "*** -------------------------------------------------------------------------" (2013, 2, 6, 2, 25, 31) la-vector-access-cpp 25.9241 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 6, 2, 25, 59) la-vector-assignment-cpp 28.0415 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 7, 2, 14, 24) common-progress-cpp 28.9074 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 7, 2, 14, 53) common-timing-cpp 29.0648 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 7, 2, 16, 41) fem-multicore-cpp 108.198 "Coloring mesh." (2013, 2, 7, 2, 16, 54) fem-convergence-cpp 11.7889 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 7, 2, 16, 56) fem-jit-python 0.00122221 "JIT compilation (in memory cache)" (2013, 2, 7, 2, 22, 4) fem-speedup-cpp 307.608 "Assembly/solve speedup running on 4 processors" (2013, 2, 7, 2, 22, 4) fem-speedup-cpp-assembly 6.43816 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 7, 2, 22, 4) fem-speedup-cpp-solve 2.36678 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 7, 2, 22, 30) mesh-refinement-cpp 25.0651 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 7, 2, 22, 52) mesh-topology-cpp 22.0341 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 7, 2, 23, 21) mesh-unitcube-cpp 28.1955 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 7, 2, 24, 4) mesh-iteration-cpp 40.2668 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 7, 2, 24, 25) function-evaluation-cpp 21.3928 "Evaluations of functions at arbitrary points." (2013, 2, 7, 2, 24, 25) function-evaluation-cpp 21.2568 "Evaluations of functions at arbitrary points." (2013, 2, 7, 2, 24, 30) function-extrapolation-python 4.94471 "*** -------------------------------------------------------------------------" (2013, 2, 7, 2, 24, 30) function-extrapolation-python 1.86673 "*** -------------------------------------------------------------------------" (2013, 2, 7, 2, 24, 53) la-vector-access-cpp 23.0027 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 7, 2, 25, 19) la-vector-assignment-cpp 26.0184 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 8, 2, 13, 38) common-progress-cpp 28.9574 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 8, 2, 14, 6) common-timing-cpp 28.3846 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 8, 2, 15, 54) fem-multicore-cpp 107.901 "Coloring mesh." (2013, 2, 8, 2, 18, 24) fem-assembly-cpp 150.086 "Assembly for various forms and backends" (2013, 2, 8, 2, 18, 36) fem-convergence-cpp 11.6963 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 8, 2, 18, 38) fem-jit-python 0.00120771 "JIT compilation (in memory cache)" (2013, 2, 8, 2, 23, 46) fem-speedup-cpp 308.366 "Assembly/solve speedup running on 4 processors" (2013, 2, 8, 2, 23, 46) fem-speedup-cpp-assembly 6.48082 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 8, 2, 23, 46) fem-speedup-cpp-solve 2.34454 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 8, 2, 24, 13) mesh-refinement-cpp 25.0465 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 8, 2, 24, 35) mesh-topology-cpp 22.0649 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 8, 2, 25, 3) mesh-unitcube-cpp 28.1039 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 8, 2, 25, 47) mesh-iteration-cpp 40.2657 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 8, 2, 26, 9) function-evaluation-cpp 22.3809 "Evaluations of functions at arbitrary points." (2013, 2, 8, 2, 26, 9) function-evaluation-cpp 22.2596 "Evaluations of functions at arbitrary points." (2013, 2, 8, 2, 26, 14) function-extrapolation-python 5.15655 "*** -------------------------------------------------------------------------" (2013, 2, 8, 2, 26, 14) function-extrapolation-python 1.90242 "*** -------------------------------------------------------------------------" (2013, 2, 8, 2, 26, 37) la-vector-access-cpp 22.9383 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 8, 2, 27, 3) la-vector-assignment-cpp 26.0266 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 9, 2, 13, 33) common-progress-cpp 28.9655 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 9, 2, 14, 2) common-timing-cpp 28.9988 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 9, 2, 15, 51) fem-multicore-cpp 108.211 "Coloring mesh." (2013, 2, 9, 2, 18, 20) fem-assembly-cpp 149.044 "Assembly for various forms and backends" (2013, 2, 9, 2, 18, 31) fem-convergence-cpp 11.658 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 9, 2, 18, 33) fem-jit-python 0.00125461 "JIT compilation (in memory cache)" (2013, 2, 9, 2, 23, 37) fem-speedup-cpp 303.356 "Assembly/solve speedup running on 4 processors" (2013, 2, 9, 2, 23, 37) fem-speedup-cpp-assembly 6.47674 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 9, 2, 23, 37) fem-speedup-cpp-solve 2.47292 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 9, 2, 24, 3) mesh-refinement-cpp 24.9881 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 9, 2, 24, 25) mesh-topology-cpp 22.0403 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 9, 2, 24, 54) mesh-unitcube-cpp 28.2083 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 9, 2, 25, 38) mesh-iteration-cpp 40.9762 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 9, 2, 26, 0) function-evaluation-cpp 22.7584 "Evaluations of functions at arbitrary points." (2013, 2, 9, 2, 26, 0) function-evaluation-cpp 22.6253 "Evaluations of functions at arbitrary points." (2013, 2, 9, 2, 26, 6) function-extrapolation-python 5.27845 "*** -------------------------------------------------------------------------" (2013, 2, 9, 2, 26, 6) function-extrapolation-python 1.92038 "*** -------------------------------------------------------------------------" (2013, 2, 9, 2, 26, 29) la-vector-access-cpp 23.0386 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 9, 2, 26, 55) la-vector-assignment-cpp 26.0226 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 10, 2, 13, 12) common-progress-cpp 28.9739 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 10, 2, 13, 41) common-timing-cpp 28.7327 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 10, 2, 15, 29) fem-multicore-cpp 108.072 "Coloring mesh." (2013, 2, 10, 2, 17, 58) fem-assembly-cpp 149.41 "Assembly for various forms and backends" (2013, 2, 10, 2, 18, 10) fem-convergence-cpp 11.7535 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 10, 2, 18, 12) fem-jit-python 0.00121648 "JIT compilation (in memory cache)" (2013, 2, 10, 2, 23, 18) fem-speedup-cpp 305.659 "Assembly/solve speedup running on 4 processors" (2013, 2, 10, 2, 23, 18) fem-speedup-cpp-assembly 6.35544 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 10, 2, 23, 18) fem-speedup-cpp-solve 2.41892 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 10, 2, 23, 44) mesh-refinement-cpp 25.0709 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 10, 2, 24, 7) mesh-topology-cpp 22.0626 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 10, 2, 24, 35) mesh-unitcube-cpp 28.122 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 10, 2, 25, 19) mesh-iteration-cpp 41.6044 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 10, 2, 25, 41) function-evaluation-cpp 21.7655 "Evaluations of functions at arbitrary points." (2013, 2, 10, 2, 25, 41) function-evaluation-cpp 21.6049 "Evaluations of functions at arbitrary points." (2013, 2, 10, 2, 25, 46) function-extrapolation-python 5.34174 "*** -------------------------------------------------------------------------" (2013, 2, 10, 2, 25, 46) function-extrapolation-python 1.90602 "*** -------------------------------------------------------------------------" (2013, 2, 10, 2, 26, 10) la-vector-access-cpp 23.9848 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 10, 2, 26, 36) la-vector-assignment-cpp 25.9775 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 11, 2, 13, 16) common-progress-cpp 29.1488 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 11, 2, 13, 44) common-timing-cpp 28.7064 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 11, 2, 15, 33) fem-multicore-cpp 108.558 "Coloring mesh." (2013, 2, 11, 2, 18, 3) fem-assembly-cpp 150.23 "Assembly for various forms and backends" (2013, 2, 11, 2, 18, 15) fem-convergence-cpp 11.7624 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 11, 2, 18, 17) fem-jit-python 0.00121739 "JIT compilation (in memory cache)" (2013, 2, 11, 2, 23, 29) fem-speedup-cpp 312.283 "Assembly/solve speedup running on 4 processors" (2013, 2, 11, 2, 23, 29) fem-speedup-cpp-assembly 6.48718 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 11, 2, 23, 29) fem-speedup-cpp-solve 2.24288 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 11, 2, 23, 56) mesh-refinement-cpp 25.0178 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 11, 2, 24, 19) mesh-topology-cpp 22.0694 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 11, 2, 24, 47) mesh-unitcube-cpp 28.1513 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 11, 2, 25, 30) mesh-iteration-cpp 40.2508 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 11, 2, 25, 51) function-evaluation-cpp 21.2304 "Evaluations of functions at arbitrary points." (2013, 2, 11, 2, 25, 51) function-evaluation-cpp 21.127 "Evaluations of functions at arbitrary points." (2013, 2, 11, 2, 25, 56) function-extrapolation-python 5.16633 "*** -------------------------------------------------------------------------" (2013, 2, 11, 2, 25, 56) function-extrapolation-python 1.89689 "*** -------------------------------------------------------------------------" (2013, 2, 11, 2, 26, 19) la-vector-access-cpp 22.9786 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 11, 2, 26, 45) la-vector-assignment-cpp 26.0351 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 13, 2, 13, 23) common-progress-cpp 37.991 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 13, 2, 13, 52) common-timing-cpp 29.257 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 13, 2, 15, 40) fem-multicore-cpp 107.9 "Coloring mesh." (2013, 2, 13, 2, 18, 10) fem-assembly-cpp 149.526 "Assembly for various forms and backends" (2013, 2, 13, 2, 18, 21) fem-convergence-cpp 11.7732 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 13, 2, 18, 23) fem-jit-python 0.0012167 "JIT compilation (in memory cache)" (2013, 2, 13, 2, 23, 34) fem-speedup-cpp 310.742 "Assembly/solve speedup running on 4 processors" (2013, 2, 13, 2, 23, 34) fem-speedup-cpp-assembly 6.40043 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 13, 2, 23, 34) fem-speedup-cpp-solve 2.27336 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 13, 2, 24, 1) mesh-refinement-cpp 25.0649 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 13, 2, 24, 23) mesh-topology-cpp 22.0066 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 13, 2, 24, 51) mesh-unitcube-cpp 27.4921 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 13, 2, 25, 37) mesh-iteration-cpp 43.3767 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 13, 2, 25, 59) function-evaluation-cpp 21.7028 "Evaluations of functions at arbitrary points." (2013, 2, 13, 2, 25, 59) function-evaluation-cpp 21.5992 "Evaluations of functions at arbitrary points." (2013, 2, 13, 2, 26, 4) function-extrapolation-python 5.17176 "*** -------------------------------------------------------------------------" (2013, 2, 13, 2, 26, 4) function-extrapolation-python 1.88215 "*** -------------------------------------------------------------------------" (2013, 2, 13, 2, 26, 29) la-vector-access-cpp 24.9309 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 13, 2, 26, 55) la-vector-assignment-cpp 26.0104 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 14, 12, 55, 19) common-progress-cpp 28.7135 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 14, 12, 55, 48) common-timing-cpp 28.8756 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 14, 12, 57, 36) fem-multicore-cpp 107.991 "Coloring mesh." (2013, 2, 14, 13, 0, 6) fem-assembly-cpp 150.234 "Assembly for various forms and backends" (2013, 2, 14, 13, 0, 18) fem-convergence-cpp 11.7666 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 14, 13, 0, 20) fem-jit-python 0.00122778 "JIT compilation (in memory cache)" (2013, 2, 14, 13, 5, 27) fem-speedup-cpp 307.219 "Assembly/solve speedup running on 4 processors" (2013, 2, 14, 13, 5, 27) fem-speedup-cpp-assembly 6.54057 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 14, 13, 5, 27) fem-speedup-cpp-solve 2.38725 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 14, 13, 5, 54) mesh-refinement-cpp 25.2902 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 14, 13, 6, 16) mesh-topology-cpp 22.0283 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 14, 13, 6, 44) mesh-unitcube-cpp 27.2148 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 14, 13, 7, 32) mesh-iteration-cpp 46.0374 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 14, 13, 7, 54) function-evaluation-cpp 21.5406 "Evaluations of functions at arbitrary points." (2013, 2, 14, 13, 7, 54) function-evaluation-cpp 21.4457 "Evaluations of functions at arbitrary points." (2013, 2, 14, 13, 8, 23) la-vector-access-cpp 25.6993 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 14, 13, 8, 55) la-vector-assignment-cpp 31.5685 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 15, 2, 13, 24) common-progress-cpp 28.8301 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 15, 2, 13, 55) common-timing-cpp 30.0053 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 15, 2, 15, 43) fem-multicore-cpp 108.608 "Coloring mesh." (2013, 2, 15, 2, 18, 16) fem-assembly-cpp 152.935 "Assembly for various forms and backends" (2013, 2, 15, 2, 18, 28) fem-convergence-cpp 11.7358 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 15, 2, 18, 30) fem-jit-python 0.00121601 "JIT compilation (in memory cache)" (2013, 2, 15, 2, 23, 36) fem-speedup-cpp 306.106 "Assembly/solve speedup running on 4 processors" (2013, 2, 15, 2, 23, 36) fem-speedup-cpp-assembly 6.4591 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 15, 2, 23, 36) fem-speedup-cpp-solve 2.42291 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 15, 2, 24, 3) mesh-refinement-cpp 25.5327 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 15, 2, 24, 26) mesh-topology-cpp 22.1235 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 15, 2, 24, 53) mesh-unitcube-cpp 27.2293 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 15, 2, 25, 36) mesh-iteration-cpp 40.2672 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 15, 2, 25, 58) function-evaluation-cpp 22.2663 "Evaluations of functions at arbitrary points." (2013, 2, 15, 2, 25, 58) function-evaluation-cpp 22.1668 "Evaluations of functions at arbitrary points." (2013, 2, 15, 2, 26, 3) function-extrapolation-python 4.78032 "*** -------------------------------------------------------------------------" (2013, 2, 15, 2, 26, 3) function-extrapolation-python 1.95565 "*** -------------------------------------------------------------------------" (2013, 2, 15, 2, 26, 26) la-vector-access-cpp 22.9809 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 15, 2, 26, 54) la-vector-assignment-cpp 28.0228 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 2, 16, 2, 13, 48) common-progress-cpp 28.8133 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 2, 16, 2, 14, 17) common-timing-cpp 29.3088 "Timing access and registration of timings (10000000 repetitions)" (2013, 2, 16, 2, 16, 7) fem-multicore-cpp 109.268 "Coloring mesh." (2013, 2, 16, 2, 18, 40) fem-assembly-cpp 152.789 "Assembly for various forms and backends" (2013, 2, 16, 2, 18, 51) fem-convergence-cpp 11.7382 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 2, 16, 2, 18, 53) fem-jit-python 0.00122449 "JIT compilation (in memory cache)" (2013, 2, 16, 2, 24, 1) fem-speedup-cpp 307.572 "Assembly/solve speedup running on 4 processors" (2013, 2, 16, 2, 24, 1) fem-speedup-cpp-assembly 6.4494 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 2, 16, 2, 24, 1) fem-speedup-cpp-solve 2.36775 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 2, 16, 2, 24, 28) mesh-refinement-cpp 25.528 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 2, 16, 2, 24, 51) mesh-topology-cpp 22.094 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 2, 16, 2, 25, 18) mesh-unitcube-cpp 27.1552 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 2, 16, 2, 26, 1) mesh-iteration-cpp 40.2643 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 2, 16, 2, 26, 23) function-evaluation-cpp 21.6683 "Evaluations of functions at arbitrary points." (2013, 2, 16, 2, 26, 23) function-evaluation-cpp 21.5472 "Evaluations of functions at arbitrary points." (2013, 2, 16, 2, 26, 38) function-extrapolation-python 15.0923 "*** -------------------------------------------------------------------------" (2013, 2, 16, 2, 26, 38) function-extrapolation-python 1.95866 "*** -------------------------------------------------------------------------" (2013, 2, 16, 2, 27, 1) la-vector-access-cpp 23.4226 "Accessing vector of size 10000000 (100 repetitions)" (2013, 2, 16, 2, 27, 31) la-vector-assignment-cpp 29.5305 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 3, 13, 7, 16) common-progress-cpp 28.7683 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 3, 13, 7, 47) common-timing-cpp 31.3816 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 3, 13, 9, 35) fem-multicore-cpp 107.387 "Coloring mesh." (2013, 3, 3, 13, 12, 3) fem-assembly-cpp 148.528 "Assembly for various forms and backends" (2013, 3, 3, 13, 12, 15) fem-convergence-cpp 11.893 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 3, 13, 12, 17) fem-jit-python 0.0012048 "JIT compilation (in memory cache)" (2013, 3, 3, 13, 17, 26) fem-speedup-cpp 308.684 "Assembly/solve speedup running on 4 processors" (2013, 3, 3, 13, 17, 26) fem-speedup-cpp-assembly 6.48294 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 3, 13, 17, 26) fem-speedup-cpp-solve 2.31179 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 3, 13, 17, 52) mesh-refinement-cpp 24.1048 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 3, 13, 18, 14) mesh-topology-cpp 22.1031 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 3, 13, 18, 37) mesh-unitcube-cpp 23.584 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 3, 13, 19, 18) mesh-iteration-cpp 38.4754 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 3, 13, 19, 40) function-evaluation-cpp 21.6033 "Evaluations of functions at arbitrary points." (2013, 3, 3, 13, 19, 40) function-evaluation-cpp 21.4773 "Evaluations of functions at arbitrary points." (2013, 3, 3, 13, 19, 45) function-extrapolation-python 5.35753 "*** -------------------------------------------------------------------------" (2013, 3, 3, 13, 19, 45) function-extrapolation-python 1.97276 "*** -------------------------------------------------------------------------" (2013, 3, 3, 13, 20, 8) la-vector-access-cpp 22.8951 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 3, 13, 20, 34) la-vector-assignment-cpp 25.9654 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 4, 2, 13, 58) common-progress-cpp 28.8767 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 4, 2, 14, 29) common-timing-cpp 30.6059 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 4, 2, 16, 16) fem-multicore-cpp 107.368 "Coloring mesh." (2013, 3, 4, 2, 18, 45) fem-assembly-cpp 149.109 "Assembly for various forms and backends" (2013, 3, 4, 2, 18, 57) fem-convergence-cpp 11.5695 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 4, 2, 18, 59) fem-jit-python 0.0012198 "JIT compilation (in memory cache)" (2013, 3, 4, 2, 24, 7) fem-speedup-cpp 308.564 "Assembly/solve speedup running on 4 processors" (2013, 3, 4, 2, 24, 7) fem-speedup-cpp-assembly 6.49526 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 4, 2, 24, 7) fem-speedup-cpp-solve 2.3264 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 4, 2, 24, 33) mesh-refinement-cpp 24.0848 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 4, 2, 24, 55) mesh-topology-cpp 22.372 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 4, 2, 25, 19) mesh-unitcube-cpp 23.8255 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 4, 2, 25, 59) mesh-iteration-cpp 37.3498 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 4, 2, 26, 21) function-evaluation-cpp 21.5945 "Evaluations of functions at arbitrary points." (2013, 3, 4, 2, 26, 21) function-evaluation-cpp 21.4631 "Evaluations of functions at arbitrary points." (2013, 3, 4, 2, 26, 36) function-extrapolation-python 14.8548 "*** -------------------------------------------------------------------------" (2013, 3, 4, 2, 26, 36) function-extrapolation-python 2.01239 "*** -------------------------------------------------------------------------" (2013, 3, 4, 2, 26, 58) la-vector-access-cpp 22.5985 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 4, 2, 27, 24) la-vector-assignment-cpp 25.9598 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 5, 2, 14, 33) common-progress-cpp 37.5771 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 5, 2, 15, 4) common-timing-cpp 30.5963 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 5, 2, 16, 52) fem-multicore-cpp 107.857 "Coloring mesh." (2013, 3, 5, 2, 19, 22) fem-assembly-cpp 150.47 "Assembly for various forms and backends" (2013, 3, 5, 2, 19, 34) fem-convergence-cpp 11.6881 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 5, 2, 19, 50) fem-jit-python 0.00128992 "JIT compilation (in memory cache)" (2013, 3, 5, 2, 24, 59) fem-speedup-cpp 308.883 "Assembly/solve speedup running on 4 processors" (2013, 3, 5, 2, 24, 59) fem-speedup-cpp-assembly 6.60461 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 5, 2, 24, 59) fem-speedup-cpp-solve 2.30416 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 5, 2, 25, 25) mesh-refinement-cpp 24.162 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 5, 2, 25, 47) mesh-topology-cpp 22.2656 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 5, 2, 26, 11) mesh-unitcube-cpp 23.8759 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 5, 2, 26, 51) mesh-iteration-cpp 37.2091 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 5, 2, 27, 12) function-evaluation-cpp 21.6553 "Evaluations of functions at arbitrary points." (2013, 3, 5, 2, 27, 12) function-evaluation-cpp 21.5275 "Evaluations of functions at arbitrary points." (2013, 3, 5, 2, 28, 0) function-extrapolation-python 47.2473 "*** -------------------------------------------------------------------------" (2013, 3, 5, 2, 28, 0) function-extrapolation-python 2.15593 "*** -------------------------------------------------------------------------" (2013, 3, 5, 2, 28, 25) la-vector-access-cpp 25.4 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 5, 2, 28, 53) la-vector-assignment-cpp 27.4834 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 6, 2, 13, 48) common-progress-cpp 37.7604 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 6, 2, 14, 18) common-timing-cpp 30.5238 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 6, 2, 16, 6) fem-multicore-cpp 107.718 "Coloring mesh." (2013, 3, 6, 2, 18, 36) fem-assembly-cpp 150.135 "Assembly for various forms and backends" (2013, 3, 6, 2, 18, 48) fem-convergence-cpp 11.6943 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 6, 2, 18, 50) fem-jit-python 0.0012342 "JIT compilation (in memory cache)" (2013, 3, 6, 2, 23, 59) fem-speedup-cpp 309.399 "Assembly/solve speedup running on 4 processors" (2013, 3, 6, 2, 23, 59) fem-speedup-cpp-assembly 6.56379 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 6, 2, 23, 59) fem-speedup-cpp-solve 2.29875 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 6, 2, 24, 25) mesh-refinement-cpp 24.1371 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 6, 2, 24, 47) mesh-topology-cpp 22.0929 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 6, 2, 25, 11) mesh-unitcube-cpp 23.7726 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 6, 2, 25, 50) mesh-iteration-cpp 37.2055 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 6, 2, 26, 12) function-evaluation-cpp 21.5366 "Evaluations of functions at arbitrary points." (2013, 3, 6, 2, 26, 12) function-evaluation-cpp 21.4162 "Evaluations of functions at arbitrary points." (2013, 3, 6, 2, 26, 17) function-extrapolation-python 5.30403 "*** -------------------------------------------------------------------------" (2013, 3, 6, 2, 26, 17) function-extrapolation-python 2.14405 "*** -------------------------------------------------------------------------" (2013, 3, 6, 2, 26, 40) la-vector-access-cpp 22.8846 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 6, 2, 27, 6) la-vector-assignment-cpp 25.9638 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 7, 2, 14, 0) common-progress-cpp 28.8432 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 7, 2, 14, 33) common-timing-cpp 32.5581 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 7, 2, 16, 20) fem-multicore-cpp 107.121 "Coloring mesh." (2013, 3, 7, 2, 18, 50) fem-assembly-cpp 150.293 "Assembly for various forms and backends" (2013, 3, 7, 2, 19, 2) fem-convergence-cpp 11.7221 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 7, 2, 19, 4) fem-jit-python 0.00121648 "JIT compilation (in memory cache)" (2013, 3, 7, 2, 24, 14) fem-speedup-cpp 309.767 "Assembly/solve speedup running on 4 processors" (2013, 3, 7, 2, 24, 14) fem-speedup-cpp-assembly 6.61758 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 7, 2, 24, 14) fem-speedup-cpp-solve 2.30439 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 7, 2, 24, 39) mesh-refinement-cpp 24.4643 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 7, 2, 25, 2) mesh-topology-cpp 22.5519 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 7, 2, 25, 26) mesh-unitcube-cpp 23.6465 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 7, 2, 26, 10) mesh-iteration-cpp 41.3081 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 7, 2, 26, 31) function-evaluation-cpp 21.3388 "Evaluations of functions at arbitrary points." (2013, 3, 7, 2, 26, 31) function-evaluation-cpp 21.2109 "Evaluations of functions at arbitrary points." (2013, 3, 7, 2, 26, 36) function-extrapolation-python 5.38117 "*** -------------------------------------------------------------------------" (2013, 3, 7, 2, 26, 36) function-extrapolation-python 2.14497 "*** -------------------------------------------------------------------------" (2013, 3, 7, 2, 27, 2) la-vector-access-cpp 25.4054 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 7, 2, 27, 29) la-vector-assignment-cpp 27.5381 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 8, 2, 14, 19) common-progress-cpp 47.56 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 8, 2, 14, 52) common-timing-cpp 32.3784 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 8, 2, 16, 39) fem-multicore-cpp 107.116 "Coloring mesh." (2013, 3, 8, 2, 19, 9) fem-assembly-cpp 149.545 "Assembly for various forms and backends" (2013, 3, 8, 2, 19, 20) fem-convergence-cpp 11.7503 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 8, 2, 19, 22) fem-jit-python 0.0012197 "JIT compilation (in memory cache)" (2013, 3, 8, 2, 24, 30) fem-speedup-cpp 307.962 "Assembly/solve speedup running on 4 processors" (2013, 3, 8, 2, 24, 30) fem-speedup-cpp-assembly 6.61209 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 8, 2, 24, 30) fem-speedup-cpp-solve 2.34787 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 8, 2, 24, 56) mesh-refinement-cpp 24.3243 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 8, 2, 25, 19) mesh-topology-cpp 22.6476 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 8, 2, 25, 43) mesh-unitcube-cpp 24.2202 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 8, 2, 26, 29) mesh-iteration-cpp 43.6634 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 8, 2, 26, 51) function-evaluation-cpp 21.6032 "Evaluations of functions at arbitrary points." (2013, 3, 8, 2, 26, 51) function-evaluation-cpp 21.4784 "Evaluations of functions at arbitrary points." (2013, 3, 8, 2, 26, 56) function-extrapolation-python 5.2382 "*** -------------------------------------------------------------------------" (2013, 3, 8, 2, 26, 56) function-extrapolation-python 2.14476 "*** -------------------------------------------------------------------------" (2013, 3, 8, 2, 27, 20) la-vector-access-cpp 23.3109 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 8, 2, 27, 46) la-vector-assignment-cpp 25.9593 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 9, 2, 13, 56) common-progress-cpp 28.8184 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 9, 2, 14, 28) common-timing-cpp 32.053 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 9, 2, 16, 15) fem-multicore-cpp 107.571 "Coloring mesh." (2013, 3, 9, 2, 18, 44) fem-assembly-cpp 149.283 "Assembly for various forms and backends" (2013, 3, 9, 2, 18, 57) fem-convergence-cpp 12.2405 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 9, 2, 18, 59) fem-jit-python 0.00121739 "JIT compilation (in memory cache)" (2013, 3, 9, 2, 24, 7) fem-speedup-cpp 308.411 "Assembly/solve speedup running on 4 processors" (2013, 3, 9, 2, 24, 7) fem-speedup-cpp-assembly 6.57784 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 9, 2, 24, 7) fem-speedup-cpp-solve 2.34974 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 9, 2, 24, 33) mesh-refinement-cpp 24.3245 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 9, 2, 24, 55) mesh-topology-cpp 22.4345 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 9, 2, 25, 19) mesh-unitcube-cpp 23.7048 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 9, 2, 26, 3) mesh-iteration-cpp 41.2939 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 9, 2, 26, 25) function-evaluation-cpp 21.853 "Evaluations of functions at arbitrary points." (2013, 3, 9, 2, 26, 25) function-evaluation-cpp 21.7216 "Evaluations of functions at arbitrary points." (2013, 3, 9, 2, 26, 30) function-extrapolation-python 5.3218 "*** -------------------------------------------------------------------------" (2013, 3, 9, 2, 26, 30) function-extrapolation-python 2.15123 "*** -------------------------------------------------------------------------" (2013, 3, 9, 2, 26, 56) la-vector-access-cpp 25.4647 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 9, 2, 27, 22) la-vector-assignment-cpp 25.9641 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 10, 2, 13, 37) common-progress-cpp 28.8017 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 10, 2, 14, 10) common-timing-cpp 33.037 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 10, 2, 15, 57) fem-multicore-cpp 106.971 "Coloring mesh." (2013, 3, 10, 2, 18, 26) fem-assembly-cpp 149.295 "Assembly for various forms and backends" (2013, 3, 10, 2, 18, 38) fem-convergence-cpp 12.2664 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 10, 2, 18, 40) fem-jit-python 0.00122659 "JIT compilation (in memory cache)" (2013, 3, 10, 2, 23, 49) fem-speedup-cpp 308.88 "Assembly/solve speedup running on 4 processors" (2013, 3, 10, 2, 23, 49) fem-speedup-cpp-assembly 6.52528 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 10, 2, 23, 49) fem-speedup-cpp-solve 2.3563 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 10, 2, 24, 15) mesh-refinement-cpp 24.3412 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 10, 2, 24, 37) mesh-topology-cpp 22.3231 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 10, 2, 25, 1) mesh-unitcube-cpp 23.6815 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 10, 2, 25, 45) mesh-iteration-cpp 41.182 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 10, 2, 26, 6) function-evaluation-cpp 21.6225 "Evaluations of functions at arbitrary points." (2013, 3, 10, 2, 26, 6) function-evaluation-cpp 21.4896 "Evaluations of functions at arbitrary points." (2013, 3, 10, 2, 26, 12) function-extrapolation-python 5.10432 "*** -------------------------------------------------------------------------" (2013, 3, 10, 2, 26, 12) function-extrapolation-python 2.15485 "*** -------------------------------------------------------------------------" (2013, 3, 10, 2, 26, 35) la-vector-access-cpp 23.0955 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 10, 2, 27, 1) la-vector-assignment-cpp 25.9728 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 11, 2, 13, 43) common-progress-cpp 37.5522 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 11, 2, 14, 14) common-timing-cpp 31.7833 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 11, 2, 16, 2) fem-multicore-cpp 107.314 "Coloring mesh." (2013, 3, 11, 2, 18, 31) fem-assembly-cpp 149.155 "Assembly for various forms and backends" (2013, 3, 11, 2, 18, 43) fem-convergence-cpp 12.196 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 11, 2, 18, 45) fem-jit-python 0.00122781 "JIT compilation (in memory cache)" (2013, 3, 11, 2, 23, 54) fem-speedup-cpp 309.246 "Assembly/solve speedup running on 4 processors" (2013, 3, 11, 2, 23, 54) fem-speedup-cpp-assembly 6.50769 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 11, 2, 23, 54) fem-speedup-cpp-solve 2.34776 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 11, 2, 24, 20) mesh-refinement-cpp 24.3332 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 11, 2, 24, 43) mesh-topology-cpp 22.2754 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 11, 2, 25, 6) mesh-unitcube-cpp 23.6453 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 11, 2, 25, 50) mesh-iteration-cpp 41.2463 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 11, 2, 26, 12) function-evaluation-cpp 21.8302 "Evaluations of functions at arbitrary points." (2013, 3, 11, 2, 26, 12) function-evaluation-cpp 21.6935 "Evaluations of functions at arbitrary points." (2013, 3, 11, 2, 26, 17) function-extrapolation-python 5.2171 "*** -------------------------------------------------------------------------" (2013, 3, 11, 2, 26, 17) function-extrapolation-python 2.16002 "*** -------------------------------------------------------------------------" (2013, 3, 11, 2, 26, 40) la-vector-access-cpp 22.9469 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 11, 2, 27, 6) la-vector-assignment-cpp 25.9677 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 12, 2, 14, 14) common-progress-cpp 28.8084 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 12, 2, 14, 46) common-timing-cpp 32.5913 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 12, 2, 16, 34) fem-multicore-cpp 107.404 "Coloring mesh." (2013, 3, 12, 2, 19, 1) fem-assembly-cpp 147.424 "Assembly for various forms and backends" (2013, 3, 12, 2, 19, 13) fem-convergence-cpp 12.2643 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 12, 2, 19, 15) fem-jit-python 0.00121729 "JIT compilation (in memory cache)" (2013, 3, 12, 2, 24, 26) fem-speedup-cpp 310.399 "Assembly/solve speedup running on 4 processors" (2013, 3, 12, 2, 24, 26) fem-speedup-cpp-assembly 6.47694 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 12, 2, 24, 26) fem-speedup-cpp-solve 2.32033 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 12, 2, 24, 52) mesh-refinement-cpp 24.4576 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 12, 2, 25, 14) mesh-topology-cpp 22.2033 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 12, 2, 25, 38) mesh-unitcube-cpp 23.5273 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 12, 2, 26, 19) mesh-iteration-cpp 39.4213 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 12, 2, 26, 41) function-evaluation-cpp 21.8973 "Evaluations of functions at arbitrary points." (2013, 3, 12, 2, 26, 41) function-evaluation-cpp 21.7654 "Evaluations of functions at arbitrary points." (2013, 3, 12, 2, 26, 47) function-extrapolation-python 5.11899 "*** -------------------------------------------------------------------------" (2013, 3, 12, 2, 26, 47) function-extrapolation-python 2.15039 "*** -------------------------------------------------------------------------" (2013, 3, 12, 2, 27, 9) la-vector-access-cpp 22.9179 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 12, 2, 27, 35) la-vector-assignment-cpp 25.966 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 13, 2, 14, 29) common-progress-cpp 37.6021 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 13, 2, 15, 2) common-timing-cpp 32.7789 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 13, 2, 16, 49) fem-multicore-cpp 107.121 "Coloring mesh." (2013, 3, 13, 2, 19, 17) fem-assembly-cpp 148.339 "Assembly for various forms and backends" (2013, 3, 13, 2, 19, 30) fem-convergence-cpp 12.3528 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 13, 2, 19, 46) fem-jit-python 0.00127511 "JIT compilation (in memory cache)" (2013, 3, 13, 2, 24, 55) fem-speedup-cpp 308.687 "Assembly/solve speedup running on 4 processors" (2013, 3, 13, 2, 24, 55) fem-speedup-cpp-assembly 6.56106 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 13, 2, 24, 55) fem-speedup-cpp-solve 2.37074 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 13, 2, 25, 21) mesh-refinement-cpp 24.2996 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 13, 2, 25, 43) mesh-topology-cpp 22.4627 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 13, 2, 26, 7) mesh-unitcube-cpp 23.8317 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 13, 2, 26, 47) mesh-iteration-cpp 37.2392 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 13, 2, 27, 8) function-evaluation-cpp 21.6867 "Evaluations of functions at arbitrary points." (2013, 3, 13, 2, 27, 8) function-evaluation-cpp 21.5673 "Evaluations of functions at arbitrary points." (2013, 3, 13, 2, 27, 55) function-extrapolation-python 46.914 "*** -------------------------------------------------------------------------" (2013, 3, 13, 2, 27, 55) function-extrapolation-python 2.17642 "*** -------------------------------------------------------------------------" (2013, 3, 13, 2, 28, 18) la-vector-access-cpp 22.6385 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 13, 2, 28, 45) la-vector-assignment-cpp 27.4089 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 14, 2, 14, 9) common-progress-cpp 28.7684 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 14, 2, 14, 42) common-timing-cpp 32.9984 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 14, 2, 16, 29) fem-multicore-cpp 107.233 "Coloring mesh." (2013, 3, 14, 2, 19, 0) fem-assembly-cpp 150.523 "Assembly for various forms and backends" (2013, 3, 14, 2, 19, 12) fem-convergence-cpp 12.2397 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 14, 2, 19, 14) fem-jit-python 0.00122569 "JIT compilation (in memory cache)" (2013, 3, 14, 2, 24, 26) fem-speedup-cpp 311.559 "Assembly/solve speedup running on 4 processors" (2013, 3, 14, 2, 24, 26) fem-speedup-cpp-assembly 6.58504 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 14, 2, 24, 26) fem-speedup-cpp-solve 2.30054 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 14, 2, 24, 52) mesh-refinement-cpp 24.3645 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 14, 2, 25, 14) mesh-topology-cpp 22.3912 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 14, 2, 25, 37) mesh-unitcube-cpp 23.0243 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 14, 2, 26, 17) mesh-iteration-cpp 37.5232 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 14, 2, 26, 39) function-evaluation-cpp 21.9613 "Evaluations of functions at arbitrary points." (2013, 3, 14, 2, 26, 39) function-evaluation-cpp 21.8542 "Evaluations of functions at arbitrary points." (2013, 3, 14, 2, 26, 45) function-extrapolation-python 5.24009 "*** -------------------------------------------------------------------------" (2013, 3, 14, 2, 26, 45) function-extrapolation-python 2.10843 "*** -------------------------------------------------------------------------" (2013, 3, 14, 2, 27, 8) la-vector-access-cpp 22.9719 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 14, 2, 27, 34) la-vector-assignment-cpp 25.9694 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 15, 2, 13, 32) common-progress-cpp 28.8016 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 15, 2, 14, 5) common-timing-cpp 32.0957 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 15, 2, 15, 52) fem-multicore-cpp 107.226 "Coloring mesh." (2013, 3, 15, 2, 18, 20) fem-assembly-cpp 148.401 "Assembly for various forms and backends" (2013, 3, 15, 2, 18, 32) fem-convergence-cpp 12.2013 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 15, 2, 18, 34) fem-jit-python 0.0012234 "JIT compilation (in memory cache)" (2013, 3, 15, 2, 23, 45) fem-speedup-cpp 310.362 "Assembly/solve speedup running on 4 processors" (2013, 3, 15, 2, 23, 45) fem-speedup-cpp-assembly 6.47895 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 15, 2, 23, 45) fem-speedup-cpp-solve 2.31461 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 15, 2, 24, 11) mesh-refinement-cpp 24.3441 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 15, 2, 24, 33) mesh-topology-cpp 22.3299 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 15, 2, 24, 56) mesh-unitcube-cpp 22.9755 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 15, 2, 25, 37) mesh-iteration-cpp 39.0737 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 15, 2, 25, 59) function-evaluation-cpp 21.8787 "Evaluations of functions at arbitrary points." (2013, 3, 15, 2, 25, 59) function-evaluation-cpp 21.7553 "Evaluations of functions at arbitrary points." (2013, 3, 15, 2, 26, 5) function-extrapolation-python 5.21209 "*** -------------------------------------------------------------------------" (2013, 3, 15, 2, 26, 5) function-extrapolation-python 2.15956 "*** -------------------------------------------------------------------------" (2013, 3, 15, 2, 26, 28) la-vector-access-cpp 22.9567 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 15, 2, 26, 55) la-vector-assignment-cpp 27.4805 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 16, 2, 14, 11) common-progress-cpp 28.8684 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 16, 2, 14, 43) common-timing-cpp 31.3065 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 16, 2, 16, 30) fem-multicore-cpp 107.333 "Coloring mesh." (2013, 3, 16, 2, 19, 0) fem-assembly-cpp 149.993 "Assembly for various forms and backends" (2013, 3, 16, 2, 19, 12) fem-convergence-cpp 12.2928 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 16, 2, 19, 14) fem-jit-python 0.00123 "JIT compilation (in memory cache)" (2013, 3, 16, 2, 24, 26) fem-speedup-cpp 312.124 "Assembly/solve speedup running on 4 processors" (2013, 3, 16, 2, 24, 26) fem-speedup-cpp-assembly 6.46337 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 16, 2, 24, 26) fem-speedup-cpp-solve 2.30694 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 16, 2, 24, 53) mesh-refinement-cpp 24.9901 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 16, 2, 25, 16) mesh-topology-cpp 22.5543 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 16, 2, 25, 42) mesh-unitcube-cpp 26.5926 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 16, 2, 26, 25) mesh-iteration-cpp 40.4265 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 16, 2, 26, 47) function-evaluation-cpp 21.8843 "Evaluations of functions at arbitrary points." (2013, 3, 16, 2, 26, 47) function-evaluation-cpp 21.7497 "Evaluations of functions at arbitrary points." (2013, 3, 16, 2, 26, 52) function-extrapolation-python 5.09462 "*** -------------------------------------------------------------------------" (2013, 3, 16, 2, 26, 52) function-extrapolation-python 2.10553 "*** -------------------------------------------------------------------------" (2013, 3, 16, 2, 27, 15) la-vector-access-cpp 22.4321 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 16, 2, 27, 42) la-vector-assignment-cpp 27.4719 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 17, 2, 29, 42) common-progress-cpp 28.9765 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 17, 2, 30, 13) common-timing-cpp 31.3009 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 17, 2, 32, 0) fem-multicore-cpp 107.195 "Coloring mesh." (2013, 3, 17, 2, 34, 30) fem-assembly-cpp 149.737 "Assembly for various forms and backends" (2013, 3, 17, 2, 34, 42) fem-convergence-cpp 12.3258 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 17, 2, 34, 44) fem-jit-python 0.00122299 "JIT compilation (in memory cache)" (2013, 3, 17, 2, 39, 54) fem-speedup-cpp 310.183 "Assembly/solve speedup running on 4 processors" (2013, 3, 17, 2, 39, 54) fem-speedup-cpp-assembly 6.51568 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 17, 2, 39, 54) fem-speedup-cpp-solve 2.35324 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 17, 2, 40, 21) mesh-refinement-cpp 25.0468 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 17, 2, 40, 43) mesh-topology-cpp 22.547 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 17, 2, 41, 10) mesh-unitcube-cpp 26.493 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 17, 2, 41, 50) mesh-iteration-cpp 37.4055 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 17, 2, 42, 12) function-evaluation-cpp 21.5286 "Evaluations of functions at arbitrary points." (2013, 3, 17, 2, 42, 12) function-evaluation-cpp 21.4091 "Evaluations of functions at arbitrary points." (2013, 3, 17, 2, 42, 17) function-extrapolation-python 5.24485 "*** -------------------------------------------------------------------------" (2013, 3, 17, 2, 42, 17) function-extrapolation-python 2.16948 "*** -------------------------------------------------------------------------" (2013, 3, 17, 2, 42, 45) la-vector-access-cpp 27.9113 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 17, 2, 43, 13) la-vector-assignment-cpp 27.9133 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 18, 2, 13, 58) common-progress-cpp 37.7687 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 18, 2, 14, 31) common-timing-cpp 32.4334 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 18, 2, 16, 18) fem-multicore-cpp 107.27 "Coloring mesh." (2013, 3, 18, 2, 18, 48) fem-assembly-cpp 149.848 "Assembly for various forms and backends" (2013, 3, 18, 2, 19, 0) fem-convergence-cpp 12.3602 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 18, 2, 19, 2) fem-jit-python 0.00122349 "JIT compilation (in memory cache)" (2013, 3, 18, 2, 24, 14) fem-speedup-cpp 311.341 "Assembly/solve speedup running on 4 processors" (2013, 3, 18, 2, 24, 14) fem-speedup-cpp-assembly 6.5241 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 18, 2, 24, 14) fem-speedup-cpp-solve 2.31743 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 18, 2, 24, 40) mesh-refinement-cpp 25.0306 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 18, 2, 25, 3) mesh-topology-cpp 22.5197 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 18, 2, 25, 29) mesh-unitcube-cpp 26.524 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 18, 2, 26, 9) mesh-iteration-cpp 37.4762 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 18, 2, 26, 31) function-evaluation-cpp 21.9725 "Evaluations of functions at arbitrary points." (2013, 3, 18, 2, 26, 31) function-evaluation-cpp 21.8378 "Evaluations of functions at arbitrary points." (2013, 3, 18, 2, 26, 37) function-extrapolation-python 5.22097 "*** -------------------------------------------------------------------------" (2013, 3, 18, 2, 26, 37) function-extrapolation-python 2.15231 "*** -------------------------------------------------------------------------" (2013, 3, 18, 2, 26, 59) la-vector-access-cpp 22.6207 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 18, 2, 27, 25) la-vector-assignment-cpp 25.9718 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 19, 2, 13, 51) common-progress-cpp 28.8619 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 19, 2, 14, 22) common-timing-cpp 31.2971 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 19, 2, 16, 10) fem-multicore-cpp 107.35 "Coloring mesh." (2013, 3, 19, 2, 18, 39) fem-assembly-cpp 148.884 "Assembly for various forms and backends" (2013, 3, 19, 2, 18, 51) fem-convergence-cpp 12.375 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 19, 2, 18, 53) fem-jit-python 0.00122199 "JIT compilation (in memory cache)" (2013, 3, 19, 2, 24, 3) fem-speedup-cpp 309.909 "Assembly/solve speedup running on 4 processors" (2013, 3, 19, 2, 24, 3) fem-speedup-cpp-assembly 6.50401 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 19, 2, 24, 3) fem-speedup-cpp-solve 2.34787 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 19, 2, 24, 29) mesh-refinement-cpp 24.9867 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 19, 2, 24, 52) mesh-topology-cpp 22.3912 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 19, 2, 25, 19) mesh-unitcube-cpp 27.1669 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 19, 2, 25, 59) mesh-iteration-cpp 37.195 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 19, 2, 26, 21) function-evaluation-cpp 21.845 "Evaluations of functions at arbitrary points." (2013, 3, 19, 2, 26, 21) function-evaluation-cpp 21.7126 "Evaluations of functions at arbitrary points." (2013, 3, 19, 2, 26, 26) function-extrapolation-python 5.39671 "*** -------------------------------------------------------------------------" (2013, 3, 19, 2, 26, 26) function-extrapolation-python 2.17694 "*** -------------------------------------------------------------------------" (2013, 3, 19, 2, 26, 49) la-vector-access-cpp 23.0423 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 19, 2, 27, 15) la-vector-assignment-cpp 25.9685 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 20, 2, 13, 30) common-progress-cpp 28.8516 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 20, 2, 14, 1) common-timing-cpp 31.3052 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 20, 2, 15, 49) fem-multicore-cpp 107.1 "Coloring mesh." (2013, 3, 20, 2, 18, 18) fem-assembly-cpp 149.056 "Assembly for various forms and backends" (2013, 3, 20, 2, 18, 30) fem-convergence-cpp 12.2928 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 20, 2, 18, 32) fem-jit-python 0.00124729 "JIT compilation (in memory cache)" (2013, 3, 20, 2, 23, 42) fem-speedup-cpp 309.893 "Assembly/solve speedup running on 4 processors" (2013, 3, 20, 2, 23, 42) fem-speedup-cpp-assembly 6.50628 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 20, 2, 23, 42) fem-speedup-cpp-solve 2.34703 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 20, 2, 24, 8) mesh-refinement-cpp 24.9927 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 20, 2, 24, 31) mesh-topology-cpp 22.528 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 20, 2, 24, 58) mesh-unitcube-cpp 27.1177 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 20, 2, 25, 38) mesh-iteration-cpp 37.2224 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 20, 2, 26, 0) function-evaluation-cpp 21.8283 "Evaluations of functions at arbitrary points." (2013, 3, 20, 2, 26, 0) function-evaluation-cpp 21.7086 "Evaluations of functions at arbitrary points." (2013, 3, 20, 2, 26, 5) function-extrapolation-python 5.31842 "*** -------------------------------------------------------------------------" (2013, 3, 20, 2, 26, 5) function-extrapolation-python 2.18448 "*** -------------------------------------------------------------------------" (2013, 3, 20, 2, 26, 31) la-vector-access-cpp 25.4125 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 20, 2, 26, 58) la-vector-assignment-cpp 27.5367 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 21, 2, 13, 45) common-progress-cpp 37.6687 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 21, 2, 14, 16) common-timing-cpp 31.3976 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 21, 2, 16, 5) fem-multicore-cpp 108.533 "Coloring mesh." (2013, 3, 21, 2, 18, 34) fem-assembly-cpp 148.958 "Assembly for various forms and backends" (2013, 3, 21, 2, 18, 46) fem-convergence-cpp 12.3336 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 21, 2, 18, 48) fem-jit-python 0.0012275 "JIT compilation (in memory cache)" (2013, 3, 21, 2, 23, 58) fem-speedup-cpp 309.647 "Assembly/solve speedup running on 4 processors" (2013, 3, 21, 2, 23, 58) fem-speedup-cpp-assembly 6.58366 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 21, 2, 23, 58) fem-speedup-cpp-solve 2.33447 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 21, 2, 24, 24) mesh-refinement-cpp 24.9678 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 21, 2, 24, 47) mesh-topology-cpp 22.419 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 21, 2, 25, 14) mesh-unitcube-cpp 27.2319 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 21, 2, 25, 54) mesh-iteration-cpp 37.2007 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 21, 2, 26, 16) function-evaluation-cpp 21.82 "Evaluations of functions at arbitrary points." (2013, 3, 21, 2, 26, 16) function-evaluation-cpp 21.6916 "Evaluations of functions at arbitrary points." (2013, 3, 21, 2, 26, 21) function-extrapolation-python 5.29022 "*** -------------------------------------------------------------------------" (2013, 3, 21, 2, 26, 21) function-extrapolation-python 2.18094 "*** -------------------------------------------------------------------------" (2013, 3, 21, 2, 26, 44) la-vector-access-cpp 22.9142 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 21, 2, 27, 12) la-vector-assignment-cpp 27.486 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 3, 24, 6, 22, 37) common-progress-cpp 27.6739 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 3, 24, 6, 23, 9) common-timing-cpp 32.9443 "Timing access and registration of timings (10000000 repetitions)" (2013, 3, 24, 6, 24, 57) fem-multicore-cpp 107.69 "Coloring mesh." (2013, 3, 24, 6, 27, 27) fem-assembly-cpp 150.216 "Assembly for various forms and backends" (2013, 3, 24, 6, 27, 39) fem-convergence-cpp 11.6622 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 3, 24, 6, 27, 40) fem-jit-python 0.001227 "JIT compilation (in memory cache)" (2013, 3, 24, 6, 32, 51) fem-speedup-cpp 311.42 "Assembly/solve speedup running on 4 processors" (2013, 3, 24, 6, 32, 51) fem-speedup-cpp-assembly 6.65614 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 3, 24, 6, 32, 51) fem-speedup-cpp-solve 2.25599 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 3, 24, 6, 33, 17) mesh-refinement-cpp 24.3632 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 3, 24, 6, 33, 40) mesh-topology-cpp 22.3285 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 3, 24, 6, 34, 3) mesh-unitcube-cpp 23.0828 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 3, 24, 6, 34, 43) mesh-iteration-cpp 37.7172 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 3, 24, 6, 35, 5) function-evaluation-cpp 21.6222 "Evaluations of functions at arbitrary points." (2013, 3, 24, 6, 35, 5) function-evaluation-cpp 21.4611 "Evaluations of functions at arbitrary points." (2013, 3, 24, 6, 35, 10) function-extrapolation-python 5.17026 "*** -------------------------------------------------------------------------" (2013, 3, 24, 6, 35, 10) function-extrapolation-python 2.13267 "*** -------------------------------------------------------------------------" (2013, 3, 24, 6, 35, 35) la-vector-access-cpp 22.9433 "Accessing vector of size 10000000 (100 repetitions)" (2013, 3, 24, 6, 36, 1) la-vector-assignment-cpp 25.9617 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 3, 10, 37, 41) common-progress-cpp 28.6709 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 3, 10, 38, 12) common-timing-cpp 31.0144 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 3, 10, 39, 59) fem-multicore-cpp 107.346 "Coloring mesh." (2013, 4, 3, 10, 42, 31) fem-assembly-cpp 151.204 "Assembly for various forms and backends" (2013, 4, 3, 10, 42, 43) fem-convergence-cpp 12.2534 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 3, 10, 43, 0) fem-jit-python 0.001281 "JIT compilation (in memory cache)" (2013, 4, 3, 10, 48, 10) fem-speedup-cpp 309.873 "Assembly/solve speedup running on 4 processors" (2013, 4, 3, 10, 48, 10) fem-speedup-cpp-assembly 6.69817 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 3, 10, 48, 10) fem-speedup-cpp-solve 2.33368 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 3, 10, 48, 36) mesh-refinement-cpp 24.3806 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 3, 10, 48, 58) mesh-topology-cpp 22.284 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 3, 10, 49, 22) mesh-unitcube-cpp 23.9109 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 3, 10, 50, 2) mesh-iteration-cpp 37.2358 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 3, 10, 50, 24) function-evaluation-cpp 21.6453 "Evaluations of functions at arbitrary points." (2013, 4, 3, 10, 50, 24) function-evaluation-cpp 21.5208 "Evaluations of functions at arbitrary points." (2013, 4, 3, 10, 51, 21) function-extrapolation-python 57.1881 "*** -------------------------------------------------------------------------" (2013, 4, 3, 10, 51, 21) function-extrapolation-python 2.1405 "*** -------------------------------------------------------------------------" (2013, 4, 3, 10, 51, 44) la-vector-access-cpp 22.7763 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 3, 10, 52, 10) la-vector-assignment-cpp 26.174 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 4, 1, 16, 22) common-progress-cpp 28.8295 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 4, 1, 16, 53) common-timing-cpp 31.1556 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 4, 1, 18, 41) fem-multicore-cpp 107.981 "Coloring mesh." (2013, 4, 4, 1, 21, 9) fem-assembly-cpp 148.047 "Assembly for various forms and backends" (2013, 4, 4, 1, 21, 21) fem-convergence-cpp 12.2995 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 4, 1, 21, 23) fem-jit-python 0.00122399 "JIT compilation (in memory cache)" (2013, 4, 4, 1, 26, 34) fem-speedup-cpp 310.941 "Assembly/solve speedup running on 4 processors" (2013, 4, 4, 1, 26, 34) fem-speedup-cpp-assembly 6.66642 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 4, 1, 26, 34) fem-speedup-cpp-solve 2.34365 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 4, 1, 27, 0) mesh-refinement-cpp 24.3782 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 4, 1, 27, 22) mesh-topology-cpp 22.2689 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 4, 1, 27, 46) mesh-unitcube-cpp 23.9058 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 4, 1, 28, 29) mesh-iteration-cpp 40.411 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 4, 1, 28, 51) function-evaluation-cpp 21.7702 "Evaluations of functions at arbitrary points." (2013, 4, 4, 1, 28, 51) function-evaluation-cpp 21.6467 "Evaluations of functions at arbitrary points." (2013, 4, 4, 1, 28, 56) function-extrapolation-python 4.99667 "*** -------------------------------------------------------------------------" (2013, 4, 4, 1, 28, 56) function-extrapolation-python 2.11086 "*** -------------------------------------------------------------------------" (2013, 4, 4, 1, 29, 19) la-vector-access-cpp 22.656 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 4, 1, 29, 50) la-vector-assignment-cpp 31.4756 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 5, 1, 16, 37) common-progress-cpp 28.8126 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 5, 1, 17, 8) common-timing-cpp 31.1561 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 5, 1, 18, 56) fem-multicore-cpp 107.415 "Coloring mesh." (2013, 4, 5, 1, 21, 24) fem-assembly-cpp 148.539 "Assembly for various forms and backends" (2013, 4, 5, 1, 21, 36) fem-convergence-cpp 12.2717 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 5, 1, 21, 39) fem-jit-python 0.00122499 "JIT compilation (in memory cache)" (2013, 4, 5, 1, 26, 48) fem-speedup-cpp 309.227 "Assembly/solve speedup running on 4 processors" (2013, 4, 5, 1, 26, 48) fem-speedup-cpp-assembly 6.61499 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 5, 1, 26, 48) fem-speedup-cpp-solve 2.3687 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 5, 1, 27, 14) mesh-refinement-cpp 24.3807 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 5, 1, 27, 36) mesh-topology-cpp 22.3226 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 5, 1, 28, 0) mesh-unitcube-cpp 23.931 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 5, 1, 28, 42) mesh-iteration-cpp 39.0971 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 5, 1, 29, 3) function-evaluation-cpp 21.8304 "Evaluations of functions at arbitrary points." (2013, 4, 5, 1, 29, 3) function-evaluation-cpp 21.6999 "Evaluations of functions at arbitrary points." (2013, 4, 5, 1, 29, 8) function-extrapolation-python 5.08045 "*** -------------------------------------------------------------------------" (2013, 4, 5, 1, 29, 8) function-extrapolation-python 2.13236 "*** -------------------------------------------------------------------------" (2013, 4, 5, 1, 29, 31) la-vector-access-cpp 22.4153 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 5, 1, 29, 58) la-vector-assignment-cpp 26.9331 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 6, 1, 17, 12) common-progress-cpp 30.0282 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 6, 1, 17, 42) common-timing-cpp 30.0913 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 6, 1, 19, 29) fem-multicore-cpp 107.415 "Coloring mesh." (2013, 4, 6, 1, 21, 59) fem-assembly-cpp 149.664 "Assembly for various forms and backends" (2013, 4, 6, 1, 22, 11) fem-convergence-cpp 12.3273 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 6, 1, 22, 14) fem-jit-python 0.00123191 "JIT compilation (in memory cache)" (2013, 4, 6, 1, 27, 24) fem-speedup-cpp 310.03 "Assembly/solve speedup running on 4 processors" (2013, 4, 6, 1, 27, 24) fem-speedup-cpp-assembly 6.51814 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 6, 1, 27, 24) fem-speedup-cpp-solve 2.31374 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 6, 1, 27, 49) mesh-refinement-cpp 24.0426 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 6, 1, 28, 11) mesh-topology-cpp 22.0998 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 6, 1, 28, 35) mesh-unitcube-cpp 23.5254 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 6, 1, 29, 15) mesh-iteration-cpp 37.2303 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 6, 1, 29, 36) function-evaluation-cpp 21.7618 "Evaluations of functions at arbitrary points." (2013, 4, 6, 1, 29, 36) function-evaluation-cpp 21.6373 "Evaluations of functions at arbitrary points." (2013, 4, 6, 1, 29, 41) function-extrapolation-python 5.1518 "*** -------------------------------------------------------------------------" (2013, 4, 6, 1, 29, 41) function-extrapolation-python 2.11751 "*** -------------------------------------------------------------------------" (2013, 4, 6, 1, 30, 9) la-vector-access-cpp 27.9036 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 6, 1, 30, 37) la-vector-assignment-cpp 27.5259 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 7, 1, 16, 29) common-progress-cpp 29.9531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 7, 1, 16, 59) common-timing-cpp 30.0019 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 7, 1, 18, 47) fem-multicore-cpp 107.778 "Coloring mesh." (2013, 4, 7, 1, 21, 17) fem-assembly-cpp 149.832 "Assembly for various forms and backends" (2013, 4, 7, 1, 21, 29) fem-convergence-cpp 12.2765 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 7, 1, 21, 31) fem-jit-python 0.00122931 "JIT compilation (in memory cache)" (2013, 4, 7, 1, 26, 40) fem-speedup-cpp 308.661 "Assembly/solve speedup running on 4 processors" (2013, 4, 7, 1, 26, 40) fem-speedup-cpp-assembly 6.43973 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 7, 1, 26, 40) fem-speedup-cpp-solve 2.3552 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 7, 1, 27, 5) mesh-refinement-cpp 24.0794 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 7, 1, 27, 27) mesh-topology-cpp 22.0646 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 7, 1, 27, 51) mesh-unitcube-cpp 23.4444 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 7, 1, 28, 31) mesh-iteration-cpp 37.3231 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 7, 1, 28, 52) function-evaluation-cpp 21.9451 "Evaluations of functions at arbitrary points." (2013, 4, 7, 1, 28, 52) function-evaluation-cpp 21.8204 "Evaluations of functions at arbitrary points." (2013, 4, 7, 1, 28, 58) function-extrapolation-python 5.31725 "*** -------------------------------------------------------------------------" (2013, 4, 7, 1, 28, 58) function-extrapolation-python 2.11719 "*** -------------------------------------------------------------------------" (2013, 4, 7, 1, 29, 26) la-vector-access-cpp 28.3989 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 7, 1, 29, 54) la-vector-assignment-cpp 27.5348 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 8, 1, 16, 28) common-progress-cpp 37.7627 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 8, 1, 16, 58) common-timing-cpp 29.9162 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 8, 1, 18, 46) fem-multicore-cpp 107.609 "Coloring mesh." (2013, 4, 8, 1, 21, 14) fem-assembly-cpp 148.673 "Assembly for various forms and backends" (2013, 4, 8, 1, 21, 26) fem-convergence-cpp 12.2434 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 8, 1, 21, 29) fem-jit-python 0.00123191 "JIT compilation (in memory cache)" (2013, 4, 8, 1, 26, 37) fem-speedup-cpp 308.861 "Assembly/solve speedup running on 4 processors" (2013, 4, 8, 1, 26, 37) fem-speedup-cpp-assembly 6.45204 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 8, 1, 26, 37) fem-speedup-cpp-solve 2.35208 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 8, 1, 27, 3) mesh-refinement-cpp 24.0579 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 8, 1, 27, 25) mesh-topology-cpp 22.104 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 8, 1, 27, 49) mesh-unitcube-cpp 23.4969 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 8, 1, 28, 30) mesh-iteration-cpp 38.4778 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 8, 1, 28, 51) function-evaluation-cpp 21.9117 "Evaluations of functions at arbitrary points." (2013, 4, 8, 1, 28, 51) function-evaluation-cpp 21.7856 "Evaluations of functions at arbitrary points." (2013, 4, 8, 1, 28, 57) function-extrapolation-python 5.14718 "*** -------------------------------------------------------------------------" (2013, 4, 8, 1, 28, 57) function-extrapolation-python 2.12018 "*** -------------------------------------------------------------------------" (2013, 4, 8, 1, 29, 25) la-vector-access-cpp 28.3954 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 8, 1, 29, 53) la-vector-assignment-cpp 27.6135 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 9, 1, 16, 31) common-progress-cpp 30.0448 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 9, 1, 17, 1) common-timing-cpp 29.8397 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 9, 1, 18, 48) fem-multicore-cpp 107.257 "Coloring mesh." (2013, 4, 9, 1, 21, 18) fem-assembly-cpp 149.894 "Assembly for various forms and backends" (2013, 4, 9, 1, 21, 30) fem-convergence-cpp 12.2793 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 9, 1, 21, 32) fem-jit-python 0.0012243 "JIT compilation (in memory cache)" (2013, 4, 9, 1, 26, 41) fem-speedup-cpp 309.246 "Assembly/solve speedup running on 4 processors" (2013, 4, 9, 1, 26, 41) fem-speedup-cpp-assembly 6.44508 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 9, 1, 26, 41) fem-speedup-cpp-solve 2.35306 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 9, 1, 27, 7) mesh-refinement-cpp 24.0455 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 9, 1, 27, 29) mesh-topology-cpp 22.0375 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 9, 1, 27, 52) mesh-unitcube-cpp 23.4152 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 9, 1, 28, 33) mesh-iteration-cpp 37.7987 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 9, 1, 28, 55) function-evaluation-cpp 22.0637 "Evaluations of functions at arbitrary points." (2013, 4, 9, 1, 28, 55) function-evaluation-cpp 21.9178 "Evaluations of functions at arbitrary points." (2013, 4, 9, 1, 29, 0) function-extrapolation-python 5.28518 "*** -------------------------------------------------------------------------" (2013, 4, 9, 1, 29, 0) function-extrapolation-python 2.12131 "*** -------------------------------------------------------------------------" (2013, 4, 9, 1, 29, 26) la-vector-access-cpp 25.4006 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 9, 1, 29, 53) la-vector-assignment-cpp 27.5325 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 10, 1, 16, 22) common-progress-cpp 30.4026 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 10, 1, 16, 52) common-timing-cpp 29.8269 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 10, 1, 18, 39) fem-multicore-cpp 107.227 "Coloring mesh." (2013, 4, 10, 1, 21, 8) fem-assembly-cpp 149.014 "Assembly for various forms and backends" (2013, 4, 10, 1, 21, 20) fem-convergence-cpp 12.2822 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 10, 1, 21, 22) fem-jit-python 0.00123022 "JIT compilation (in memory cache)" (2013, 4, 10, 1, 26, 33) fem-speedup-cpp 310.705 "Assembly/solve speedup running on 4 processors" (2013, 4, 10, 1, 26, 33) fem-speedup-cpp-assembly 6.52232 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 10, 1, 26, 33) fem-speedup-cpp-solve 2.31407 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 10, 1, 26, 58) mesh-refinement-cpp 24.0041 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 10, 1, 27, 21) mesh-topology-cpp 22.1267 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 10, 1, 27, 44) mesh-unitcube-cpp 23.4961 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 10, 1, 28, 24) mesh-iteration-cpp 37.2778 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 10, 1, 28, 46) function-evaluation-cpp 21.8222 "Evaluations of functions at arbitrary points." (2013, 4, 10, 1, 28, 46) function-evaluation-cpp 21.6903 "Evaluations of functions at arbitrary points." (2013, 4, 10, 1, 28, 51) function-extrapolation-python 5.24485 "*** -------------------------------------------------------------------------" (2013, 4, 10, 1, 28, 51) function-extrapolation-python 2.14506 "*** -------------------------------------------------------------------------" (2013, 4, 10, 1, 29, 19) la-vector-access-cpp 27.9033 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 10, 1, 29, 47) la-vector-assignment-cpp 27.5347 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 11, 1, 16, 36) common-progress-cpp 30.0364 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 11, 1, 17, 6) common-timing-cpp 30.624 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 11, 1, 18, 54) fem-multicore-cpp 107.282 "Coloring mesh." (2013, 4, 11, 1, 21, 23) fem-assembly-cpp 149.614 "Assembly for various forms and backends" (2013, 4, 11, 1, 21, 36) fem-convergence-cpp 12.2424 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 11, 1, 21, 38) fem-jit-python 0.0012377 "JIT compilation (in memory cache)" (2013, 4, 11, 1, 26, 46) fem-speedup-cpp 308.627 "Assembly/solve speedup running on 4 processors" (2013, 4, 11, 1, 26, 46) fem-speedup-cpp-assembly 6.57084 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 11, 1, 26, 46) fem-speedup-cpp-solve 2.37068 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 11, 1, 27, 12) mesh-refinement-cpp 24.0488 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 11, 1, 27, 34) mesh-topology-cpp 22.1544 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 11, 1, 27, 58) mesh-unitcube-cpp 23.5401 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 11, 1, 28, 38) mesh-iteration-cpp 37.6379 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 11, 1, 29, 0) function-evaluation-cpp 21.8286 "Evaluations of functions at arbitrary points." (2013, 4, 11, 1, 29, 0) function-evaluation-cpp 21.7027 "Evaluations of functions at arbitrary points." (2013, 4, 11, 1, 29, 5) function-extrapolation-python 5.35448 "*** -------------------------------------------------------------------------" (2013, 4, 11, 1, 29, 5) function-extrapolation-python 2.12137 "*** -------------------------------------------------------------------------" (2013, 4, 11, 1, 29, 30) la-vector-access-cpp 25.4105 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 11, 1, 29, 58) la-vector-assignment-cpp 27.4704 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 12, 1, 16, 26) common-progress-cpp 30.0612 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 12, 1, 16, 57) common-timing-cpp 30.9756 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 12, 1, 18, 44) fem-multicore-cpp 107.025 "Coloring mesh." (2013, 4, 12, 1, 21, 13) fem-assembly-cpp 149.179 "Assembly for various forms and backends" (2013, 4, 12, 1, 21, 26) fem-convergence-cpp 12.2428 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 12, 1, 21, 28) fem-jit-python 0.00122929 "JIT compilation (in memory cache)" (2013, 4, 12, 1, 26, 38) fem-speedup-cpp 310.413 "Assembly/solve speedup running on 4 processors" (2013, 4, 12, 1, 26, 38) fem-speedup-cpp-assembly 6.49091 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 12, 1, 26, 38) fem-speedup-cpp-solve 2.32624 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 12, 1, 27, 4) mesh-refinement-cpp 24.0474 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 12, 1, 27, 26) mesh-topology-cpp 22.0204 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 12, 1, 27, 49) mesh-unitcube-cpp 23.5027 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 12, 1, 28, 29) mesh-iteration-cpp 37.2771 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 12, 1, 28, 51) function-evaluation-cpp 21.8202 "Evaluations of functions at arbitrary points." (2013, 4, 12, 1, 28, 51) function-evaluation-cpp 21.6921 "Evaluations of functions at arbitrary points." (2013, 4, 12, 1, 28, 56) function-extrapolation-python 5.23324 "*** -------------------------------------------------------------------------" (2013, 4, 12, 1, 28, 56) function-extrapolation-python 2.1324 "*** -------------------------------------------------------------------------" (2013, 4, 12, 1, 29, 25) la-vector-access-cpp 28.4149 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 12, 1, 29, 56) la-vector-assignment-cpp 31.4842 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 13, 1, 16, 25) common-progress-cpp 30.078 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 13, 1, 16, 56) common-timing-cpp 30.8103 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 13, 1, 18, 43) fem-multicore-cpp 107.104 "Coloring mesh." (2013, 4, 13, 1, 21, 12) fem-assembly-cpp 149.179 "Assembly for various forms and backends" (2013, 4, 13, 1, 21, 24) fem-convergence-cpp 12.3201 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 13, 1, 21, 26) fem-jit-python 0.00122671 "JIT compilation (in memory cache)" (2013, 4, 13, 1, 26, 37) fem-speedup-cpp 310.668 "Assembly/solve speedup running on 4 processors" (2013, 4, 13, 1, 26, 37) fem-speedup-cpp-assembly 6.48678 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 13, 1, 26, 37) fem-speedup-cpp-solve 2.3043 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 13, 1, 27, 2) mesh-refinement-cpp 24.0435 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 13, 1, 27, 25) mesh-topology-cpp 22.0711 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 13, 1, 27, 48) mesh-unitcube-cpp 23.5141 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 13, 1, 28, 28) mesh-iteration-cpp 37.2366 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 13, 1, 28, 50) function-evaluation-cpp 21.9283 "Evaluations of functions at arbitrary points." (2013, 4, 13, 1, 28, 50) function-evaluation-cpp 21.8007 "Evaluations of functions at arbitrary points." (2013, 4, 13, 1, 28, 55) function-extrapolation-python 5.2738 "*** -------------------------------------------------------------------------" (2013, 4, 13, 1, 28, 55) function-extrapolation-python 2.12933 "*** -------------------------------------------------------------------------" (2013, 4, 13, 1, 29, 21) la-vector-access-cpp 25.4122 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 13, 1, 29, 50) la-vector-assignment-cpp 29.5329 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 14, 1, 16, 22) common-progress-cpp 30.0946 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 14, 1, 16, 52) common-timing-cpp 30.4087 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 14, 1, 18, 40) fem-multicore-cpp 107.529 "Coloring mesh." (2013, 4, 14, 1, 21, 9) fem-assembly-cpp 149.576 "Assembly for various forms and backends" (2013, 4, 14, 1, 21, 21) fem-convergence-cpp 12.2776 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 14, 1, 21, 24) fem-jit-python 0.0012233 "JIT compilation (in memory cache)" (2013, 4, 14, 1, 26, 33) fem-speedup-cpp 309.251 "Assembly/solve speedup running on 4 processors" (2013, 4, 14, 1, 26, 33) fem-speedup-cpp-assembly 6.57893 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 14, 1, 26, 33) fem-speedup-cpp-solve 2.34953 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 14, 1, 26, 58) mesh-refinement-cpp 24.0256 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 14, 1, 27, 20) mesh-topology-cpp 22.0164 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 14, 1, 27, 44) mesh-unitcube-cpp 23.4539 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 14, 1, 28, 24) mesh-iteration-cpp 37.2981 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 14, 1, 28, 45) function-evaluation-cpp 21.4629 "Evaluations of functions at arbitrary points." (2013, 4, 14, 1, 28, 45) function-evaluation-cpp 21.3353 "Evaluations of functions at arbitrary points." (2013, 4, 14, 1, 28, 50) function-extrapolation-python 5.19524 "*** -------------------------------------------------------------------------" (2013, 4, 14, 1, 28, 50) function-extrapolation-python 2.11549 "*** -------------------------------------------------------------------------" (2013, 4, 14, 1, 29, 21) la-vector-access-cpp 30.8065 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 14, 1, 29, 49) la-vector-assignment-cpp 27.538 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 15, 1, 16, 34) common-progress-cpp 30.0689 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 15, 1, 17, 5) common-timing-cpp 30.4732 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 15, 1, 18, 52) fem-multicore-cpp 106.941 "Coloring mesh." (2013, 4, 15, 1, 21, 21) fem-assembly-cpp 149.51 "Assembly for various forms and backends" (2013, 4, 15, 1, 21, 33) fem-convergence-cpp 12.2485 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 15, 1, 21, 36) fem-jit-python 0.0012269 "JIT compilation (in memory cache)" (2013, 4, 15, 1, 26, 45) fem-speedup-cpp 309.596 "Assembly/solve speedup running on 4 processors" (2013, 4, 15, 1, 26, 45) fem-speedup-cpp-assembly 6.53485 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 15, 1, 26, 45) fem-speedup-cpp-solve 2.33955 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 15, 1, 27, 11) mesh-refinement-cpp 24.0765 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 15, 1, 27, 33) mesh-topology-cpp 22.0727 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 15, 1, 27, 56) mesh-unitcube-cpp 23.4702 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 15, 1, 28, 37) mesh-iteration-cpp 38.5673 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 15, 1, 28, 59) function-evaluation-cpp 21.7059 "Evaluations of functions at arbitrary points." (2013, 4, 15, 1, 28, 59) function-evaluation-cpp 21.5747 "Evaluations of functions at arbitrary points." (2013, 4, 15, 1, 29, 4) function-extrapolation-python 5.17164 "*** -------------------------------------------------------------------------" (2013, 4, 15, 1, 29, 4) function-extrapolation-python 2.12217 "*** -------------------------------------------------------------------------" (2013, 4, 15, 1, 29, 30) la-vector-access-cpp 25.4026 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 15, 1, 29, 57) la-vector-assignment-cpp 27.5354 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 16, 1, 16, 41) common-progress-cpp 37.6048 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 16, 1, 17, 12) common-timing-cpp 30.3956 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 16, 1, 18, 59) fem-multicore-cpp 107.191 "Coloring mesh." (2013, 4, 16, 1, 21, 28) fem-assembly-cpp 149.562 "Assembly for various forms and backends" (2013, 4, 16, 1, 21, 41) fem-convergence-cpp 12.2565 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 16, 1, 21, 43) fem-jit-python 0.0012275 "JIT compilation (in memory cache)" (2013, 4, 16, 1, 26, 53) fem-speedup-cpp 310.21 "Assembly/solve speedup running on 4 processors" (2013, 4, 16, 1, 26, 53) fem-speedup-cpp-assembly 6.50801 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 16, 1, 26, 53) fem-speedup-cpp-solve 2.32547 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 16, 1, 27, 18) mesh-refinement-cpp 24.0031 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 16, 1, 27, 41) mesh-topology-cpp 22.0714 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 16, 1, 28, 4) mesh-unitcube-cpp 23.5169 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 16, 1, 28, 44) mesh-iteration-cpp 37.3408 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 16, 1, 29, 6) function-evaluation-cpp 21.9287 "Evaluations of functions at arbitrary points." (2013, 4, 16, 1, 29, 6) function-evaluation-cpp 21.8047 "Evaluations of functions at arbitrary points." (2013, 4, 16, 1, 29, 11) function-extrapolation-python 5.18916 "*** -------------------------------------------------------------------------" (2013, 4, 16, 1, 29, 11) function-extrapolation-python 2.11961 "*** -------------------------------------------------------------------------" (2013, 4, 16, 1, 29, 37) la-vector-access-cpp 25.4169 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 16, 1, 30, 4) la-vector-assignment-cpp 27.5381 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 17, 1, 16, 41) common-progress-cpp 30.0281 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 17, 1, 17, 11) common-timing-cpp 30.3992 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 17, 1, 18, 58) fem-multicore-cpp 107.095 "Coloring mesh." (2013, 4, 17, 1, 21, 28) fem-assembly-cpp 149.916 "Assembly for various forms and backends" (2013, 4, 17, 1, 21, 40) fem-convergence-cpp 12.291 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 17, 1, 21, 42) fem-jit-python 0.00123098 "JIT compilation (in memory cache)" (2013, 4, 17, 1, 26, 52) fem-speedup-cpp 309.229 "Assembly/solve speedup running on 4 processors" (2013, 4, 17, 1, 26, 52) fem-speedup-cpp-assembly 6.50473 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 17, 1, 26, 52) fem-speedup-cpp-solve 2.35744 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 17, 1, 27, 17) mesh-refinement-cpp 24.0897 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 17, 1, 27, 39) mesh-topology-cpp 22.1139 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 17, 1, 28, 3) mesh-unitcube-cpp 23.4394 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 17, 1, 28, 43) mesh-iteration-cpp 37.3842 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 17, 1, 29, 5) function-evaluation-cpp 21.7642 "Evaluations of functions at arbitrary points." (2013, 4, 17, 1, 29, 5) function-evaluation-cpp 21.6307 "Evaluations of functions at arbitrary points." (2013, 4, 17, 1, 29, 10) function-extrapolation-python 5.09776 "*** -------------------------------------------------------------------------" (2013, 4, 17, 1, 29, 10) function-extrapolation-python 2.12191 "*** -------------------------------------------------------------------------" (2013, 4, 17, 1, 29, 41) la-vector-access-cpp 30.8804 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 17, 1, 30, 8) la-vector-assignment-cpp 27.5269 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 18, 1, 16, 43) common-progress-cpp 30.0864 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 18, 1, 17, 13) common-timing-cpp 30.6651 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 18, 1, 19, 1) fem-multicore-cpp 107.203 "Coloring mesh." (2013, 4, 18, 1, 21, 30) fem-assembly-cpp 148.897 "Assembly for various forms and backends" (2013, 4, 18, 1, 21, 42) fem-convergence-cpp 12.2786 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 18, 1, 21, 44) fem-jit-python 0.00123661 "JIT compilation (in memory cache)" (2013, 4, 18, 1, 26, 54) fem-speedup-cpp 310.546 "Assembly/solve speedup running on 4 processors" (2013, 4, 18, 1, 26, 54) fem-speedup-cpp-assembly 6.5257 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 18, 1, 26, 54) fem-speedup-cpp-solve 2.30883 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 18, 1, 27, 20) mesh-refinement-cpp 24.0494 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 18, 1, 27, 42) mesh-topology-cpp 22.0448 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 18, 1, 28, 6) mesh-unitcube-cpp 23.5334 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 18, 1, 28, 46) mesh-iteration-cpp 37.844 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 18, 1, 29, 8) function-evaluation-cpp 21.7619 "Evaluations of functions at arbitrary points." (2013, 4, 18, 1, 29, 8) function-evaluation-cpp 21.6312 "Evaluations of functions at arbitrary points." (2013, 4, 18, 1, 29, 13) function-extrapolation-python 5.16996 "*** -------------------------------------------------------------------------" (2013, 4, 18, 1, 29, 13) function-extrapolation-python 2.11797 "*** -------------------------------------------------------------------------" (2013, 4, 18, 1, 29, 39) la-vector-access-cpp 25.4085 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 18, 1, 30, 6) la-vector-assignment-cpp 27.4324 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 19, 1, 16, 25) common-progress-cpp 30.0612 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 19, 1, 16, 55) common-timing-cpp 30.163 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 19, 1, 18, 42) fem-multicore-cpp 107.24 "Coloring mesh." (2013, 4, 19, 1, 21, 12) fem-assembly-cpp 149.212 "Assembly for various forms and backends" (2013, 4, 19, 1, 21, 24) fem-convergence-cpp 12.2827 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 19, 1, 21, 26) fem-jit-python 0.00122929 "JIT compilation (in memory cache)" (2013, 4, 19, 1, 26, 35) fem-speedup-cpp 309.438 "Assembly/solve speedup running on 4 processors" (2013, 4, 19, 1, 26, 35) fem-speedup-cpp-assembly 6.47643 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 19, 1, 26, 35) fem-speedup-cpp-solve 2.33866 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 19, 1, 27, 1) mesh-refinement-cpp 24.0889 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 19, 1, 27, 23) mesh-topology-cpp 22.0827 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 19, 1, 27, 47) mesh-unitcube-cpp 23.48 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 19, 1, 28, 26) mesh-iteration-cpp 37.2363 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 19, 1, 28, 48) function-evaluation-cpp 21.7474 "Evaluations of functions at arbitrary points." (2013, 4, 19, 1, 28, 48) function-evaluation-cpp 21.6206 "Evaluations of functions at arbitrary points." (2013, 4, 19, 1, 28, 53) function-extrapolation-python 5.12529 "*** -------------------------------------------------------------------------" (2013, 4, 19, 1, 28, 53) function-extrapolation-python 2.12127 "*** -------------------------------------------------------------------------" (2013, 4, 19, 1, 29, 19) la-vector-access-cpp 25.4028 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 19, 1, 29, 46) la-vector-assignment-cpp 27.5266 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 20, 1, 16, 27) common-progress-cpp 30.0697 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 20, 1, 16, 56) common-timing-cpp 29.4944 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 20, 1, 18, 44) fem-multicore-cpp 107.152 "Coloring mesh." (2013, 4, 20, 1, 21, 13) fem-assembly-cpp 149.299 "Assembly for various forms and backends" (2013, 4, 20, 1, 21, 25) fem-convergence-cpp 12.1712 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 20, 1, 21, 27) fem-jit-python 0.00123081 "JIT compilation (in memory cache)" (2013, 4, 20, 1, 26, 36) fem-speedup-cpp 308.726 "Assembly/solve speedup running on 4 processors" (2013, 4, 20, 1, 26, 36) fem-speedup-cpp-assembly 6.57181 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 20, 1, 26, 36) fem-speedup-cpp-solve 2.36212 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 20, 1, 27, 1) mesh-refinement-cpp 24.0528 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 20, 1, 27, 24) mesh-topology-cpp 22.3305 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 20, 1, 27, 47) mesh-unitcube-cpp 23.5215 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 20, 1, 28, 27) mesh-iteration-cpp 37.2495 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 20, 1, 28, 49) function-evaluation-cpp 21.8205 "Evaluations of functions at arbitrary points." (2013, 4, 20, 1, 28, 49) function-evaluation-cpp 21.6922 "Evaluations of functions at arbitrary points." (2013, 4, 20, 1, 28, 54) function-extrapolation-python 5.1729 "*** -------------------------------------------------------------------------" (2013, 4, 20, 1, 28, 54) function-extrapolation-python 2.12485 "*** -------------------------------------------------------------------------" (2013, 4, 20, 1, 29, 23) la-vector-access-cpp 29.0416 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 20, 1, 30, 24) la-vector-assignment-cpp 61.0233 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 21, 1, 16, 29) common-progress-cpp 30.1195 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 21, 1, 16, 59) common-timing-cpp 30.4108 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 21, 1, 18, 46) fem-multicore-cpp 107.171 "Coloring mesh." (2013, 4, 21, 1, 21, 16) fem-assembly-cpp 149.312 "Assembly for various forms and backends" (2013, 4, 21, 1, 21, 28) fem-convergence-cpp 12.2573 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 21, 1, 21, 30) fem-jit-python 0.00121622 "JIT compilation (in memory cache)" (2013, 4, 21, 1, 26, 41) fem-speedup-cpp 310.378 "Assembly/solve speedup running on 4 processors" (2013, 4, 21, 1, 26, 41) fem-speedup-cpp-assembly 6.44424 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 21, 1, 26, 41) fem-speedup-cpp-solve 2.31931 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 21, 1, 27, 6) mesh-refinement-cpp 24.014 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 21, 1, 27, 28) mesh-topology-cpp 22.0332 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 21, 1, 27, 52) mesh-unitcube-cpp 23.4614 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 21, 1, 28, 31) mesh-iteration-cpp 37.2483 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 21, 1, 28, 53) function-evaluation-cpp 21.8204 "Evaluations of functions at arbitrary points." (2013, 4, 21, 1, 28, 53) function-evaluation-cpp 21.6965 "Evaluations of functions at arbitrary points." (2013, 4, 21, 1, 28, 59) function-extrapolation-python 5.26024 "*** -------------------------------------------------------------------------" (2013, 4, 21, 1, 28, 59) function-extrapolation-python 2.1406 "*** -------------------------------------------------------------------------" (2013, 4, 21, 1, 29, 24) la-vector-access-cpp 25.3963 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 21, 1, 29, 51) la-vector-assignment-cpp 27.5293 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 22, 1, 16, 28) common-progress-cpp 30.0779 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 22, 1, 16, 58) common-timing-cpp 30.3436 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 22, 1, 18, 45) fem-multicore-cpp 107.127 "Coloring mesh." (2013, 4, 22, 1, 21, 15) fem-assembly-cpp 149.673 "Assembly for various forms and backends" (2013, 4, 22, 1, 21, 27) fem-convergence-cpp 12.2513 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 22, 1, 21, 29) fem-jit-python 0.00122828 "JIT compilation (in memory cache)" (2013, 4, 22, 1, 26, 41) fem-speedup-cpp 311.468 "Assembly/solve speedup running on 4 processors" (2013, 4, 22, 1, 26, 41) fem-speedup-cpp-assembly 6.5123 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 22, 1, 26, 41) fem-speedup-cpp-solve 2.29889 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 22, 1, 27, 7) mesh-refinement-cpp 24.055 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 22, 1, 27, 29) mesh-topology-cpp 22.1764 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 22, 1, 27, 52) mesh-unitcube-cpp 23.4557 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 22, 1, 28, 32) mesh-iteration-cpp 37.2372 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 22, 1, 28, 54) function-evaluation-cpp 21.8006 "Evaluations of functions at arbitrary points." (2013, 4, 22, 1, 28, 54) function-evaluation-cpp 21.7006 "Evaluations of functions at arbitrary points." (2013, 4, 22, 1, 28, 59) function-extrapolation-python 5.0892 "*** -------------------------------------------------------------------------" (2013, 4, 22, 1, 28, 59) function-extrapolation-python 2.09897 "*** -------------------------------------------------------------------------" (2013, 4, 22, 1, 29, 27) la-vector-access-cpp 28.411 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 22, 1, 29, 59) la-vector-assignment-cpp 31.4175 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 23, 1, 16, 32) common-progress-cpp 37.5714 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 23, 1, 17, 2) common-timing-cpp 29.992 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 23, 1, 18, 49) fem-multicore-cpp 107.08 "Coloring mesh." (2013, 4, 23, 1, 21, 18) fem-assembly-cpp 148.779 "Assembly for various forms and backends" (2013, 4, 23, 1, 21, 30) fem-convergence-cpp 12.2415 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 23, 1, 21, 32) fem-jit-python 0.00122111 "JIT compilation (in memory cache)" (2013, 4, 23, 1, 26, 42) fem-speedup-cpp 309.393 "Assembly/solve speedup running on 4 processors" (2013, 4, 23, 1, 26, 42) fem-speedup-cpp-assembly 6.58957 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 23, 1, 26, 42) fem-speedup-cpp-solve 2.34169 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 23, 1, 27, 7) mesh-refinement-cpp 24.0729 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 23, 1, 27, 30) mesh-topology-cpp 22.0567 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 23, 1, 27, 53) mesh-unitcube-cpp 23.5832 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 23, 1, 28, 35) mesh-iteration-cpp 39.1265 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 23, 1, 28, 57) function-evaluation-cpp 21.7725 "Evaluations of functions at arbitrary points." (2013, 4, 23, 1, 28, 57) function-evaluation-cpp 21.6337 "Evaluations of functions at arbitrary points." (2013, 4, 23, 1, 29, 2) function-extrapolation-python 5.11435 "*** -------------------------------------------------------------------------" (2013, 4, 23, 1, 29, 2) function-extrapolation-python 2.13043 "*** -------------------------------------------------------------------------" (2013, 4, 23, 1, 29, 27) la-vector-access-cpp 25.4071 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 23, 1, 29, 55) la-vector-assignment-cpp 27.5341 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 26, 12, 47, 40) common-progress-cpp 27.6499 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 26, 12, 48, 10) common-timing-cpp 30.1125 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 26, 12, 49, 57) fem-multicore-cpp 106.995 "Coloring mesh." (2013, 4, 26, 12, 52, 29) fem-assembly-cpp 152.106 "Assembly for various forms and backends" (2013, 4, 26, 12, 52, 41) fem-convergence-cpp 12.1343 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 26, 12, 52, 42) fem-jit-python 0.00104089 "JIT compilation (in memory cache)" (2013, 4, 26, 12, 57, 52) fem-speedup-cpp 309.935 "Assembly/solve speedup running on 4 processors" (2013, 4, 26, 12, 57, 52) fem-speedup-cpp-assembly 6.77273 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 26, 12, 57, 52) fem-speedup-cpp-solve 2.22318 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 26, 12, 58, 14) mesh-refinement-cpp 19.9167 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 26, 12, 58, 33) mesh-topology-cpp 19.4751 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 26, 12, 58, 58) mesh-unitcube-cpp 24.414 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 26, 12, 59, 39) mesh-iteration-cpp 39.2249 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 26, 13, 0, 1) function-evaluation-cpp 21.2531 "Evaluations of functions at arbitrary points." (2013, 4, 26, 13, 0, 1) function-evaluation-cpp 21.1609 "Evaluations of functions at arbitrary points." (2013, 4, 26, 13, 0, 5) function-extrapolation-python 4.73804 "*** -------------------------------------------------------------------------" (2013, 4, 26, 13, 0, 5) function-extrapolation-python 2.0828 "*** -------------------------------------------------------------------------" (2013, 4, 26, 13, 0, 28) la-vector-access-cpp 22.9922 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 26, 13, 0, 56) la-vector-assignment-cpp 27.1467 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 27, 1, 22, 13) common-progress-cpp 28.7031 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 27, 1, 22, 43) common-timing-cpp 29.6109 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 27, 1, 24, 29) fem-multicore-cpp 106.523 "Coloring mesh." (2013, 4, 27, 1, 27, 1) fem-assembly-cpp 152.207 "Assembly for various forms and backends" (2013, 4, 27, 1, 27, 13) fem-convergence-cpp 12.088 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 27, 1, 27, 15) fem-jit-python 0.0010329 "JIT compilation (in memory cache)" (2013, 4, 27, 1, 32, 18) fem-speedup-cpp 302.445 "Assembly/solve speedup running on 4 processors" (2013, 4, 27, 1, 32, 18) fem-speedup-cpp-assembly 6.5291 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 27, 1, 32, 18) fem-speedup-cpp-solve 2.37791 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 27, 1, 32, 38) mesh-refinement-cpp 19.8266 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 27, 1, 32, 58) mesh-topology-cpp 19.5002 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 27, 1, 33, 22) mesh-unitcube-cpp 24.3913 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 27, 1, 34, 4) mesh-iteration-cpp 39.1551 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 27, 1, 34, 25) function-evaluation-cpp 21.1631 "Evaluations of functions at arbitrary points." (2013, 4, 27, 1, 34, 25) function-evaluation-cpp 21.0797 "Evaluations of functions at arbitrary points." (2013, 4, 27, 1, 34, 30) function-extrapolation-python 4.5029 "*** -------------------------------------------------------------------------" (2013, 4, 27, 1, 34, 30) function-extrapolation-python 2.10061 "*** -------------------------------------------------------------------------" (2013, 4, 27, 1, 34, 53) la-vector-access-cpp 23.6455 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 27, 1, 35, 18) la-vector-assignment-cpp 25.0595 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 28, 1, 19, 43) common-progress-cpp 28.728 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 28, 1, 20, 13) common-timing-cpp 30.2908 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 28, 1, 22, 0) fem-multicore-cpp 106.645 "Coloring mesh." (2013, 4, 28, 1, 24, 32) fem-assembly-cpp 151.774 "Assembly for various forms and backends" (2013, 4, 28, 1, 24, 44) fem-convergence-cpp 12.1097 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 28, 1, 24, 46) fem-jit-python 0.00103259 "JIT compilation (in memory cache)" (2013, 4, 28, 1, 29, 50) fem-speedup-cpp 304.72 "Assembly/solve speedup running on 4 processors" (2013, 4, 28, 1, 29, 50) fem-speedup-cpp-assembly 6.41555 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 28, 1, 29, 50) fem-speedup-cpp-solve 2.34267 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 28, 1, 30, 12) mesh-refinement-cpp 19.8524 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 28, 1, 30, 31) mesh-topology-cpp 19.5594 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 28, 1, 30, 56) mesh-unitcube-cpp 24.3569 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 28, 1, 31, 37) mesh-iteration-cpp 39.1565 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 28, 1, 31, 59) function-evaluation-cpp 21.1951 "Evaluations of functions at arbitrary points." (2013, 4, 28, 1, 31, 59) function-evaluation-cpp 21.0698 "Evaluations of functions at arbitrary points." (2013, 4, 28, 1, 32, 3) function-extrapolation-python 4.68604 "*** -------------------------------------------------------------------------" (2013, 4, 28, 1, 32, 3) function-extrapolation-python 2.1135 "*** -------------------------------------------------------------------------" (2013, 4, 28, 1, 32, 27) la-vector-access-cpp 23.447 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 28, 1, 32, 52) la-vector-assignment-cpp 25.0858 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 29, 1, 21, 46) common-progress-cpp 28.6946 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 29, 1, 22, 16) common-timing-cpp 30.0305 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 29, 1, 24, 2) fem-multicore-cpp 106.72 "Coloring mesh." (2013, 4, 29, 1, 26, 35) fem-assembly-cpp 152.258 "Assembly for various forms and backends" (2013, 4, 29, 1, 26, 47) fem-convergence-cpp 12.114 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 29, 1, 26, 49) fem-jit-python 0.00103331 "JIT compilation (in memory cache)" (2013, 4, 29, 1, 31, 55) fem-speedup-cpp 306.045 "Assembly/solve speedup running on 4 processors" (2013, 4, 29, 1, 31, 55) fem-speedup-cpp-assembly 6.5082 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 29, 1, 31, 55) fem-speedup-cpp-solve 2.27672 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 29, 1, 32, 16) mesh-refinement-cpp 19.8818 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 29, 1, 32, 35) mesh-topology-cpp 19.5351 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 29, 1, 33, 0) mesh-unitcube-cpp 24.4207 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 29, 1, 33, 42) mesh-iteration-cpp 39.1558 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 29, 1, 34, 3) function-evaluation-cpp 21.1693 "Evaluations of functions at arbitrary points." (2013, 4, 29, 1, 34, 3) function-evaluation-cpp 21.0766 "Evaluations of functions at arbitrary points." (2013, 4, 29, 1, 34, 7) function-extrapolation-python 4.54451 "*** -------------------------------------------------------------------------" (2013, 4, 29, 1, 34, 7) function-extrapolation-python 2.10333 "*** -------------------------------------------------------------------------" (2013, 4, 29, 1, 34, 31) la-vector-access-cpp 23.4516 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 29, 1, 34, 56) la-vector-assignment-cpp 25.0252 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 4, 30, 1, 25, 46) common-progress-cpp 28.6698 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 4, 30, 1, 26, 17) common-timing-cpp 31.0393 "Timing access and registration of timings (10000000 repetitions)" (2013, 4, 30, 1, 28, 4) fem-multicore-cpp 106.913 "Coloring mesh." (2013, 4, 30, 1, 30, 36) fem-assembly-cpp 152.33 "Assembly for various forms and backends" (2013, 4, 30, 1, 30, 48) fem-convergence-cpp 12.1062 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 4, 30, 1, 30, 54) fem-jit-python 0.00108891 "JIT compilation (in memory cache)" (2013, 4, 30, 1, 36, 2) fem-speedup-cpp 307.453 "Assembly/solve speedup running on 4 processors" (2013, 4, 30, 1, 36, 2) fem-speedup-cpp-assembly 6.53321 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 4, 30, 1, 36, 2) fem-speedup-cpp-solve 2.27357 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 4, 30, 1, 36, 24) mesh-refinement-cpp 19.8983 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 4, 30, 1, 36, 43) mesh-topology-cpp 19.5177 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 4, 30, 1, 37, 8) mesh-unitcube-cpp 24.3351 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 4, 30, 1, 37, 49) mesh-iteration-cpp 39.1636 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 4, 30, 1, 38, 11) function-evaluation-cpp 21.4616 "Evaluations of functions at arbitrary points." (2013, 4, 30, 1, 38, 11) function-evaluation-cpp 21.3271 "Evaluations of functions at arbitrary points." (2013, 4, 30, 1, 38, 16) function-extrapolation-python 4.68595 "*** -------------------------------------------------------------------------" (2013, 4, 30, 1, 38, 16) function-extrapolation-python 2.10592 "*** -------------------------------------------------------------------------" (2013, 4, 30, 1, 38, 39) la-vector-access-cpp 23.4471 "Accessing vector of size 10000000 (100 repetitions)" (2013, 4, 30, 1, 39, 4) la-vector-assignment-cpp 25.0839 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 1, 1, 21, 37) common-progress-cpp 28.7197 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 1, 1, 22, 7) common-timing-cpp 30.488 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 1, 1, 23, 54) fem-multicore-cpp 106.667 "Coloring mesh." (2013, 5, 1, 1, 26, 26) fem-assembly-cpp 152 "Assembly for various forms and backends" (2013, 5, 1, 1, 26, 38) fem-convergence-cpp 12.1005 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 1, 1, 26, 40) fem-jit-python 0.00103481 "JIT compilation (in memory cache)" (2013, 5, 1, 1, 31, 43) fem-speedup-cpp 302.781 "Assembly/solve speedup running on 4 processors" (2013, 5, 1, 1, 31, 43) fem-speedup-cpp-assembly 6.54239 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 1, 1, 31, 43) fem-speedup-cpp-solve 2.35936 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 1, 1, 32, 4) mesh-refinement-cpp 19.8865 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 1, 1, 32, 23) mesh-topology-cpp 19.5457 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 1, 1, 32, 47) mesh-unitcube-cpp 24.4115 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 1, 1, 33, 29) mesh-iteration-cpp 39.1655 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 1, 1, 33, 50) function-evaluation-cpp 21.2094 "Evaluations of functions at arbitrary points." (2013, 5, 1, 1, 33, 50) function-evaluation-cpp 21.1268 "Evaluations of functions at arbitrary points." (2013, 5, 1, 1, 33, 55) function-extrapolation-python 4.33048 "*** -------------------------------------------------------------------------" (2013, 5, 1, 1, 33, 55) function-extrapolation-python 2.11074 "*** -------------------------------------------------------------------------" (2013, 5, 1, 1, 34, 18) la-vector-access-cpp 23.4327 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 1, 1, 34, 44) la-vector-assignment-cpp 25.3839 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 2, 1, 19, 40) common-progress-cpp 28.703 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 2, 1, 20, 10) common-timing-cpp 30.3627 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 2, 1, 21, 57) fem-multicore-cpp 107.058 "Coloring mesh." (2013, 5, 2, 1, 24, 30) fem-assembly-cpp 152.541 "Assembly for various forms and backends" (2013, 5, 2, 1, 24, 42) fem-convergence-cpp 12.1145 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 2, 1, 24, 44) fem-jit-python 0.0010366 "JIT compilation (in memory cache)" (2013, 5, 2, 1, 29, 50) fem-speedup-cpp 305.85 "Assembly/solve speedup running on 4 processors" (2013, 5, 2, 1, 29, 50) fem-speedup-cpp-assembly 6.4985 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 2, 1, 29, 50) fem-speedup-cpp-solve 2.30241 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 2, 1, 30, 12) mesh-refinement-cpp 19.9071 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 2, 1, 30, 32) mesh-topology-cpp 19.6088 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 2, 1, 30, 56) mesh-unitcube-cpp 24.332 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 2, 1, 31, 43) mesh-iteration-cpp 44.1971 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 2, 1, 32, 4) function-evaluation-cpp 21.1703 "Evaluations of functions at arbitrary points." (2013, 5, 2, 1, 32, 4) function-evaluation-cpp 21.0478 "Evaluations of functions at arbitrary points." (2013, 5, 2, 1, 32, 9) function-extrapolation-python 4.57198 "*** -------------------------------------------------------------------------" (2013, 5, 2, 1, 32, 9) function-extrapolation-python 2.10814 "*** -------------------------------------------------------------------------" (2013, 5, 2, 1, 32, 32) la-vector-access-cpp 23.462 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 2, 1, 32, 57) la-vector-assignment-cpp 25.0895 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 3, 1, 21, 2) common-progress-cpp 28.703 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 3, 1, 21, 32) common-timing-cpp 29.5902 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 3, 1, 23, 19) fem-multicore-cpp 106.725 "Coloring mesh." (2013, 5, 3, 1, 25, 51) fem-assembly-cpp 152.213 "Assembly for various forms and backends" (2013, 5, 3, 1, 26, 3) fem-convergence-cpp 12.0994 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 3, 1, 26, 5) fem-jit-python 0.0010428 "JIT compilation (in memory cache)" (2013, 5, 3, 1, 31, 8) fem-speedup-cpp 303.394 "Assembly/solve speedup running on 4 processors" (2013, 5, 3, 1, 31, 8) fem-speedup-cpp-assembly 6.57193 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 3, 1, 31, 8) fem-speedup-cpp-solve 2.22086 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 3, 1, 31, 30) mesh-refinement-cpp 19.8577 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 3, 1, 31, 50) mesh-topology-cpp 19.5836 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 3, 1, 32, 14) mesh-unitcube-cpp 24.3928 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 3, 1, 32, 56) mesh-iteration-cpp 39.1616 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 3, 1, 33, 18) function-evaluation-cpp 21.8032 "Evaluations of functions at arbitrary points." (2013, 5, 3, 1, 33, 18) function-evaluation-cpp 21.6738 "Evaluations of functions at arbitrary points." (2013, 5, 3, 1, 33, 23) function-extrapolation-python 4.70257 "*** -------------------------------------------------------------------------" (2013, 5, 3, 1, 33, 23) function-extrapolation-python 2.11634 "*** -------------------------------------------------------------------------" (2013, 5, 3, 1, 33, 46) la-vector-access-cpp 23.6619 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 3, 1, 34, 11) la-vector-assignment-cpp 25.0234 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 4, 1, 19, 17) common-progress-cpp 28.703 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 4, 1, 19, 48) common-timing-cpp 31.7999 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 4, 1, 21, 35) fem-multicore-cpp 106.937 "Coloring mesh." (2013, 5, 4, 1, 24, 7) fem-assembly-cpp 151.884 "Assembly for various forms and backends" (2013, 5, 4, 1, 24, 19) fem-convergence-cpp 12.0982 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 4, 1, 24, 21) fem-jit-python 0.0010298 "JIT compilation (in memory cache)" (2013, 5, 4, 1, 29, 24) fem-speedup-cpp 302.639 "Assembly/solve speedup running on 4 processors" (2013, 5, 4, 1, 29, 24) fem-speedup-cpp-assembly 6.4109 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 4, 1, 29, 24) fem-speedup-cpp-solve 2.37475 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 4, 1, 29, 45) mesh-refinement-cpp 19.9123 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 4, 1, 30, 5) mesh-topology-cpp 19.6394 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 4, 1, 30, 29) mesh-unitcube-cpp 24.4061 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 4, 1, 31, 18) mesh-iteration-cpp 46.0641 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 4, 1, 31, 39) function-evaluation-cpp 21.1095 "Evaluations of functions at arbitrary points." (2013, 5, 4, 1, 31, 39) function-evaluation-cpp 21.0277 "Evaluations of functions at arbitrary points." (2013, 5, 4, 1, 31, 43) function-extrapolation-python 4.42952 "*** -------------------------------------------------------------------------" (2013, 5, 4, 1, 31, 43) function-extrapolation-python 2.1133 "*** -------------------------------------------------------------------------" (2013, 5, 4, 1, 32, 7) la-vector-access-cpp 23.3996 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 4, 1, 32, 34) la-vector-assignment-cpp 27.5743 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 5, 1, 21, 54) common-progress-cpp 28.6863 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 5, 1, 22, 24) common-timing-cpp 30.3428 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 5, 1, 24, 11) fem-multicore-cpp 106.663 "Coloring mesh." (2013, 5, 5, 1, 26, 44) fem-assembly-cpp 153.035 "Assembly for various forms and backends" (2013, 5, 5, 1, 26, 56) fem-convergence-cpp 12.0975 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 5, 1, 26, 58) fem-jit-python 0.00102999 "JIT compilation (in memory cache)" (2013, 5, 5, 1, 32, 4) fem-speedup-cpp 305.597 "Assembly/solve speedup running on 4 processors" (2013, 5, 5, 1, 32, 4) fem-speedup-cpp-assembly 6.56843 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 5, 1, 32, 4) fem-speedup-cpp-solve 2.31122 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 5, 1, 32, 24) mesh-refinement-cpp 19.8644 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 5, 1, 32, 44) mesh-topology-cpp 19.553 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 5, 1, 33, 8) mesh-unitcube-cpp 24.3934 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 5, 1, 33, 50) mesh-iteration-cpp 39.1597 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 5, 1, 34, 11) function-evaluation-cpp 21.1446 "Evaluations of functions at arbitrary points." (2013, 5, 5, 1, 34, 11) function-evaluation-cpp 21.0471 "Evaluations of functions at arbitrary points." (2013, 5, 5, 1, 34, 16) function-extrapolation-python 4.55283 "*** -------------------------------------------------------------------------" (2013, 5, 5, 1, 34, 16) function-extrapolation-python 2.12224 "*** -------------------------------------------------------------------------" (2013, 5, 5, 1, 34, 39) la-vector-access-cpp 23.4574 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 5, 1, 35, 4) la-vector-assignment-cpp 25.087 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 6, 1, 20, 4) common-progress-cpp 28.703 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 6, 1, 20, 35) common-timing-cpp 30.3224 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 6, 1, 22, 22) fem-multicore-cpp 106.92 "Coloring mesh." (2013, 5, 6, 1, 24, 53) fem-assembly-cpp 151.941 "Assembly for various forms and backends" (2013, 5, 6, 1, 25, 6) fem-convergence-cpp 12.0977 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 6, 1, 25, 7) fem-jit-python 0.00104599 "JIT compilation (in memory cache)" (2013, 5, 6, 1, 30, 13) fem-speedup-cpp 306.103 "Assembly/solve speedup running on 4 processors" (2013, 5, 6, 1, 30, 13) fem-speedup-cpp-assembly 6.455 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 6, 1, 30, 13) fem-speedup-cpp-solve 2.3164 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 6, 1, 30, 35) mesh-refinement-cpp 19.8456 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 6, 1, 30, 55) mesh-topology-cpp 19.601 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 6, 1, 31, 19) mesh-unitcube-cpp 24.4714 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 6, 1, 32, 1) mesh-iteration-cpp 39.1292 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 6, 1, 32, 22) function-evaluation-cpp 21.1705 "Evaluations of functions at arbitrary points." (2013, 5, 6, 1, 32, 22) function-evaluation-cpp 21.0599 "Evaluations of functions at arbitrary points." (2013, 5, 6, 1, 32, 27) function-extrapolation-python 4.59439 "*** -------------------------------------------------------------------------" (2013, 5, 6, 1, 32, 27) function-extrapolation-python 2.08691 "*** -------------------------------------------------------------------------" (2013, 5, 6, 1, 32, 50) la-vector-access-cpp 23.4394 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 6, 1, 33, 15) la-vector-assignment-cpp 25.0899 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 7, 1, 18, 16) common-progress-cpp 28.6531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 7, 1, 18, 46) common-timing-cpp 29.9226 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 7, 1, 20, 33) fem-multicore-cpp 106.748 "Coloring mesh." (2013, 5, 7, 1, 23, 5) fem-assembly-cpp 152.267 "Assembly for various forms and backends" (2013, 5, 7, 1, 23, 17) fem-convergence-cpp 12.1049 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 7, 1, 23, 19) fem-jit-python 0.00104439 "JIT compilation (in memory cache)" (2013, 5, 7, 1, 28, 24) fem-speedup-cpp 305.046 "Assembly/solve speedup running on 4 processors" (2013, 5, 7, 1, 28, 24) fem-speedup-cpp-assembly 6.45969 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 7, 1, 28, 24) fem-speedup-cpp-solve 2.23675 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 7, 1, 28, 46) mesh-refinement-cpp 19.876 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 7, 1, 29, 6) mesh-topology-cpp 19.5867 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 7, 1, 29, 30) mesh-unitcube-cpp 24.3237 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 7, 1, 30, 12) mesh-iteration-cpp 39.1545 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 7, 1, 30, 33) function-evaluation-cpp 21.2371 "Evaluations of functions at arbitrary points." (2013, 5, 7, 1, 30, 33) function-evaluation-cpp 21.1068 "Evaluations of functions at arbitrary points." (2013, 5, 7, 1, 30, 38) function-extrapolation-python 4.56615 "*** -------------------------------------------------------------------------" (2013, 5, 7, 1, 30, 38) function-extrapolation-python 2.11616 "*** -------------------------------------------------------------------------" (2013, 5, 7, 1, 31, 1) la-vector-access-cpp 23.4819 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 7, 1, 31, 26) la-vector-assignment-cpp 25.0778 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 8, 1, 18, 44) common-progress-cpp 28.6864 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 8, 1, 19, 14) common-timing-cpp 29.8535 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 8, 1, 21, 1) fem-multicore-cpp 107.235 "Coloring mesh." (2013, 5, 8, 1, 23, 33) fem-assembly-cpp 152.249 "Assembly for various forms and backends" (2013, 5, 8, 1, 23, 45) fem-convergence-cpp 12.1019 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 8, 1, 23, 47) fem-jit-python 0.00104451 "JIT compilation (in memory cache)" (2013, 5, 8, 1, 28, 51) fem-speedup-cpp 304.416 "Assembly/solve speedup running on 4 processors" (2013, 5, 8, 1, 28, 51) fem-speedup-cpp-assembly 6.5183 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 8, 1, 28, 51) fem-speedup-cpp-solve 2.31567 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 8, 1, 29, 12) mesh-refinement-cpp 19.8711 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 8, 1, 29, 32) mesh-topology-cpp 19.499 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 8, 1, 29, 56) mesh-unitcube-cpp 24.5936 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 8, 1, 30, 38) mesh-iteration-cpp 39.1602 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 8, 1, 30, 59) function-evaluation-cpp 21.3978 "Evaluations of functions at arbitrary points." (2013, 5, 8, 1, 30, 59) function-evaluation-cpp 21.2933 "Evaluations of functions at arbitrary points." (2013, 5, 8, 1, 31, 16) function-extrapolation-python 16.7852 "*** -------------------------------------------------------------------------" (2013, 5, 8, 1, 31, 16) function-extrapolation-python 2.13427 "*** -------------------------------------------------------------------------" (2013, 5, 8, 1, 31, 41) la-vector-access-cpp 24.9319 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 8, 1, 32, 6) la-vector-assignment-cpp 25.066 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 9, 1, 21, 1) common-progress-cpp 28.7281 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 9, 1, 21, 31) common-timing-cpp 30.2288 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 9, 1, 23, 18) fem-multicore-cpp 106.799 "Coloring mesh." (2013, 5, 9, 1, 25, 46) fem-assembly-cpp 147.739 "Assembly for various forms and backends" (2013, 5, 9, 1, 25, 58) fem-convergence-cpp 12.1154 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 9, 1, 26, 0) fem-jit-python 0.00103281 "JIT compilation (in memory cache)" (2013, 5, 9, 1, 31, 4) fem-speedup-cpp 303.736 "Assembly/solve speedup running on 4 processors" (2013, 5, 9, 1, 31, 4) fem-speedup-cpp-assembly 6.43074 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 9, 1, 31, 4) fem-speedup-cpp-solve 2.33124 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 9, 1, 31, 24) mesh-refinement-cpp 19.8871 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 9, 1, 31, 44) mesh-topology-cpp 19.3851 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 9, 1, 32, 8) mesh-unitcube-cpp 24.3987 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 9, 1, 32, 57) mesh-iteration-cpp 46.0594 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 9, 1, 33, 18) function-evaluation-cpp 21.1426 "Evaluations of functions at arbitrary points." (2013, 5, 9, 1, 33, 18) function-evaluation-cpp 21.0643 "Evaluations of functions at arbitrary points." (2013, 5, 9, 1, 33, 22) function-extrapolation-python 4.54238 "*** -------------------------------------------------------------------------" (2013, 5, 9, 1, 33, 22) function-extrapolation-python 2.11416 "*** -------------------------------------------------------------------------" (2013, 5, 9, 1, 33, 46) la-vector-access-cpp 23.4261 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 9, 1, 34, 12) la-vector-assignment-cpp 26.4632 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 10, 1, 20, 11) common-progress-cpp 29.0283 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 10, 1, 20, 43) common-timing-cpp 31.4199 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 10, 1, 22, 30) fem-multicore-cpp 107.097 "Coloring mesh." (2013, 5, 10, 1, 24, 57) fem-assembly-cpp 147.533 "Assembly for various forms and backends" (2013, 5, 10, 1, 25, 9) fem-convergence-cpp 12.1081 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 10, 1, 25, 11) fem-jit-python 0.0010258 "JIT compilation (in memory cache)" (2013, 5, 10, 1, 30, 16) fem-speedup-cpp 304.707 "Assembly/solve speedup running on 4 processors" (2013, 5, 10, 1, 30, 16) fem-speedup-cpp-assembly 6.50599 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 10, 1, 30, 16) fem-speedup-cpp-solve 2.33266 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 10, 1, 30, 37) mesh-refinement-cpp 19.8851 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 10, 1, 30, 56) mesh-topology-cpp 19.4559 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 10, 1, 31, 21) mesh-unitcube-cpp 24.3756 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 10, 1, 32, 3) mesh-iteration-cpp 39.1606 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 10, 1, 32, 24) function-evaluation-cpp 21.1395 "Evaluations of functions at arbitrary points." (2013, 5, 10, 1, 32, 24) function-evaluation-cpp 21.0513 "Evaluations of functions at arbitrary points." (2013, 5, 10, 1, 32, 28) function-extrapolation-python 4.56953 "*** -------------------------------------------------------------------------" (2013, 5, 10, 1, 32, 28) function-extrapolation-python 2.10541 "*** -------------------------------------------------------------------------" (2013, 5, 10, 1, 32, 53) la-vector-access-cpp 24.9269 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 10, 1, 33, 18) la-vector-assignment-cpp 25.0606 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 11, 1, 21, 30) common-progress-cpp 28.7779 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 11, 1, 22, 1) common-timing-cpp 30.3501 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 11, 1, 23, 48) fem-multicore-cpp 107.454 "Coloring mesh." (2013, 5, 11, 1, 26, 18) fem-assembly-cpp 150.228 "Assembly for various forms and backends" (2013, 5, 11, 1, 26, 30) fem-convergence-cpp 12.1122 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 11, 1, 26, 32) fem-jit-python 0.00103781 "JIT compilation (in memory cache)" (2013, 5, 11, 1, 31, 39) fem-speedup-cpp 306.255 "Assembly/solve speedup running on 4 processors" (2013, 5, 11, 1, 31, 39) fem-speedup-cpp-assembly 6.66266 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 11, 1, 31, 39) fem-speedup-cpp-solve 2.318 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 11, 1, 32, 0) mesh-refinement-cpp 19.8429 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 11, 1, 32, 20) mesh-topology-cpp 19.2927 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 11, 1, 32, 44) mesh-unitcube-cpp 24.5239 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 11, 1, 33, 22) mesh-iteration-cpp 35.48 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 11, 1, 33, 44) function-evaluation-cpp 21.2372 "Evaluations of functions at arbitrary points." (2013, 5, 11, 1, 33, 44) function-evaluation-cpp 21.1171 "Evaluations of functions at arbitrary points." (2013, 5, 11, 1, 33, 48) function-extrapolation-python 4.48031 "*** -------------------------------------------------------------------------" (2013, 5, 11, 1, 33, 48) function-extrapolation-python 2.09146 "*** -------------------------------------------------------------------------" (2013, 5, 11, 1, 34, 13) la-vector-access-cpp 24.9474 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 11, 1, 34, 38) la-vector-assignment-cpp 25.0796 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 12, 1, 20, 34) common-progress-cpp 28.728 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 12, 1, 21, 5) common-timing-cpp 31.223 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 12, 1, 22, 53) fem-multicore-cpp 108.313 "Coloring mesh." (2013, 5, 12, 1, 25, 24) fem-assembly-cpp 151.04 "Assembly for various forms and backends" (2013, 5, 12, 1, 25, 37) fem-convergence-cpp 12.1588 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 12, 1, 25, 38) fem-jit-python 0.00104308 "JIT compilation (in memory cache)" (2013, 5, 12, 1, 30, 45) fem-speedup-cpp 306.497 "Assembly/solve speedup running on 4 processors" (2013, 5, 12, 1, 30, 45) fem-speedup-cpp-assembly 6.58497 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 12, 1, 30, 45) fem-speedup-cpp-solve 2.32124 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 12, 1, 31, 7) mesh-refinement-cpp 19.967 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 12, 1, 31, 27) mesh-topology-cpp 19.464 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 12, 1, 31, 51) mesh-unitcube-cpp 24.2139 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 12, 1, 32, 33) mesh-iteration-cpp 39.1528 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 12, 1, 32, 55) function-evaluation-cpp 22.6945 "Evaluations of functions at arbitrary points." (2013, 5, 12, 1, 32, 55) function-evaluation-cpp 22.568 "Evaluations of functions at arbitrary points." (2013, 5, 12, 1, 33, 0) function-extrapolation-python 4.52773 "*** -------------------------------------------------------------------------" (2013, 5, 12, 1, 33, 0) function-extrapolation-python 2.10171 "*** -------------------------------------------------------------------------" (2013, 5, 12, 1, 33, 25) la-vector-access-cpp 24.9897 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 12, 1, 33, 50) la-vector-assignment-cpp 25.0889 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 13, 1, 20, 41) common-progress-cpp 28.7446 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 13, 1, 21, 12) common-timing-cpp 30.9912 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 13, 1, 23, 0) fem-multicore-cpp 108.233 "Coloring mesh." (2013, 5, 13, 1, 25, 31) fem-assembly-cpp 151.069 "Assembly for various forms and backends" (2013, 5, 13, 1, 25, 43) fem-convergence-cpp 12.1688 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 13, 1, 25, 45) fem-jit-python 0.00102742 "JIT compilation (in memory cache)" (2013, 5, 13, 1, 30, 49) fem-speedup-cpp 304.105 "Assembly/solve speedup running on 4 processors" (2013, 5, 13, 1, 30, 49) fem-speedup-cpp-assembly 6.54235 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 13, 1, 30, 49) fem-speedup-cpp-solve 2.33474 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 13, 1, 31, 10) mesh-refinement-cpp 19.9462 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 13, 1, 31, 30) mesh-topology-cpp 19.4084 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 13, 1, 31, 54) mesh-unitcube-cpp 24.257 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 13, 1, 32, 36) mesh-iteration-cpp 39.1609 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 13, 1, 32, 57) function-evaluation-cpp 21.1819 "Evaluations of functions at arbitrary points." (2013, 5, 13, 1, 32, 57) function-evaluation-cpp 21.1019 "Evaluations of functions at arbitrary points." (2013, 5, 13, 1, 33, 1) function-extrapolation-python 4.42833 "*** -------------------------------------------------------------------------" (2013, 5, 13, 1, 33, 1) function-extrapolation-python 2.09207 "*** -------------------------------------------------------------------------" (2013, 5, 13, 1, 33, 24) la-vector-access-cpp 22.9352 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 13, 1, 33, 52) la-vector-assignment-cpp 27.5797 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 14, 1, 24, 29) common-progress-cpp 32.7661 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 14, 1, 24, 58) common-timing-cpp 29.1928 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 14, 1, 26, 46) fem-multicore-cpp 107.239 "Coloring mesh." (2013, 5, 14, 1, 29, 16) fem-assembly-cpp 149.901 "Assembly for various forms and backends" (2013, 5, 14, 1, 29, 28) fem-convergence-cpp 12.0958 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 14, 1, 29, 30) fem-jit-python 0.00102239 "JIT compilation (in memory cache)" (2013, 5, 14, 1, 34, 36) fem-speedup-cpp 306.824 "Assembly/solve speedup running on 4 processors" (2013, 5, 14, 1, 34, 36) fem-speedup-cpp-assembly 6.60443 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 14, 1, 34, 36) fem-speedup-cpp-solve 2.29173 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 14, 1, 34, 59) mesh-refinement-cpp 20.0175 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 14, 1, 35, 18) mesh-topology-cpp 19.3419 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 14, 1, 35, 42) mesh-unitcube-cpp 24.0576 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 14, 1, 36, 24) mesh-iteration-cpp 39.1568 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 14, 1, 36, 45) function-evaluation-cpp 21.3955 "Evaluations of functions at arbitrary points." (2013, 5, 14, 1, 36, 45) function-evaluation-cpp 21.2643 "Evaluations of functions at arbitrary points." (2013, 5, 14, 1, 36, 50) function-extrapolation-python 4.50211 "*** -------------------------------------------------------------------------" (2013, 5, 14, 1, 36, 50) function-extrapolation-python 2.11037 "*** -------------------------------------------------------------------------" (2013, 5, 14, 1, 37, 13) la-vector-access-cpp 22.9491 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 14, 1, 37, 38) la-vector-assignment-cpp 25.0906 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 15, 1, 19, 10) common-progress-cpp 29.1026 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 15, 1, 19, 41) common-timing-cpp 30.4436 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 15, 1, 21, 28) fem-multicore-cpp 106.814 "Coloring mesh." (2013, 5, 15, 1, 23, 59) fem-assembly-cpp 150.894 "Assembly for various forms and backends" (2013, 5, 15, 1, 24, 11) fem-convergence-cpp 12.0981 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 15, 1, 24, 12) fem-jit-python 0.00103028 "JIT compilation (in memory cache)" (2013, 5, 15, 1, 29, 21) fem-speedup-cpp 308.904 "Assembly/solve speedup running on 4 processors" (2013, 5, 15, 1, 29, 21) fem-speedup-cpp-assembly 6.5603 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 15, 1, 29, 21) fem-speedup-cpp-solve 2.24798 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 15, 1, 29, 43) mesh-refinement-cpp 19.894 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 15, 1, 30, 3) mesh-topology-cpp 19.3737 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 15, 1, 30, 27) mesh-unitcube-cpp 24.0552 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 15, 1, 31, 9) mesh-iteration-cpp 39.1598 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 15, 1, 31, 30) function-evaluation-cpp 21.2177 "Evaluations of functions at arbitrary points." (2013, 5, 15, 1, 31, 30) function-evaluation-cpp 21.1229 "Evaluations of functions at arbitrary points." (2013, 5, 15, 1, 31, 34) function-extrapolation-python 4.52671 "*** -------------------------------------------------------------------------" (2013, 5, 15, 1, 31, 34) function-extrapolation-python 2.10369 "*** -------------------------------------------------------------------------" (2013, 5, 15, 1, 31, 59) la-vector-access-cpp 24.9479 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 15, 1, 32, 25) la-vector-assignment-cpp 25.3165 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 16, 1, 20, 51) common-progress-cpp 28.8445 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 16, 1, 21, 22) common-timing-cpp 30.1864 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 16, 1, 23, 9) fem-multicore-cpp 106.955 "Coloring mesh." (2013, 5, 16, 1, 25, 40) fem-assembly-cpp 151.816 "Assembly for various forms and backends" (2013, 5, 16, 1, 25, 53) fem-convergence-cpp 12.1272 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 16, 1, 25, 54) fem-jit-python 0.00103111 "JIT compilation (in memory cache)" (2013, 5, 16, 1, 30, 58) fem-speedup-cpp 304.063 "Assembly/solve speedup running on 4 processors" (2013, 5, 16, 1, 30, 58) fem-speedup-cpp-assembly 6.52952 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 16, 1, 30, 58) fem-speedup-cpp-solve 2.33616 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 16, 1, 31, 21) mesh-refinement-cpp 20.122 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 16, 1, 31, 40) mesh-topology-cpp 19.4495 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 16, 1, 32, 4) mesh-unitcube-cpp 23.958 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 16, 1, 32, 46) mesh-iteration-cpp 39.1588 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 16, 1, 33, 7) function-evaluation-cpp 21.1297 "Evaluations of functions at arbitrary points." (2013, 5, 16, 1, 33, 7) function-evaluation-cpp 21.0501 "Evaluations of functions at arbitrary points." (2013, 5, 16, 1, 33, 11) function-extrapolation-python 4.57905 "*** -------------------------------------------------------------------------" (2013, 5, 16, 1, 33, 11) function-extrapolation-python 2.14267 "*** -------------------------------------------------------------------------" (2013, 5, 16, 1, 33, 35) la-vector-access-cpp 23.4297 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 16, 1, 34, 0) la-vector-assignment-cpp 25.0683 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 17, 1, 19, 35) common-progress-cpp 28.9361 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 17, 1, 20, 6) common-timing-cpp 30.6966 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 17, 1, 21, 53) fem-multicore-cpp 107.309 "Coloring mesh." (2013, 5, 17, 1, 24, 25) fem-assembly-cpp 151.509 "Assembly for various forms and backends" (2013, 5, 17, 1, 24, 37) fem-convergence-cpp 12.1082 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 17, 1, 24, 39) fem-jit-python 0.00105009 "JIT compilation (in memory cache)" (2013, 5, 17, 1, 29, 47) fem-speedup-cpp 307.57 "Assembly/solve speedup running on 4 processors" (2013, 5, 17, 1, 29, 47) fem-speedup-cpp-assembly 6.55186 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 17, 1, 29, 47) fem-speedup-cpp-solve 2.29484 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 17, 1, 30, 9) mesh-refinement-cpp 20.0431 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 17, 1, 30, 28) mesh-topology-cpp 19.4711 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 17, 1, 30, 52) mesh-unitcube-cpp 24.0535 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 17, 1, 31, 34) mesh-iteration-cpp 39.1519 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 17, 1, 31, 55) function-evaluation-cpp 21.2443 "Evaluations of functions at arbitrary points." (2013, 5, 17, 1, 31, 55) function-evaluation-cpp 21.1529 "Evaluations of functions at arbitrary points." (2013, 5, 17, 1, 32, 0) function-extrapolation-python 4.52667 "*** -------------------------------------------------------------------------" (2013, 5, 17, 1, 32, 0) function-extrapolation-python 2.09405 "*** -------------------------------------------------------------------------" (2013, 5, 17, 1, 32, 25) la-vector-access-cpp 24.9493 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 17, 1, 32, 51) la-vector-assignment-cpp 26.5935 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 18, 1, 21, 52) common-progress-cpp 28.8361 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 18, 1, 22, 22) common-timing-cpp 29.8164 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 18, 1, 24, 8) fem-multicore-cpp 106.682 "Coloring mesh." (2013, 5, 18, 1, 26, 38) fem-assembly-cpp 150.036 "Assembly for various forms and backends" (2013, 5, 18, 1, 26, 50) fem-convergence-cpp 12.1088 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 18, 1, 26, 52) fem-jit-python 0.00104172 "JIT compilation (in memory cache)" (2013, 5, 18, 1, 31, 57) fem-speedup-cpp 304.491 "Assembly/solve speedup running on 4 processors" (2013, 5, 18, 1, 31, 57) fem-speedup-cpp-assembly 6.5882 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 18, 1, 31, 57) fem-speedup-cpp-solve 2.32749 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 18, 1, 32, 18) mesh-refinement-cpp 20.0809 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 18, 1, 32, 37) mesh-topology-cpp 19.4287 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 18, 1, 33, 1) mesh-unitcube-cpp 23.9386 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 18, 1, 33, 43) mesh-iteration-cpp 39.1571 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 18, 1, 34, 4) function-evaluation-cpp 21.4158 "Evaluations of functions at arbitrary points." (2013, 5, 18, 1, 34, 4) function-evaluation-cpp 21.3358 "Evaluations of functions at arbitrary points." (2013, 5, 18, 1, 34, 9) function-extrapolation-python 4.44161 "*** -------------------------------------------------------------------------" (2013, 5, 18, 1, 34, 9) function-extrapolation-python 2.12951 "*** -------------------------------------------------------------------------" (2013, 5, 18, 1, 34, 33) la-vector-access-cpp 24.9375 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 18, 1, 34, 59) la-vector-assignment-cpp 25.0731 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 19, 1, 18, 39) common-progress-cpp 28.8946 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 19, 1, 19, 9) common-timing-cpp 30.0161 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 19, 1, 20, 56) fem-multicore-cpp 106.846 "Coloring mesh." (2013, 5, 19, 1, 23, 26) fem-assembly-cpp 149.82 "Assembly for various forms and backends" (2013, 5, 19, 1, 23, 38) fem-convergence-cpp 12.1073 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 19, 1, 23, 40) fem-jit-python 0.00102971 "JIT compilation (in memory cache)" (2013, 5, 19, 1, 28, 44) fem-speedup-cpp 304.363 "Assembly/solve speedup running on 4 processors" (2013, 5, 19, 1, 28, 44) fem-speedup-cpp-assembly 6.41508 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 19, 1, 28, 44) fem-speedup-cpp-solve 2.34097 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 19, 1, 29, 5) mesh-refinement-cpp 20.1861 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 19, 1, 29, 25) mesh-topology-cpp 19.5613 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 19, 1, 29, 49) mesh-unitcube-cpp 23.9706 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 19, 1, 30, 30) mesh-iteration-cpp 39.1538 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 19, 1, 30, 52) function-evaluation-cpp 21.2196 "Evaluations of functions at arbitrary points." (2013, 5, 19, 1, 30, 52) function-evaluation-cpp 21.0766 "Evaluations of functions at arbitrary points." (2013, 5, 19, 1, 30, 56) function-extrapolation-python 4.52784 "*** -------------------------------------------------------------------------" (2013, 5, 19, 1, 30, 56) function-extrapolation-python 2.14135 "*** -------------------------------------------------------------------------" (2013, 5, 19, 1, 31, 20) la-vector-access-cpp 23.4278 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 19, 1, 31, 47) la-vector-assignment-cpp 27.0797 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 20, 1, 22, 21) common-progress-cpp 32.6912 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 20, 1, 22, 52) common-timing-cpp 30.752 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 20, 1, 24, 39) fem-multicore-cpp 106.931 "Coloring mesh." (2013, 5, 20, 1, 27, 9) fem-assembly-cpp 150.006 "Assembly for various forms and backends" (2013, 5, 20, 1, 27, 21) fem-convergence-cpp 12.0994 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 20, 1, 27, 23) fem-jit-python 0.0010319 "JIT compilation (in memory cache)" (2013, 5, 20, 1, 32, 28) fem-speedup-cpp 305.075 "Assembly/solve speedup running on 4 processors" (2013, 5, 20, 1, 32, 28) fem-speedup-cpp-assembly 6.53101 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 20, 1, 32, 28) fem-speedup-cpp-solve 2.31491 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 20, 1, 32, 50) mesh-refinement-cpp 20.094 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 20, 1, 33, 9) mesh-topology-cpp 19.4123 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 20, 1, 33, 33) mesh-unitcube-cpp 23.9109 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 20, 1, 34, 15) mesh-iteration-cpp 39.1567 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 20, 1, 34, 36) function-evaluation-cpp 21.1334 "Evaluations of functions at arbitrary points." (2013, 5, 20, 1, 34, 36) function-evaluation-cpp 21.051 "Evaluations of functions at arbitrary points." (2013, 5, 20, 1, 34, 40) function-extrapolation-python 4.57326 "*** -------------------------------------------------------------------------" (2013, 5, 20, 1, 34, 40) function-extrapolation-python 2.13656 "*** -------------------------------------------------------------------------" (2013, 5, 20, 1, 35, 5) la-vector-access-cpp 24.946 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 20, 1, 35, 30) la-vector-assignment-cpp 25.0624 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 21, 1, 20, 10) common-progress-cpp 28.8362 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 21, 1, 20, 40) common-timing-cpp 29.9423 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 21, 1, 22, 27) fem-multicore-cpp 107.041 "Coloring mesh." (2013, 5, 21, 1, 24, 57) fem-assembly-cpp 150.408 "Assembly for various forms and backends" (2013, 5, 21, 1, 25, 9) fem-convergence-cpp 12.157 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 21, 1, 25, 11) fem-jit-python 0.00105901 "JIT compilation (in memory cache)" (2013, 5, 21, 1, 30, 18) fem-speedup-cpp 306.65 "Assembly/solve speedup running on 4 processors" (2013, 5, 21, 1, 30, 18) fem-speedup-cpp-assembly 6.57408 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 21, 1, 30, 18) fem-speedup-cpp-solve 2.29544 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 21, 1, 30, 39) mesh-refinement-cpp 20.0847 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 21, 1, 30, 59) mesh-topology-cpp 19.4154 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 21, 1, 31, 23) mesh-unitcube-cpp 23.9815 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 21, 1, 32, 4) mesh-iteration-cpp 39.1527 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 21, 1, 32, 26) function-evaluation-cpp 21.1544 "Evaluations of functions at arbitrary points." (2013, 5, 21, 1, 32, 26) function-evaluation-cpp 21.0314 "Evaluations of functions at arbitrary points." (2013, 5, 21, 1, 32, 30) function-extrapolation-python 4.61956 "*** -------------------------------------------------------------------------" (2013, 5, 21, 1, 32, 30) function-extrapolation-python 2.11824 "*** -------------------------------------------------------------------------" (2013, 5, 21, 1, 32, 55) la-vector-access-cpp 24.9548 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 21, 1, 33, 20) la-vector-assignment-cpp 25.089 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 22, 1, 20, 42) common-progress-cpp 28.7197 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 22, 1, 21, 12) common-timing-cpp 29.7857 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 22, 1, 22, 59) fem-multicore-cpp 106.819 "Coloring mesh." (2013, 5, 22, 1, 25, 30) fem-assembly-cpp 150.91 "Assembly for various forms and backends" (2013, 5, 22, 1, 25, 42) fem-convergence-cpp 12.1158 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 22, 1, 25, 44) fem-jit-python 0.00103281 "JIT compilation (in memory cache)" (2013, 5, 22, 1, 30, 49) fem-speedup-cpp 304.746 "Assembly/solve speedup running on 4 processors" (2013, 5, 22, 1, 30, 49) fem-speedup-cpp-assembly 6.6097 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 22, 1, 30, 49) fem-speedup-cpp-solve 2.32667 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 22, 1, 31, 9) mesh-refinement-cpp 20.0798 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 22, 1, 31, 29) mesh-topology-cpp 19.4705 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 22, 1, 31, 53) mesh-unitcube-cpp 24.0869 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 22, 1, 32, 35) mesh-iteration-cpp 39.1569 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 22, 1, 32, 56) function-evaluation-cpp 21.1544 "Evaluations of functions at arbitrary points." (2013, 5, 22, 1, 32, 56) function-evaluation-cpp 21.0712 "Evaluations of functions at arbitrary points." (2013, 5, 22, 1, 33, 0) function-extrapolation-python 4.51483 "*** -------------------------------------------------------------------------" (2013, 5, 22, 1, 33, 0) function-extrapolation-python 2.12681 "*** -------------------------------------------------------------------------" (2013, 5, 22, 1, 33, 24) la-vector-access-cpp 23.4383 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 22, 1, 33, 51) la-vector-assignment-cpp 27.1967 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 23, 1, 22, 18) common-progress-cpp 28.9694 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 23, 1, 22, 48) common-timing-cpp 30.7527 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 23, 1, 24, 36) fem-multicore-cpp 107.227 "Coloring mesh." (2013, 5, 23, 1, 27, 6) fem-assembly-cpp 150.524 "Assembly for various forms and backends" (2013, 5, 23, 1, 27, 18) fem-convergence-cpp 12.1274 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 23, 1, 27, 20) fem-jit-python 0.00103579 "JIT compilation (in memory cache)" (2013, 5, 23, 1, 32, 29) fem-speedup-cpp 309.053 "Assembly/solve speedup running on 4 processors" (2013, 5, 23, 1, 32, 29) fem-speedup-cpp-assembly 6.51775 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 23, 1, 32, 29) fem-speedup-cpp-solve 2.23861 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 23, 1, 32, 51) mesh-refinement-cpp 20.1012 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 23, 1, 33, 11) mesh-topology-cpp 19.4229 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 23, 1, 33, 35) mesh-unitcube-cpp 23.9371 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 23, 1, 34, 26) mesh-iteration-cpp 49.2226 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 23, 1, 34, 48) function-evaluation-cpp 21.3877 "Evaluations of functions at arbitrary points." (2013, 5, 23, 1, 34, 48) function-evaluation-cpp 21.2816 "Evaluations of functions at arbitrary points." (2013, 5, 23, 1, 34, 52) function-extrapolation-python 4.51764 "*** -------------------------------------------------------------------------" (2013, 5, 23, 1, 34, 52) function-extrapolation-python 2.08921 "*** -------------------------------------------------------------------------" (2013, 5, 23, 1, 35, 16) la-vector-access-cpp 23.4442 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 23, 1, 35, 41) la-vector-assignment-cpp 25.036 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 24, 1, 21, 35) common-progress-cpp 28.9109 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 24, 1, 22, 6) common-timing-cpp 30.8263 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 24, 1, 23, 52) fem-multicore-cpp 106.961 "Coloring mesh." (2013, 5, 24, 1, 26, 22) fem-assembly-cpp 149.883 "Assembly for various forms and backends" (2013, 5, 24, 1, 26, 34) fem-convergence-cpp 12.1327 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 24, 1, 26, 36) fem-jit-python 0.00103981 "JIT compilation (in memory cache)" (2013, 5, 24, 1, 31, 40) fem-speedup-cpp 304.123 "Assembly/solve speedup running on 4 processors" (2013, 5, 24, 1, 31, 40) fem-speedup-cpp-assembly 6.52779 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 24, 1, 31, 40) fem-speedup-cpp-solve 2.34078 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 24, 1, 32, 2) mesh-refinement-cpp 20.1018 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 24, 1, 32, 21) mesh-topology-cpp 19.3792 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 24, 1, 32, 45) mesh-unitcube-cpp 23.9445 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 24, 1, 33, 27) mesh-iteration-cpp 39.1624 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 24, 1, 33, 48) function-evaluation-cpp 21.1176 "Evaluations of functions at arbitrary points." (2013, 5, 24, 1, 33, 48) function-evaluation-cpp 21.0336 "Evaluations of functions at arbitrary points." (2013, 5, 24, 1, 33, 52) function-extrapolation-python 4.62782 "*** -------------------------------------------------------------------------" (2013, 5, 24, 1, 33, 52) function-extrapolation-python 2.16172 "*** -------------------------------------------------------------------------" (2013, 5, 24, 1, 34, 17) la-vector-access-cpp 24.9448 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 24, 1, 34, 42) la-vector-assignment-cpp 24.9165 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 25, 1, 20, 41) common-progress-cpp 28.7695 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 25, 1, 21, 12) common-timing-cpp 30.9639 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 25, 1, 22, 59) fem-multicore-cpp 107.133 "Coloring mesh." (2013, 5, 25, 1, 25, 30) fem-assembly-cpp 150.222 "Assembly for various forms and backends" (2013, 5, 25, 1, 25, 42) fem-convergence-cpp 12.128 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 25, 1, 25, 44) fem-jit-python 0.0010354 "JIT compilation (in memory cache)" (2013, 5, 25, 1, 30, 51) fem-speedup-cpp 307.203 "Assembly/solve speedup running on 4 processors" (2013, 5, 25, 1, 30, 51) fem-speedup-cpp-assembly 6.57998 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 25, 1, 30, 51) fem-speedup-cpp-solve 2.26721 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 25, 1, 31, 13) mesh-refinement-cpp 19.9634 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 25, 1, 31, 32) mesh-topology-cpp 19.3921 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 25, 1, 31, 56) mesh-unitcube-cpp 23.9344 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 25, 1, 32, 38) mesh-iteration-cpp 39.1571 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 25, 1, 32, 59) function-evaluation-cpp 21.2128 "Evaluations of functions at arbitrary points." (2013, 5, 25, 1, 32, 59) function-evaluation-cpp 21.0869 "Evaluations of functions at arbitrary points." (2013, 5, 25, 1, 33, 4) function-extrapolation-python 4.59302 "*** -------------------------------------------------------------------------" (2013, 5, 25, 1, 33, 4) function-extrapolation-python 2.09164 "*** -------------------------------------------------------------------------" (2013, 5, 25, 1, 33, 27) la-vector-access-cpp 23.444 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 25, 1, 33, 55) la-vector-assignment-cpp 27.5433 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 26, 1, 20, 12) common-progress-cpp 32.5165 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 26, 1, 20, 43) common-timing-cpp 31.43 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 26, 1, 22, 31) fem-multicore-cpp 107.112 "Coloring mesh." (2013, 5, 26, 1, 25, 0) fem-assembly-cpp 149.708 "Assembly for various forms and backends" (2013, 5, 26, 1, 25, 12) fem-convergence-cpp 12.1366 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 26, 1, 25, 14) fem-jit-python 0.00103519 "JIT compilation (in memory cache)" (2013, 5, 26, 1, 30, 21) fem-speedup-cpp 306.286 "Assembly/solve speedup running on 4 processors" (2013, 5, 26, 1, 30, 21) fem-speedup-cpp-assembly 6.60275 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 26, 1, 30, 21) fem-speedup-cpp-solve 2.28959 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 26, 1, 30, 41) mesh-refinement-cpp 19.9603 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 26, 1, 31, 1) mesh-topology-cpp 19.4221 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 26, 1, 31, 25) mesh-unitcube-cpp 23.9701 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 26, 1, 32, 7) mesh-iteration-cpp 39.1547 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 26, 1, 32, 28) function-evaluation-cpp 21.1501 "Evaluations of functions at arbitrary points." (2013, 5, 26, 1, 32, 28) function-evaluation-cpp 21.0719 "Evaluations of functions at arbitrary points." (2013, 5, 26, 1, 32, 32) function-extrapolation-python 4.58616 "*** -------------------------------------------------------------------------" (2013, 5, 26, 1, 32, 32) function-extrapolation-python 2.13118 "*** -------------------------------------------------------------------------" (2013, 5, 26, 1, 32, 56) la-vector-access-cpp 23.4307 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 26, 1, 33, 53) la-vector-assignment-cpp 57.0087 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 27, 1, 20, 55) common-progress-cpp 28.6947 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 27, 1, 21, 25) common-timing-cpp 30.2411 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 27, 1, 23, 12) fem-multicore-cpp 106.289 "Coloring mesh." (2013, 5, 27, 1, 25, 42) fem-assembly-cpp 150.881 "Assembly for various forms and backends" (2013, 5, 27, 1, 25, 54) fem-convergence-cpp 12.0935 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 27, 1, 25, 56) fem-jit-python 0.0010488 "JIT compilation (in memory cache)" (2013, 5, 27, 1, 31, 0) fem-speedup-cpp 303.779 "Assembly/solve speedup running on 4 processors" (2013, 5, 27, 1, 31, 0) fem-speedup-cpp-assembly 6.69875 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 27, 1, 31, 0) fem-speedup-cpp-solve 2.34753 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 27, 1, 31, 21) mesh-refinement-cpp 19.9028 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 27, 1, 31, 40) mesh-topology-cpp 19.4461 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 27, 1, 32, 5) mesh-unitcube-cpp 24.131 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 27, 1, 32, 46) mesh-iteration-cpp 39.1556 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 27, 1, 33, 7) function-evaluation-cpp 21.1814 "Evaluations of functions at arbitrary points." (2013, 5, 27, 1, 33, 7) function-evaluation-cpp 21.1019 "Evaluations of functions at arbitrary points." (2013, 5, 27, 1, 33, 12) function-extrapolation-python 4.51966 "*** -------------------------------------------------------------------------" (2013, 5, 27, 1, 33, 12) function-extrapolation-python 2.12959 "*** -------------------------------------------------------------------------" (2013, 5, 27, 1, 33, 35) la-vector-access-cpp 22.9838 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 27, 1, 34, 0) la-vector-assignment-cpp 25.0716 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 28, 1, 19, 5) common-progress-cpp 29.011 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 28, 1, 19, 37) common-timing-cpp 31.242 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 28, 1, 21, 24) fem-multicore-cpp 107.088 "Coloring mesh." (2013, 5, 28, 1, 23, 55) fem-assembly-cpp 151.585 "Assembly for various forms and backends" (2013, 5, 28, 1, 24, 7) fem-convergence-cpp 12.0813 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 28, 1, 24, 9) fem-jit-python 0.0010371 "JIT compilation (in memory cache)" (2013, 5, 28, 1, 29, 16) fem-speedup-cpp 307.109 "Assembly/solve speedup running on 4 processors" (2013, 5, 28, 1, 29, 16) fem-speedup-cpp-assembly 6.62981 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 28, 1, 29, 16) fem-speedup-cpp-solve 2.28976 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 28, 1, 29, 39) mesh-refinement-cpp 19.8446 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 28, 1, 29, 59) mesh-topology-cpp 19.4459 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 28, 1, 30, 23) mesh-unitcube-cpp 24.1726 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 28, 1, 31, 5) mesh-iteration-cpp 39.162 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 28, 1, 31, 26) function-evaluation-cpp 21.2293 "Evaluations of functions at arbitrary points." (2013, 5, 28, 1, 31, 26) function-evaluation-cpp 21.0526 "Evaluations of functions at arbitrary points." (2013, 5, 28, 1, 31, 31) function-extrapolation-python 4.57018 "*** -------------------------------------------------------------------------" (2013, 5, 28, 1, 31, 31) function-extrapolation-python 2.11285 "*** -------------------------------------------------------------------------" (2013, 5, 28, 1, 31, 54) la-vector-access-cpp 23.0034 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 28, 1, 32, 19) la-vector-assignment-cpp 25.083 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 29, 1, 18, 58) common-progress-cpp 28.9861 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 29, 1, 19, 28) common-timing-cpp 30.5528 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 29, 1, 21, 14) fem-multicore-cpp 106.3 "Coloring mesh." (2013, 5, 29, 1, 23, 46) fem-assembly-cpp 151.697 "Assembly for various forms and backends" (2013, 5, 29, 1, 23, 58) fem-convergence-cpp 12.0829 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 29, 1, 24, 0) fem-jit-python 0.0010299 "JIT compilation (in memory cache)" (2013, 5, 29, 1, 29, 3) fem-speedup-cpp 303.439 "Assembly/solve speedup running on 4 processors" (2013, 5, 29, 1, 29, 3) fem-speedup-cpp-assembly 6.65012 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 29, 1, 29, 3) fem-speedup-cpp-solve 2.35138 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 29, 1, 29, 24) mesh-refinement-cpp 19.8514 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 29, 1, 29, 44) mesh-topology-cpp 19.4783 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 29, 1, 30, 8) mesh-unitcube-cpp 24.1873 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 29, 1, 30, 50) mesh-iteration-cpp 39.1601 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 29, 1, 31, 11) function-evaluation-cpp 21.148 "Evaluations of functions at arbitrary points." (2013, 5, 29, 1, 31, 11) function-evaluation-cpp 21.0599 "Evaluations of functions at arbitrary points." (2013, 5, 29, 1, 31, 15) function-extrapolation-python 4.58603 "*** -------------------------------------------------------------------------" (2013, 5, 29, 1, 31, 15) function-extrapolation-python 2.11564 "*** -------------------------------------------------------------------------" (2013, 5, 29, 1, 31, 38) la-vector-access-cpp 23.171 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 29, 1, 32, 4) la-vector-assignment-cpp 25.119 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 30, 1, 18, 25) common-progress-cpp 29.0192 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 30, 1, 18, 56) common-timing-cpp 30.4525 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 30, 1, 20, 43) fem-multicore-cpp 107.009 "Coloring mesh." (2013, 5, 30, 1, 23, 14) fem-assembly-cpp 151.376 "Assembly for various forms and backends" (2013, 5, 30, 1, 23, 26) fem-convergence-cpp 12.0844 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 30, 1, 23, 28) fem-jit-python 0.00106471 "JIT compilation (in memory cache)" (2013, 5, 30, 1, 28, 32) fem-speedup-cpp 303.388 "Assembly/solve speedup running on 4 processors" (2013, 5, 30, 1, 28, 32) fem-speedup-cpp-assembly 6.58356 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 30, 1, 28, 32) fem-speedup-cpp-solve 2.35103 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 30, 1, 28, 52) mesh-refinement-cpp 19.876 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 30, 1, 29, 12) mesh-topology-cpp 19.6286 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 30, 1, 29, 36) mesh-unitcube-cpp 24.2816 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 30, 1, 30, 18) mesh-iteration-cpp 39.1608 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 30, 1, 30, 39) function-evaluation-cpp 21.1254 "Evaluations of functions at arbitrary points." (2013, 5, 30, 1, 30, 39) function-evaluation-cpp 21.0471 "Evaluations of functions at arbitrary points." (2013, 5, 30, 1, 30, 43) function-extrapolation-python 4.42653 "*** -------------------------------------------------------------------------" (2013, 5, 30, 1, 30, 43) function-extrapolation-python 2.13002 "*** -------------------------------------------------------------------------" (2013, 5, 30, 1, 31, 6) la-vector-access-cpp 22.9348 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 30, 1, 31, 33) la-vector-assignment-cpp 27.0872 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 5, 31, 1, 20, 38) common-progress-cpp 28.7612 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 5, 31, 1, 21, 9) common-timing-cpp 30.7114 "Timing access and registration of timings (10000000 repetitions)" (2013, 5, 31, 1, 22, 56) fem-multicore-cpp 106.856 "Coloring mesh." (2013, 5, 31, 1, 25, 26) fem-assembly-cpp 150.784 "Assembly for various forms and backends" (2013, 5, 31, 1, 25, 38) fem-convergence-cpp 12.1384 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 5, 31, 1, 25, 40) fem-jit-python 0.0010422 "JIT compilation (in memory cache)" (2013, 5, 31, 1, 30, 44) fem-speedup-cpp 303.213 "Assembly/solve speedup running on 4 processors" (2013, 5, 31, 1, 30, 44) fem-speedup-cpp-assembly 6.56542 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 5, 31, 1, 30, 44) fem-speedup-cpp-solve 2.36584 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 5, 31, 1, 31, 4) mesh-refinement-cpp 19.843 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 5, 31, 1, 31, 24) mesh-topology-cpp 19.2905 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 5, 31, 1, 31, 47) mesh-unitcube-cpp 23.8696 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 5, 31, 1, 32, 25) mesh-iteration-cpp 35.5184 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 5, 31, 1, 32, 47) function-evaluation-cpp 21.1315 "Evaluations of functions at arbitrary points." (2013, 5, 31, 1, 32, 47) function-evaluation-cpp 21.0523 "Evaluations of functions at arbitrary points." (2013, 5, 31, 1, 32, 51) function-extrapolation-python 4.50307 "*** -------------------------------------------------------------------------" (2013, 5, 31, 1, 32, 51) function-extrapolation-python 2.11167 "*** -------------------------------------------------------------------------" (2013, 5, 31, 1, 33, 15) la-vector-access-cpp 23.4316 "Accessing vector of size 10000000 (100 repetitions)" (2013, 5, 31, 1, 33, 40) la-vector-assignment-cpp 25.0665 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 1, 1, 20, 10) common-progress-cpp 28.9527 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 1, 1, 20, 40) common-timing-cpp 29.7848 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 1, 1, 22, 26) fem-multicore-cpp 106.183 "Coloring mesh." (2013, 6, 1, 1, 24, 56) fem-assembly-cpp 150.162 "Assembly for various forms and backends" (2013, 6, 1, 1, 25, 8) fem-convergence-cpp 12.0929 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 1, 1, 25, 10) fem-jit-python 0.00105009 "JIT compilation (in memory cache)" (2013, 6, 1, 1, 30, 15) fem-speedup-cpp 304.325 "Assembly/solve speedup running on 4 processors" (2013, 6, 1, 1, 30, 15) fem-speedup-cpp-assembly 6.56287 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 1, 1, 30, 15) fem-speedup-cpp-solve 2.3471 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 1, 1, 30, 35) mesh-refinement-cpp 19.8949 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 1, 1, 30, 55) mesh-topology-cpp 19.5427 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 1, 1, 31, 19) mesh-unitcube-cpp 24.1476 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 1, 1, 32, 1) mesh-iteration-cpp 39.1554 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 1, 1, 32, 22) function-evaluation-cpp 21.2354 "Evaluations of functions at arbitrary points." (2013, 6, 1, 1, 32, 22) function-evaluation-cpp 21.1289 "Evaluations of functions at arbitrary points." (2013, 6, 1, 1, 32, 27) function-extrapolation-python 4.51113 "*** -------------------------------------------------------------------------" (2013, 6, 1, 1, 32, 27) function-extrapolation-python 2.11699 "*** -------------------------------------------------------------------------" (2013, 6, 1, 1, 32, 52) la-vector-access-cpp 24.925 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 1, 1, 33, 19) la-vector-assignment-cpp 27.0494 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 2, 1, 21, 33) common-progress-cpp 29.0277 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 2, 1, 22, 3) common-timing-cpp 30.1406 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 2, 1, 23, 49) fem-multicore-cpp 106.31 "Coloring mesh." (2013, 6, 2, 1, 26, 19) fem-assembly-cpp 150.112 "Assembly for various forms and backends" (2013, 6, 2, 1, 26, 32) fem-convergence-cpp 12.0952 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 2, 1, 26, 33) fem-jit-python 0.0010268 "JIT compilation (in memory cache)" (2013, 6, 2, 1, 31, 37) fem-speedup-cpp 303.771 "Assembly/solve speedup running on 4 processors" (2013, 6, 2, 1, 31, 37) fem-speedup-cpp-assembly 6.60848 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 2, 1, 31, 37) fem-speedup-cpp-solve 2.34083 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 2, 1, 31, 58) mesh-refinement-cpp 19.878 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 2, 1, 32, 17) mesh-topology-cpp 19.5544 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 2, 1, 32, 42) mesh-unitcube-cpp 24.1094 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 2, 1, 33, 23) mesh-iteration-cpp 39.1558 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 2, 1, 33, 44) function-evaluation-cpp 21.1284 "Evaluations of functions at arbitrary points." (2013, 6, 2, 1, 33, 44) function-evaluation-cpp 21.0596 "Evaluations of functions at arbitrary points." (2013, 6, 2, 1, 33, 49) function-extrapolation-python 4.57792 "*** -------------------------------------------------------------------------" (2013, 6, 2, 1, 33, 49) function-extrapolation-python 2.13477 "*** -------------------------------------------------------------------------" (2013, 6, 2, 1, 34, 12) la-vector-access-cpp 22.9349 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 2, 1, 34, 37) la-vector-assignment-cpp 25.0653 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 3, 1, 18, 31) common-progress-cpp 28.9318 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 3, 1, 19, 2) common-timing-cpp 30.5338 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 3, 1, 20, 49) fem-multicore-cpp 107.012 "Coloring mesh." (2013, 6, 3, 1, 23, 19) fem-assembly-cpp 149.945 "Assembly for various forms and backends" (2013, 6, 3, 1, 23, 31) fem-convergence-cpp 12.0869 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 3, 1, 23, 33) fem-jit-python 0.001033 "JIT compilation (in memory cache)" (2013, 6, 3, 1, 28, 38) fem-speedup-cpp 305.454 "Assembly/solve speedup running on 4 processors" (2013, 6, 3, 1, 28, 38) fem-speedup-cpp-assembly 6.66777 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 3, 1, 28, 38) fem-speedup-cpp-solve 2.29007 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 3, 1, 28, 59) mesh-refinement-cpp 19.8768 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 3, 1, 29, 19) mesh-topology-cpp 19.5038 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 3, 1, 29, 43) mesh-unitcube-cpp 24.1324 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 3, 1, 30, 24) mesh-iteration-cpp 39.1625 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 3, 1, 30, 46) function-evaluation-cpp 21.3895 "Evaluations of functions at arbitrary points." (2013, 6, 3, 1, 30, 46) function-evaluation-cpp 21.3203 "Evaluations of functions at arbitrary points." (2013, 6, 3, 1, 30, 50) function-extrapolation-python 4.54526 "*** -------------------------------------------------------------------------" (2013, 6, 3, 1, 30, 50) function-extrapolation-python 2.13303 "*** -------------------------------------------------------------------------" (2013, 6, 3, 1, 31, 15) la-vector-access-cpp 24.9275 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 3, 1, 31, 42) la-vector-assignment-cpp 26.4625 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 4, 1, 19, 24) common-progress-cpp 28.8704 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 4, 1, 19, 54) common-timing-cpp 29.7689 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 4, 1, 21, 43) fem-multicore-cpp 109.287 "Coloring mesh." (2013, 6, 4, 1, 24, 17) fem-assembly-cpp 154.155 "Assembly for various forms and backends" (2013, 6, 4, 1, 24, 29) fem-convergence-cpp 12.1457 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 4, 1, 24, 31) fem-jit-python 0.0010354 "JIT compilation (in memory cache)" (2013, 6, 4, 1, 29, 35) fem-speedup-cpp 304.081 "Assembly/solve speedup running on 4 processors" (2013, 6, 4, 1, 29, 35) fem-speedup-cpp-assembly 6.55852 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 4, 1, 29, 35) fem-speedup-cpp-solve 2.33502 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 4, 1, 29, 56) mesh-refinement-cpp 19.7441 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 4, 1, 30, 15) mesh-topology-cpp 19.4309 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 4, 1, 30, 39) mesh-unitcube-cpp 24.1853 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 4, 1, 31, 18) mesh-iteration-cpp 35.6294 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 4, 1, 31, 39) function-evaluation-cpp 21.1423 "Evaluations of functions at arbitrary points." (2013, 6, 4, 1, 31, 39) function-evaluation-cpp 21.0674 "Evaluations of functions at arbitrary points." (2013, 6, 4, 1, 31, 43) function-extrapolation-python 4.45936 "*** -------------------------------------------------------------------------" (2013, 6, 4, 1, 31, 43) function-extrapolation-python 2.12229 "*** -------------------------------------------------------------------------" (2013, 6, 4, 1, 32, 8) la-vector-access-cpp 24.9485 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 4, 1, 32, 33) la-vector-assignment-cpp 25.0679 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 5, 1, 18, 46) common-progress-cpp 28.9092 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 5, 1, 19, 16) common-timing-cpp 29.9818 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 5, 1, 21, 6) fem-multicore-cpp 109.886 "Coloring mesh." (2013, 6, 5, 1, 23, 39) fem-assembly-cpp 153.32 "Assembly for various forms and backends" (2013, 6, 5, 1, 23, 51) fem-convergence-cpp 12.1586 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 5, 1, 23, 53) fem-jit-python 0.001039 "JIT compilation (in memory cache)" (2013, 6, 5, 1, 28, 59) fem-speedup-cpp 306.246 "Assembly/solve speedup running on 4 processors" (2013, 6, 5, 1, 28, 59) fem-speedup-cpp-assembly 6.5046 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 5, 1, 28, 59) fem-speedup-cpp-solve 2.30423 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 5, 1, 29, 20) mesh-refinement-cpp 19.7301 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 5, 1, 29, 40) mesh-topology-cpp 19.5537 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 5, 1, 30, 4) mesh-unitcube-cpp 24.5751 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 5, 1, 30, 42) mesh-iteration-cpp 35.492 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 5, 1, 31, 3) function-evaluation-cpp 21.1502 "Evaluations of functions at arbitrary points." (2013, 6, 5, 1, 31, 3) function-evaluation-cpp 21.0668 "Evaluations of functions at arbitrary points." (2013, 6, 5, 1, 31, 8) function-extrapolation-python 4.49461 "*** -------------------------------------------------------------------------" (2013, 6, 5, 1, 31, 8) function-extrapolation-python 2.15063 "*** -------------------------------------------------------------------------" (2013, 6, 5, 1, 31, 33) la-vector-access-cpp 25.0229 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 5, 1, 31, 58) la-vector-assignment-cpp 25.0633 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 6, 1, 20, 25) common-progress-cpp 28.628 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 6, 1, 20, 56) common-timing-cpp 30.264 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 6, 1, 22, 45) fem-multicore-cpp 109.217 "Coloring mesh." (2013, 6, 6, 1, 25, 18) fem-assembly-cpp 153.592 "Assembly for various forms and backends" (2013, 6, 6, 1, 25, 31) fem-convergence-cpp 12.135 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 6, 1, 25, 32) fem-jit-python 0.0010386 "JIT compilation (in memory cache)" (2013, 6, 6, 1, 30, 42) fem-speedup-cpp 309.396 "Assembly/solve speedup running on 4 processors" (2013, 6, 6, 1, 30, 42) fem-speedup-cpp-assembly 6.44119 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 6, 1, 30, 42) fem-speedup-cpp-solve 2.2324 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 6, 1, 31, 3) mesh-refinement-cpp 19.7073 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 6, 1, 31, 23) mesh-topology-cpp 19.5126 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 6, 1, 31, 47) mesh-unitcube-cpp 24.1189 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 6, 1, 32, 34) mesh-iteration-cpp 44.1734 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 6, 1, 32, 55) function-evaluation-cpp 21.205 "Evaluations of functions at arbitrary points." (2013, 6, 6, 1, 32, 55) function-evaluation-cpp 21.0518 "Evaluations of functions at arbitrary points." (2013, 6, 6, 1, 33, 0) function-extrapolation-python 4.59656 "*** -------------------------------------------------------------------------" (2013, 6, 6, 1, 33, 0) function-extrapolation-python 2.13076 "*** -------------------------------------------------------------------------" (2013, 6, 6, 1, 33, 23) la-vector-access-cpp 23.4494 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 6, 1, 33, 48) la-vector-assignment-cpp 25.0937 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 7, 1, 21, 5) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.01301 "Running DOLFIN bench" (2013, 6, 7, 1, 21, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 0.249131 "Running DOLFIN bench" (2013, 6, 7, 1, 21, 15) geometry-bounding_box_tree_build-cpp 8.95832 "Running DOLFIN bench" (2013, 6, 7, 1, 21, 43) common-progress-cpp 27.6497 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 7, 1, 22, 12) common-timing-cpp 29.3385 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 7, 1, 23, 59) fem-multicore-cpp 106.492 "Coloring mesh." (2013, 6, 7, 1, 26, 28) fem-assembly-cpp 148.787 "Assembly for various forms and backends" (2013, 6, 7, 1, 26, 40) fem-convergence-cpp 12.124 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 7, 1, 26, 41) fem-jit-python 0.00103331 "JIT compilation (in memory cache)" (2013, 6, 7, 1, 31, 47) fem-speedup-cpp 305.662 "Assembly/solve speedup running on 4 processors" (2013, 6, 7, 1, 31, 47) fem-speedup-cpp-assembly 6.5561 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 7, 1, 31, 47) fem-speedup-cpp-solve 2.22155 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 7, 1, 32, 9) mesh-refinement-cpp 19.831 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 7, 1, 32, 28) mesh-topology-cpp 19.4082 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 7, 1, 32, 52) mesh-unitcube-cpp 23.9951 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 7, 1, 33, 38) mesh-iteration-cpp 43.4799 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 7, 1, 34, 0) function-evaluation-cpp 21.2135 "Evaluations of functions at arbitrary points." (2013, 6, 7, 1, 34, 0) function-evaluation-cpp 21.0912 "Evaluations of functions at arbitrary points." (2013, 6, 7, 1, 34, 4) function-extrapolation-python 4.5052 "*** -------------------------------------------------------------------------" (2013, 6, 7, 1, 34, 4) function-extrapolation-python 2.11318 "*** -------------------------------------------------------------------------" (2013, 6, 7, 1, 34, 31) la-vector-access-cpp 26.7159 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 7, 1, 34, 58) la-vector-assignment-cpp 26.6114 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 8, 1, 20, 22) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.05756 "Running DOLFIN bench" (2013, 6, 8, 1, 20, 23) geometry-bounding_box_tree_compute_closest_entity-cpp 0.245334 "Running DOLFIN bench" (2013, 6, 8, 1, 20, 32) geometry-bounding_box_tree_build-cpp 8.98392 "Running DOLFIN bench" (2013, 6, 8, 1, 21, 0) common-progress-cpp 27.6508 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 8, 1, 21, 30) common-timing-cpp 29.5223 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 8, 1, 23, 16) fem-multicore-cpp 106.322 "Coloring mesh." (2013, 6, 8, 1, 25, 44) fem-assembly-cpp 147.95 "Assembly for various forms and backends" (2013, 6, 8, 1, 25, 56) fem-convergence-cpp 12.1327 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 8, 1, 25, 58) fem-jit-python 0.0010324 "JIT compilation (in memory cache)" (2013, 6, 8, 1, 31, 2) fem-speedup-cpp 304.169 "Assembly/solve speedup running on 4 processors" (2013, 6, 8, 1, 31, 2) fem-speedup-cpp-assembly 6.56678 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 8, 1, 31, 2) fem-speedup-cpp-solve 2.25447 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 8, 1, 31, 24) mesh-refinement-cpp 19.856 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 8, 1, 31, 43) mesh-topology-cpp 19.3393 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 8, 1, 32, 7) mesh-unitcube-cpp 23.9121 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 8, 1, 32, 49) mesh-iteration-cpp 39.1578 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 8, 1, 33, 10) function-evaluation-cpp 21.5966 "Evaluations of functions at arbitrary points." (2013, 6, 8, 1, 33, 10) function-evaluation-cpp 21.4718 "Evaluations of functions at arbitrary points." (2013, 6, 8, 1, 33, 15) function-extrapolation-python 4.53625 "*** -------------------------------------------------------------------------" (2013, 6, 8, 1, 33, 15) function-extrapolation-python 2.13548 "*** -------------------------------------------------------------------------" (2013, 6, 8, 1, 33, 42) la-vector-access-cpp 27.0107 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 8, 1, 34, 7) la-vector-assignment-cpp 25.085 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 9, 1, 22, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.02184 "Running DOLFIN bench" (2013, 6, 9, 1, 22, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 0.244613 "Running DOLFIN bench" (2013, 6, 9, 1, 22, 41) geometry-bounding_box_tree_build-cpp 8.95586 "Running DOLFIN bench" (2013, 6, 9, 1, 23, 9) common-progress-cpp 27.6507 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 9, 1, 23, 37) common-timing-cpp 28.906 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 9, 1, 25, 24) fem-multicore-cpp 106.276 "Coloring mesh." (2013, 6, 9, 1, 27, 53) fem-assembly-cpp 148.887 "Assembly for various forms and backends" (2013, 6, 9, 1, 28, 5) fem-convergence-cpp 12.1382 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 9, 1, 28, 7) fem-jit-python 0.00104301 "JIT compilation (in memory cache)" (2013, 6, 9, 1, 33, 17) fem-speedup-cpp 310.704 "Assembly/solve speedup running on 4 processors" (2013, 6, 9, 1, 33, 17) fem-speedup-cpp-assembly 6.53361 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 9, 1, 33, 17) fem-speedup-cpp-solve 2.23057 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 9, 1, 33, 39) mesh-refinement-cpp 19.888 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 9, 1, 33, 59) mesh-topology-cpp 19.5623 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 9, 1, 34, 23) mesh-unitcube-cpp 23.926 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 9, 1, 35, 1) mesh-iteration-cpp 35.4889 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 9, 1, 35, 22) function-evaluation-cpp 21.3549 "Evaluations of functions at arbitrary points." (2013, 6, 9, 1, 35, 22) function-evaluation-cpp 21.2372 "Evaluations of functions at arbitrary points." (2013, 6, 9, 1, 35, 27) function-extrapolation-python 4.56941 "*** -------------------------------------------------------------------------" (2013, 6, 9, 1, 35, 27) function-extrapolation-python 2.10789 "*** -------------------------------------------------------------------------" (2013, 6, 9, 1, 35, 53) la-vector-access-cpp 26.7159 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 9, 1, 36, 19) la-vector-assignment-cpp 25.0904 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 10, 1, 20, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.0468 "Running DOLFIN bench" (2013, 6, 10, 1, 20, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 0.24488 "Running DOLFIN bench" (2013, 6, 10, 1, 20, 13) geometry-bounding_box_tree_build-cpp 8.95046 "Running DOLFIN bench" (2013, 6, 10, 1, 20, 40) common-progress-cpp 27.6524 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 10, 1, 21, 10) common-timing-cpp 29.6591 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 10, 1, 22, 57) fem-multicore-cpp 107.124 "Coloring mesh." (2013, 6, 10, 1, 25, 26) fem-assembly-cpp 148.408 "Assembly for various forms and backends" (2013, 6, 10, 1, 25, 38) fem-convergence-cpp 12.1444 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 10, 1, 25, 40) fem-jit-python 0.00103419 "JIT compilation (in memory cache)" (2013, 6, 10, 1, 30, 44) fem-speedup-cpp 304.582 "Assembly/solve speedup running on 4 processors" (2013, 6, 10, 1, 30, 44) fem-speedup-cpp-assembly 6.54888 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 10, 1, 30, 44) fem-speedup-cpp-solve 2.2433 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 10, 1, 31, 6) mesh-refinement-cpp 19.8181 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 10, 1, 31, 25) mesh-topology-cpp 19.3632 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 10, 1, 31, 49) mesh-unitcube-cpp 23.8818 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 10, 1, 32, 27) mesh-iteration-cpp 35.4235 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 10, 1, 32, 49) function-evaluation-cpp 21.4318 "Evaluations of functions at arbitrary points." (2013, 6, 10, 1, 32, 49) function-evaluation-cpp 21.3466 "Evaluations of functions at arbitrary points." (2013, 6, 10, 1, 32, 53) function-extrapolation-python 4.49854 "*** -------------------------------------------------------------------------" (2013, 6, 10, 1, 32, 53) function-extrapolation-python 2.10525 "*** -------------------------------------------------------------------------" (2013, 6, 10, 1, 33, 20) la-vector-access-cpp 26.6579 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 10, 1, 33, 45) la-vector-assignment-cpp 25.0978 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 11, 1, 19, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.0324 "Running DOLFIN bench" (2013, 6, 11, 1, 19, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 0.246274 "Running DOLFIN bench" (2013, 6, 11, 1, 19, 53) geometry-bounding_box_tree_build-cpp 8.97825 "Running DOLFIN bench" (2013, 6, 11, 1, 20, 21) common-progress-cpp 27.6511 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 11, 1, 20, 50) common-timing-cpp 29.1142 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 11, 1, 22, 36) fem-multicore-cpp 106.106 "Coloring mesh." (2013, 6, 11, 1, 25, 6) fem-assembly-cpp 149.317 "Assembly for various forms and backends" (2013, 6, 11, 1, 25, 18) fem-convergence-cpp 12.1185 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 11, 1, 25, 20) fem-jit-python 0.00104868 "JIT compilation (in memory cache)" (2013, 6, 11, 1, 30, 25) fem-speedup-cpp 305.527 "Assembly/solve speedup running on 4 processors" (2013, 6, 11, 1, 30, 25) fem-speedup-cpp-assembly 6.51268 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 11, 1, 30, 25) fem-speedup-cpp-solve 2.32068 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 11, 1, 30, 46) mesh-refinement-cpp 19.8779 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 11, 1, 31, 5) mesh-topology-cpp 19.3061 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 11, 1, 31, 29) mesh-unitcube-cpp 23.9519 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 11, 1, 32, 7) mesh-iteration-cpp 35.4795 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 11, 1, 32, 28) function-evaluation-cpp 21.1894 "Evaluations of functions at arbitrary points." (2013, 6, 11, 1, 32, 28) function-evaluation-cpp 21.0572 "Evaluations of functions at arbitrary points." (2013, 6, 11, 1, 32, 33) function-extrapolation-python 4.55296 "*** -------------------------------------------------------------------------" (2013, 6, 11, 1, 32, 33) function-extrapolation-python 2.12619 "*** -------------------------------------------------------------------------" (2013, 6, 11, 1, 33, 0) la-vector-access-cpp 26.7174 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 11, 1, 33, 25) la-vector-assignment-cpp 25.0665 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 12, 1, 20, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.0526 "Running DOLFIN bench" (2013, 6, 12, 1, 20, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 0.247519 "Running DOLFIN bench" (2013, 6, 12, 1, 21, 8) geometry-bounding_box_tree_build-cpp 8.97001 "Running DOLFIN bench" (2013, 6, 12, 1, 21, 36) common-progress-cpp 27.6509 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 12, 1, 22, 5) common-timing-cpp 29.1896 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 12, 1, 23, 52) fem-multicore-cpp 106.902 "Coloring mesh." (2013, 6, 12, 1, 26, 21) fem-assembly-cpp 149.272 "Assembly for various forms and backends" (2013, 6, 12, 1, 26, 33) fem-convergence-cpp 12.1211 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 12, 1, 26, 35) fem-jit-python 0.00102742 "JIT compilation (in memory cache)" (2013, 6, 12, 1, 31, 39) fem-speedup-cpp 303.354 "Assembly/solve speedup running on 4 processors" (2013, 6, 12, 1, 31, 39) fem-speedup-cpp-assembly 6.51311 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 12, 1, 31, 39) fem-speedup-cpp-solve 2.35757 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 12, 1, 32, 0) mesh-refinement-cpp 19.9212 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 12, 1, 32, 19) mesh-topology-cpp 19.3652 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 12, 1, 32, 43) mesh-unitcube-cpp 23.9507 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 12, 1, 33, 21) mesh-iteration-cpp 35.4818 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 12, 1, 33, 42) function-evaluation-cpp 21.2842 "Evaluations of functions at arbitrary points." (2013, 6, 12, 1, 33, 42) function-evaluation-cpp 21.2095 "Evaluations of functions at arbitrary points." (2013, 6, 12, 1, 33, 47) function-extrapolation-python 4.43415 "*** -------------------------------------------------------------------------" (2013, 6, 12, 1, 33, 47) function-extrapolation-python 2.10769 "*** -------------------------------------------------------------------------" (2013, 6, 12, 1, 34, 13) la-vector-access-cpp 26.6957 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 12, 1, 34, 38) la-vector-assignment-cpp 25.0686 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 13, 1, 19, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.00226 "Running DOLFIN bench" (2013, 6, 13, 1, 19, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 0.245903 "Running DOLFIN bench" (2013, 6, 13, 1, 19, 44) geometry-bounding_box_tree_build-cpp 8.97117 "Running DOLFIN bench" (2013, 6, 13, 1, 20, 12) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 13, 1, 20, 41) common-timing-cpp 28.9743 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 13, 1, 22, 27) fem-multicore-cpp 106.276 "Coloring mesh." (2013, 6, 13, 1, 24, 55) fem-assembly-cpp 148.083 "Assembly for various forms and backends" (2013, 6, 13, 1, 25, 7) fem-convergence-cpp 12.1385 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 13, 1, 25, 26) fem-jit-python 0.0011157 "JIT compilation (in memory cache)" (2013, 6, 13, 1, 30, 32) fem-speedup-cpp 305.62 "Assembly/solve speedup running on 4 processors" (2013, 6, 13, 1, 30, 32) fem-speedup-cpp-assembly 6.54277 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 13, 1, 30, 32) fem-speedup-cpp-solve 2.31912 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 13, 1, 30, 53) mesh-refinement-cpp 19.8245 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 13, 1, 31, 12) mesh-topology-cpp 19.2943 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 13, 1, 31, 36) mesh-unitcube-cpp 23.908 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 13, 1, 32, 14) mesh-iteration-cpp 35.4946 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 13, 1, 32, 36) function-evaluation-cpp 21.1554 "Evaluations of functions at arbitrary points." (2013, 6, 13, 1, 32, 36) function-evaluation-cpp 21.0298 "Evaluations of functions at arbitrary points." (2013, 6, 13, 1, 33, 32) function-extrapolation-python 56.0351 "*** -------------------------------------------------------------------------" (2013, 6, 13, 1, 33, 32) function-extrapolation-python 1.09231 "*** -------------------------------------------------------------------------" (2013, 6, 13, 1, 33, 58) la-vector-access-cpp 26.6967 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 13, 1, 34, 23) la-vector-assignment-cpp 25.1072 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 14, 1, 21, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.02256 "Running DOLFIN bench" (2013, 6, 14, 1, 21, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 0.243262 "Running DOLFIN bench" (2013, 6, 14, 1, 21, 47) geometry-bounding_box_tree_build-cpp 8.96069 "Running DOLFIN bench" (2013, 6, 14, 1, 22, 14) common-progress-cpp 27.65 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 14, 1, 22, 44) common-timing-cpp 29.3873 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 14, 1, 24, 30) fem-multicore-cpp 106.398 "Coloring mesh." (2013, 6, 14, 1, 27, 0) fem-assembly-cpp 149.471 "Assembly for various forms and backends" (2013, 6, 14, 1, 27, 12) fem-convergence-cpp 12.1346 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 14, 1, 27, 14) fem-jit-python 0.0010407 "JIT compilation (in memory cache)" (2013, 6, 14, 1, 32, 17) fem-speedup-cpp 303.655 "Assembly/solve speedup running on 4 processors" (2013, 6, 14, 1, 32, 17) fem-speedup-cpp-assembly 6.52897 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 14, 1, 32, 17) fem-speedup-cpp-solve 2.34996 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 14, 1, 32, 38) mesh-refinement-cpp 19.8584 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 14, 1, 32, 57) mesh-topology-cpp 19.3516 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 14, 1, 33, 21) mesh-unitcube-cpp 24.0054 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 14, 1, 33, 59) mesh-iteration-cpp 35.495 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 14, 1, 34, 21) function-evaluation-cpp 21.1744 "Evaluations of functions at arbitrary points." (2013, 6, 14, 1, 34, 21) function-evaluation-cpp 21.1004 "Evaluations of functions at arbitrary points." (2013, 6, 14, 1, 34, 24) function-extrapolation-python 3.32842 "*** -------------------------------------------------------------------------" (2013, 6, 14, 1, 34, 24) function-extrapolation-python 1.0946 "*** -------------------------------------------------------------------------" (2013, 6, 14, 1, 34, 52) la-vector-access-cpp 28.6016 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 14, 1, 35, 20) la-vector-assignment-cpp 27.0824 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 15, 1, 24, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.00732 "Running DOLFIN bench" (2013, 6, 15, 1, 24, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 0.245619 "Running DOLFIN bench" (2013, 6, 15, 1, 24, 52) geometry-bounding_box_tree_build-cpp 8.95958 "Running DOLFIN bench" (2013, 6, 15, 1, 25, 20) common-progress-cpp 27.6515 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 15, 1, 25, 49) common-timing-cpp 29.1221 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 15, 1, 27, 36) fem-multicore-cpp 106.553 "Coloring mesh." (2013, 6, 15, 1, 30, 4) fem-assembly-cpp 148.474 "Assembly for various forms and backends" (2013, 6, 15, 1, 30, 16) fem-convergence-cpp 12.1375 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 15, 1, 30, 18) fem-jit-python 0.00101709 "JIT compilation (in memory cache)" (2013, 6, 15, 1, 35, 21) fem-speedup-cpp 302.668 "Assembly/solve speedup running on 4 processors" (2013, 6, 15, 1, 35, 21) fem-speedup-cpp-assembly 6.54733 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 15, 1, 35, 21) fem-speedup-cpp-solve 2.38717 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 15, 1, 35, 42) mesh-refinement-cpp 19.8638 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 15, 1, 36, 1) mesh-topology-cpp 19.2633 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 15, 1, 36, 25) mesh-unitcube-cpp 24.0531 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 15, 1, 37, 3) mesh-iteration-cpp 35.4788 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 15, 1, 37, 24) function-evaluation-cpp 21.1652 "Evaluations of functions at arbitrary points." (2013, 6, 15, 1, 37, 24) function-evaluation-cpp 21.0717 "Evaluations of functions at arbitrary points." (2013, 6, 15, 1, 37, 28) function-extrapolation-python 3.41584 "*** -------------------------------------------------------------------------" (2013, 6, 15, 1, 37, 28) function-extrapolation-python 1.08063 "*** -------------------------------------------------------------------------" (2013, 6, 15, 1, 37, 54) la-vector-access-cpp 26.699 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 15, 1, 38, 19) la-vector-assignment-cpp 25.0603 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 16, 1, 21, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.00694 "Running DOLFIN bench" (2013, 6, 16, 1, 21, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 0.244941 "Running DOLFIN bench" (2013, 6, 16, 1, 21, 14) geometry-bounding_box_tree_build-cpp 8.95179 "Running DOLFIN bench" (2013, 6, 16, 1, 21, 41) common-progress-cpp 27.7328 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 16, 1, 22, 11) common-timing-cpp 29.8826 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 16, 1, 23, 58) fem-multicore-cpp 106.802 "Coloring mesh." (2013, 6, 16, 1, 26, 27) fem-assembly-cpp 149.307 "Assembly for various forms and backends" (2013, 6, 16, 1, 26, 39) fem-convergence-cpp 12.1309 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 16, 1, 26, 41) fem-jit-python 0.00104001 "JIT compilation (in memory cache)" (2013, 6, 16, 1, 31, 46) fem-speedup-cpp 304.33 "Assembly/solve speedup running on 4 processors" (2013, 6, 16, 1, 31, 46) fem-speedup-cpp-assembly 6.56543 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 16, 1, 31, 46) fem-speedup-cpp-solve 2.32645 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 16, 1, 32, 6) mesh-refinement-cpp 19.8714 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 16, 1, 32, 26) mesh-topology-cpp 19.1904 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 16, 1, 32, 50) mesh-unitcube-cpp 24.0324 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 16, 1, 33, 28) mesh-iteration-cpp 35.4825 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 16, 1, 33, 49) function-evaluation-cpp 21.1587 "Evaluations of functions at arbitrary points." (2013, 6, 16, 1, 33, 49) function-evaluation-cpp 21.0778 "Evaluations of functions at arbitrary points." (2013, 6, 16, 1, 33, 52) function-extrapolation-python 3.47736 "*** -------------------------------------------------------------------------" (2013, 6, 16, 1, 33, 52) function-extrapolation-python 1.09515 "*** -------------------------------------------------------------------------" (2013, 6, 16, 1, 34, 18) la-vector-access-cpp 26.1826 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 16, 1, 34, 46) la-vector-assignment-cpp 27.1088 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 17, 1, 20, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.01547 "Running DOLFIN bench" (2013, 6, 17, 1, 20, 13) geometry-bounding_box_tree_compute_closest_entity-cpp 0.244685 "Running DOLFIN bench" (2013, 6, 17, 1, 20, 21) geometry-bounding_box_tree_build-cpp 8.93985 "Running DOLFIN bench" (2013, 6, 17, 1, 20, 49) common-progress-cpp 27.6513 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 17, 1, 21, 18) common-timing-cpp 29.1432 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 17, 1, 23, 4) fem-multicore-cpp 106.193 "Coloring mesh." (2013, 6, 17, 1, 25, 34) fem-assembly-cpp 149.157 "Assembly for various forms and backends" (2013, 6, 17, 1, 25, 46) fem-convergence-cpp 12.1364 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 17, 1, 25, 48) fem-jit-python 0.0010232 "JIT compilation (in memory cache)" (2013, 6, 17, 1, 30, 51) fem-speedup-cpp 303.697 "Assembly/solve speedup running on 4 processors" (2013, 6, 17, 1, 30, 51) fem-speedup-cpp-assembly 6.5317 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 17, 1, 30, 51) fem-speedup-cpp-solve 2.3499 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 17, 1, 31, 12) mesh-refinement-cpp 19.8781 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 17, 1, 31, 31) mesh-topology-cpp 19.2823 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 17, 1, 31, 55) mesh-unitcube-cpp 23.9485 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 17, 1, 32, 33) mesh-iteration-cpp 35.4873 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 17, 1, 32, 55) function-evaluation-cpp 21.1531 "Evaluations of functions at arbitrary points." (2013, 6, 17, 1, 32, 55) function-evaluation-cpp 21.0757 "Evaluations of functions at arbitrary points." (2013, 6, 17, 1, 32, 58) function-extrapolation-python 3.47327 "*** -------------------------------------------------------------------------" (2013, 6, 17, 1, 32, 58) function-extrapolation-python 1.06724 "*** -------------------------------------------------------------------------" (2013, 6, 17, 1, 33, 24) la-vector-access-cpp 26.1886 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 17, 1, 33, 52) la-vector-assignment-cpp 27.5728 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 18, 1, 20, 2) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.03107 "Running DOLFIN bench" (2013, 6, 18, 1, 20, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 0.246672 "Running DOLFIN bench" (2013, 6, 18, 1, 20, 12) geometry-bounding_box_tree_build-cpp 8.94435 "Running DOLFIN bench" (2013, 6, 18, 1, 20, 40) common-progress-cpp 27.6514 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 18, 1, 21, 9) common-timing-cpp 29.2873 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 18, 1, 22, 56) fem-multicore-cpp 106.936 "Coloring mesh." (2013, 6, 18, 1, 25, 25) fem-assembly-cpp 149.183 "Assembly for various forms and backends" (2013, 6, 18, 1, 25, 37) fem-convergence-cpp 12.1295 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 18, 1, 25, 39) fem-jit-python 0.00102999 "JIT compilation (in memory cache)" (2013, 6, 18, 1, 30, 43) fem-speedup-cpp 304.447 "Assembly/solve speedup running on 4 processors" (2013, 6, 18, 1, 30, 43) fem-speedup-cpp-assembly 6.55596 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 18, 1, 30, 43) fem-speedup-cpp-solve 2.32533 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 18, 1, 31, 4) mesh-refinement-cpp 19.8619 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 18, 1, 31, 24) mesh-topology-cpp 19.3972 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 18, 1, 31, 48) mesh-unitcube-cpp 23.9717 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 18, 1, 32, 26) mesh-iteration-cpp 35.4805 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 18, 1, 32, 47) function-evaluation-cpp 21.1808 "Evaluations of functions at arbitrary points." (2013, 6, 18, 1, 32, 47) function-evaluation-cpp 21.075 "Evaluations of functions at arbitrary points." (2013, 6, 18, 1, 32, 50) function-extrapolation-python 3.52044 "*** -------------------------------------------------------------------------" (2013, 6, 18, 1, 32, 50) function-extrapolation-python 1.07925 "*** -------------------------------------------------------------------------" (2013, 6, 18, 1, 33, 17) la-vector-access-cpp 26.7025 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 18, 1, 33, 44) la-vector-assignment-cpp 27.0588 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 19, 1, 22, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 1.9954 "Running DOLFIN bench" (2013, 6, 19, 1, 22, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 0.245347 "Running DOLFIN bench" (2013, 6, 19, 1, 23, 8) geometry-bounding_box_tree_build-cpp 8.94959 "Running DOLFIN bench" (2013, 6, 19, 1, 23, 35) common-progress-cpp 27.6504 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 19, 1, 24, 6) common-timing-cpp 30.2021 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 19, 1, 25, 52) fem-multicore-cpp 106.283 "Coloring mesh." (2013, 6, 19, 1, 28, 21) fem-assembly-cpp 148.838 "Assembly for various forms and backends" (2013, 6, 19, 1, 28, 33) fem-convergence-cpp 12.1174 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 19, 1, 28, 35) fem-jit-python 0.00101779 "JIT compilation (in memory cache)" (2013, 6, 19, 1, 33, 41) fem-speedup-cpp 306.198 "Assembly/solve speedup running on 4 processors" (2013, 6, 19, 1, 33, 41) fem-speedup-cpp-assembly 6.49712 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 19, 1, 33, 41) fem-speedup-cpp-solve 2.24618 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 19, 1, 34, 3) mesh-refinement-cpp 19.8246 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 19, 1, 34, 22) mesh-topology-cpp 19.2895 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 19, 1, 34, 46) mesh-unitcube-cpp 23.931 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 19, 1, 35, 24) mesh-iteration-cpp 35.463 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 19, 1, 35, 46) function-evaluation-cpp 21.6718 "Evaluations of functions at arbitrary points." (2013, 6, 19, 1, 35, 46) function-evaluation-cpp 21.5515 "Evaluations of functions at arbitrary points." (2013, 6, 19, 1, 35, 49) function-extrapolation-python 3.42869 "*** -------------------------------------------------------------------------" (2013, 6, 19, 1, 35, 49) function-extrapolation-python 1.072 "*** -------------------------------------------------------------------------" (2013, 6, 19, 1, 36, 18) la-vector-access-cpp 28.5933 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 19, 1, 36, 43) la-vector-assignment-cpp 25.0884 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 20, 1, 19, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.04821 "Running DOLFIN bench" (2013, 6, 20, 1, 19, 34) geometry-bounding_box_tree_compute_closest_entity-cpp 0.247757 "Running DOLFIN bench" (2013, 6, 20, 1, 19, 43) geometry-bounding_box_tree_build-cpp 8.94202 "Running DOLFIN bench" (2013, 6, 20, 1, 20, 10) common-progress-cpp 27.6682 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 20, 1, 20, 39) common-timing-cpp 29.0679 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 20, 1, 22, 26) fem-multicore-cpp 106.75 "Coloring mesh." (2013, 6, 20, 1, 24, 56) fem-assembly-cpp 150.162 "Assembly for various forms and backends" (2013, 6, 20, 1, 25, 8) fem-convergence-cpp 12.1359 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 20, 1, 25, 10) fem-jit-python 0.00104589 "JIT compilation (in memory cache)" (2013, 6, 20, 1, 30, 16) fem-speedup-cpp 305.57 "Assembly/solve speedup running on 4 processors" (2013, 6, 20, 1, 30, 16) fem-speedup-cpp-assembly 6.59022 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 20, 1, 30, 16) fem-speedup-cpp-solve 2.30706 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 20, 1, 30, 37) mesh-refinement-cpp 19.9497 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 20, 1, 30, 56) mesh-topology-cpp 19.2791 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 20, 1, 31, 20) mesh-unitcube-cpp 23.703 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 20, 1, 31, 58) mesh-iteration-cpp 35.6198 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 20, 1, 32, 19) function-evaluation-cpp 21.1828 "Evaluations of functions at arbitrary points." (2013, 6, 20, 1, 32, 19) function-evaluation-cpp 21.0847 "Evaluations of functions at arbitrary points." (2013, 6, 20, 1, 32, 23) function-extrapolation-python 3.48642 "*** -------------------------------------------------------------------------" (2013, 6, 20, 1, 32, 23) function-extrapolation-python 1.07007 "*** -------------------------------------------------------------------------" (2013, 6, 20, 1, 32, 49) la-vector-access-cpp 26.6633 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 20, 1, 33, 14) la-vector-assignment-cpp 25.0629 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 21, 1, 20, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.00255 "Running DOLFIN bench" (2013, 6, 21, 1, 20, 33) geometry-bounding_box_tree_compute_closest_entity-cpp 0.241965 "Running DOLFIN bench" (2013, 6, 21, 1, 20, 42) geometry-bounding_box_tree_build-cpp 8.91783 "Running DOLFIN bench" (2013, 6, 21, 1, 21, 10) common-progress-cpp 27.6518 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 21, 1, 21, 39) common-timing-cpp 29.6996 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 21, 1, 23, 26) fem-multicore-cpp 106.675 "Coloring mesh." (2013, 6, 21, 1, 25, 56) fem-assembly-cpp 149.796 "Assembly for various forms and backends" (2013, 6, 21, 1, 26, 8) fem-convergence-cpp 12.1228 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 21, 1, 26, 10) fem-jit-python 0.00104182 "JIT compilation (in memory cache)" (2013, 6, 21, 1, 31, 14) fem-speedup-cpp 304.175 "Assembly/solve speedup running on 4 processors" (2013, 6, 21, 1, 31, 14) fem-speedup-cpp-assembly 6.52679 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 21, 1, 31, 14) fem-speedup-cpp-solve 2.35608 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 21, 1, 31, 35) mesh-refinement-cpp 19.9568 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 21, 1, 31, 54) mesh-topology-cpp 19.2496 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 21, 1, 32, 18) mesh-unitcube-cpp 23.7255 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 21, 1, 32, 56) mesh-iteration-cpp 35.5501 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 21, 1, 33, 17) function-evaluation-cpp 21.2465 "Evaluations of functions at arbitrary points." (2013, 6, 21, 1, 33, 17) function-evaluation-cpp 21.0945 "Evaluations of functions at arbitrary points." (2013, 6, 21, 1, 33, 20) function-extrapolation-python 3.34933 "*** -------------------------------------------------------------------------" (2013, 6, 21, 1, 33, 20) function-extrapolation-python 1.07003 "*** -------------------------------------------------------------------------" (2013, 6, 21, 1, 33, 47) la-vector-access-cpp 26.6105 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 21, 1, 34, 12) la-vector-assignment-cpp 25.0683 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 22, 1, 19, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.0347 "Running DOLFIN bench" (2013, 6, 22, 1, 19, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 0.247956 "Running DOLFIN bench" (2013, 6, 22, 1, 19, 41) geometry-bounding_box_tree_build-cpp 8.91841 "Running DOLFIN bench" (2013, 6, 22, 1, 20, 8) common-progress-cpp 27.6515 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 22, 1, 20, 38) common-timing-cpp 29.363 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 22, 1, 22, 24) fem-multicore-cpp 106.15 "Coloring mesh." (2013, 6, 22, 1, 24, 54) fem-assembly-cpp 150.281 "Assembly for various forms and backends" (2013, 6, 22, 1, 25, 6) fem-convergence-cpp 12.1131 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 22, 1, 25, 8) fem-jit-python 0.0010313 "JIT compilation (in memory cache)" (2013, 6, 22, 1, 30, 12) fem-speedup-cpp 304.27 "Assembly/solve speedup running on 4 processors" (2013, 6, 22, 1, 30, 12) fem-speedup-cpp-assembly 6.65971 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 22, 1, 30, 12) fem-speedup-cpp-solve 2.34752 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 22, 1, 30, 33) mesh-refinement-cpp 19.977 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 22, 1, 30, 53) mesh-topology-cpp 19.3671 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 22, 1, 31, 16) mesh-unitcube-cpp 23.7933 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 22, 1, 31, 54) mesh-iteration-cpp 35.5379 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 22, 1, 32, 16) function-evaluation-cpp 21.1421 "Evaluations of functions at arbitrary points." (2013, 6, 22, 1, 32, 16) function-evaluation-cpp 21.0617 "Evaluations of functions at arbitrary points." (2013, 6, 22, 1, 32, 19) function-extrapolation-python 3.48722 "*** -------------------------------------------------------------------------" (2013, 6, 22, 1, 32, 19) function-extrapolation-python 1.06074 "*** -------------------------------------------------------------------------" (2013, 6, 22, 1, 32, 46) la-vector-access-cpp 26.6689 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 22, 1, 33, 11) la-vector-assignment-cpp 25.0185 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 23, 1, 20, 24) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.04981 "Running DOLFIN bench" (2013, 6, 23, 1, 20, 25) geometry-bounding_box_tree_compute_closest_entity-cpp 0.251087 "Running DOLFIN bench" (2013, 6, 23, 1, 20, 34) geometry-bounding_box_tree_build-cpp 8.91578 "Running DOLFIN bench" (2013, 6, 23, 1, 21, 1) common-progress-cpp 27.6709 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 23, 1, 21, 30) common-timing-cpp 29.0022 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 23, 1, 23, 18) fem-multicore-cpp 107.152 "Coloring mesh." (2013, 6, 23, 1, 25, 48) fem-assembly-cpp 150.594 "Assembly for various forms and backends" (2013, 6, 23, 1, 26, 0) fem-convergence-cpp 12.1143 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 23, 1, 26, 2) fem-jit-python 0.00102971 "JIT compilation (in memory cache)" (2013, 6, 23, 1, 31, 9) fem-speedup-cpp 306.745 "Assembly/solve speedup running on 4 processors" (2013, 6, 23, 1, 31, 9) fem-speedup-cpp-assembly 6.60189 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 23, 1, 31, 9) fem-speedup-cpp-solve 2.2781 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 23, 1, 31, 30) mesh-refinement-cpp 19.9 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 23, 1, 31, 49) mesh-topology-cpp 19.3828 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 23, 1, 32, 13) mesh-unitcube-cpp 23.6912 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 23, 1, 32, 51) mesh-iteration-cpp 35.542 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 23, 1, 33, 12) function-evaluation-cpp 21.392 "Evaluations of functions at arbitrary points." (2013, 6, 23, 1, 33, 12) function-evaluation-cpp 21.2975 "Evaluations of functions at arbitrary points." (2013, 6, 23, 1, 33, 16) function-extrapolation-python 3.52865 "*** -------------------------------------------------------------------------" (2013, 6, 23, 1, 33, 16) function-extrapolation-python 1.06646 "*** -------------------------------------------------------------------------" (2013, 6, 23, 1, 33, 43) la-vector-access-cpp 26.6464 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 23, 1, 34, 8) la-vector-assignment-cpp 25.0864 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 24, 1, 22, 5) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.02357 "Running DOLFIN bench" (2013, 6, 24, 1, 22, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 0.252157 "Running DOLFIN bench" (2013, 6, 24, 1, 22, 15) geometry-bounding_box_tree_build-cpp 8.92266 "Running DOLFIN bench" (2013, 6, 24, 1, 22, 43) common-progress-cpp 27.6514 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 24, 1, 23, 12) common-timing-cpp 29.4971 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 24, 1, 24, 59) fem-multicore-cpp 106.448 "Coloring mesh." (2013, 6, 24, 1, 27, 28) fem-assembly-cpp 149.021 "Assembly for various forms and backends" (2013, 6, 24, 1, 27, 40) fem-convergence-cpp 12.0973 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 24, 1, 27, 42) fem-jit-python 0.0010267 "JIT compilation (in memory cache)" (2013, 6, 24, 1, 32, 47) fem-speedup-cpp 305.462 "Assembly/solve speedup running on 4 processors" (2013, 6, 24, 1, 32, 47) fem-speedup-cpp-assembly 6.57214 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 24, 1, 32, 47) fem-speedup-cpp-solve 2.30769 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 24, 1, 33, 8) mesh-refinement-cpp 19.841 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 24, 1, 33, 27) mesh-topology-cpp 19.2275 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 24, 1, 33, 51) mesh-unitcube-cpp 23.7731 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 24, 1, 34, 38) mesh-iteration-cpp 44.1729 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 24, 1, 34, 59) function-evaluation-cpp 21.1377 "Evaluations of functions at arbitrary points." (2013, 6, 24, 1, 34, 59) function-evaluation-cpp 21.0585 "Evaluations of functions at arbitrary points." (2013, 6, 24, 1, 35, 3) function-extrapolation-python 3.44717 "*** -------------------------------------------------------------------------" (2013, 6, 24, 1, 35, 3) function-extrapolation-python 1.06254 "*** -------------------------------------------------------------------------" (2013, 6, 24, 1, 35, 29) la-vector-access-cpp 26.6648 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 24, 1, 36, 21) la-vector-assignment-cpp 51.9926 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 25, 1, 24, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 2.01368 "Running DOLFIN bench" (2013, 6, 25, 1, 24, 37) geometry-bounding_box_tree_compute_closest_entity-cpp 0.249098 "Running DOLFIN bench" (2013, 6, 25, 1, 24, 46) geometry-bounding_box_tree_build-cpp 8.94414 "Running DOLFIN bench" (2013, 6, 25, 1, 25, 13) common-progress-cpp 27.6515 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 25, 1, 25, 43) common-timing-cpp 29.6993 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 25, 1, 27, 29) fem-multicore-cpp 106.12 "Coloring mesh." (2013, 6, 25, 1, 29, 58) fem-assembly-cpp 148.979 "Assembly for various forms and backends" (2013, 6, 25, 1, 30, 10) fem-convergence-cpp 12.1281 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 25, 1, 30, 12) fem-jit-python 0.00102642 "JIT compilation (in memory cache)" (2013, 6, 25, 1, 35, 17) fem-speedup-cpp 304.555 "Assembly/solve speedup running on 4 processors" (2013, 6, 25, 1, 35, 17) fem-speedup-cpp-assembly 6.56854 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 25, 1, 35, 17) fem-speedup-cpp-solve 2.3434 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 25, 1, 35, 38) mesh-refinement-cpp 19.9316 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 25, 1, 35, 57) mesh-topology-cpp 19.2516 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 25, 1, 36, 21) mesh-unitcube-cpp 23.7794 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 25, 1, 36, 59) mesh-iteration-cpp 35.482 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 25, 1, 37, 23) function-evaluation-cpp 23.8374 "Evaluations of functions at arbitrary points." (2013, 6, 25, 1, 37, 23) function-evaluation-cpp 23.7472 "Evaluations of functions at arbitrary points." (2013, 6, 25, 1, 37, 26) function-extrapolation-python 3.43714 "*** -------------------------------------------------------------------------" (2013, 6, 25, 1, 37, 26) function-extrapolation-python 1.06803 "*** -------------------------------------------------------------------------" (2013, 6, 25, 1, 37, 53) la-vector-access-cpp 26.6494 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 25, 1, 38, 18) la-vector-assignment-cpp 25.0626 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 26, 1, 19, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.052 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 26, 1, 19, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9759 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 26, 1, 20, 13) geometry-bounding_box_tree_build-cpp 13.9509 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 6, 26, 1, 20, 41) common-progress-cpp 27.6734 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 26, 1, 21, 10) common-timing-cpp 29.6124 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 26, 1, 22, 57) fem-multicore-cpp 106.824 "Coloring mesh." (2013, 6, 26, 1, 25, 26) fem-assembly-cpp 148.913 "Assembly for various forms and backends" (2013, 6, 26, 1, 25, 38) fem-convergence-cpp 12.0976 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 26, 1, 25, 40) fem-jit-python 0.0010273 "JIT compilation (in memory cache)" (2013, 6, 26, 1, 30, 45) fem-speedup-cpp 304.521 "Assembly/solve speedup running on 4 processors" (2013, 6, 26, 1, 30, 45) fem-speedup-cpp-assembly 6.56625 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 26, 1, 30, 45) fem-speedup-cpp-solve 2.3378 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 26, 1, 31, 6) mesh-refinement-cpp 20.2577 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 26, 1, 31, 25) mesh-topology-cpp 19.1865 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 26, 1, 31, 49) mesh-unitcube-cpp 24.2101 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 26, 1, 32, 27) mesh-iteration-cpp 35.4874 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 26, 1, 32, 48) function-evaluation-cpp 21.142 "Evaluations of functions at arbitrary points." (2013, 6, 26, 1, 32, 48) function-evaluation-cpp 21.0654 "Evaluations of functions at arbitrary points." (2013, 6, 26, 1, 32, 52) function-extrapolation-python 3.32757 "BENCH: 1.07621788979" (2013, 6, 26, 1, 32, 52) function-extrapolation-python 1.07622 "BENCH: 1.07621788979" (2013, 6, 26, 1, 33, 5) function-interpolation-python 13.677 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2013, 6, 26, 1, 33, 5) function-interpolation-python 1.01533 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2013, 6, 26, 1, 33, 29) la-vector-access-cpp 23.4307 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 26, 1, 33, 54) la-vector-assignment-cpp 25.2351 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 27, 1, 18, 26) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1635 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 27, 1, 18, 45) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5452 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 27, 1, 19, 2) geometry-bounding_box_tree_build-cpp 13.9163 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 6, 27, 1, 19, 29) common-progress-cpp 27.6513 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 27, 1, 19, 59) common-timing-cpp 29.4253 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 27, 1, 21, 46) fem-multicore-cpp 107.207 "Coloring mesh." (2013, 6, 27, 1, 24, 16) fem-assembly-cpp 150.237 "Assembly for various forms and backends" (2013, 6, 27, 1, 24, 28) fem-convergence-cpp 12.0987 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 27, 1, 24, 30) fem-jit-python 0.00102119 "JIT compilation (in memory cache)" (2013, 6, 27, 1, 29, 37) fem-speedup-cpp 306.713 "Assembly/solve speedup running on 4 processors" (2013, 6, 27, 1, 29, 37) fem-speedup-cpp-assembly 6.43291 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 27, 1, 29, 37) fem-speedup-cpp-solve 2.20448 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 27, 1, 29, 59) mesh-refinement-cpp 20.3919 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 27, 1, 30, 19) mesh-topology-cpp 19.2391 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 27, 1, 30, 43) mesh-unitcube-cpp 23.9996 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 27, 1, 31, 21) mesh-iteration-cpp 35.4696 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 27, 1, 31, 42) function-evaluation-cpp 21.2065 "Evaluations of functions at arbitrary points." (2013, 6, 27, 1, 31, 42) function-evaluation-cpp 21.109 "Evaluations of functions at arbitrary points." (2013, 6, 27, 1, 31, 46) function-extrapolation-python 3.39981 "BENCH: 1.04391694069" (2013, 6, 27, 1, 31, 46) function-extrapolation-python 1.04392 "BENCH: 1.04391694069" (2013, 6, 27, 1, 31, 47) function-interpolation-python 1.70294 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 27, 1, 31, 47) function-interpolation-python 1.01541 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 27, 1, 32, 11) la-vector-access-cpp 23.466 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 27, 1, 32, 36) la-vector-assignment-cpp 25.0813 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 28, 1, 21, 59) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.233 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 28, 1, 22, 18) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4551 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 28, 1, 22, 35) geometry-bounding_box_tree_build-cpp 13.9201 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 6, 28, 1, 23, 2) common-progress-cpp 27.6522 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 28, 1, 23, 32) common-timing-cpp 29.6371 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 28, 1, 25, 19) fem-multicore-cpp 107.22 "Coloring mesh." (2013, 6, 28, 1, 27, 50) fem-assembly-cpp 150.501 "Assembly for various forms and backends" (2013, 6, 28, 1, 28, 2) fem-convergence-cpp 12.1224 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 28, 1, 28, 4) fem-jit-python 0.0010252 "JIT compilation (in memory cache)" (2013, 6, 28, 1, 33, 8) fem-speedup-cpp 304.421 "Assembly/solve speedup running on 4 processors" (2013, 6, 28, 1, 33, 8) fem-speedup-cpp-assembly 6.42501 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 28, 1, 33, 8) fem-speedup-cpp-solve 2.33589 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 28, 1, 33, 29) mesh-refinement-cpp 20.4394 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 28, 1, 33, 49) mesh-topology-cpp 19.1051 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 28, 1, 34, 13) mesh-unitcube-cpp 24.1013 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 28, 1, 34, 51) mesh-iteration-cpp 35.4871 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 28, 1, 35, 12) function-evaluation-cpp 21.1355 "Evaluations of functions at arbitrary points." (2013, 6, 28, 1, 35, 12) function-evaluation-cpp 21.0556 "Evaluations of functions at arbitrary points." (2013, 6, 28, 1, 35, 15) function-extrapolation-python 3.47554 "BENCH: 1.08120799065" (2013, 6, 28, 1, 35, 15) function-extrapolation-python 1.08121 "BENCH: 1.08120799065" (2013, 6, 28, 1, 35, 17) function-interpolation-python 1.73452 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 28, 1, 35, 17) function-interpolation-python 1.02952 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 28, 1, 35, 42) la-vector-access-cpp 24.9347 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 28, 1, 36, 7) la-vector-assignment-cpp 25.0677 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 29, 1, 20, 7) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.98778 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 29, 1, 20, 26) geometry-bounding_box_tree_compute_closest_entity-cpp 15.956 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 29, 1, 20, 42) geometry-bounding_box_tree_build-cpp 13.946 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 6, 29, 1, 21, 10) common-progress-cpp 27.6508 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 29, 1, 21, 40) common-timing-cpp 29.626 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 29, 1, 23, 26) fem-multicore-cpp 106.519 "Coloring mesh." (2013, 6, 29, 1, 25, 58) fem-assembly-cpp 151.622 "Assembly for various forms and backends" (2013, 6, 29, 1, 26, 10) fem-convergence-cpp 12.14 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 29, 1, 26, 12) fem-jit-python 0.00102689 "JIT compilation (in memory cache)" (2013, 6, 29, 1, 31, 17) fem-speedup-cpp 305.375 "Assembly/solve speedup running on 4 processors" (2013, 6, 29, 1, 31, 17) fem-speedup-cpp-assembly 6.53872 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 29, 1, 31, 17) fem-speedup-cpp-solve 2.30211 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 29, 1, 31, 39) mesh-refinement-cpp 19.8389 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 29, 1, 31, 58) mesh-topology-cpp 19.189 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 29, 1, 32, 22) mesh-unitcube-cpp 23.8037 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 29, 1, 33, 0) mesh-iteration-cpp 35.5468 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 29, 1, 33, 21) function-evaluation-cpp 21.2393 "Evaluations of functions at arbitrary points." (2013, 6, 29, 1, 33, 21) function-evaluation-cpp 21.1169 "Evaluations of functions at arbitrary points." (2013, 6, 29, 1, 33, 25) function-extrapolation-python 3.48692 "BENCH: 1.05940794945" (2013, 6, 29, 1, 33, 25) function-extrapolation-python 1.05941 "BENCH: 1.05940794945" (2013, 6, 29, 1, 33, 27) function-interpolation-python 1.70543 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 29, 1, 33, 27) function-interpolation-python 0.989151 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 29, 1, 33, 50) la-vector-access-cpp 22.9622 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 29, 1, 34, 16) la-vector-assignment-cpp 26.5791 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 6, 30, 1, 18, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.94825 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 30, 1, 19, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6785 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 6, 30, 1, 19, 17) geometry-bounding_box_tree_build-cpp 13.9037 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 6, 30, 1, 19, 44) common-progress-cpp 27.6507 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 6, 30, 1, 20, 13) common-timing-cpp 29.2491 "Timing access and registration of timings (10000000 repetitions)" (2013, 6, 30, 1, 22, 1) fem-multicore-cpp 107.062 "Coloring mesh." (2013, 6, 30, 1, 24, 32) fem-assembly-cpp 151.972 "Assembly for various forms and backends" (2013, 6, 30, 1, 24, 45) fem-convergence-cpp 12.1418 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 6, 30, 1, 24, 46) fem-jit-python 0.00101938 "JIT compilation (in memory cache)" (2013, 6, 30, 1, 29, 51) fem-speedup-cpp 304.355 "Assembly/solve speedup running on 4 processors" (2013, 6, 30, 1, 29, 51) fem-speedup-cpp-assembly 6.46667 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 6, 30, 1, 29, 51) fem-speedup-cpp-solve 2.29099 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 6, 30, 1, 30, 11) mesh-refinement-cpp 19.8138 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 6, 30, 1, 30, 31) mesh-topology-cpp 19.0801 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 6, 30, 1, 30, 54) mesh-unitcube-cpp 23.7084 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 6, 30, 1, 31, 32) mesh-iteration-cpp 35.5482 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 6, 30, 1, 31, 54) function-evaluation-cpp 21.3393 "Evaluations of functions at arbitrary points." (2013, 6, 30, 1, 31, 54) function-evaluation-cpp 21.2598 "Evaluations of functions at arbitrary points." (2013, 6, 30, 1, 31, 57) function-extrapolation-python 3.43798 "BENCH: 1.06357097626" (2013, 6, 30, 1, 31, 57) function-extrapolation-python 1.06357 "BENCH: 1.06357097626" (2013, 6, 30, 1, 31, 59) function-interpolation-python 1.71728 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 30, 1, 31, 59) function-interpolation-python 0.988438 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 6, 30, 1, 32, 22) la-vector-access-cpp 22.9315 "Accessing vector of size 10000000 (100 repetitions)" (2013, 6, 30, 1, 32, 47) la-vector-assignment-cpp 25.0601 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 1, 1, 19, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.94445 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 1, 1, 19, 48) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5602 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 1, 1, 20, 5) geometry-bounding_box_tree_build-cpp 13.9307 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 1, 1, 20, 32) common-progress-cpp 27.6927 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 1, 1, 21, 2) common-timing-cpp 30.2776 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 1, 1, 22, 49) fem-multicore-cpp 106.882 "Coloring mesh." (2013, 7, 1, 1, 25, 21) fem-assembly-cpp 151.188 "Assembly for various forms and backends" (2013, 7, 1, 1, 25, 33) fem-convergence-cpp 12.1325 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 1, 1, 25, 35) fem-jit-python 0.00104339 "JIT compilation (in memory cache)" (2013, 7, 1, 1, 30, 43) fem-speedup-cpp 308.667 "Assembly/solve speedup running on 4 processors" (2013, 7, 1, 1, 30, 43) fem-speedup-cpp-assembly 6.54876 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 1, 1, 30, 43) fem-speedup-cpp-solve 2.24878 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 1, 1, 31, 5) mesh-refinement-cpp 19.8094 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 1, 1, 31, 24) mesh-topology-cpp 19.1102 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 1, 1, 31, 48) mesh-unitcube-cpp 23.6569 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 1, 1, 32, 26) mesh-iteration-cpp 35.5557 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 1, 1, 32, 48) function-evaluation-cpp 21.7388 "Evaluations of functions at arbitrary points." (2013, 7, 1, 1, 32, 48) function-evaluation-cpp 21.5251 "Evaluations of functions at arbitrary points." (2013, 7, 1, 1, 32, 51) function-extrapolation-python 3.48752 "BENCH: 1.04092788696" (2013, 7, 1, 1, 32, 51) function-extrapolation-python 1.04093 "BENCH: 1.04092788696" (2013, 7, 1, 1, 32, 53) function-interpolation-python 1.67918 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 1, 1, 32, 53) function-interpolation-python 0.988947 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 1, 1, 33, 16) la-vector-access-cpp 22.9659 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 1, 1, 33, 47) la-vector-assignment-cpp 31.0876 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 2, 1, 18, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.95872 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 2, 1, 18, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8588 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 2, 1, 19, 13) geometry-bounding_box_tree_build-cpp 13.9414 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 2, 1, 19, 41) common-progress-cpp 27.6939 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 2, 1, 20, 11) common-timing-cpp 30.0686 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 2, 1, 21, 58) fem-multicore-cpp 106.887 "Coloring mesh." (2013, 7, 2, 1, 24, 29) fem-assembly-cpp 150.977 "Assembly for various forms and backends" (2013, 7, 2, 1, 24, 41) fem-convergence-cpp 12.1506 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 2, 1, 24, 43) fem-jit-python 0.0010335 "JIT compilation (in memory cache)" (2013, 7, 2, 1, 29, 49) fem-speedup-cpp 305.941 "Assembly/solve speedup running on 4 processors" (2013, 7, 2, 1, 29, 49) fem-speedup-cpp-assembly 6.55237 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 2, 1, 29, 49) fem-speedup-cpp-solve 2.32496 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 2, 1, 30, 10) mesh-refinement-cpp 19.8874 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 2, 1, 30, 29) mesh-topology-cpp 19.1405 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 2, 1, 30, 53) mesh-unitcube-cpp 23.6454 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 2, 1, 31, 39) mesh-iteration-cpp 43.488 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 2, 1, 32, 0) function-evaluation-cpp 21.2226 "Evaluations of functions at arbitrary points." (2013, 7, 2, 1, 32, 0) function-evaluation-cpp 21.0906 "Evaluations of functions at arbitrary points." (2013, 7, 2, 1, 32, 4) function-extrapolation-python 3.43693 "BENCH: 1.08355903625" (2013, 7, 2, 1, 32, 4) function-extrapolation-python 1.08356 "BENCH: 1.08355903625" (2013, 7, 2, 1, 32, 5) function-interpolation-python 1.68331 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 2, 1, 32, 5) function-interpolation-python 0.983895 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 2, 1, 32, 28) la-vector-access-cpp 22.9534 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 2, 1, 32, 54) la-vector-assignment-cpp 25.1391 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 3, 1, 20, 15) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0174 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 3, 1, 20, 34) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8954 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 3, 1, 20, 51) geometry-bounding_box_tree_build-cpp 13.922 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 3, 1, 21, 19) common-progress-cpp 27.6511 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 3, 1, 21, 48) common-timing-cpp 29.2757 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 3, 1, 23, 35) fem-multicore-cpp 106.784 "Coloring mesh." (2013, 7, 3, 1, 26, 5) fem-assembly-cpp 150.519 "Assembly for various forms and backends" (2013, 7, 3, 1, 26, 17) fem-convergence-cpp 12.1423 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 3, 1, 26, 19) fem-jit-python 0.00102601 "JIT compilation (in memory cache)" (2013, 7, 3, 1, 31, 24) fem-speedup-cpp 304.578 "Assembly/solve speedup running on 4 processors" (2013, 7, 3, 1, 31, 24) fem-speedup-cpp-assembly 6.55427 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 3, 1, 31, 24) fem-speedup-cpp-solve 2.32802 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 3, 1, 31, 45) mesh-refinement-cpp 19.9214 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 3, 1, 32, 4) mesh-topology-cpp 19.0688 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 3, 1, 32, 27) mesh-unitcube-cpp 23.6578 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 3, 1, 33, 5) mesh-iteration-cpp 35.5686 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 3, 1, 33, 27) function-evaluation-cpp 21.5741 "Evaluations of functions at arbitrary points." (2013, 7, 3, 1, 33, 27) function-evaluation-cpp 21.4359 "Evaluations of functions at arbitrary points." (2013, 7, 3, 1, 33, 30) function-extrapolation-python 3.41227 "BENCH: 1.06535696983" (2013, 7, 3, 1, 33, 30) function-extrapolation-python 1.06536 "BENCH: 1.06535696983" (2013, 7, 3, 1, 33, 32) function-interpolation-python 1.69855 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 3, 1, 33, 32) function-interpolation-python 0.986731 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 3, 1, 33, 55) la-vector-access-cpp 22.9329 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 3, 1, 34, 20) la-vector-assignment-cpp 25.0666 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 4, 1, 19, 1) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.98408 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 4, 1, 19, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8282 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 4, 1, 19, 37) geometry-bounding_box_tree_build-cpp 13.9292 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 4, 1, 20, 4) common-progress-cpp 27.6884 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 4, 1, 20, 33) common-timing-cpp 28.9368 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 4, 1, 22, 20) fem-multicore-cpp 107.197 "Coloring mesh." (2013, 7, 4, 1, 24, 51) fem-assembly-cpp 150.949 "Assembly for various forms and backends" (2013, 7, 4, 1, 25, 3) fem-convergence-cpp 12.1425 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 4, 1, 25, 5) fem-jit-python 0.0010258 "JIT compilation (in memory cache)" (2013, 7, 4, 1, 30, 10) fem-speedup-cpp 304.242 "Assembly/solve speedup running on 4 processors" (2013, 7, 4, 1, 30, 10) fem-speedup-cpp-assembly 6.5339 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 4, 1, 30, 10) fem-speedup-cpp-solve 2.32998 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 4, 1, 30, 30) mesh-refinement-cpp 19.8843 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 4, 1, 30, 49) mesh-topology-cpp 19.0281 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 4, 1, 31, 13) mesh-unitcube-cpp 23.6529 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 4, 1, 32, 0) mesh-iteration-cpp 44.1699 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 4, 1, 32, 21) function-evaluation-cpp 21.2045 "Evaluations of functions at arbitrary points." (2013, 7, 4, 1, 32, 21) function-evaluation-cpp 21.1103 "Evaluations of functions at arbitrary points." (2013, 7, 4, 1, 32, 24) function-extrapolation-python 3.42298 "BENCH: 1.05984997749" (2013, 7, 4, 1, 32, 24) function-extrapolation-python 1.05985 "BENCH: 1.05984997749" (2013, 7, 4, 1, 32, 26) function-interpolation-python 1.72571 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 4, 1, 32, 26) function-interpolation-python 1.00254 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 4, 1, 32, 49) la-vector-access-cpp 22.9283 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 4, 1, 33, 16) la-vector-assignment-cpp 27.0832 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 5, 1, 22, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.98344 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 5, 1, 22, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7737 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 5, 1, 23, 0) geometry-bounding_box_tree_build-cpp 13.9459 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 5, 1, 23, 28) common-progress-cpp 27.6494 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 5, 1, 23, 57) common-timing-cpp 29.3252 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 5, 1, 25, 44) fem-multicore-cpp 107.175 "Coloring mesh." (2013, 7, 5, 1, 28, 15) fem-assembly-cpp 150.562 "Assembly for various forms and backends" (2013, 7, 5, 1, 28, 27) fem-convergence-cpp 12.1569 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 5, 1, 28, 29) fem-jit-python 0.00102131 "JIT compilation (in memory cache)" (2013, 7, 5, 1, 33, 35) fem-speedup-cpp 305.534 "Assembly/solve speedup running on 4 processors" (2013, 7, 5, 1, 33, 35) fem-speedup-cpp-assembly 6.42825 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 5, 1, 33, 35) fem-speedup-cpp-solve 2.3151 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 5, 1, 33, 56) mesh-refinement-cpp 19.859 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 5, 1, 34, 15) mesh-topology-cpp 19.0733 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 5, 1, 34, 38) mesh-unitcube-cpp 23.6133 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 5, 1, 35, 17) mesh-iteration-cpp 35.9329 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 5, 1, 35, 38) function-evaluation-cpp 21.2105 "Evaluations of functions at arbitrary points." (2013, 7, 5, 1, 35, 38) function-evaluation-cpp 21.1304 "Evaluations of functions at arbitrary points." (2013, 7, 5, 1, 35, 41) function-extrapolation-python 3.40392 "BENCH: 1.05796909332" (2013, 7, 5, 1, 35, 41) function-extrapolation-python 1.05797 "BENCH: 1.05796909332" (2013, 7, 5, 1, 35, 43) function-interpolation-python 1.69202 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 5, 1, 35, 43) function-interpolation-python 0.983444 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 5, 1, 36, 6) la-vector-access-cpp 22.927 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 5, 1, 36, 34) la-vector-assignment-cpp 27.5813 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 6, 1, 21, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0943 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 6, 1, 21, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9917 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 6, 1, 22, 15) geometry-bounding_box_tree_build-cpp 13.9244 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 6, 1, 22, 42) common-progress-cpp 27.6511 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 6, 1, 23, 12) common-timing-cpp 29.9151 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 6, 1, 24, 59) fem-multicore-cpp 106.766 "Coloring mesh." (2013, 7, 6, 1, 27, 30) fem-assembly-cpp 151.133 "Assembly for various forms and backends" (2013, 7, 6, 1, 27, 42) fem-convergence-cpp 12.1484 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 6, 1, 27, 44) fem-jit-python 0.00102439 "JIT compilation (in memory cache)" (2013, 7, 6, 1, 32, 52) fem-speedup-cpp 307.635 "Assembly/solve speedup running on 4 processors" (2013, 7, 6, 1, 32, 52) fem-speedup-cpp-assembly 6.56845 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 6, 1, 32, 52) fem-speedup-cpp-solve 2.31764 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 6, 1, 33, 14) mesh-refinement-cpp 19.841 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 6, 1, 33, 33) mesh-topology-cpp 19.0317 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 6, 1, 33, 56) mesh-unitcube-cpp 23.6101 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 6, 1, 34, 34) mesh-iteration-cpp 35.543 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 6, 1, 34, 56) function-evaluation-cpp 21.1976 "Evaluations of functions at arbitrary points." (2013, 7, 6, 1, 34, 56) function-evaluation-cpp 21.0719 "Evaluations of functions at arbitrary points." (2013, 7, 6, 1, 34, 59) function-extrapolation-python 3.4121 "BENCH: 1.06983804703" (2013, 7, 6, 1, 34, 59) function-extrapolation-python 1.06984 "BENCH: 1.06983804703" (2013, 7, 6, 1, 35, 1) function-interpolation-python 1.68892 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 6, 1, 35, 1) function-interpolation-python 0.990675 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 6, 1, 35, 29) la-vector-access-cpp 28.4662 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 6, 1, 36, 0) la-vector-assignment-cpp 31.1232 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 7, 1, 18, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1408 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 7, 1, 19, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8396 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 7, 1, 19, 25) geometry-bounding_box_tree_build-cpp 13.9329 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 7, 1, 19, 53) common-progress-cpp 27.6509 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 7, 1, 20, 23) common-timing-cpp 29.6991 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 7, 1, 22, 9) fem-multicore-cpp 106.778 "Coloring mesh." (2013, 7, 7, 1, 24, 41) fem-assembly-cpp 151.93 "Assembly for various forms and backends" (2013, 7, 7, 1, 24, 53) fem-convergence-cpp 12.1423 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 7, 1, 24, 55) fem-jit-python 0.00102012 "JIT compilation (in memory cache)" (2013, 7, 7, 1, 30, 2) fem-speedup-cpp 306.449 "Assembly/solve speedup running on 4 processors" (2013, 7, 7, 1, 30, 2) fem-speedup-cpp-assembly 6.51973 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 7, 1, 30, 2) fem-speedup-cpp-solve 2.30563 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 7, 1, 30, 23) mesh-refinement-cpp 19.8291 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 7, 1, 30, 44) mesh-topology-cpp 20.1929 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 7, 1, 31, 7) mesh-unitcube-cpp 23.7033 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 7, 1, 31, 46) mesh-iteration-cpp 35.7503 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 7, 1, 32, 7) function-evaluation-cpp 21.2559 "Evaluations of functions at arbitrary points." (2013, 7, 7, 1, 32, 7) function-evaluation-cpp 21.1299 "Evaluations of functions at arbitrary points." (2013, 7, 7, 1, 32, 10) function-extrapolation-python 3.44534 "BENCH: 1.04738879204" (2013, 7, 7, 1, 32, 10) function-extrapolation-python 1.04739 "BENCH: 1.04738879204" (2013, 7, 7, 1, 32, 12) function-interpolation-python 1.70355 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 7, 1, 32, 12) function-interpolation-python 0.98673 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 7, 1, 32, 35) la-vector-access-cpp 23.1092 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 7, 1, 33, 0) la-vector-assignment-cpp 25.0661 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 8, 1, 18, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0342 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 8, 1, 19, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6658 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 8, 1, 19, 22) geometry-bounding_box_tree_build-cpp 13.9396 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 8, 1, 19, 50) common-progress-cpp 27.6501 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 8, 1, 20, 18) common-timing-cpp 28.8151 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 8, 1, 22, 5) fem-multicore-cpp 106.787 "Coloring mesh." (2013, 7, 8, 1, 24, 36) fem-assembly-cpp 150.746 "Assembly for various forms and backends" (2013, 7, 8, 1, 24, 48) fem-convergence-cpp 12.1321 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 8, 1, 24, 50) fem-jit-python 0.00102851 "JIT compilation (in memory cache)" (2013, 7, 8, 1, 29, 59) fem-speedup-cpp 308.532 "Assembly/solve speedup running on 4 processors" (2013, 7, 8, 1, 29, 59) fem-speedup-cpp-assembly 6.5338 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 8, 1, 29, 59) fem-speedup-cpp-solve 2.24668 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 8, 1, 30, 20) mesh-refinement-cpp 19.8252 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 8, 1, 30, 39) mesh-topology-cpp 19.0122 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 8, 1, 31, 3) mesh-unitcube-cpp 23.6488 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 8, 1, 31, 41) mesh-iteration-cpp 35.5809 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 8, 1, 32, 2) function-evaluation-cpp 21.2309 "Evaluations of functions at arbitrary points." (2013, 7, 8, 1, 32, 2) function-evaluation-cpp 21.1236 "Evaluations of functions at arbitrary points." (2013, 7, 8, 1, 32, 6) function-extrapolation-python 3.32295 "BENCH: 1.05665493011" (2013, 7, 8, 1, 32, 6) function-extrapolation-python 1.05665 "BENCH: 1.05665493011" (2013, 7, 8, 1, 32, 8) function-interpolation-python 1.75593 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 8, 1, 32, 8) function-interpolation-python 1.00926 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 8, 1, 32, 31) la-vector-access-cpp 22.9717 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 8, 1, 32, 56) la-vector-assignment-cpp 25.084 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 9, 1, 18, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.91525 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 9, 1, 18, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7343 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 9, 1, 19, 7) geometry-bounding_box_tree_build-cpp 13.928 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 9, 1, 19, 35) common-progress-cpp 27.6506 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 9, 1, 20, 4) common-timing-cpp 29.6309 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 9, 1, 21, 51) fem-multicore-cpp 107.104 "Coloring mesh." (2013, 7, 9, 1, 24, 22) fem-assembly-cpp 150.474 "Assembly for various forms and backends" (2013, 7, 9, 1, 24, 34) fem-convergence-cpp 12.1342 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 9, 1, 24, 36) fem-jit-python 0.00103209 "JIT compilation (in memory cache)" (2013, 7, 9, 1, 29, 45) fem-speedup-cpp 309.241 "Assembly/solve speedup running on 4 processors" (2013, 7, 9, 1, 29, 45) fem-speedup-cpp-assembly 6.45651 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 9, 1, 29, 45) fem-speedup-cpp-solve 2.26068 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 9, 1, 30, 8) mesh-refinement-cpp 19.8057 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 9, 1, 30, 27) mesh-topology-cpp 19.076 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 9, 1, 30, 50) mesh-unitcube-cpp 23.6881 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 9, 1, 31, 29) mesh-iteration-cpp 35.5806 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 9, 1, 31, 50) function-evaluation-cpp 21.2677 "Evaluations of functions at arbitrary points." (2013, 7, 9, 1, 31, 50) function-evaluation-cpp 21.1783 "Evaluations of functions at arbitrary points." (2013, 7, 9, 1, 31, 53) function-extrapolation-python 3.29906 "BENCH: 1.05690097809" (2013, 7, 9, 1, 31, 53) function-extrapolation-python 1.0569 "BENCH: 1.05690097809" (2013, 7, 9, 1, 31, 55) function-interpolation-python 1.6841 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 9, 1, 31, 55) function-interpolation-python 0.987605 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 9, 1, 32, 18) la-vector-access-cpp 22.9736 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 9, 1, 32, 44) la-vector-assignment-cpp 26.4678 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 10, 1, 19, 54) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0287 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 10, 1, 20, 13) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9357 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 10, 1, 20, 30) geometry-bounding_box_tree_build-cpp 14.0298 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 10, 1, 20, 57) common-progress-cpp 27.6509 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 10, 1, 21, 26) common-timing-cpp 28.9474 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 10, 1, 23, 12) fem-multicore-cpp 106.343 "Coloring mesh." (2013, 7, 10, 1, 25, 44) fem-assembly-cpp 151.815 "Assembly for various forms and backends" (2013, 7, 10, 1, 25, 56) fem-convergence-cpp 12.1328 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 10, 1, 25, 58) fem-jit-python 0.00103672 "JIT compilation (in memory cache)" (2013, 7, 10, 1, 31, 3) fem-speedup-cpp 304.755 "Assembly/solve speedup running on 4 processors" (2013, 7, 10, 1, 31, 3) fem-speedup-cpp-assembly 6.54785 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 10, 1, 31, 3) fem-speedup-cpp-solve 2.30383 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 10, 1, 31, 24) mesh-refinement-cpp 19.8678 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 10, 1, 31, 43) mesh-topology-cpp 19.0905 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 10, 1, 32, 7) mesh-unitcube-cpp 23.6286 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 10, 1, 32, 53) mesh-iteration-cpp 44.1694 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 10, 1, 33, 15) function-evaluation-cpp 21.1804 "Evaluations of functions at arbitrary points." (2013, 7, 10, 1, 33, 15) function-evaluation-cpp 21.0951 "Evaluations of functions at arbitrary points." (2013, 7, 10, 1, 33, 18) function-extrapolation-python 3.39606 "BENCH: 1.05440497398" (2013, 7, 10, 1, 33, 18) function-extrapolation-python 1.0544 "BENCH: 1.05440497398" (2013, 7, 10, 1, 33, 20) function-interpolation-python 1.72841 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 10, 1, 33, 20) function-interpolation-python 1.01078 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 10, 1, 33, 45) la-vector-access-cpp 24.9499 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 10, 1, 34, 12) la-vector-assignment-cpp 27.5975 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 11, 1, 18, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.99981 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 11, 1, 18, 33) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8902 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 11, 1, 18, 49) geometry-bounding_box_tree_build-cpp 13.9417 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 11, 1, 19, 17) common-progress-cpp 27.6512 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 11, 1, 19, 46) common-timing-cpp 29.5256 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 11, 1, 21, 33) fem-multicore-cpp 106.466 "Coloring mesh." (2013, 7, 11, 1, 24, 4) fem-assembly-cpp 151.071 "Assembly for various forms and backends" (2013, 7, 11, 1, 24, 16) fem-convergence-cpp 12.1399 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 11, 1, 24, 18) fem-jit-python 0.00102508 "JIT compilation (in memory cache)" (2013, 7, 11, 1, 29, 25) fem-speedup-cpp 307.202 "Assembly/solve speedup running on 4 processors" (2013, 7, 11, 1, 29, 25) fem-speedup-cpp-assembly 6.49706 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 11, 1, 29, 25) fem-speedup-cpp-solve 2.2824 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 11, 1, 29, 47) mesh-refinement-cpp 19.9043 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 11, 1, 30, 6) mesh-topology-cpp 19.0098 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 11, 1, 30, 30) mesh-unitcube-cpp 23.5735 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 11, 1, 31, 8) mesh-iteration-cpp 35.5772 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 11, 1, 31, 29) function-evaluation-cpp 21.2811 "Evaluations of functions at arbitrary points." (2013, 7, 11, 1, 31, 29) function-evaluation-cpp 21.1039 "Evaluations of functions at arbitrary points." (2013, 7, 11, 1, 31, 33) function-extrapolation-python 3.48712 "BENCH: 1.04549098015" (2013, 7, 11, 1, 31, 33) function-extrapolation-python 1.04549 "BENCH: 1.04549098015" (2013, 7, 11, 1, 31, 34) function-interpolation-python 1.68644 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 11, 1, 31, 34) function-interpolation-python 0.987597 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 11, 1, 31, 57) la-vector-access-cpp 22.9651 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 11, 1, 32, 22) la-vector-assignment-cpp 24.9 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 12, 1, 18, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.064 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 12, 1, 18, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5812 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 12, 1, 18, 57) geometry-bounding_box_tree_build-cpp 13.9269 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 12, 1, 19, 24) common-progress-cpp 27.6515 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 12, 1, 19, 54) common-timing-cpp 29.5787 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 12, 1, 21, 40) fem-multicore-cpp 106.595 "Coloring mesh." (2013, 7, 12, 1, 24, 12) fem-assembly-cpp 151.348 "Assembly for various forms and backends" (2013, 7, 12, 1, 24, 24) fem-convergence-cpp 12.1808 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 12, 1, 24, 26) fem-jit-python 0.0010334 "JIT compilation (in memory cache)" (2013, 7, 12, 1, 29, 33) fem-speedup-cpp 307.086 "Assembly/solve speedup running on 4 processors" (2013, 7, 12, 1, 29, 33) fem-speedup-cpp-assembly 6.53124 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 12, 1, 29, 33) fem-speedup-cpp-solve 2.25542 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 12, 1, 29, 53) mesh-refinement-cpp 19.8769 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 12, 1, 30, 13) mesh-topology-cpp 19.0599 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 12, 1, 30, 36) mesh-unitcube-cpp 23.6652 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 12, 1, 31, 18) mesh-iteration-cpp 39.1563 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 12, 1, 31, 39) function-evaluation-cpp 21.624 "Evaluations of functions at arbitrary points." (2013, 7, 12, 1, 31, 39) function-evaluation-cpp 21.5489 "Evaluations of functions at arbitrary points." (2013, 7, 12, 1, 31, 43) function-extrapolation-python 3.36171 "BENCH: 1.06769394875" (2013, 7, 12, 1, 31, 43) function-extrapolation-python 1.06769 "BENCH: 1.06769394875" (2013, 7, 12, 1, 31, 45) function-interpolation-python 1.74685 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 12, 1, 31, 45) function-interpolation-python 0.990435 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 12, 1, 32, 8) la-vector-access-cpp 22.9349 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 12, 1, 32, 33) la-vector-assignment-cpp 25.0589 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 13, 1, 18, 51) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.92917 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 13, 1, 19, 10) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8593 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 13, 1, 19, 26) geometry-bounding_box_tree_build-cpp 13.9087 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 13, 1, 19, 54) common-progress-cpp 27.6511 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 13, 1, 20, 24) common-timing-cpp 29.876 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 13, 1, 22, 11) fem-multicore-cpp 106.654 "Coloring mesh." (2013, 7, 13, 1, 24, 41) fem-assembly-cpp 150.641 "Assembly for various forms and backends" (2013, 7, 13, 1, 24, 53) fem-convergence-cpp 12.1345 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 13, 1, 24, 55) fem-jit-python 0.00101712 "JIT compilation (in memory cache)" (2013, 7, 13, 1, 30, 0) fem-speedup-cpp 304.499 "Assembly/solve speedup running on 4 processors" (2013, 7, 13, 1, 30, 0) fem-speedup-cpp-assembly 6.53773 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 13, 1, 30, 0) fem-speedup-cpp-solve 2.34874 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 13, 1, 30, 20) mesh-refinement-cpp 19.8643 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 13, 1, 30, 40) mesh-topology-cpp 19.0804 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 13, 1, 31, 3) mesh-unitcube-cpp 23.6499 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 13, 1, 31, 41) mesh-iteration-cpp 35.5453 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 13, 1, 32, 3) function-evaluation-cpp 21.1705 "Evaluations of functions at arbitrary points." (2013, 7, 13, 1, 32, 3) function-evaluation-cpp 21.0901 "Evaluations of functions at arbitrary points." (2013, 7, 13, 1, 32, 6) function-extrapolation-python 3.37889 "BENCH: 1.05212593079" (2013, 7, 13, 1, 32, 6) function-extrapolation-python 1.05213 "BENCH: 1.05212593079" (2013, 7, 13, 1, 32, 8) function-interpolation-python 1.71661 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 13, 1, 32, 8) function-interpolation-python 0.988547 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 13, 1, 32, 31) la-vector-access-cpp 22.9248 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 13, 1, 33, 26) la-vector-assignment-cpp 55.4213 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 14, 1, 18, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.97594 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 14, 1, 18, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7256 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 14, 1, 18, 58) geometry-bounding_box_tree_build-cpp 13.9138 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 14, 1, 19, 26) common-progress-cpp 27.6515 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 14, 1, 19, 56) common-timing-cpp 29.5342 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 14, 1, 21, 42) fem-multicore-cpp 106.856 "Coloring mesh." (2013, 7, 14, 1, 24, 13) fem-assembly-cpp 150.357 "Assembly for various forms and backends" (2013, 7, 14, 1, 24, 25) fem-convergence-cpp 12.1437 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 14, 1, 24, 27) fem-jit-python 0.00100989 "JIT compilation (in memory cache)" (2013, 7, 14, 1, 29, 31) fem-speedup-cpp 304.247 "Assembly/solve speedup running on 4 processors" (2013, 7, 14, 1, 29, 31) fem-speedup-cpp-assembly 6.58345 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 14, 1, 29, 31) fem-speedup-cpp-solve 2.33907 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 14, 1, 29, 52) mesh-refinement-cpp 19.8696 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 14, 1, 30, 11) mesh-topology-cpp 19.0261 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 14, 1, 30, 34) mesh-unitcube-cpp 23.6569 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 14, 1, 31, 13) mesh-iteration-cpp 35.729 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 14, 1, 31, 34) function-evaluation-cpp 21.4095 "Evaluations of functions at arbitrary points." (2013, 7, 14, 1, 31, 34) function-evaluation-cpp 21.3343 "Evaluations of functions at arbitrary points." (2013, 7, 14, 1, 31, 37) function-extrapolation-python 3.4012 "BENCH: 1.05881810188" (2013, 7, 14, 1, 31, 37) function-extrapolation-python 1.05882 "BENCH: 1.05881810188" (2013, 7, 14, 1, 31, 39) function-interpolation-python 1.72811 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 14, 1, 31, 39) function-interpolation-python 1.00277 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 14, 1, 32, 5) la-vector-access-cpp 25.4835 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 14, 1, 32, 30) la-vector-assignment-cpp 25.0565 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 15, 1, 17, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.97036 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 15, 1, 18, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8873 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 15, 1, 18, 24) geometry-bounding_box_tree_build-cpp 14.0707 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 15, 1, 18, 51) common-progress-cpp 27.6519 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 15, 1, 19, 20) common-timing-cpp 28.9185 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 15, 1, 21, 7) fem-multicore-cpp 106.52 "Coloring mesh." (2013, 7, 15, 1, 23, 38) fem-assembly-cpp 151.459 "Assembly for various forms and backends" (2013, 7, 15, 1, 23, 50) fem-convergence-cpp 12.131 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 15, 1, 23, 52) fem-jit-python 0.00102201 "JIT compilation (in memory cache)" (2013, 7, 15, 1, 28, 57) fem-speedup-cpp 304.422 "Assembly/solve speedup running on 4 processors" (2013, 7, 15, 1, 28, 57) fem-speedup-cpp-assembly 6.48505 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 15, 1, 28, 57) fem-speedup-cpp-solve 2.23534 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 15, 1, 29, 19) mesh-refinement-cpp 19.7811 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 15, 1, 29, 38) mesh-topology-cpp 19.0518 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 15, 1, 30, 2) mesh-unitcube-cpp 23.696 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 15, 1, 30, 40) mesh-iteration-cpp 35.5452 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 15, 1, 31, 1) function-evaluation-cpp 21.2729 "Evaluations of functions at arbitrary points." (2013, 7, 15, 1, 31, 1) function-evaluation-cpp 21.1645 "Evaluations of functions at arbitrary points." (2013, 7, 15, 1, 31, 4) function-extrapolation-python 3.43764 "BENCH: 1.04265785217" (2013, 7, 15, 1, 31, 4) function-extrapolation-python 1.04266 "BENCH: 1.04265785217" (2013, 7, 15, 1, 31, 6) function-interpolation-python 1.67503 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 15, 1, 31, 6) function-interpolation-python 0.986848 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 15, 1, 31, 29) la-vector-access-cpp 22.951 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 15, 1, 32, 0) la-vector-assignment-cpp 31.0985 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 16, 1, 18, 4) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.97083 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 16, 1, 18, 23) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6486 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 16, 1, 18, 39) geometry-bounding_box_tree_build-cpp 13.9228 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 16, 1, 19, 7) common-progress-cpp 27.651 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 16, 1, 19, 36) common-timing-cpp 28.8434 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 16, 1, 21, 23) fem-multicore-cpp 106.965 "Coloring mesh." (2013, 7, 16, 1, 23, 54) fem-assembly-cpp 151.016 "Assembly for various forms and backends" (2013, 7, 16, 1, 24, 6) fem-convergence-cpp 12.1383 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 16, 1, 24, 8) fem-jit-python 0.00102201 "JIT compilation (in memory cache)" (2013, 7, 16, 1, 29, 14) fem-speedup-cpp 306.193 "Assembly/solve speedup running on 4 processors" (2013, 7, 16, 1, 29, 14) fem-speedup-cpp-assembly 6.57166 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 16, 1, 29, 14) fem-speedup-cpp-solve 2.31181 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 16, 1, 29, 36) mesh-refinement-cpp 19.8503 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 16, 1, 29, 55) mesh-topology-cpp 19.0814 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 16, 1, 30, 19) mesh-unitcube-cpp 23.6384 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 16, 1, 30, 57) mesh-iteration-cpp 35.5524 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 16, 1, 31, 18) function-evaluation-cpp 21.2645 "Evaluations of functions at arbitrary points." (2013, 7, 16, 1, 31, 18) function-evaluation-cpp 21.1568 "Evaluations of functions at arbitrary points." (2013, 7, 16, 1, 31, 22) function-extrapolation-python 3.49521 "BENCH: 1.05919599533" (2013, 7, 16, 1, 31, 22) function-extrapolation-python 1.0592 "BENCH: 1.05919599533" (2013, 7, 16, 1, 31, 23) function-interpolation-python 1.68954 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 16, 1, 31, 23) function-interpolation-python 0.989933 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 16, 1, 31, 46) la-vector-access-cpp 22.9565 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 16, 1, 32, 12) la-vector-assignment-cpp 25.0814 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 17, 1, 20, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.99746 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 17, 1, 21, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6891 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 17, 1, 21, 23) geometry-bounding_box_tree_build-cpp 13.9412 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 17, 1, 21, 54) common-progress-cpp 31.4126 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 17, 1, 22, 23) common-timing-cpp 29.3737 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 17, 1, 24, 10) fem-multicore-cpp 106.781 "Coloring mesh." (2013, 7, 17, 1, 26, 41) fem-assembly-cpp 151.302 "Assembly for various forms and backends" (2013, 7, 17, 1, 26, 54) fem-convergence-cpp 12.1408 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 17, 1, 26, 55) fem-jit-python 0.00103559 "JIT compilation (in memory cache)" (2013, 7, 17, 1, 32, 1) fem-speedup-cpp 305.248 "Assembly/solve speedup running on 4 processors" (2013, 7, 17, 1, 32, 1) fem-speedup-cpp-assembly 6.59119 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 17, 1, 32, 1) fem-speedup-cpp-solve 2.27285 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 17, 1, 32, 23) mesh-refinement-cpp 19.8289 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 17, 1, 32, 42) mesh-topology-cpp 19.1244 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 17, 1, 33, 5) mesh-unitcube-cpp 23.6103 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 17, 1, 33, 43) mesh-iteration-cpp 35.5332 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 17, 1, 34, 5) function-evaluation-cpp 21.2646 "Evaluations of functions at arbitrary points." (2013, 7, 17, 1, 34, 5) function-evaluation-cpp 21.1484 "Evaluations of functions at arbitrary points." (2013, 7, 17, 1, 34, 8) function-extrapolation-python 3.4538 "BENCH: 1.05830597878" (2013, 7, 17, 1, 34, 8) function-extrapolation-python 1.05831 "BENCH: 1.05830597878" (2013, 7, 17, 1, 34, 10) function-interpolation-python 1.72793 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 17, 1, 34, 10) function-interpolation-python 1.00475 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 17, 1, 34, 33) la-vector-access-cpp 22.9513 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 17, 1, 34, 58) la-vector-assignment-cpp 25.0889 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 18, 1, 18, 4) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.93762 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 18, 1, 18, 23) geometry-bounding_box_tree_compute_closest_entity-cpp 15.797 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 18, 1, 18, 39) geometry-bounding_box_tree_build-cpp 13.9475 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 18, 1, 19, 7) common-progress-cpp 27.6516 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 18, 1, 19, 36) common-timing-cpp 29.2863 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 18, 1, 21, 24) fem-multicore-cpp 107.129 "Coloring mesh." (2013, 7, 18, 1, 23, 54) fem-assembly-cpp 150.605 "Assembly for various forms and backends" (2013, 7, 18, 1, 24, 6) fem-convergence-cpp 12.1504 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 18, 1, 24, 8) fem-jit-python 0.0010257 "JIT compilation (in memory cache)" (2013, 7, 18, 1, 29, 17) fem-speedup-cpp 308.591 "Assembly/solve speedup running on 4 processors" (2013, 7, 18, 1, 29, 17) fem-speedup-cpp-assembly 6.51866 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 18, 1, 29, 17) fem-speedup-cpp-solve 2.28439 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 18, 1, 29, 39) mesh-refinement-cpp 19.8179 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 18, 1, 29, 58) mesh-topology-cpp 19.1706 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 18, 1, 30, 22) mesh-unitcube-cpp 23.6178 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 18, 1, 31, 0) mesh-iteration-cpp 35.5583 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 18, 1, 31, 21) function-evaluation-cpp 21.3794 "Evaluations of functions at arbitrary points." (2013, 7, 18, 1, 31, 21) function-evaluation-cpp 21.2301 "Evaluations of functions at arbitrary points." (2013, 7, 18, 1, 31, 25) function-extrapolation-python 3.53282 "BENCH: 1.06168103218" (2013, 7, 18, 1, 31, 25) function-extrapolation-python 1.06168 "BENCH: 1.06168103218" (2013, 7, 18, 1, 31, 26) function-interpolation-python 1.69614 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 18, 1, 31, 26) function-interpolation-python 1.00782 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 18, 1, 31, 51) la-vector-access-cpp 24.9473 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 18, 1, 32, 16) la-vector-assignment-cpp 25.031 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 19, 1, 18, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0751 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 19, 1, 18, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8084 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 19, 1, 19, 8) geometry-bounding_box_tree_build-cpp 14.0056 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 19, 1, 19, 35) common-progress-cpp 27.6514 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 19, 1, 20, 6) common-timing-cpp 31.0301 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 19, 1, 21, 53) fem-multicore-cpp 106.616 "Coloring mesh." (2013, 7, 19, 1, 24, 24) fem-assembly-cpp 151.515 "Assembly for various forms and backends" (2013, 7, 19, 1, 24, 37) fem-convergence-cpp 12.1277 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 19, 1, 24, 38) fem-jit-python 0.00102739 "JIT compilation (in memory cache)" (2013, 7, 19, 1, 29, 45) fem-speedup-cpp 306.558 "Assembly/solve speedup running on 4 processors" (2013, 7, 19, 1, 29, 45) fem-speedup-cpp-assembly 6.46923 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 19, 1, 29, 45) fem-speedup-cpp-solve 2.26993 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 19, 1, 30, 7) mesh-refinement-cpp 19.838 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 19, 1, 30, 26) mesh-topology-cpp 19.0439 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 19, 1, 30, 49) mesh-unitcube-cpp 23.6054 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 19, 1, 31, 27) mesh-iteration-cpp 35.5374 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 19, 1, 31, 49) function-evaluation-cpp 21.939 "Evaluations of functions at arbitrary points." (2013, 7, 19, 1, 31, 49) function-evaluation-cpp 21.7642 "Evaluations of functions at arbitrary points." (2013, 7, 19, 1, 31, 53) function-extrapolation-python 3.58701 "BENCH: 1.03702187538" (2013, 7, 19, 1, 31, 53) function-extrapolation-python 1.03702 "BENCH: 1.03702187538" (2013, 7, 19, 1, 31, 55) function-interpolation-python 1.70192 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 19, 1, 31, 55) function-interpolation-python 0.996866 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 19, 1, 32, 18) la-vector-access-cpp 22.958 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 19, 1, 32, 45) la-vector-assignment-cpp 27.1062 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 20, 1, 17, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2128 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 20, 1, 17, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7231 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 20, 1, 18, 13) geometry-bounding_box_tree_build-cpp 13.9218 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 20, 1, 18, 40) common-progress-cpp 27.6883 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 20, 1, 19, 10) common-timing-cpp 29.6875 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 20, 1, 20, 57) fem-multicore-cpp 106.824 "Coloring mesh." (2013, 7, 20, 1, 23, 28) fem-assembly-cpp 151.614 "Assembly for various forms and backends" (2013, 7, 20, 1, 23, 41) fem-convergence-cpp 12.1907 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 20, 1, 23, 42) fem-jit-python 0.00103128 "JIT compilation (in memory cache)" (2013, 7, 20, 1, 28, 50) fem-speedup-cpp 307.719 "Assembly/solve speedup running on 4 processors" (2013, 7, 20, 1, 28, 50) fem-speedup-cpp-assembly 6.52763 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 20, 1, 28, 50) fem-speedup-cpp-solve 2.29249 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 20, 1, 29, 12) mesh-refinement-cpp 19.8286 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 20, 1, 29, 31) mesh-topology-cpp 19.1506 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 20, 1, 29, 55) mesh-unitcube-cpp 23.6698 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 20, 1, 30, 41) mesh-iteration-cpp 44.1741 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 20, 1, 31, 5) function-evaluation-cpp 23.9123 "Evaluations of functions at arbitrary points." (2013, 7, 20, 1, 31, 5) function-evaluation-cpp 23.7863 "Evaluations of functions at arbitrary points." (2013, 7, 20, 1, 31, 9) function-extrapolation-python 3.49244 "BENCH: 1.07639193535" (2013, 7, 20, 1, 31, 9) function-extrapolation-python 1.07639 "BENCH: 1.07639193535" (2013, 7, 20, 1, 31, 11) function-interpolation-python 1.69812 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 20, 1, 31, 11) function-interpolation-python 1.01782 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 20, 1, 31, 34) la-vector-access-cpp 22.9654 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 20, 1, 32, 1) la-vector-assignment-cpp 27.2714 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 21, 1, 19, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0012 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 21, 1, 19, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6464 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 21, 1, 19, 43) geometry-bounding_box_tree_build-cpp 13.928 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 21, 1, 20, 11) common-progress-cpp 27.652 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 21, 1, 20, 40) common-timing-cpp 29.5734 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 21, 1, 22, 27) fem-multicore-cpp 106.923 "Coloring mesh." (2013, 7, 21, 1, 24, 59) fem-assembly-cpp 151.808 "Assembly for various forms and backends" (2013, 7, 21, 1, 25, 11) fem-convergence-cpp 12.1731 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 21, 1, 25, 13) fem-jit-python 0.0010319 "JIT compilation (in memory cache)" (2013, 7, 21, 1, 30, 18) fem-speedup-cpp 304.669 "Assembly/solve speedup running on 4 processors" (2013, 7, 21, 1, 30, 18) fem-speedup-cpp-assembly 6.52735 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 21, 1, 30, 18) fem-speedup-cpp-solve 2.30222 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 21, 1, 30, 39) mesh-refinement-cpp 19.9697 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 21, 1, 30, 58) mesh-topology-cpp 19.106 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 21, 1, 31, 22) mesh-unitcube-cpp 23.7362 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 21, 1, 32, 3) mesh-iteration-cpp 39.1036 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 21, 1, 32, 24) function-evaluation-cpp 21.217 "Evaluations of functions at arbitrary points." (2013, 7, 21, 1, 32, 24) function-evaluation-cpp 21.075 "Evaluations of functions at arbitrary points." (2013, 7, 21, 1, 32, 28) function-extrapolation-python 3.47906 "BENCH: 1.05915498734" (2013, 7, 21, 1, 32, 28) function-extrapolation-python 1.05915 "BENCH: 1.05915498734" (2013, 7, 21, 1, 32, 30) function-interpolation-python 1.75239 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 21, 1, 32, 30) function-interpolation-python 1.01089 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 21, 1, 32, 53) la-vector-access-cpp 22.9286 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 21, 1, 33, 24) la-vector-assignment-cpp 31.0843 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 22, 1, 17, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.92627 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 22, 1, 17, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.914 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 22, 1, 18, 8) geometry-bounding_box_tree_build-cpp 13.9849 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 22, 1, 18, 35) common-progress-cpp 27.6508 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 22, 1, 19, 5) common-timing-cpp 29.6839 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 22, 1, 20, 52) fem-multicore-cpp 106.671 "Coloring mesh." (2013, 7, 22, 1, 23, 23) fem-assembly-cpp 151.214 "Assembly for various forms and backends" (2013, 7, 22, 1, 23, 35) fem-convergence-cpp 12.149 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 22, 1, 23, 37) fem-jit-python 0.00104589 "JIT compilation (in memory cache)" (2013, 7, 22, 1, 28, 48) fem-speedup-cpp 310.936 "Assembly/solve speedup running on 4 processors" (2013, 7, 22, 1, 28, 48) fem-speedup-cpp-assembly 6.46761 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 22, 1, 28, 48) fem-speedup-cpp-solve 2.23589 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 22, 1, 29, 9) mesh-refinement-cpp 19.884 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 22, 1, 29, 29) mesh-topology-cpp 19.0747 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 22, 1, 29, 52) mesh-unitcube-cpp 23.5547 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 22, 1, 30, 30) mesh-iteration-cpp 35.5506 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 22, 1, 30, 52) function-evaluation-cpp 21.4473 "Evaluations of functions at arbitrary points." (2013, 7, 22, 1, 30, 52) function-evaluation-cpp 21.3504 "Evaluations of functions at arbitrary points." (2013, 7, 22, 1, 30, 55) function-extrapolation-python 3.38351 "BENCH: 1.05044412613" (2013, 7, 22, 1, 30, 55) function-extrapolation-python 1.05044 "BENCH: 1.05044412613" (2013, 7, 22, 1, 30, 57) function-interpolation-python 1.7139 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 22, 1, 30, 57) function-interpolation-python 1.01586 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 22, 1, 31, 20) la-vector-access-cpp 22.9637 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 22, 1, 31, 47) la-vector-assignment-cpp 27.0995 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 23, 1, 19, 15) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0312 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 23, 1, 19, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9057 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 23, 1, 19, 51) geometry-bounding_box_tree_build-cpp 13.9175 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 23, 1, 20, 19) common-progress-cpp 27.6897 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 23, 1, 20, 49) common-timing-cpp 29.7265 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 23, 1, 22, 35) fem-multicore-cpp 106.683 "Coloring mesh." (2013, 7, 23, 1, 25, 7) fem-assembly-cpp 151.484 "Assembly for various forms and backends" (2013, 7, 23, 1, 25, 19) fem-convergence-cpp 12.1302 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 23, 1, 25, 21) fem-jit-python 0.00102 "JIT compilation (in memory cache)" (2013, 7, 23, 1, 30, 26) fem-speedup-cpp 305.004 "Assembly/solve speedup running on 4 processors" (2013, 7, 23, 1, 30, 26) fem-speedup-cpp-assembly 6.48651 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 23, 1, 30, 26) fem-speedup-cpp-solve 2.32136 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 23, 1, 30, 46) mesh-refinement-cpp 19.8748 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 23, 1, 31, 5) mesh-topology-cpp 19.0003 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 23, 1, 31, 29) mesh-unitcube-cpp 23.7693 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 23, 1, 32, 11) mesh-iteration-cpp 39.1538 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 23, 1, 32, 32) function-evaluation-cpp 21.3518 "Evaluations of functions at arbitrary points." (2013, 7, 23, 1, 32, 32) function-evaluation-cpp 21.266 "Evaluations of functions at arbitrary points." (2013, 7, 23, 1, 32, 35) function-extrapolation-python 3.33282 "BENCH: 1.06447482109" (2013, 7, 23, 1, 32, 35) function-extrapolation-python 1.06447 "BENCH: 1.06447482109" (2013, 7, 23, 1, 32, 37) function-interpolation-python 1.71955 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 23, 1, 32, 37) function-interpolation-python 1.01365 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 23, 1, 33, 0) la-vector-access-cpp 22.9004 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 23, 1, 33, 31) la-vector-assignment-cpp 31.0893 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 24, 1, 18, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0569 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 24, 1, 18, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6179 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 24, 1, 18, 43) geometry-bounding_box_tree_build-cpp 13.9532 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 24, 1, 19, 11) common-progress-cpp 27.6516 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 24, 1, 19, 41) common-timing-cpp 29.4583 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 24, 1, 21, 27) fem-multicore-cpp 106.546 "Coloring mesh." (2013, 7, 24, 1, 23, 59) fem-assembly-cpp 151.764 "Assembly for various forms and backends" (2013, 7, 24, 1, 24, 11) fem-convergence-cpp 12.1404 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 24, 1, 24, 13) fem-jit-python 0.0010278 "JIT compilation (in memory cache)" (2013, 7, 24, 1, 29, 18) fem-speedup-cpp 305.064 "Assembly/solve speedup running on 4 processors" (2013, 7, 24, 1, 29, 18) fem-speedup-cpp-assembly 6.52501 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 24, 1, 29, 18) fem-speedup-cpp-solve 2.27892 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 24, 1, 29, 39) mesh-refinement-cpp 19.8261 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 24, 1, 29, 59) mesh-topology-cpp 19.1535 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 24, 1, 30, 22) mesh-unitcube-cpp 23.6353 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 24, 1, 31, 0) mesh-iteration-cpp 35.5519 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 24, 1, 31, 22) function-evaluation-cpp 21.248 "Evaluations of functions at arbitrary points." (2013, 7, 24, 1, 31, 22) function-evaluation-cpp 21.1217 "Evaluations of functions at arbitrary points." (2013, 7, 24, 1, 31, 25) function-extrapolation-python 3.48699 "BENCH: 1.04801487923" (2013, 7, 24, 1, 31, 25) function-extrapolation-python 1.04801 "BENCH: 1.04801487923" (2013, 7, 24, 1, 31, 27) function-interpolation-python 1.72332 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 24, 1, 31, 27) function-interpolation-python 1.01363 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 24, 1, 31, 50) la-vector-access-cpp 22.9582 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 24, 1, 32, 17) la-vector-assignment-cpp 27.1103 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 25, 1, 18, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.91429 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 25, 1, 18, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7018 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 25, 1, 19, 9) geometry-bounding_box_tree_build-cpp 13.9045 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 25, 1, 19, 37) common-progress-cpp 27.6518 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 25, 1, 20, 6) common-timing-cpp 29.0688 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 25, 1, 21, 52) fem-multicore-cpp 106.354 "Coloring mesh." (2013, 7, 25, 1, 24, 23) fem-assembly-cpp 151.178 "Assembly for various forms and backends" (2013, 7, 25, 1, 24, 35) fem-convergence-cpp 12.1495 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 25, 1, 24, 37) fem-jit-python 0.0010262 "JIT compilation (in memory cache)" (2013, 7, 25, 1, 29, 42) fem-speedup-cpp 305.293 "Assembly/solve speedup running on 4 processors" (2013, 7, 25, 1, 29, 42) fem-speedup-cpp-assembly 6.53432 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 25, 1, 29, 42) fem-speedup-cpp-solve 2.26699 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 25, 1, 30, 3) mesh-refinement-cpp 19.8821 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 25, 1, 30, 22) mesh-topology-cpp 19.074 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 25, 1, 30, 46) mesh-unitcube-cpp 23.7186 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 25, 1, 31, 28) mesh-iteration-cpp 39.1559 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 25, 1, 31, 50) function-evaluation-cpp 22.0183 "Evaluations of functions at arbitrary points." (2013, 7, 25, 1, 31, 50) function-evaluation-cpp 21.9331 "Evaluations of functions at arbitrary points." (2013, 7, 25, 1, 31, 53) function-extrapolation-python 3.52895 "BENCH: 1.08823299408" (2013, 7, 25, 1, 31, 53) function-extrapolation-python 1.08823 "BENCH: 1.08823299408" (2013, 7, 25, 1, 31, 55) function-interpolation-python 1.7827 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 25, 1, 31, 55) function-interpolation-python 1.01551 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 25, 1, 32, 20) la-vector-access-cpp 24.9518 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 25, 1, 32, 47) la-vector-assignment-cpp 27.0816 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 26, 1, 32, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8357 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 26, 1, 33, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4289 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 26, 1, 33, 32) geometry-bounding_box_tree_build-cpp 13.9295 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 26, 1, 34, 0) common-progress-cpp 27.6522 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 26, 1, 34, 29) common-timing-cpp 29.3048 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 26, 1, 36, 16) fem-multicore-cpp 106.808 "Coloring mesh." (2013, 7, 26, 1, 38, 45) fem-assembly-cpp 149.245 "Assembly for various forms and backends" (2013, 7, 26, 1, 38, 57) fem-convergence-cpp 12.0954 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 26, 1, 38, 59) fem-jit-python 0.0010324 "JIT compilation (in memory cache)" (2013, 7, 26, 1, 44, 6) fem-speedup-cpp 306.664 "Assembly/solve speedup running on 4 processors" (2013, 7, 26, 1, 44, 6) fem-speedup-cpp-assembly 6.46767 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 26, 1, 44, 6) fem-speedup-cpp-solve 2.28157 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 26, 1, 44, 27) mesh-refinement-cpp 19.9331 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 26, 1, 44, 46) mesh-topology-cpp 19.2752 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 26, 1, 45, 10) mesh-unitcube-cpp 23.9851 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 26, 1, 45, 48) mesh-iteration-cpp 35.5488 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 26, 1, 46, 9) function-evaluation-cpp 21.1529 "Evaluations of functions at arbitrary points." (2013, 7, 26, 1, 46, 9) function-evaluation-cpp 21.0716 "Evaluations of functions at arbitrary points." (2013, 7, 26, 1, 46, 13) function-extrapolation-python 3.41242 "BENCH: 1.06968593597" (2013, 7, 26, 1, 46, 13) function-extrapolation-python 1.06969 "BENCH: 1.06968593597" (2013, 7, 26, 1, 46, 15) function-interpolation-python 1.7068 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 26, 1, 46, 15) function-interpolation-python 0.974432 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 26, 1, 46, 39) la-vector-access-cpp 24.9422 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 26, 1, 47, 5) la-vector-assignment-cpp 25.0615 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 27, 1, 25, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.648 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 27, 1, 25, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1914 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 27, 1, 26, 0) geometry-bounding_box_tree_build-cpp 13.8779 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 27, 1, 26, 27) common-progress-cpp 27.6531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 27, 1, 26, 57) common-timing-cpp 29.1611 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 27, 1, 28, 43) fem-multicore-cpp 106.705 "Coloring mesh." (2013, 7, 27, 1, 31, 12) fem-assembly-cpp 148.199 "Assembly for various forms and backends" (2013, 7, 27, 1, 31, 24) fem-convergence-cpp 12.1193 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 27, 1, 31, 26) fem-jit-python 0.0010288 "JIT compilation (in memory cache)" (2013, 7, 27, 1, 36, 33) fem-speedup-cpp 307.907 "Assembly/solve speedup running on 4 processors" (2013, 7, 27, 1, 36, 33) fem-speedup-cpp-assembly 6.7843 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 27, 1, 36, 33) fem-speedup-cpp-solve 2.21279 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 27, 1, 36, 54) mesh-refinement-cpp 19.8739 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 27, 1, 37, 13) mesh-topology-cpp 19.1819 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 27, 1, 37, 37) mesh-unitcube-cpp 23.8984 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 27, 1, 38, 23) mesh-iteration-cpp 43.4933 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 27, 1, 38, 44) function-evaluation-cpp 21.1308 "Evaluations of functions at arbitrary points." (2013, 7, 27, 1, 38, 44) function-evaluation-cpp 21.0487 "Evaluations of functions at arbitrary points." (2013, 7, 27, 1, 38, 48) function-extrapolation-python 3.39592 "BENCH: 1.06241202354" (2013, 7, 27, 1, 38, 48) function-extrapolation-python 1.06241 "BENCH: 1.06241202354" (2013, 7, 27, 1, 38, 50) function-interpolation-python 1.71973 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 27, 1, 38, 50) function-interpolation-python 0.983558 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 27, 1, 39, 15) la-vector-access-cpp 24.9409 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 27, 1, 39, 40) la-vector-assignment-cpp 25.0484 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 28, 1, 39, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.4281 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 28, 1, 39, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3285 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 28, 1, 39, 46) geometry-bounding_box_tree_build-cpp 13.8874 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 28, 1, 40, 13) common-progress-cpp 27.6524 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 28, 1, 40, 42) common-timing-cpp 28.2414 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 28, 1, 42, 28) fem-multicore-cpp 106.675 "Coloring mesh." (2013, 7, 28, 1, 44, 57) fem-assembly-cpp 148.21 "Assembly for various forms and backends" (2013, 7, 28, 1, 45, 9) fem-convergence-cpp 12.1267 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 28, 1, 45, 11) fem-jit-python 0.00103991 "JIT compilation (in memory cache)" (2013, 7, 28, 1, 50, 17) fem-speedup-cpp 306.216 "Assembly/solve speedup running on 4 processors" (2013, 7, 28, 1, 50, 17) fem-speedup-cpp-assembly 6.42771 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 28, 1, 50, 17) fem-speedup-cpp-solve 2.28056 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 28, 1, 50, 38) mesh-refinement-cpp 19.9213 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 28, 1, 50, 57) mesh-topology-cpp 19.1526 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 28, 1, 51, 21) mesh-unitcube-cpp 23.9458 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 28, 1, 52, 7) mesh-iteration-cpp 43.5389 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 28, 1, 52, 28) function-evaluation-cpp 21.1276 "Evaluations of functions at arbitrary points." (2013, 7, 28, 1, 52, 28) function-evaluation-cpp 21.0374 "Evaluations of functions at arbitrary points." (2013, 7, 28, 1, 52, 31) function-extrapolation-python 3.34089 "BENCH: 1.0704369545" (2013, 7, 28, 1, 52, 31) function-extrapolation-python 1.07044 "BENCH: 1.0704369545" (2013, 7, 28, 1, 52, 33) function-interpolation-python 1.69298 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 28, 1, 52, 33) function-interpolation-python 0.974667 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 28, 1, 52, 58) la-vector-access-cpp 24.9371 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 28, 1, 53, 25) la-vector-assignment-cpp 27.5753 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 29, 1, 33, 16) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.86 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 29, 1, 33, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.404 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 29, 1, 33, 51) geometry-bounding_box_tree_build-cpp 13.9519 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 29, 1, 34, 19) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 29, 1, 34, 48) common-timing-cpp 28.8879 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 29, 1, 36, 35) fem-multicore-cpp 106.715 "Coloring mesh." (2013, 7, 29, 1, 39, 3) fem-assembly-cpp 148.025 "Assembly for various forms and backends" (2013, 7, 29, 1, 39, 15) fem-convergence-cpp 12.1061 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 29, 1, 39, 17) fem-jit-python 0.0010309 "JIT compilation (in memory cache)" (2013, 7, 29, 1, 44, 22) fem-speedup-cpp 305.176 "Assembly/solve speedup running on 4 processors" (2013, 7, 29, 1, 44, 22) fem-speedup-cpp-assembly 6.48856 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 29, 1, 44, 22) fem-speedup-cpp-solve 2.26292 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 29, 1, 44, 42) mesh-refinement-cpp 19.8754 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 29, 1, 45, 2) mesh-topology-cpp 19.1465 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 29, 1, 45, 25) mesh-unitcube-cpp 23.8806 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 29, 1, 46, 3) mesh-iteration-cpp 35.4578 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 29, 1, 46, 25) function-evaluation-cpp 21.6172 "Evaluations of functions at arbitrary points." (2013, 7, 29, 1, 46, 25) function-evaluation-cpp 21.5314 "Evaluations of functions at arbitrary points." (2013, 7, 29, 1, 46, 28) function-extrapolation-python 3.38748 "BENCH: 1.08705210686" (2013, 7, 29, 1, 46, 28) function-extrapolation-python 1.08705 "BENCH: 1.08705210686" (2013, 7, 29, 1, 46, 30) function-interpolation-python 1.68298 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 29, 1, 46, 30) function-interpolation-python 0.977137 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 29, 1, 46, 58) la-vector-access-cpp 27.9328 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 29, 1, 47, 23) la-vector-assignment-cpp 25.1531 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 7, 31, 1, 26, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9718 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 31, 1, 27, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5362 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 7, 31, 1, 27, 25) geometry-bounding_box_tree_build-cpp 13.8878 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 7, 31, 1, 27, 52) common-progress-cpp 27.652 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 7, 31, 1, 28, 21) common-timing-cpp 29.0704 "Timing access and registration of timings (10000000 repetitions)" (2013, 7, 31, 1, 30, 9) fem-multicore-cpp 107.287 "Coloring mesh." (2013, 7, 31, 1, 32, 36) fem-assembly-cpp 147.742 "Assembly for various forms and backends" (2013, 7, 31, 1, 32, 49) fem-convergence-cpp 12.1113 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 7, 31, 1, 32, 50) fem-jit-python 0.00104589 "JIT compilation (in memory cache)" (2013, 7, 31, 1, 37, 58) fem-speedup-cpp 307.615 "Assembly/solve speedup running on 4 processors" (2013, 7, 31, 1, 37, 58) fem-speedup-cpp-assembly 6.55567 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 7, 31, 1, 37, 58) fem-speedup-cpp-solve 2.22618 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 7, 31, 1, 38, 19) mesh-refinement-cpp 19.8377 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 7, 31, 1, 38, 39) mesh-topology-cpp 19.1642 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 7, 31, 1, 39, 2) mesh-unitcube-cpp 23.8466 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 7, 31, 1, 39, 40) mesh-iteration-cpp 35.4885 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 7, 31, 1, 40, 2) function-evaluation-cpp 21.3148 "Evaluations of functions at arbitrary points." (2013, 7, 31, 1, 40, 2) function-evaluation-cpp 21.196 "Evaluations of functions at arbitrary points." (2013, 7, 31, 1, 40, 5) function-extrapolation-python 3.59531 "BENCH: 1.07835102081" (2013, 7, 31, 1, 40, 5) function-extrapolation-python 1.07835 "BENCH: 1.07835102081" (2013, 7, 31, 1, 40, 7) function-interpolation-python 1.66624 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 31, 1, 40, 7) function-interpolation-python 0.979514 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 7, 31, 1, 40, 35) la-vector-access-cpp 27.9492 "Accessing vector of size 10000000 (100 repetitions)" (2013, 7, 31, 1, 41, 0) la-vector-assignment-cpp 25.0869 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 1, 1, 39, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.4727 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 1, 1, 39, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3798 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 1, 1, 39, 48) geometry-bounding_box_tree_build-cpp 13.9167 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 1, 1, 40, 16) common-progress-cpp 27.6525 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 1, 1, 40, 45) common-timing-cpp 29.2722 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 1, 1, 42, 32) fem-multicore-cpp 106.555 "Coloring mesh." (2013, 8, 1, 1, 45, 0) fem-assembly-cpp 147.688 "Assembly for various forms and backends" (2013, 8, 1, 1, 45, 12) fem-convergence-cpp 12.0977 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 1, 1, 45, 14) fem-jit-python 0.0010354 "JIT compilation (in memory cache)" (2013, 8, 1, 1, 50, 19) fem-speedup-cpp 305.365 "Assembly/solve speedup running on 4 processors" (2013, 8, 1, 1, 50, 19) fem-speedup-cpp-assembly 6.74386 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 1, 1, 50, 19) fem-speedup-cpp-solve 2.2743 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 1, 1, 50, 40) mesh-refinement-cpp 19.8651 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 1, 1, 50, 59) mesh-topology-cpp 19.1834 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 1, 1, 51, 23) mesh-unitcube-cpp 23.8155 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 1, 1, 52, 5) mesh-iteration-cpp 39.1078 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 1, 1, 52, 26) function-evaluation-cpp 21.4897 "Evaluations of functions at arbitrary points." (2013, 8, 1, 1, 52, 26) function-evaluation-cpp 21.3422 "Evaluations of functions at arbitrary points." (2013, 8, 1, 1, 52, 30) function-extrapolation-python 3.5455 "BENCH: 1.09359121323" (2013, 8, 1, 1, 52, 30) function-extrapolation-python 1.09359 "BENCH: 1.09359121323" (2013, 8, 1, 1, 52, 32) function-interpolation-python 1.70183 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 1, 1, 52, 32) function-interpolation-python 0.976344 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 1, 1, 52, 57) la-vector-access-cpp 24.974 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 1, 1, 53, 22) la-vector-assignment-cpp 25.3144 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 2, 1, 28, 52) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3877 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 2, 1, 29, 11) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3117 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 2, 1, 29, 27) geometry-bounding_box_tree_build-cpp 13.8861 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 2, 1, 29, 55) common-progress-cpp 27.6521 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 2, 1, 30, 24) common-timing-cpp 28.4944 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 2, 1, 32, 10) fem-multicore-cpp 106.684 "Coloring mesh." (2013, 8, 2, 1, 34, 38) fem-assembly-cpp 147.827 "Assembly for various forms and backends" (2013, 8, 2, 1, 34, 50) fem-convergence-cpp 12.1092 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 2, 1, 34, 52) fem-jit-python 0.00102439 "JIT compilation (in memory cache)" (2013, 8, 2, 1, 39, 58) fem-speedup-cpp 305.712 "Assembly/solve speedup running on 4 processors" (2013, 8, 2, 1, 39, 58) fem-speedup-cpp-assembly 6.49978 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 2, 1, 39, 58) fem-speedup-cpp-solve 2.29703 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 2, 1, 40, 18) mesh-refinement-cpp 19.8816 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 2, 1, 40, 38) mesh-topology-cpp 19.2233 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 2, 1, 41, 2) mesh-unitcube-cpp 23.926 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 2, 1, 41, 48) mesh-iteration-cpp 44.1865 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 2, 1, 42, 10) function-evaluation-cpp 21.2475 "Evaluations of functions at arbitrary points." (2013, 8, 2, 1, 42, 10) function-evaluation-cpp 21.1655 "Evaluations of functions at arbitrary points." (2013, 8, 2, 1, 42, 13) function-extrapolation-python 3.45499 "BENCH: 1.0774269104" (2013, 8, 2, 1, 42, 13) function-extrapolation-python 1.07743 "BENCH: 1.0774269104" (2013, 8, 2, 1, 42, 15) function-interpolation-python 1.70972 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 2, 1, 42, 15) function-interpolation-python 0.992673 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 2, 1, 42, 40) la-vector-access-cpp 24.9398 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 2, 1, 43, 5) la-vector-assignment-cpp 25.0641 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 3, 1, 31, 14) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.4989 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 3, 1, 31, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4774 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 3, 1, 31, 49) geometry-bounding_box_tree_build-cpp 13.9001 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 3, 1, 32, 17) common-progress-cpp 27.6714 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 3, 1, 32, 45) common-timing-cpp 28.8472 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 3, 1, 34, 32) fem-multicore-cpp 107.079 "Coloring mesh." (2013, 8, 3, 1, 37, 1) fem-assembly-cpp 148.654 "Assembly for various forms and backends" (2013, 8, 3, 1, 37, 13) fem-convergence-cpp 12.1355 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 3, 1, 37, 15) fem-jit-python 0.00103362 "JIT compilation (in memory cache)" (2013, 8, 3, 1, 42, 22) fem-speedup-cpp 306.73 "Assembly/solve speedup running on 4 processors" (2013, 8, 3, 1, 42, 22) fem-speedup-cpp-assembly 6.56741 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 3, 1, 42, 22) fem-speedup-cpp-solve 2.28335 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 3, 1, 42, 43) mesh-refinement-cpp 19.8179 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 3, 1, 43, 3) mesh-topology-cpp 19.1521 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 3, 1, 43, 26) mesh-unitcube-cpp 23.881 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 3, 1, 44, 13) mesh-iteration-cpp 44.185 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 3, 1, 44, 35) function-evaluation-cpp 21.8312 "Evaluations of functions at arbitrary points." (2013, 8, 3, 1, 44, 35) function-evaluation-cpp 21.6971 "Evaluations of functions at arbitrary points." (2013, 8, 3, 1, 44, 38) function-extrapolation-python 3.52665 "BENCH: 1.07765603065" (2013, 8, 3, 1, 44, 38) function-extrapolation-python 1.07766 "BENCH: 1.07765603065" (2013, 8, 3, 1, 44, 40) function-interpolation-python 1.67445 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 3, 1, 44, 40) function-interpolation-python 0.969365 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 3, 1, 45, 5) la-vector-access-cpp 24.971 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 3, 1, 46, 1) la-vector-assignment-cpp 55.5208 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 4, 1, 41, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.6843 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 4, 1, 41, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3567 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 4, 1, 42, 0) geometry-bounding_box_tree_build-cpp 13.9098 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 4, 1, 42, 28) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 4, 1, 42, 57) common-timing-cpp 28.8279 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 4, 1, 44, 44) fem-multicore-cpp 106.909 "Coloring mesh." (2013, 8, 4, 1, 47, 12) fem-assembly-cpp 148.587 "Assembly for various forms and backends" (2013, 8, 4, 1, 47, 24) fem-convergence-cpp 12.1192 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 4, 1, 47, 26) fem-jit-python 0.00103061 "JIT compilation (in memory cache)" (2013, 8, 4, 1, 52, 34) fem-speedup-cpp 307.233 "Assembly/solve speedup running on 4 processors" (2013, 8, 4, 1, 52, 34) fem-speedup-cpp-assembly 6.56102 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 4, 1, 52, 34) fem-speedup-cpp-solve 2.22183 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 4, 1, 52, 54) mesh-refinement-cpp 19.835 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 4, 1, 53, 13) mesh-topology-cpp 19.1706 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 4, 1, 53, 38) mesh-unitcube-cpp 24.1551 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 4, 1, 54, 24) mesh-iteration-cpp 43.553 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 4, 1, 54, 45) function-evaluation-cpp 21.1334 "Evaluations of functions at arbitrary points." (2013, 8, 4, 1, 54, 45) function-evaluation-cpp 21.0477 "Evaluations of functions at arbitrary points." (2013, 8, 4, 1, 54, 48) function-extrapolation-python 3.39345 "BENCH: 1.08501887321" (2013, 8, 4, 1, 54, 48) function-extrapolation-python 1.08502 "BENCH: 1.08501887321" (2013, 8, 4, 1, 54, 50) function-interpolation-python 1.67907 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 4, 1, 54, 50) function-interpolation-python 0.961259 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 4, 1, 55, 15) la-vector-access-cpp 24.9584 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 4, 1, 55, 40) la-vector-assignment-cpp 25.0679 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 5, 1, 25, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.7885 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 5, 1, 26, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4096 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 5, 1, 26, 23) geometry-bounding_box_tree_build-cpp 13.8964 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 5, 1, 26, 51) common-progress-cpp 27.6527 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 5, 1, 27, 20) common-timing-cpp 28.7543 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 5, 1, 29, 7) fem-multicore-cpp 106.983 "Coloring mesh." (2013, 8, 5, 1, 31, 35) fem-assembly-cpp 147.844 "Assembly for various forms and backends" (2013, 8, 5, 1, 31, 47) fem-convergence-cpp 12.1354 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 5, 1, 31, 49) fem-jit-python 0.00102918 "JIT compilation (in memory cache)" (2013, 8, 5, 1, 36, 55) fem-speedup-cpp 305.959 "Assembly/solve speedup running on 4 processors" (2013, 8, 5, 1, 36, 55) fem-speedup-cpp-assembly 6.53383 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 5, 1, 36, 55) fem-speedup-cpp-solve 2.27532 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 5, 1, 37, 15) mesh-refinement-cpp 19.8757 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 5, 1, 37, 34) mesh-topology-cpp 19.1757 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 5, 1, 37, 58) mesh-unitcube-cpp 23.9099 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 5, 1, 38, 36) mesh-iteration-cpp 35.4793 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 5, 1, 38, 58) function-evaluation-cpp 21.263 "Evaluations of functions at arbitrary points." (2013, 8, 5, 1, 38, 58) function-evaluation-cpp 21.1828 "Evaluations of functions at arbitrary points." (2013, 8, 5, 1, 39, 1) function-extrapolation-python 3.40403 "BENCH: 1.0744330883" (2013, 8, 5, 1, 39, 1) function-extrapolation-python 1.07443 "BENCH: 1.0744330883" (2013, 8, 5, 1, 39, 3) function-interpolation-python 1.68084 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 5, 1, 39, 3) function-interpolation-python 0.968702 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 5, 1, 39, 28) la-vector-access-cpp 24.9795 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 5, 1, 39, 53) la-vector-assignment-cpp 25.0686 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 6, 1, 35, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.831 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 6, 1, 35, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2973 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 6, 1, 36, 0) geometry-bounding_box_tree_build-cpp 13.8768 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 6, 1, 36, 28) common-progress-cpp 27.6525 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 6, 1, 36, 57) common-timing-cpp 28.669 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 6, 1, 38, 44) fem-multicore-cpp 107.62 "Coloring mesh." (2013, 8, 6, 1, 41, 13) fem-assembly-cpp 148.393 "Assembly for various forms and backends" (2013, 8, 6, 1, 41, 25) fem-convergence-cpp 12.1228 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 6, 1, 41, 27) fem-jit-python 0.00102811 "JIT compilation (in memory cache)" (2013, 8, 6, 1, 46, 35) fem-speedup-cpp 308.59 "Assembly/solve speedup running on 4 processors" (2013, 8, 6, 1, 46, 35) fem-speedup-cpp-assembly 6.54911 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 6, 1, 46, 35) fem-speedup-cpp-solve 2.21345 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 6, 1, 46, 56) mesh-refinement-cpp 19.8853 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 6, 1, 47, 15) mesh-topology-cpp 19.3026 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 6, 1, 47, 39) mesh-unitcube-cpp 23.9211 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 6, 1, 48, 17) mesh-iteration-cpp 35.5593 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 6, 1, 48, 39) function-evaluation-cpp 21.3737 "Evaluations of functions at arbitrary points." (2013, 8, 6, 1, 48, 39) function-evaluation-cpp 21.2876 "Evaluations of functions at arbitrary points." (2013, 8, 6, 1, 48, 42) function-extrapolation-python 3.49559 "BENCH: 1.08021306992" (2013, 8, 6, 1, 48, 42) function-extrapolation-python 1.08021 "BENCH: 1.08021306992" (2013, 8, 6, 1, 48, 44) function-interpolation-python 1.70168 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 6, 1, 48, 44) function-interpolation-python 0.96744 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 6, 1, 49, 12) la-vector-access-cpp 27.9191 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 6, 1, 49, 37) la-vector-assignment-cpp 25.026 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 7, 1, 38, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.6532 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 7, 1, 38, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5974 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 7, 1, 38, 54) geometry-bounding_box_tree_build-cpp 13.9513 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 7, 1, 39, 27) common-progress-cpp 32.72 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 7, 1, 39, 56) common-timing-cpp 29.6147 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 7, 1, 41, 44) fem-multicore-cpp 107.075 "Coloring mesh." (2013, 8, 7, 1, 44, 12) fem-assembly-cpp 148.323 "Assembly for various forms and backends" (2013, 8, 7, 1, 44, 24) fem-convergence-cpp 12.128 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 7, 1, 44, 26) fem-jit-python 0.0010227 "JIT compilation (in memory cache)" (2013, 8, 7, 1, 49, 31) fem-speedup-cpp 305.171 "Assembly/solve speedup running on 4 processors" (2013, 8, 7, 1, 49, 31) fem-speedup-cpp-assembly 6.54031 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 7, 1, 49, 31) fem-speedup-cpp-solve 2.22884 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 7, 1, 49, 53) mesh-refinement-cpp 19.859 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 7, 1, 50, 12) mesh-topology-cpp 19.145 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 7, 1, 50, 36) mesh-unitcube-cpp 23.9015 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 7, 1, 51, 14) mesh-iteration-cpp 35.4751 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 7, 1, 51, 35) function-evaluation-cpp 21.1654 "Evaluations of functions at arbitrary points." (2013, 8, 7, 1, 51, 35) function-evaluation-cpp 21.03 "Evaluations of functions at arbitrary points." (2013, 8, 7, 1, 51, 38) function-extrapolation-python 3.33722 "BENCH: 1.06779313087" (2013, 8, 7, 1, 51, 38) function-extrapolation-python 1.06779 "BENCH: 1.06779313087" (2013, 8, 7, 1, 51, 40) function-interpolation-python 1.6575 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 7, 1, 51, 40) function-interpolation-python 0.967171 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 7, 1, 52, 8) la-vector-access-cpp 27.9762 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 7, 1, 52, 33) la-vector-assignment-cpp 25.0818 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 8, 1, 39, 7) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.5775 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 8, 1, 39, 26) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4071 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 8, 1, 39, 42) geometry-bounding_box_tree_build-cpp 13.9409 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 8, 1, 40, 10) common-progress-cpp 27.6519 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 8, 1, 40, 39) common-timing-cpp 28.7396 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 8, 1, 42, 25) fem-multicore-cpp 106.911 "Coloring mesh." (2013, 8, 8, 1, 44, 54) fem-assembly-cpp 148.626 "Assembly for various forms and backends" (2013, 8, 8, 1, 45, 6) fem-convergence-cpp 12.1204 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 8, 1, 45, 8) fem-jit-python 0.0010474 "JIT compilation (in memory cache)" (2013, 8, 8, 1, 50, 15) fem-speedup-cpp 307.236 "Assembly/solve speedup running on 4 processors" (2013, 8, 8, 1, 50, 15) fem-speedup-cpp-assembly 6.50746 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 8, 1, 50, 15) fem-speedup-cpp-solve 2.26756 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 8, 1, 50, 39) mesh-refinement-cpp 19.8766 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 8, 1, 50, 58) mesh-topology-cpp 19.1145 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 8, 1, 51, 22) mesh-unitcube-cpp 23.8653 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 8, 1, 52, 0) mesh-iteration-cpp 35.4708 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 8, 1, 52, 21) function-evaluation-cpp 21.2067 "Evaluations of functions at arbitrary points." (2013, 8, 8, 1, 52, 21) function-evaluation-cpp 21.0854 "Evaluations of functions at arbitrary points." (2013, 8, 8, 1, 52, 24) function-extrapolation-python 3.37869 "BENCH: 1.0582280159" (2013, 8, 8, 1, 52, 24) function-extrapolation-python 1.05823 "BENCH: 1.0582280159" (2013, 8, 8, 1, 52, 26) function-interpolation-python 1.66341 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 8, 1, 52, 26) function-interpolation-python 0.967375 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 8, 1, 52, 54) la-vector-access-cpp 27.9801 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 8, 1, 53, 19) la-vector-assignment-cpp 25.075 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 9, 1, 38, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.97718 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 9, 1, 38, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4435 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 9, 1, 39, 13) geometry-bounding_box_tree_build-cpp 13.959 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 9, 1, 39, 40) common-progress-cpp 27.6523 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 9, 1, 40, 10) common-timing-cpp 29.978 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 9, 1, 41, 58) fem-multicore-cpp 107.297 "Coloring mesh." (2013, 8, 9, 1, 44, 26) fem-assembly-cpp 148.325 "Assembly for various forms and backends" (2013, 8, 9, 1, 44, 38) fem-convergence-cpp 12.1115 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 9, 1, 44, 40) fem-jit-python 0.00103259 "JIT compilation (in memory cache)" (2013, 8, 9, 1, 49, 47) fem-speedup-cpp 307.202 "Assembly/solve speedup running on 4 processors" (2013, 8, 9, 1, 49, 47) fem-speedup-cpp-assembly 6.52362 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 9, 1, 49, 47) fem-speedup-cpp-solve 2.23068 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 9, 1, 50, 9) mesh-refinement-cpp 20.0758 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 9, 1, 50, 28) mesh-topology-cpp 19.1616 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 9, 1, 50, 53) mesh-unitcube-cpp 24.3457 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 9, 1, 51, 39) mesh-iteration-cpp 44.1844 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 9, 1, 52, 1) function-evaluation-cpp 21.1735 "Evaluations of functions at arbitrary points." (2013, 8, 9, 1, 52, 1) function-evaluation-cpp 21.0478 "Evaluations of functions at arbitrary points." (2013, 8, 9, 1, 52, 4) function-extrapolation-python 3.36801 "BENCH: 1.06341600418" (2013, 8, 9, 1, 52, 4) function-extrapolation-python 1.06342 "BENCH: 1.06341600418" (2013, 8, 9, 1, 52, 6) function-interpolation-python 1.69133 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 9, 1, 52, 6) function-interpolation-python 1.00928 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 9, 1, 52, 34) la-vector-access-cpp 27.9606 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 9, 1, 52, 59) la-vector-assignment-cpp 25.0921 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 10, 1, 28, 30) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0617 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 10, 1, 28, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5376 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 10, 1, 29, 6) geometry-bounding_box_tree_build-cpp 13.9398 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 10, 1, 29, 33) common-progress-cpp 27.711 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 10, 1, 30, 3) common-timing-cpp 29.5057 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 10, 1, 31, 50) fem-multicore-cpp 107.191 "Coloring mesh." (2013, 8, 10, 1, 34, 19) fem-assembly-cpp 148.787 "Assembly for various forms and backends" (2013, 8, 10, 1, 34, 31) fem-convergence-cpp 12.1214 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 10, 1, 34, 33) fem-jit-python 0.00102639 "JIT compilation (in memory cache)" (2013, 8, 10, 1, 39, 41) fem-speedup-cpp 308.48 "Assembly/solve speedup running on 4 processors" (2013, 8, 10, 1, 39, 41) fem-speedup-cpp-assembly 6.56523 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 10, 1, 39, 41) fem-speedup-cpp-solve 2.21603 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 10, 1, 40, 3) mesh-refinement-cpp 19.9983 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 10, 1, 40, 22) mesh-topology-cpp 19.185 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 10, 1, 40, 47) mesh-unitcube-cpp 24.3062 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 10, 1, 41, 26) mesh-iteration-cpp 36.7437 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 10, 1, 41, 47) function-evaluation-cpp 21.1904 "Evaluations of functions at arbitrary points." (2013, 8, 10, 1, 41, 47) function-evaluation-cpp 21.0738 "Evaluations of functions at arbitrary points." (2013, 8, 10, 1, 41, 51) function-extrapolation-python 3.4954 "BENCH: 1.07068109512" (2013, 8, 10, 1, 41, 51) function-extrapolation-python 1.07068 "BENCH: 1.07068109512" (2013, 8, 10, 1, 41, 52) function-interpolation-python 1.68025 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 10, 1, 41, 52) function-interpolation-python 0.998028 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 10, 1, 42, 17) la-vector-access-cpp 24.9651 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 10, 1, 42, 42) la-vector-assignment-cpp 25.0923 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 11, 1, 28, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1327 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 11, 1, 28, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4899 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 11, 1, 28, 55) geometry-bounding_box_tree_build-cpp 13.9146 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 11, 1, 29, 23) common-progress-cpp 27.6527 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 11, 1, 29, 52) common-timing-cpp 29.3516 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 11, 1, 31, 39) fem-multicore-cpp 107.135 "Coloring mesh." (2013, 8, 11, 1, 34, 8) fem-assembly-cpp 148.826 "Assembly for various forms and backends" (2013, 8, 11, 1, 34, 20) fem-convergence-cpp 12.1183 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 11, 1, 34, 22) fem-jit-python 0.00103371 "JIT compilation (in memory cache)" (2013, 8, 11, 1, 39, 32) fem-speedup-cpp 309.779 "Assembly/solve speedup running on 4 processors" (2013, 8, 11, 1, 39, 32) fem-speedup-cpp-assembly 6.5308 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 11, 1, 39, 32) fem-speedup-cpp-solve 2.19844 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 11, 1, 39, 54) mesh-refinement-cpp 19.9707 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 11, 1, 40, 13) mesh-topology-cpp 19.1777 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 11, 1, 40, 38) mesh-unitcube-cpp 24.3165 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 11, 1, 41, 16) mesh-iteration-cpp 36.0375 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 11, 1, 41, 38) function-evaluation-cpp 21.1652 "Evaluations of functions at arbitrary points." (2013, 8, 11, 1, 41, 38) function-evaluation-cpp 21.0418 "Evaluations of functions at arbitrary points." (2013, 8, 11, 1, 41, 41) function-extrapolation-python 3.39699 "BENCH: 1.05698800087" (2013, 8, 11, 1, 41, 41) function-extrapolation-python 1.05699 "BENCH: 1.05698800087" (2013, 8, 11, 1, 41, 43) function-interpolation-python 1.688 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 11, 1, 41, 43) function-interpolation-python 0.992373 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 11, 1, 42, 8) la-vector-access-cpp 24.9549 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 11, 1, 42, 35) la-vector-assignment-cpp 27.0904 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 12, 1, 29, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2828 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 12, 1, 29, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6988 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 12, 1, 29, 54) geometry-bounding_box_tree_build-cpp 13.8845 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 12, 1, 30, 22) common-progress-cpp 27.6521 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 12, 1, 30, 53) common-timing-cpp 30.9291 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 12, 1, 32, 40) fem-multicore-cpp 107.116 "Coloring mesh." (2013, 8, 12, 1, 35, 11) fem-assembly-cpp 150.797 "Assembly for various forms and backends" (2013, 8, 12, 1, 35, 23) fem-convergence-cpp 12.1069 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 12, 1, 35, 25) fem-jit-python 0.00104201 "JIT compilation (in memory cache)" (2013, 8, 12, 1, 40, 30) fem-speedup-cpp 305.437 "Assembly/solve speedup running on 4 processors" (2013, 8, 12, 1, 40, 30) fem-speedup-cpp-assembly 6.58536 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2013, 8, 12, 1, 40, 30) fem-speedup-cpp-solve 2.25804 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2013, 8, 12, 1, 40, 51) mesh-refinement-cpp 19.969 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 12, 1, 41, 10) mesh-topology-cpp 19.078 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 12, 1, 41, 34) mesh-unitcube-cpp 24.2732 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 12, 1, 42, 16) mesh-iteration-cpp 39.1608 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 12, 1, 42, 38) function-evaluation-cpp 21.5864 "Evaluations of functions at arbitrary points." (2013, 8, 12, 1, 42, 38) function-evaluation-cpp 21.5077 "Evaluations of functions at arbitrary points." (2013, 8, 12, 1, 42, 41) function-extrapolation-python 3.45743 "BENCH: 1.06352710724" (2013, 8, 12, 1, 42, 41) function-extrapolation-python 1.06353 "BENCH: 1.06352710724" (2013, 8, 12, 1, 42, 43) function-interpolation-python 1.73152 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 12, 1, 42, 43) function-interpolation-python 0.999738 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 12, 1, 43, 6) la-vector-access-cpp 23.4342 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 12, 1, 43, 31) la-vector-assignment-cpp 25.0658 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 13, 1, 30, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0241 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 13, 1, 30, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4037 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 13, 1, 31, 7) geometry-bounding_box_tree_build-cpp 13.9484 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 13, 1, 31, 35) common-progress-cpp 27.6525 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 13, 1, 32, 5) common-timing-cpp 29.6965 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 13, 1, 33, 52) fem-multicore-cpp 107.115 "Coloring mesh." (2013, 8, 13, 1, 36, 21) fem-assembly-cpp 149.547 "Assembly for various forms and backends" (2013, 8, 13, 1, 36, 34) fem-convergence-cpp 12.1174 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 13, 1, 36, 35) fem-jit-python 0.00102611 "JIT compilation (in memory cache)" (2013, 8, 13, 1, 42, 1) mesh-refinement-cpp 19.7741 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 13, 1, 42, 21) mesh-topology-cpp 19.069 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 13, 1, 42, 45) mesh-unitcube-cpp 23.9753 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 13, 1, 43, 23) mesh-iteration-cpp 35.5453 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 13, 1, 43, 45) function-evaluation-cpp 21.989 "Evaluations of functions at arbitrary points." (2013, 8, 13, 1, 43, 45) function-evaluation-cpp 21.9033 "Evaluations of functions at arbitrary points." (2013, 8, 13, 1, 43, 48) function-extrapolation-python 3.45407 "BENCH: 1.06975007057" (2013, 8, 13, 1, 43, 48) function-extrapolation-python 1.06975 "BENCH: 1.06975007057" (2013, 8, 13, 1, 43, 50) function-interpolation-python 1.70201 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 13, 1, 43, 50) function-interpolation-python 0.993179 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 13, 1, 44, 15) la-vector-access-cpp 25.4377 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 13, 1, 44, 44) la-vector-assignment-cpp 29.099 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 14, 1, 34, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1619 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 14, 1, 34, 22) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4298 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 14, 1, 34, 38) geometry-bounding_box_tree_build-cpp 13.9632 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 14, 1, 35, 6) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 14, 1, 35, 36) common-timing-cpp 30.0964 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 14, 1, 37, 24) fem-multicore-cpp 107.553 "Coloring mesh." (2013, 8, 14, 1, 39, 53) fem-assembly-cpp 149.226 "Assembly for various forms and backends" (2013, 8, 14, 1, 40, 5) fem-convergence-cpp 12.119 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 14, 1, 40, 7) fem-jit-python 0.00104291 "JIT compilation (in memory cache)" (2013, 8, 14, 1, 45, 34) mesh-refinement-cpp 19.6692 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 14, 1, 45, 53) mesh-topology-cpp 19.0427 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 14, 1, 46, 17) mesh-unitcube-cpp 24.1043 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 14, 1, 46, 59) mesh-iteration-cpp 39.1619 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 14, 1, 47, 20) function-evaluation-cpp 21.1819 "Evaluations of functions at arbitrary points." (2013, 8, 14, 1, 47, 20) function-evaluation-cpp 21.0348 "Evaluations of functions at arbitrary points." (2013, 8, 14, 1, 47, 24) function-extrapolation-python 3.54554 "BENCH: 1.07405281067" (2013, 8, 14, 1, 47, 24) function-extrapolation-python 1.07405 "BENCH: 1.07405281067" (2013, 8, 14, 1, 47, 25) function-interpolation-python 1.68059 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 14, 1, 47, 25) function-interpolation-python 0.985128 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 14, 1, 47, 49) la-vector-access-cpp 23.4845 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 14, 1, 48, 16) la-vector-assignment-cpp 27.0837 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 15, 1, 35, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0388 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 15, 1, 35, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5463 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 15, 1, 36, 13) geometry-bounding_box_tree_build-cpp 13.949 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 15, 1, 36, 40) common-progress-cpp 27.6926 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 15, 1, 37, 10) common-timing-cpp 29.5317 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 15, 1, 38, 57) fem-multicore-cpp 107.211 "Coloring mesh." (2013, 8, 15, 1, 41, 26) fem-assembly-cpp 149.318 "Assembly for various forms and backends" (2013, 8, 15, 1, 41, 39) fem-convergence-cpp 12.1089 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 15, 1, 41, 40) fem-jit-python 0.00103989 "JIT compilation (in memory cache)" (2013, 8, 15, 1, 47, 7) mesh-refinement-cpp 19.6627 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 15, 1, 47, 26) mesh-topology-cpp 19.0479 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 15, 1, 47, 50) mesh-unitcube-cpp 23.9587 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 15, 1, 48, 28) mesh-iteration-cpp 35.5438 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 15, 1, 48, 50) function-evaluation-cpp 21.4899 "Evaluations of functions at arbitrary points." (2013, 8, 15, 1, 48, 50) function-evaluation-cpp 21.3608 "Evaluations of functions at arbitrary points." (2013, 8, 15, 1, 48, 53) function-extrapolation-python 3.42887 "BENCH: 1.06464219093" (2013, 8, 15, 1, 48, 53) function-extrapolation-python 1.06464 "BENCH: 1.06464219093" (2013, 8, 15, 1, 48, 55) function-interpolation-python 1.68364 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 15, 1, 48, 55) function-interpolation-python 0.987284 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 15, 1, 49, 18) la-vector-access-cpp 23.4684 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 15, 1, 49, 46) la-vector-assignment-cpp 28.1084 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 16, 1, 30, 1) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.157 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 16, 1, 30, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5268 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 16, 1, 30, 37) geometry-bounding_box_tree_build-cpp 13.9169 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 16, 1, 31, 4) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 16, 1, 31, 34) common-timing-cpp 29.8024 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 16, 1, 33, 22) fem-multicore-cpp 107.582 "Coloring mesh." (2013, 8, 16, 1, 35, 51) fem-assembly-cpp 149.686 "Assembly for various forms and backends" (2013, 8, 16, 1, 36, 3) fem-convergence-cpp 12.1138 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 16, 1, 36, 5) fem-jit-python 0.0010246 "JIT compilation (in memory cache)" (2013, 8, 16, 1, 41, 32) mesh-refinement-cpp 19.7091 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 16, 1, 41, 52) mesh-topology-cpp 19.0539 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 16, 1, 42, 16) mesh-unitcube-cpp 24.0192 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 16, 1, 42, 57) mesh-iteration-cpp 39.1605 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 16, 1, 43, 19) function-evaluation-cpp 21.4923 "Evaluations of functions at arbitrary points." (2013, 8, 16, 1, 43, 19) function-evaluation-cpp 21.4079 "Evaluations of functions at arbitrary points." (2013, 8, 16, 1, 43, 22) function-extrapolation-python 3.45402 "BENCH: 1.0782160759" (2013, 8, 16, 1, 43, 22) function-extrapolation-python 1.07822 "BENCH: 1.0782160759" (2013, 8, 16, 1, 43, 24) function-interpolation-python 1.70071 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 16, 1, 43, 24) function-interpolation-python 0.980738 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 16, 1, 43, 47) la-vector-access-cpp 23.4338 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 16, 1, 44, 14) la-vector-assignment-cpp 26.9666 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 17, 1, 37, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1059 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 17, 1, 37, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6572 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 17, 1, 38, 10) geometry-bounding_box_tree_build-cpp 13.9366 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 17, 1, 38, 37) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 17, 1, 39, 7) common-timing-cpp 29.6877 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 17, 1, 40, 54) fem-multicore-cpp 107.153 "Coloring mesh." (2013, 8, 17, 1, 43, 24) fem-assembly-cpp 149.321 "Assembly for various forms and backends" (2013, 8, 17, 1, 43, 36) fem-convergence-cpp 12.1125 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 17, 1, 43, 38) fem-jit-python 0.0010309 "JIT compilation (in memory cache)" (2013, 8, 17, 1, 49, 5) mesh-refinement-cpp 19.7317 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 17, 1, 49, 24) mesh-topology-cpp 19.1088 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 17, 1, 49, 48) mesh-unitcube-cpp 23.9583 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 17, 1, 50, 26) mesh-iteration-cpp 35.5424 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 17, 1, 50, 47) function-evaluation-cpp 21.1737 "Evaluations of functions at arbitrary points." (2013, 8, 17, 1, 50, 47) function-evaluation-cpp 21.0623 "Evaluations of functions at arbitrary points." (2013, 8, 17, 1, 50, 50) function-extrapolation-python 3.42052 "BENCH: 1.05454802513" (2013, 8, 17, 1, 50, 50) function-extrapolation-python 1.05455 "BENCH: 1.05454802513" (2013, 8, 17, 1, 50, 52) function-interpolation-python 1.66117 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 17, 1, 50, 52) function-interpolation-python 0.981249 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 17, 1, 51, 16) la-vector-access-cpp 23.4603 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 17, 1, 51, 43) la-vector-assignment-cpp 27.0856 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 18, 1, 34, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0011 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 18, 1, 34, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5313 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 18, 1, 35, 16) geometry-bounding_box_tree_build-cpp 13.8817 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 18, 1, 35, 43) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 18, 1, 36, 13) common-timing-cpp 29.8438 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 18, 1, 38, 1) fem-multicore-cpp 107.524 "Coloring mesh." (2013, 8, 18, 1, 40, 30) fem-assembly-cpp 149.51 "Assembly for various forms and backends" (2013, 8, 18, 1, 40, 42) fem-convergence-cpp 12.1168 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 18, 1, 40, 44) fem-jit-python 0.00102959 "JIT compilation (in memory cache)" (2013, 8, 18, 1, 46, 11) mesh-refinement-cpp 19.7557 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 18, 1, 46, 30) mesh-topology-cpp 19.0728 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 18, 1, 46, 54) mesh-unitcube-cpp 23.9239 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 18, 1, 47, 32) mesh-iteration-cpp 35.5647 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 18, 1, 47, 53) function-evaluation-cpp 21.1502 "Evaluations of functions at arbitrary points." (2013, 8, 18, 1, 47, 53) function-evaluation-cpp 21.0625 "Evaluations of functions at arbitrary points." (2013, 8, 18, 1, 47, 57) function-extrapolation-python 3.39587 "BENCH: 1.07850408554" (2013, 8, 18, 1, 47, 57) function-extrapolation-python 1.0785 "BENCH: 1.07850408554" (2013, 8, 18, 1, 47, 58) function-interpolation-python 1.71663 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 18, 1, 47, 58) function-interpolation-python 0.991286 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 18, 1, 48, 22) la-vector-access-cpp 23.4148 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 18, 1, 48, 50) la-vector-assignment-cpp 28.0935 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 19, 1, 33, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0347 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 19, 1, 33, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5302 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 19, 1, 33, 57) geometry-bounding_box_tree_build-cpp 13.959 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 19, 1, 34, 24) common-progress-cpp 27.6894 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 19, 1, 34, 54) common-timing-cpp 29.7698 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 19, 1, 36, 42) fem-multicore-cpp 107.61 "Coloring mesh." (2013, 8, 19, 1, 39, 11) fem-assembly-cpp 149.545 "Assembly for various forms and backends" (2013, 8, 19, 1, 39, 23) fem-convergence-cpp 12.1109 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 19, 1, 39, 25) fem-jit-python 0.0010288 "JIT compilation (in memory cache)" (2013, 8, 19, 1, 44, 56) mesh-refinement-cpp 19.7029 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 19, 1, 45, 15) mesh-topology-cpp 19.0506 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 19, 1, 45, 39) mesh-unitcube-cpp 23.8949 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 19, 1, 46, 17) mesh-iteration-cpp 35.5753 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 19, 1, 46, 38) function-evaluation-cpp 21.3738 "Evaluations of functions at arbitrary points." (2013, 8, 19, 1, 46, 38) function-evaluation-cpp 21.2511 "Evaluations of functions at arbitrary points." (2013, 8, 19, 1, 46, 42) function-extrapolation-python 3.36224 "BENCH: 1.0701379776" (2013, 8, 19, 1, 46, 42) function-extrapolation-python 1.07014 "BENCH: 1.0701379776" (2013, 8, 19, 1, 46, 44) function-interpolation-python 1.68547 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 19, 1, 46, 44) function-interpolation-python 0.994866 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 19, 1, 47, 9) la-vector-access-cpp 25.4601 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 19, 1, 47, 36) la-vector-assignment-cpp 27.0887 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 20, 1, 33, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2098 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 20, 1, 33, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6292 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 20, 1, 33, 59) geometry-bounding_box_tree_build-cpp 13.936 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 20, 1, 34, 26) common-progress-cpp 27.6523 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 20, 1, 34, 56) common-timing-cpp 29.9126 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 20, 1, 36, 43) fem-multicore-cpp 107.315 "Coloring mesh." (2013, 8, 20, 1, 39, 13) fem-assembly-cpp 149.665 "Assembly for various forms and backends" (2013, 8, 20, 1, 39, 25) fem-convergence-cpp 12.1433 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 20, 1, 39, 27) fem-jit-python 0.00102808 "JIT compilation (in memory cache)" (2013, 8, 20, 1, 44, 54) mesh-refinement-cpp 19.688 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 20, 1, 45, 13) mesh-topology-cpp 19.0522 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 20, 1, 45, 37) mesh-unitcube-cpp 24.3722 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 20, 1, 46, 15) mesh-iteration-cpp 35.5501 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 20, 1, 46, 36) function-evaluation-cpp 21.2071 "Evaluations of functions at arbitrary points." (2013, 8, 20, 1, 46, 36) function-evaluation-cpp 21.047 "Evaluations of functions at arbitrary points." (2013, 8, 20, 1, 46, 40) function-extrapolation-python 3.39304 "BENCH: 1.07953190804" (2013, 8, 20, 1, 46, 40) function-extrapolation-python 1.07953 "BENCH: 1.07953190804" (2013, 8, 20, 1, 46, 42) function-interpolation-python 1.66658 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 20, 1, 46, 42) function-interpolation-python 0.97045 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 20, 1, 47, 7) la-vector-access-cpp 25.4608 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 20, 1, 47, 34) la-vector-assignment-cpp 27.0924 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 21, 1, 34, 16) geometry-bounding_box_tree_compute_entity_collisions-cpp 9.97891 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 21, 1, 34, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4209 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 21, 1, 34, 51) geometry-bounding_box_tree_build-cpp 13.9314 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 21, 1, 35, 19) common-progress-cpp 27.6531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 21, 1, 35, 48) common-timing-cpp 29.5588 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 21, 1, 37, 36) fem-multicore-cpp 107.83 "Coloring mesh." (2013, 8, 21, 1, 40, 5) fem-assembly-cpp 149.148 "Assembly for various forms and backends" (2013, 8, 21, 1, 40, 18) fem-convergence-cpp 12.1096 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 21, 1, 40, 19) fem-jit-python 0.0010334 "JIT compilation (in memory cache)" (2013, 8, 21, 1, 45, 47) mesh-refinement-cpp 19.7165 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 21, 1, 46, 6) mesh-topology-cpp 19.1289 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 21, 1, 46, 30) mesh-unitcube-cpp 23.9397 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 21, 1, 47, 8) mesh-iteration-cpp 35.5482 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 21, 1, 47, 29) function-evaluation-cpp 21.152 "Evaluations of functions at arbitrary points." (2013, 8, 21, 1, 47, 29) function-evaluation-cpp 21.0574 "Evaluations of functions at arbitrary points." (2013, 8, 21, 1, 47, 33) function-extrapolation-python 3.43729 "BENCH: 1.07766795158" (2013, 8, 21, 1, 47, 33) function-extrapolation-python 1.07767 "BENCH: 1.07766795158" (2013, 8, 21, 1, 47, 34) function-interpolation-python 1.68293 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 21, 1, 47, 34) function-interpolation-python 0.98242 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 21, 1, 47, 58) la-vector-access-cpp 23.4316 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 21, 1, 48, 25) la-vector-assignment-cpp 27.0692 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 22, 1, 41, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1633 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 22, 1, 41, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5437 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 22, 1, 41, 48) geometry-bounding_box_tree_build-cpp 13.9018 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 22, 1, 42, 16) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 22, 1, 42, 45) common-timing-cpp 29.7343 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 22, 1, 44, 33) fem-multicore-cpp 107.339 "Coloring mesh." (2013, 8, 22, 1, 47, 1) fem-assembly-cpp 147.821 "Assembly for various forms and backends" (2013, 8, 22, 1, 47, 13) fem-convergence-cpp 12.1131 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 22, 1, 47, 14) fem-jit-python 0.00101988 "JIT compilation (in memory cache)" (2013, 8, 22, 1, 52, 42) mesh-refinement-cpp 19.8313 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 22, 1, 53, 1) mesh-topology-cpp 19.1747 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 22, 1, 53, 25) mesh-unitcube-cpp 24.0708 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 22, 1, 54, 3) mesh-iteration-cpp 35.4753 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 22, 1, 54, 24) function-evaluation-cpp 21.161 "Evaluations of functions at arbitrary points." (2013, 8, 22, 1, 54, 24) function-evaluation-cpp 21.0795 "Evaluations of functions at arbitrary points." (2013, 8, 22, 1, 54, 28) function-extrapolation-python 3.44571 "BENCH: 1.06874084473" (2013, 8, 22, 1, 54, 28) function-extrapolation-python 1.06874 "BENCH: 1.06874084473" (2013, 8, 22, 1, 54, 29) function-interpolation-python 1.71545 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 22, 1, 54, 29) function-interpolation-python 0.98559 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 22, 1, 54, 53) la-vector-access-cpp 23.4312 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 22, 1, 55, 20) la-vector-assignment-cpp 27.073 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 23, 1, 28, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.242 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 23, 1, 28, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5556 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 23, 1, 29, 15) geometry-bounding_box_tree_build-cpp 14.0003 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 23, 1, 29, 43) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 23, 1, 30, 13) common-timing-cpp 29.5955 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 23, 1, 31, 59) fem-multicore-cpp 106.916 "Coloring mesh." (2013, 8, 23, 1, 34, 28) fem-assembly-cpp 148.097 "Assembly for various forms and backends" (2013, 8, 23, 1, 34, 40) fem-convergence-cpp 12.1088 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 23, 1, 34, 42) fem-jit-python 0.00104151 "JIT compilation (in memory cache)" (2013, 8, 23, 1, 40, 12) mesh-refinement-cpp 19.8325 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 23, 1, 40, 32) mesh-topology-cpp 19.0871 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 23, 1, 40, 56) mesh-unitcube-cpp 23.9952 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 23, 1, 41, 34) mesh-iteration-cpp 35.4766 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 23, 1, 41, 55) function-evaluation-cpp 21.2071 "Evaluations of functions at arbitrary points." (2013, 8, 23, 1, 41, 55) function-evaluation-cpp 21.0508 "Evaluations of functions at arbitrary points." (2013, 8, 23, 1, 41, 58) function-extrapolation-python 3.54535 "BENCH: 1.09432315826" (2013, 8, 23, 1, 41, 58) function-extrapolation-python 1.09432 "BENCH: 1.09432315826" (2013, 8, 23, 1, 42, 0) function-interpolation-python 1.70435 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 23, 1, 42, 0) function-interpolation-python 0.997619 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 23, 1, 42, 24) la-vector-access-cpp 23.4479 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 23, 1, 42, 51) la-vector-assignment-cpp 27.0923 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 24, 1, 26, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2205 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 24, 1, 26, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5829 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 24, 1, 26, 57) geometry-bounding_box_tree_build-cpp 13.9053 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 24, 1, 27, 24) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 24, 1, 27, 54) common-timing-cpp 29.9517 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 24, 1, 29, 42) fem-multicore-cpp 107.16 "Coloring mesh." (2013, 8, 24, 1, 32, 9) fem-assembly-cpp 147.87 "Assembly for various forms and backends" (2013, 8, 24, 1, 32, 22) fem-convergence-cpp 12.1414 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 24, 1, 32, 23) fem-jit-python 0.00104651 "JIT compilation (in memory cache)" (2013, 8, 24, 1, 37, 51) mesh-refinement-cpp 19.8106 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 24, 1, 38, 10) mesh-topology-cpp 19.028 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 24, 1, 38, 34) mesh-unitcube-cpp 24.0868 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 24, 1, 39, 12) mesh-iteration-cpp 35.4311 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 24, 1, 39, 34) function-evaluation-cpp 21.9966 "Evaluations of functions at arbitrary points." (2013, 8, 24, 1, 39, 34) function-evaluation-cpp 21.8937 "Evaluations of functions at arbitrary points." (2013, 8, 24, 1, 39, 38) function-extrapolation-python 3.63718 "BENCH: 1.0871860981" (2013, 8, 24, 1, 39, 38) function-extrapolation-python 1.08719 "BENCH: 1.0871860981" (2013, 8, 24, 1, 39, 39) function-interpolation-python 1.68271 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 24, 1, 39, 39) function-interpolation-python 0.965442 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 24, 1, 40, 3) la-vector-access-cpp 23.4306 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 24, 1, 40, 30) la-vector-assignment-cpp 27.0702 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 25, 1, 27, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2155 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 25, 1, 28, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.556 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 25, 1, 28, 23) geometry-bounding_box_tree_build-cpp 13.9012 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 25, 1, 28, 50) common-progress-cpp 27.6527 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 25, 1, 29, 20) common-timing-cpp 30.2048 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 25, 1, 31, 8) fem-multicore-cpp 107.387 "Coloring mesh." (2013, 8, 25, 1, 33, 34) fem-assembly-cpp 146.65 "Assembly for various forms and backends" (2013, 8, 25, 1, 33, 47) fem-convergence-cpp 12.1122 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 25, 1, 33, 48) fem-jit-python 0.00102611 "JIT compilation (in memory cache)" (2013, 8, 25, 1, 39, 18) mesh-refinement-cpp 19.7606 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 25, 1, 39, 37) mesh-topology-cpp 19.0406 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 25, 1, 40, 1) mesh-unitcube-cpp 24.0438 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 25, 1, 40, 48) mesh-iteration-cpp 44.1876 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 25, 1, 41, 10) function-evaluation-cpp 22.0397 "Evaluations of functions at arbitrary points." (2013, 8, 25, 1, 41, 10) function-evaluation-cpp 21.917 "Evaluations of functions at arbitrary points." (2013, 8, 25, 1, 41, 14) function-extrapolation-python 3.64267 "BENCH: 1.06951498985" (2013, 8, 25, 1, 41, 14) function-extrapolation-python 1.06951 "BENCH: 1.06951498985" (2013, 8, 25, 1, 41, 15) function-interpolation-python 1.68502 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 25, 1, 41, 15) function-interpolation-python 0.970874 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 25, 1, 41, 39) la-vector-access-cpp 23.4612 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 25, 1, 42, 7) la-vector-assignment-cpp 28.1235 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 26, 1, 28, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.159 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 26, 1, 28, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5303 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 26, 1, 28, 43) geometry-bounding_box_tree_build-cpp 13.9238 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 26, 1, 29, 11) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 26, 1, 29, 41) common-timing-cpp 30.3243 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 26, 1, 31, 28) fem-multicore-cpp 106.721 "Coloring mesh." (2013, 8, 26, 1, 33, 55) fem-assembly-cpp 147.296 "Assembly for various forms and backends" (2013, 8, 26, 1, 34, 8) fem-convergence-cpp 12.1133 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 26, 1, 34, 9) fem-jit-python 0.00102899 "JIT compilation (in memory cache)" (2013, 8, 26, 1, 39, 38) mesh-refinement-cpp 19.7435 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 26, 1, 39, 57) mesh-topology-cpp 19.0231 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 26, 1, 40, 21) mesh-unitcube-cpp 24.0455 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 26, 1, 40, 59) mesh-iteration-cpp 35.4755 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 26, 1, 41, 20) function-evaluation-cpp 21.174 "Evaluations of functions at arbitrary points." (2013, 8, 26, 1, 41, 20) function-evaluation-cpp 21.0568 "Evaluations of functions at arbitrary points." (2013, 8, 26, 1, 41, 24) function-extrapolation-python 3.3543 "BENCH: 1.06886506081" (2013, 8, 26, 1, 41, 24) function-extrapolation-python 1.06887 "BENCH: 1.06886506081" (2013, 8, 26, 1, 41, 25) function-interpolation-python 1.64721 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 26, 1, 41, 25) function-interpolation-python 0.967554 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 26, 1, 41, 51) la-vector-access-cpp 25.4723 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 26, 1, 42, 20) la-vector-assignment-cpp 29.1231 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 27, 1, 36, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2084 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 27, 1, 37, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6492 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 27, 1, 37, 24) geometry-bounding_box_tree_build-cpp 13.9458 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 27, 1, 37, 52) common-progress-cpp 27.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 27, 1, 38, 21) common-timing-cpp 29.6701 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 27, 1, 40, 8) fem-multicore-cpp 106.952 "Coloring mesh." (2013, 8, 27, 1, 42, 36) fem-assembly-cpp 147.639 "Assembly for various forms and backends" (2013, 8, 27, 1, 42, 48) fem-convergence-cpp 12.1161 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 27, 1, 42, 50) fem-jit-python 0.00104239 "JIT compilation (in memory cache)" (2013, 8, 27, 1, 48, 21) mesh-refinement-cpp 19.7705 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 27, 1, 48, 40) mesh-topology-cpp 19.0239 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 27, 1, 49, 4) mesh-unitcube-cpp 24.032 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 27, 1, 49, 42) mesh-iteration-cpp 35.4677 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 27, 1, 50, 3) function-evaluation-cpp 21.2154 "Evaluations of functions at arbitrary points." (2013, 8, 27, 1, 50, 3) function-evaluation-cpp 21.0981 "Evaluations of functions at arbitrary points." (2013, 8, 27, 1, 50, 6) function-extrapolation-python 3.34552 "BENCH: 1.05961799622" (2013, 8, 27, 1, 50, 6) function-extrapolation-python 1.05962 "BENCH: 1.05961799622" (2013, 8, 27, 1, 50, 8) function-interpolation-python 1.64476 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 27, 1, 50, 8) function-interpolation-python 0.965227 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 27, 1, 50, 34) la-vector-access-cpp 25.4667 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 27, 1, 51, 1) la-vector-assignment-cpp 27.0917 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 28, 1, 37, 9) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2287 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 28, 1, 37, 28) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6886 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 28, 1, 37, 44) geometry-bounding_box_tree_build-cpp 13.8839 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 28, 1, 38, 12) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 28, 1, 38, 42) common-timing-cpp 30.357 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 28, 1, 40, 30) fem-multicore-cpp 107.501 "Coloring mesh." (2013, 8, 28, 1, 42, 57) fem-assembly-cpp 147.489 "Assembly for various forms and backends" (2013, 8, 28, 1, 43, 9) fem-convergence-cpp 12.1169 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 28, 1, 43, 11) fem-jit-python 0.00102992 "JIT compilation (in memory cache)" (2013, 8, 28, 1, 48, 38) mesh-refinement-cpp 19.8076 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 28, 1, 48, 57) mesh-topology-cpp 19.06 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 28, 1, 49, 21) mesh-unitcube-cpp 24.056 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 28, 1, 49, 59) mesh-iteration-cpp 35.5001 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 28, 1, 50, 20) function-evaluation-cpp 21.1397 "Evaluations of functions at arbitrary points." (2013, 8, 28, 1, 50, 20) function-evaluation-cpp 21.0499 "Evaluations of functions at arbitrary points." (2013, 8, 28, 1, 50, 24) function-extrapolation-python 3.37918 "BENCH: 1.06580996513" (2013, 8, 28, 1, 50, 24) function-extrapolation-python 1.06581 "BENCH: 1.06580996513" (2013, 8, 28, 1, 50, 26) function-interpolation-python 1.68922 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 28, 1, 50, 26) function-interpolation-python 0.968645 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 28, 1, 50, 49) la-vector-access-cpp 23.4405 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 28, 1, 51, 16) la-vector-assignment-cpp 27.0238 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 29, 1, 38, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2082 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 29, 1, 39, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4964 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 29, 1, 39, 32) geometry-bounding_box_tree_build-cpp 13.9043 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 29, 1, 40, 0) common-progress-cpp 27.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 29, 1, 40, 30) common-timing-cpp 30.0317 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 29, 1, 42, 17) fem-multicore-cpp 107.421 "Coloring mesh." (2013, 8, 29, 1, 44, 45) fem-assembly-cpp 147.434 "Assembly for various forms and backends" (2013, 8, 29, 1, 44, 57) fem-convergence-cpp 12.107 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 29, 1, 44, 58) fem-jit-python 0.0010339 "JIT compilation (in memory cache)" (2013, 8, 29, 1, 50, 26) mesh-refinement-cpp 19.8443 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 29, 1, 50, 45) mesh-topology-cpp 19.1561 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 29, 1, 51, 9) mesh-unitcube-cpp 24.0152 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 29, 1, 51, 47) mesh-iteration-cpp 35.4744 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 29, 1, 52, 8) function-evaluation-cpp 21.136 "Evaluations of functions at arbitrary points." (2013, 8, 29, 1, 52, 8) function-evaluation-cpp 21.0444 "Evaluations of functions at arbitrary points." (2013, 8, 29, 1, 52, 12) function-extrapolation-python 3.52903 "BENCH: 1.08780002594" (2013, 8, 29, 1, 52, 12) function-extrapolation-python 1.0878 "BENCH: 1.08780002594" (2013, 8, 29, 1, 52, 14) function-interpolation-python 1.7117 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 29, 1, 52, 14) function-interpolation-python 0.989075 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 29, 1, 52, 37) la-vector-access-cpp 23.4331 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 29, 1, 53, 4) la-vector-assignment-cpp 27.0694 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 30, 1, 35, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1712 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 30, 1, 35, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6562 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 30, 1, 35, 56) geometry-bounding_box_tree_build-cpp 13.8993 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 30, 1, 36, 23) common-progress-cpp 27.6536 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 30, 1, 36, 53) common-timing-cpp 29.2374 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 30, 1, 38, 40) fem-multicore-cpp 106.99 "Coloring mesh." (2013, 8, 30, 1, 41, 6) fem-assembly-cpp 146.731 "Assembly for various forms and backends" (2013, 8, 30, 1, 41, 18) fem-convergence-cpp 12.1084 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 30, 1, 41, 20) fem-jit-python 0.00102789 "JIT compilation (in memory cache)" (2013, 8, 30, 1, 46, 50) mesh-refinement-cpp 19.8221 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 30, 1, 47, 9) mesh-topology-cpp 19.1056 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 30, 1, 47, 33) mesh-unitcube-cpp 24.1155 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 30, 1, 48, 15) mesh-iteration-cpp 39.1589 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 30, 1, 48, 36) function-evaluation-cpp 21.1466 "Evaluations of functions at arbitrary points." (2013, 8, 30, 1, 48, 36) function-evaluation-cpp 21.0684 "Evaluations of functions at arbitrary points." (2013, 8, 30, 1, 48, 39) function-extrapolation-python 3.44779 "BENCH: 1.09775018692" (2013, 8, 30, 1, 48, 39) function-extrapolation-python 1.09775 "BENCH: 1.09775018692" (2013, 8, 30, 1, 48, 41) function-interpolation-python 1.71379 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 30, 1, 48, 41) function-interpolation-python 0.967359 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 30, 1, 49, 4) la-vector-access-cpp 23.4089 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 30, 1, 49, 31) la-vector-assignment-cpp 27.0456 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 8, 31, 1, 34, 26) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.159 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 31, 1, 34, 45) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6174 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 8, 31, 1, 35, 2) geometry-bounding_box_tree_build-cpp 13.9047 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 8, 31, 1, 35, 29) common-progress-cpp 27.6531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 8, 31, 1, 35, 59) common-timing-cpp 29.7881 "Timing access and registration of timings (10000000 repetitions)" (2013, 8, 31, 1, 37, 46) fem-multicore-cpp 107.484 "Coloring mesh." (2013, 8, 31, 1, 40, 14) fem-assembly-cpp 147.879 "Assembly for various forms and backends" (2013, 8, 31, 1, 40, 26) fem-convergence-cpp 12.1066 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 8, 31, 1, 40, 28) fem-jit-python 0.0010278 "JIT compilation (in memory cache)" (2013, 8, 31, 1, 45, 57) mesh-refinement-cpp 19.85 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 8, 31, 1, 46, 16) mesh-topology-cpp 19.0538 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 8, 31, 1, 46, 40) mesh-unitcube-cpp 24.3912 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 8, 31, 1, 47, 27) mesh-iteration-cpp 44.1629 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 8, 31, 1, 47, 49) function-evaluation-cpp 21.5885 "Evaluations of functions at arbitrary points." (2013, 8, 31, 1, 47, 49) function-evaluation-cpp 21.5053 "Evaluations of functions at arbitrary points." (2013, 8, 31, 1, 47, 52) function-extrapolation-python 3.47949 "BENCH: 1.09370994568" (2013, 8, 31, 1, 47, 52) function-extrapolation-python 1.09371 "BENCH: 1.09370994568" (2013, 8, 31, 1, 47, 54) function-interpolation-python 1.6867 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 31, 1, 47, 54) function-interpolation-python 0.966482 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 8, 31, 1, 48, 17) la-vector-access-cpp 23.4141 "Accessing vector of size 10000000 (100 repetitions)" (2013, 8, 31, 1, 48, 45) la-vector-assignment-cpp 28.078 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 1, 1, 32, 0) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.337 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 1, 1, 32, 19) geometry-bounding_box_tree_compute_closest_entity-cpp 15.456 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 1, 1, 32, 35) geometry-bounding_box_tree_build-cpp 13.8984 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 1, 1, 33, 3) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 1, 1, 33, 34) common-timing-cpp 30.4644 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 1, 1, 35, 21) fem-multicore-cpp 107.359 "Coloring mesh." (2013, 9, 1, 1, 37, 49) fem-assembly-cpp 147.849 "Assembly for various forms and backends" (2013, 9, 1, 1, 38, 1) fem-convergence-cpp 12.1151 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 1, 1, 38, 3) fem-jit-python 0.00103521 "JIT compilation (in memory cache)" (2013, 9, 1, 1, 43, 33) mesh-refinement-cpp 19.7962 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 1, 1, 43, 52) mesh-topology-cpp 19.0728 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 1, 1, 44, 16) mesh-unitcube-cpp 24.1598 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 1, 1, 45, 3) mesh-iteration-cpp 44.1031 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 1, 1, 45, 24) function-evaluation-cpp 21.3237 "Evaluations of functions at arbitrary points." (2013, 9, 1, 1, 45, 24) function-evaluation-cpp 21.2078 "Evaluations of functions at arbitrary points." (2013, 9, 1, 1, 45, 28) function-extrapolation-python 3.45091 "BENCH: 1.05152201653" (2013, 9, 1, 1, 45, 28) function-extrapolation-python 1.05152 "BENCH: 1.05152201653" (2013, 9, 1, 1, 45, 29) function-interpolation-python 1.65548 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 1, 1, 45, 29) function-interpolation-python 0.967372 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 1, 1, 45, 53) la-vector-access-cpp 23.448 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 1, 1, 46, 20) la-vector-assignment-cpp 27.0937 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 2, 1, 35, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.4671 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 2, 1, 35, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5409 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 2, 1, 36, 13) geometry-bounding_box_tree_build-cpp 13.8917 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 2, 1, 36, 41) common-progress-cpp 27.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 2, 1, 37, 10) common-timing-cpp 29.1117 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 2, 1, 38, 57) fem-multicore-cpp 106.798 "Coloring mesh." (2013, 9, 2, 1, 41, 23) fem-assembly-cpp 146.611 "Assembly for various forms and backends" (2013, 9, 2, 1, 41, 36) fem-convergence-cpp 12.1059 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 2, 1, 41, 37) fem-jit-python 0.00103259 "JIT compilation (in memory cache)" (2013, 9, 2, 1, 47, 5) mesh-refinement-cpp 19.7983 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 2, 1, 47, 24) mesh-topology-cpp 19.1523 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 2, 1, 47, 48) mesh-unitcube-cpp 24.0441 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 2, 1, 48, 26) mesh-iteration-cpp 35.4857 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 2, 1, 48, 47) function-evaluation-cpp 21.1558 "Evaluations of functions at arbitrary points." (2013, 9, 2, 1, 48, 47) function-evaluation-cpp 21.0742 "Evaluations of functions at arbitrary points." (2013, 9, 2, 1, 48, 51) function-extrapolation-python 3.52892 "BENCH: 1.08873105049" (2013, 9, 2, 1, 48, 51) function-extrapolation-python 1.08873 "BENCH: 1.08873105049" (2013, 9, 2, 1, 48, 53) function-interpolation-python 1.69405 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 2, 1, 48, 53) function-interpolation-python 0.981467 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 2, 1, 49, 16) la-vector-access-cpp 23.4271 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 2, 1, 49, 43) la-vector-assignment-cpp 27.0741 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 3, 1, 36, 30) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.5103 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 3, 1, 36, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5622 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 3, 1, 37, 5) geometry-bounding_box_tree_build-cpp 13.9055 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 3, 1, 37, 33) common-progress-cpp 27.6518 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 3, 1, 38, 3) common-timing-cpp 29.5935 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 3, 1, 39, 49) fem-multicore-cpp 106.892 "Coloring mesh." (2013, 9, 3, 1, 42, 16) fem-assembly-cpp 146.958 "Assembly for various forms and backends" (2013, 9, 3, 1, 42, 29) fem-convergence-cpp 12.1185 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 3, 1, 42, 30) fem-jit-python 0.00103302 "JIT compilation (in memory cache)" (2013, 9, 3, 1, 47, 59) mesh-refinement-cpp 19.7749 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 3, 1, 48, 18) mesh-topology-cpp 19.0566 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 3, 1, 48, 43) mesh-unitcube-cpp 24.0798 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 3, 1, 49, 21) mesh-iteration-cpp 35.5072 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 3, 1, 49, 42) function-evaluation-cpp 21.1668 "Evaluations of functions at arbitrary points." (2013, 9, 3, 1, 49, 42) function-evaluation-cpp 21.0691 "Evaluations of functions at arbitrary points." (2013, 9, 3, 1, 49, 45) function-extrapolation-python 3.47091 "BENCH: 1.07803201675" (2013, 9, 3, 1, 49, 45) function-extrapolation-python 1.07803 "BENCH: 1.07803201675" (2013, 9, 3, 1, 49, 47) function-interpolation-python 1.73744 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 3, 1, 49, 47) function-interpolation-python 0.968631 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 3, 1, 50, 10) la-vector-access-cpp 23.45 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 3, 1, 50, 39) la-vector-assignment-cpp 28.1161 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 4, 1, 27, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1979 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 4, 1, 28, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5105 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 4, 1, 28, 18) geometry-bounding_box_tree_build-cpp 13.9288 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 4, 1, 28, 46) common-progress-cpp 27.6527 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 4, 1, 29, 15) common-timing-cpp 29.0341 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 4, 1, 31, 2) fem-multicore-cpp 107.006 "Coloring mesh." (2013, 9, 4, 1, 33, 29) fem-assembly-cpp 147.47 "Assembly for various forms and backends" (2013, 9, 4, 1, 33, 41) fem-convergence-cpp 12.1119 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 4, 1, 33, 54) fem-jit-python 0.00110939 "JIT compilation (in memory cache)" (2013, 9, 4, 1, 39, 29) mesh-refinement-cpp 19.7505 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 4, 1, 39, 48) mesh-topology-cpp 19.0354 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 4, 1, 40, 12) mesh-unitcube-cpp 24.0708 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 4, 1, 40, 50) mesh-iteration-cpp 35.4269 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 4, 1, 41, 12) function-evaluation-cpp 21.3437 "Evaluations of functions at arbitrary points." (2013, 9, 4, 1, 41, 12) function-evaluation-cpp 21.2508 "Evaluations of functions at arbitrary points." (2013, 9, 4, 1, 42, 2) function-extrapolation-python 50.223 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 9, 4, 1, 42, 2) function-extrapolation-python 1.06637 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 9, 4, 1, 42, 3) function-interpolation-python 1.65448 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 4, 1, 42, 3) function-interpolation-python 0.96664 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 4, 1, 42, 27) la-vector-access-cpp 23.4428 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 4, 1, 42, 54) la-vector-assignment-cpp 27.1227 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 5, 1, 40, 28) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1056 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 5, 1, 40, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3015 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 5, 1, 41, 3) geometry-bounding_box_tree_build-cpp 13.8614 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 5, 1, 41, 31) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 5, 1, 42, 0) common-timing-cpp 29.4477 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 5, 1, 43, 48) fem-multicore-cpp 107.477 "Coloring mesh." (2013, 9, 5, 1, 46, 18) fem-assembly-cpp 150.269 "Assembly for various forms and backends" (2013, 9, 5, 1, 46, 30) fem-convergence-cpp 12.1362 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 5, 1, 46, 32) fem-jit-python 0.00103431 "JIT compilation (in memory cache)" (2013, 9, 5, 1, 51, 59) mesh-refinement-cpp 19.9393 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 5, 1, 52, 19) mesh-topology-cpp 19.3966 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 5, 1, 52, 43) mesh-unitcube-cpp 23.9958 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 5, 1, 53, 21) mesh-iteration-cpp 35.5334 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 5, 1, 53, 42) function-evaluation-cpp 21.1233 "Evaluations of functions at arbitrary points." (2013, 9, 5, 1, 53, 42) function-evaluation-cpp 21.0443 "Evaluations of functions at arbitrary points." (2013, 9, 5, 1, 53, 45) function-extrapolation-python 3.58762 "BENCH: 1.09185791016" (2013, 9, 5, 1, 53, 45) function-extrapolation-python 1.09186 "BENCH: 1.09185791016" (2013, 9, 5, 1, 53, 47) function-interpolation-python 1.68164 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 5, 1, 53, 47) function-interpolation-python 0.964694 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 5, 1, 54, 11) la-vector-access-cpp 23.4282 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 5, 1, 54, 38) la-vector-assignment-cpp 27.0729 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 6, 1, 35, 56) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0468 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 6, 1, 36, 15) geometry-bounding_box_tree_compute_closest_entity-cpp 15.502 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 6, 1, 36, 31) geometry-bounding_box_tree_build-cpp 13.874 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 6, 1, 36, 59) common-progress-cpp 27.6544 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 6, 1, 37, 28) common-timing-cpp 29.4024 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 6, 1, 39, 16) fem-multicore-cpp 107.387 "Coloring mesh." (2013, 9, 6, 1, 41, 46) fem-assembly-cpp 150.033 "Assembly for various forms and backends" (2013, 9, 6, 1, 41, 58) fem-convergence-cpp 12.1347 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 6, 1, 42, 0) fem-jit-python 0.00102112 "JIT compilation (in memory cache)" (2013, 9, 6, 1, 47, 26) mesh-refinement-cpp 19.932 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 6, 1, 47, 46) mesh-topology-cpp 19.3848 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 6, 1, 48, 10) mesh-unitcube-cpp 24.1627 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 6, 1, 48, 56) mesh-iteration-cpp 43.5492 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 6, 1, 49, 17) function-evaluation-cpp 21.1839 "Evaluations of functions at arbitrary points." (2013, 9, 6, 1, 49, 17) function-evaluation-cpp 21.0936 "Evaluations of functions at arbitrary points." (2013, 9, 6, 1, 49, 21) function-extrapolation-python 3.46722 "BENCH: 1.08668613434" (2013, 9, 6, 1, 49, 21) function-extrapolation-python 1.08669 "BENCH: 1.08668613434" (2013, 9, 6, 1, 49, 22) function-interpolation-python 1.65644 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 6, 1, 49, 22) function-interpolation-python 0.951913 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 6, 1, 49, 47) la-vector-access-cpp 24.9374 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 6, 1, 50, 16) la-vector-assignment-cpp 29.1041 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 7, 1, 31, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1463 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 7, 1, 31, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4807 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 7, 1, 31, 44) geometry-bounding_box_tree_build-cpp 13.8554 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 7, 1, 32, 11) common-progress-cpp 27.6525 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 7, 1, 32, 41) common-timing-cpp 29.3273 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 7, 1, 34, 29) fem-multicore-cpp 107.96 "Coloring mesh." (2013, 9, 7, 1, 36, 58) fem-assembly-cpp 149.216 "Assembly for various forms and backends" (2013, 9, 7, 1, 37, 10) fem-convergence-cpp 12.1415 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 7, 1, 37, 12) fem-jit-python 0.00102489 "JIT compilation (in memory cache)" (2013, 9, 7, 1, 42, 40) mesh-refinement-cpp 19.9405 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 7, 1, 42, 59) mesh-topology-cpp 19.3759 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 7, 1, 43, 23) mesh-unitcube-cpp 23.9579 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 7, 1, 44, 1) mesh-iteration-cpp 35.5765 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 7, 1, 44, 23) function-evaluation-cpp 21.1302 "Evaluations of functions at arbitrary points." (2013, 9, 7, 1, 44, 23) function-evaluation-cpp 21.0385 "Evaluations of functions at arbitrary points." (2013, 9, 7, 1, 44, 26) function-extrapolation-python 3.59679 "BENCH: 1.09853887558" (2013, 9, 7, 1, 44, 26) function-extrapolation-python 1.09854 "BENCH: 1.09853887558" (2013, 9, 7, 1, 44, 28) function-interpolation-python 1.65632 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 7, 1, 44, 28) function-interpolation-python 0.949793 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 7, 1, 44, 51) la-vector-access-cpp 23.4279 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 7, 1, 45, 18) la-vector-assignment-cpp 27.072 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 8, 1, 35, 55) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0233 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 8, 1, 36, 14) geometry-bounding_box_tree_compute_closest_entity-cpp 15.416 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 8, 1, 36, 30) geometry-bounding_box_tree_build-cpp 13.8931 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 8, 1, 36, 58) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 8, 1, 37, 27) common-timing-cpp 29.2261 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 8, 1, 39, 15) fem-multicore-cpp 107.691 "Coloring mesh." (2013, 9, 8, 1, 41, 44) fem-assembly-cpp 148.944 "Assembly for various forms and backends" (2013, 9, 8, 1, 41, 56) fem-convergence-cpp 12.145 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 8, 1, 41, 58) fem-jit-python 0.00103338 "JIT compilation (in memory cache)" (2013, 9, 8, 1, 47, 30) mesh-refinement-cpp 19.8907 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 8, 1, 47, 50) mesh-topology-cpp 19.416 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 8, 1, 48, 14) mesh-unitcube-cpp 23.911 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 8, 1, 48, 52) mesh-iteration-cpp 35.5526 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 8, 1, 49, 13) function-evaluation-cpp 21.2074 "Evaluations of functions at arbitrary points." (2013, 9, 8, 1, 49, 13) function-evaluation-cpp 21.0866 "Evaluations of functions at arbitrary points." (2013, 9, 8, 1, 49, 17) function-extrapolation-python 3.49526 "BENCH: 1.07830500603" (2013, 9, 8, 1, 49, 17) function-extrapolation-python 1.07831 "BENCH: 1.07830500603" (2013, 9, 8, 1, 49, 18) function-interpolation-python 1.64315 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 8, 1, 49, 18) function-interpolation-python 0.954983 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 8, 1, 49, 44) la-vector-access-cpp 25.9725 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 8, 1, 50, 12) la-vector-assignment-cpp 27.2369 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 9, 1, 43, 6) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7717 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 9, 1, 43, 25) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5203 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 9, 1, 43, 41) geometry-bounding_box_tree_build-cpp 13.9121 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 9, 1, 44, 9) common-progress-cpp 27.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 9, 1, 44, 39) common-timing-cpp 30.073 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 9, 1, 46, 25) fem-multicore-cpp 106.602 "Coloring mesh." (2013, 9, 9, 1, 48, 55) fem-assembly-cpp 149.27 "Assembly for various forms and backends" (2013, 9, 9, 1, 49, 7) fem-convergence-cpp 12.1329 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 9, 1, 49, 9) fem-jit-python 0.00102019 "JIT compilation (in memory cache)" (2013, 9, 9, 1, 54, 35) mesh-refinement-cpp 19.8754 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 9, 1, 54, 54) mesh-topology-cpp 19.5646 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 9, 1, 55, 18) mesh-unitcube-cpp 23.8683 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 9, 1, 56, 5) mesh-iteration-cpp 44.1777 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 9, 1, 56, 26) function-evaluation-cpp 21.1301 "Evaluations of functions at arbitrary points." (2013, 9, 9, 1, 56, 26) function-evaluation-cpp 21.0513 "Evaluations of functions at arbitrary points." (2013, 9, 9, 1, 56, 29) function-extrapolation-python 3.52172 "BENCH: 1.07437300682" (2013, 9, 9, 1, 56, 29) function-extrapolation-python 1.07437 "BENCH: 1.07437300682" (2013, 9, 9, 1, 56, 31) function-interpolation-python 1.70656 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 9, 1, 56, 31) function-interpolation-python 0.99112 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 9, 1, 56, 55) la-vector-access-cpp 23.407 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 9, 1, 57, 22) la-vector-assignment-cpp 27.0531 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 10, 1, 27, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.4991 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 10, 1, 27, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4587 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 10, 1, 27, 56) geometry-bounding_box_tree_build-cpp 13.9781 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 10, 1, 28, 24) common-progress-cpp 27.6536 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 10, 1, 28, 53) common-timing-cpp 29.768 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 10, 1, 30, 41) fem-multicore-cpp 107.737 "Coloring mesh." (2013, 9, 10, 1, 33, 13) fem-assembly-cpp 152.4 "Assembly for various forms and backends" (2013, 9, 10, 1, 33, 26) fem-convergence-cpp 12.1337 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 10, 1, 33, 28) fem-jit-python 0.00102949 "JIT compilation (in memory cache)" (2013, 9, 10, 1, 38, 55) mesh-refinement-cpp 19.804 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 10, 1, 39, 14) mesh-topology-cpp 19.1878 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 10, 1, 39, 38) mesh-unitcube-cpp 23.8731 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 10, 1, 40, 16) mesh-iteration-cpp 35.9371 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 10, 1, 40, 37) function-evaluation-cpp 21.1614 "Evaluations of functions at arbitrary points." (2013, 9, 10, 1, 40, 37) function-evaluation-cpp 21.0859 "Evaluations of functions at arbitrary points." (2013, 9, 10, 1, 40, 41) function-extrapolation-python 3.52456 "BENCH: 1.06768894196" (2013, 9, 10, 1, 40, 41) function-extrapolation-python 1.06769 "BENCH: 1.06768894196" (2013, 9, 10, 1, 40, 43) function-interpolation-python 1.69319 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 10, 1, 40, 43) function-interpolation-python 0.972653 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 10, 1, 41, 6) la-vector-access-cpp 23.4405 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 10, 1, 41, 33) la-vector-assignment-cpp 27.0772 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 11, 1, 32, 16) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8305 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 11, 1, 32, 36) geometry-bounding_box_tree_compute_closest_entity-cpp 16.0055 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 11, 1, 32, 52) geometry-bounding_box_tree_build-cpp 13.9812 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 11, 1, 33, 20) common-progress-cpp 27.6532 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 11, 1, 33, 49) common-timing-cpp 28.5469 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 11, 1, 35, 36) fem-multicore-cpp 107.624 "Coloring mesh." (2013, 9, 11, 1, 38, 7) fem-assembly-cpp 150.794 "Assembly for various forms and backends" (2013, 9, 11, 1, 38, 19) fem-convergence-cpp 12.0821 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 11, 1, 38, 21) fem-jit-python 0.00106239 "JIT compilation (in memory cache)" (2013, 9, 11, 1, 43, 50) mesh-refinement-cpp 20.1488 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 11, 1, 44, 10) mesh-topology-cpp 19.4903 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 11, 1, 44, 34) mesh-unitcube-cpp 24.4336 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 11, 1, 45, 12) mesh-iteration-cpp 35.5755 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 11, 1, 45, 33) function-evaluation-cpp 21.1335 "Evaluations of functions at arbitrary points." (2013, 9, 11, 1, 45, 33) function-evaluation-cpp 21.0549 "Evaluations of functions at arbitrary points." (2013, 9, 11, 1, 45, 37) function-extrapolation-python 3.4873 "BENCH: 1.07768201828" (2013, 9, 11, 1, 45, 37) function-extrapolation-python 1.07768 "BENCH: 1.07768201828" (2013, 9, 11, 1, 45, 39) function-interpolation-python 1.73838 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 11, 1, 45, 39) function-interpolation-python 0.998629 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 11, 1, 46, 2) la-vector-access-cpp 23.4346 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 11, 1, 46, 29) la-vector-assignment-cpp 27.0901 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 12, 1, 33, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9082 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 12, 1, 34, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6911 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 12, 1, 34, 19) geometry-bounding_box_tree_build-cpp 14.0068 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 12, 1, 34, 47) common-progress-cpp 27.6528 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 12, 1, 35, 16) common-timing-cpp 28.6927 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 12, 1, 37, 3) fem-multicore-cpp 107.704 "Coloring mesh." (2013, 9, 12, 1, 39, 35) fem-assembly-cpp 151.063 "Assembly for various forms and backends" (2013, 9, 12, 1, 39, 47) fem-convergence-cpp 12.084 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 12, 1, 39, 48) fem-jit-python 0.0010443 "JIT compilation (in memory cache)" (2013, 9, 12, 1, 45, 15) mesh-refinement-cpp 20.0849 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 12, 1, 45, 35) mesh-topology-cpp 19.3911 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 12, 1, 45, 59) mesh-unitcube-cpp 24.3966 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 12, 1, 46, 41) mesh-iteration-cpp 39.1688 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 12, 1, 47, 2) function-evaluation-cpp 21.1757 "Evaluations of functions at arbitrary points." (2013, 9, 12, 1, 47, 2) function-evaluation-cpp 21.0767 "Evaluations of functions at arbitrary points." (2013, 9, 12, 1, 47, 5) function-extrapolation-python 3.57691 "BENCH: 1.1063439846" (2013, 9, 12, 1, 47, 5) function-extrapolation-python 1.10634 "BENCH: 1.1063439846" (2013, 9, 12, 1, 47, 7) function-interpolation-python 1.71146 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 12, 1, 47, 7) function-interpolation-python 1.00486 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 12, 1, 47, 36) la-vector-access-cpp 28.4178 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 12, 1, 48, 3) la-vector-assignment-cpp 27.087 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 13, 1, 31, 55) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9989 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 13, 1, 32, 14) geometry-bounding_box_tree_compute_closest_entity-cpp 16.0555 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 13, 1, 32, 31) geometry-bounding_box_tree_build-cpp 14.0016 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 13, 1, 32, 59) common-progress-cpp 27.663 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 13, 1, 33, 28) common-timing-cpp 29.4416 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 13, 1, 35, 15) fem-multicore-cpp 106.7 "Coloring mesh." (2013, 9, 13, 1, 37, 46) fem-assembly-cpp 150.908 "Assembly for various forms and backends" (2013, 9, 13, 1, 37, 58) fem-convergence-cpp 12.0873 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 13, 1, 38, 0) fem-jit-python 0.0010401 "JIT compilation (in memory cache)" (2013, 9, 13, 1, 43, 27) mesh-refinement-cpp 20.0904 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 13, 1, 43, 46) mesh-topology-cpp 19.3394 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 13, 1, 44, 11) mesh-unitcube-cpp 24.4129 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 13, 1, 44, 49) mesh-iteration-cpp 35.4855 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 13, 1, 45, 10) function-evaluation-cpp 21.1258 "Evaluations of functions at arbitrary points." (2013, 9, 13, 1, 45, 10) function-evaluation-cpp 21.038 "Evaluations of functions at arbitrary points." (2013, 9, 13, 1, 45, 13) function-extrapolation-python 3.51222 "BENCH: 1.07154798508" (2013, 9, 13, 1, 45, 13) function-extrapolation-python 1.07155 "BENCH: 1.07154798508" (2013, 9, 13, 1, 45, 15) function-interpolation-python 1.72971 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 13, 1, 45, 15) function-interpolation-python 1.0023 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 13, 1, 45, 40) la-vector-access-cpp 24.9403 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 13, 1, 46, 8) la-vector-assignment-cpp 27.3666 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 14, 1, 30, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8375 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 14, 1, 31, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7463 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 14, 1, 31, 23) geometry-bounding_box_tree_build-cpp 13.9461 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 14, 1, 31, 51) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 14, 1, 32, 20) common-timing-cpp 28.7382 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 14, 1, 34, 7) fem-multicore-cpp 107.21 "Coloring mesh." (2013, 9, 14, 1, 36, 38) fem-assembly-cpp 151.091 "Assembly for various forms and backends" (2013, 9, 14, 1, 36, 50) fem-convergence-cpp 12.0862 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 14, 1, 37, 9) fem-jit-python 0.00106699 "JIT compilation (in memory cache)" (2013, 9, 14, 1, 42, 36) mesh-refinement-cpp 20.0807 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 14, 1, 42, 56) mesh-topology-cpp 19.3361 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 14, 1, 43, 20) mesh-unitcube-cpp 24.4357 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 14, 1, 43, 58) mesh-iteration-cpp 35.4249 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 14, 1, 44, 19) function-evaluation-cpp 21.2198 "Evaluations of functions at arbitrary points." (2013, 9, 14, 1, 44, 19) function-evaluation-cpp 21.1381 "Evaluations of functions at arbitrary points." (2013, 9, 14, 1, 45, 24) function-extrapolation-python 64.3285 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 9, 14, 1, 45, 24) function-extrapolation-python 1.08295 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 9, 14, 1, 45, 31) function-interpolation-python 7.60645 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2013, 9, 14, 1, 45, 31) function-interpolation-python 0.995712 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2013, 9, 14, 1, 45, 55) la-vector-access-cpp 23.4345 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 14, 1, 46, 22) la-vector-assignment-cpp 27.0854 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 15, 1, 31, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8126 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 15, 1, 31, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7425 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 15, 1, 31, 55) geometry-bounding_box_tree_build-cpp 14.0139 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 15, 1, 32, 23) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 15, 1, 32, 52) common-timing-cpp 29.4479 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 15, 1, 34, 39) fem-multicore-cpp 106.679 "Coloring mesh." (2013, 9, 15, 1, 37, 10) fem-assembly-cpp 151.156 "Assembly for various forms and backends" (2013, 9, 15, 1, 37, 22) fem-convergence-cpp 12.0846 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 15, 1, 37, 24) fem-jit-python 0.000998187 "JIT compilation (in memory cache)" (2013, 9, 15, 1, 42, 54) mesh-refinement-cpp 20.0672 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 15, 1, 43, 14) mesh-topology-cpp 19.3549 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 15, 1, 43, 38) mesh-unitcube-cpp 24.3444 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 15, 1, 44, 16) mesh-iteration-cpp 35.4816 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 15, 1, 44, 37) function-evaluation-cpp 21.1492 "Evaluations of functions at arbitrary points." (2013, 9, 15, 1, 44, 37) function-evaluation-cpp 21.0238 "Evaluations of functions at arbitrary points." (2013, 9, 15, 1, 44, 41) function-extrapolation-python 3.46043 "BENCH: 1.10047793388" (2013, 9, 15, 1, 44, 41) function-extrapolation-python 1.10048 "BENCH: 1.10047793388" (2013, 9, 15, 1, 44, 43) function-interpolation-python 1.66484 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 15, 1, 44, 43) function-interpolation-python 0.991965 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 15, 1, 45, 6) la-vector-access-cpp 23.4761 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 15, 1, 45, 33) la-vector-assignment-cpp 27.0938 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 16, 1, 32, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8358 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 16, 1, 32, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7564 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 16, 1, 32, 56) geometry-bounding_box_tree_build-cpp 14.0046 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 16, 1, 33, 23) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 16, 1, 33, 52) common-timing-cpp 28.8452 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 16, 1, 35, 40) fem-multicore-cpp 107.695 "Coloring mesh." (2013, 9, 16, 1, 38, 10) fem-assembly-cpp 150.593 "Assembly for various forms and backends" (2013, 9, 16, 1, 38, 23) fem-convergence-cpp 12.0833 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 16, 1, 38, 24) fem-jit-python 0.0010113 "JIT compilation (in memory cache)" (2013, 9, 16, 1, 43, 51) mesh-refinement-cpp 20.0519 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 16, 1, 44, 11) mesh-topology-cpp 19.3845 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 16, 1, 44, 35) mesh-unitcube-cpp 24.3572 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 16, 1, 45, 13) mesh-iteration-cpp 35.4788 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 16, 1, 45, 35) function-evaluation-cpp 21.9118 "Evaluations of functions at arbitrary points." (2013, 9, 16, 1, 45, 35) function-evaluation-cpp 21.8173 "Evaluations of functions at arbitrary points." (2013, 9, 16, 1, 45, 39) function-extrapolation-python 3.51208 "BENCH: 1.07490205765" (2013, 9, 16, 1, 45, 39) function-extrapolation-python 1.0749 "BENCH: 1.07490205765" (2013, 9, 16, 1, 45, 41) function-interpolation-python 1.69376 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 16, 1, 45, 41) function-interpolation-python 0.99663 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 16, 1, 46, 4) la-vector-access-cpp 23.5684 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 16, 1, 46, 31) la-vector-assignment-cpp 27.0687 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 17, 1, 33, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8691 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 17, 1, 33, 31) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8719 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 17, 1, 33, 47) geometry-bounding_box_tree_build-cpp 13.9539 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 17, 1, 34, 15) common-progress-cpp 27.6534 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 17, 1, 34, 45) common-timing-cpp 29.9478 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 17, 1, 36, 32) fem-multicore-cpp 107.503 "Coloring mesh." (2013, 9, 17, 1, 39, 3) fem-assembly-cpp 150.59 "Assembly for various forms and backends" (2013, 9, 17, 1, 39, 15) fem-convergence-cpp 12.1392 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 17, 1, 39, 17) fem-jit-python 0.001001 "JIT compilation (in memory cache)" (2013, 9, 17, 1, 44, 43) mesh-refinement-cpp 20.0807 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 17, 1, 45, 2) mesh-topology-cpp 19.3754 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 17, 1, 45, 27) mesh-unitcube-cpp 24.421 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 17, 1, 46, 5) mesh-iteration-cpp 35.4924 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 17, 1, 46, 26) function-evaluation-cpp 21.1404 "Evaluations of functions at arbitrary points." (2013, 9, 17, 1, 46, 26) function-evaluation-cpp 21.0562 "Evaluations of functions at arbitrary points." (2013, 9, 17, 1, 46, 30) function-extrapolation-python 3.54555 "BENCH: 1.07709693909" (2013, 9, 17, 1, 46, 30) function-extrapolation-python 1.0771 "BENCH: 1.07709693909" (2013, 9, 17, 1, 46, 31) function-interpolation-python 1.69311 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 17, 1, 46, 31) function-interpolation-python 0.999534 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 17, 1, 46, 55) la-vector-access-cpp 23.4384 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 17, 1, 47, 23) la-vector-assignment-cpp 28.1092 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 18, 1, 37, 24) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2919 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 18, 1, 37, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8306 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 18, 1, 38, 0) geometry-bounding_box_tree_build-cpp 13.9817 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 18, 1, 38, 28) common-progress-cpp 27.6542 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 18, 1, 38, 57) common-timing-cpp 29.5945 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 18, 1, 42, 22) fem-multicore-cpp 204.88 "Coloring mesh." (2013, 9, 18, 1, 44, 54) fem-assembly-cpp 152.387 "Assembly for various forms and backends" (2013, 9, 18, 1, 45, 9) fem-convergence-cpp 14.2262 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 18, 1, 45, 10) fem-jit-python 0.00105371 "JIT compilation (in memory cache)" (2013, 9, 18, 1, 53, 15) mesh-refinement-cpp 20.0068 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 18, 1, 53, 35) mesh-topology-cpp 19.5757 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 18, 1, 53, 59) mesh-unitcube-cpp 24.083 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 18, 1, 54, 40) mesh-iteration-cpp 39.1739 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 18, 1, 55, 2) function-evaluation-cpp 21.0941 "Evaluations of functions at arbitrary points." (2013, 9, 18, 1, 55, 2) function-evaluation-cpp 20.9717 "Evaluations of functions at arbitrary points." (2013, 9, 18, 1, 55, 5) function-extrapolation-python 3.60408 "BENCH: 1.05839109421" (2013, 9, 18, 1, 55, 5) function-extrapolation-python 1.05839 "BENCH: 1.05839109421" (2013, 9, 18, 1, 55, 7) function-interpolation-python 1.62787 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 18, 1, 55, 7) function-interpolation-python 0.964344 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 18, 1, 55, 32) la-vector-access-cpp 25.4647 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 18, 1, 55, 59) la-vector-assignment-cpp 27.0758 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 19, 1, 24, 27) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1688 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 19, 1, 24, 46) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5593 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 19, 1, 25, 3) geometry-bounding_box_tree_build-cpp 13.9742 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 19, 1, 25, 30) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 19, 1, 26, 1) common-timing-cpp 30.1424 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 19, 1, 29, 26) fem-multicore-cpp 205.269 "Coloring mesh." (2013, 9, 19, 1, 31, 58) fem-assembly-cpp 152 "Assembly for various forms and backends" (2013, 9, 19, 1, 32, 12) fem-convergence-cpp 14.1866 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 19, 1, 32, 14) fem-jit-python 0.00103731 "JIT compilation (in memory cache)" (2013, 9, 19, 1, 40, 15) mesh-refinement-cpp 20.0784 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 19, 1, 40, 35) mesh-topology-cpp 19.5747 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 19, 1, 41, 0) mesh-unitcube-cpp 24.6586 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 19, 1, 41, 46) mesh-iteration-cpp 44.1798 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 19, 1, 42, 7) function-evaluation-cpp 21.0493 "Evaluations of functions at arbitrary points." (2013, 9, 19, 1, 42, 7) function-evaluation-cpp 20.9664 "Evaluations of functions at arbitrary points." (2013, 9, 19, 1, 42, 11) function-extrapolation-python 3.54431 "BENCH: 1.06100296974" (2013, 9, 19, 1, 42, 11) function-extrapolation-python 1.061 "BENCH: 1.06100296974" (2013, 9, 19, 1, 42, 13) function-interpolation-python 1.65769 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 19, 1, 42, 13) function-interpolation-python 0.965463 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 19, 1, 42, 38) la-vector-access-cpp 25.4484 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 19, 1, 43, 6) la-vector-assignment-cpp 28.1904 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 20, 1, 29, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1764 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 20, 1, 30, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4981 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 20, 1, 30, 33) geometry-bounding_box_tree_build-cpp 13.9017 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 20, 1, 31, 1) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 20, 1, 31, 32) common-timing-cpp 31.0592 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 20, 1, 34, 57) fem-multicore-cpp 205.494 "Coloring mesh." (2013, 9, 20, 1, 37, 29) fem-assembly-cpp 151.32 "Assembly for various forms and backends" (2013, 9, 20, 1, 37, 43) fem-convergence-cpp 14.1858 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 20, 1, 37, 45) fem-jit-python 0.001034 "JIT compilation (in memory cache)" (2013, 9, 20, 1, 45, 48) mesh-refinement-cpp 19.9887 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 20, 1, 46, 8) mesh-topology-cpp 19.6018 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 20, 1, 46, 32) mesh-unitcube-cpp 24.1416 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 20, 1, 47, 10) mesh-iteration-cpp 35.4887 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 20, 1, 47, 31) function-evaluation-cpp 21.1095 "Evaluations of functions at arbitrary points." (2013, 9, 20, 1, 47, 31) function-evaluation-cpp 21.0156 "Evaluations of functions at arbitrary points." (2013, 9, 20, 1, 47, 35) function-extrapolation-python 3.44591 "BENCH: 1.0674598217" (2013, 9, 20, 1, 47, 35) function-extrapolation-python 1.06746 "BENCH: 1.0674598217" (2013, 9, 20, 1, 47, 37) function-interpolation-python 1.63662 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 20, 1, 47, 37) function-interpolation-python 0.971224 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 20, 1, 48, 5) la-vector-access-cpp 28.4881 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 20, 1, 48, 32) la-vector-assignment-cpp 27.2363 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 21, 1, 27, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3061 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 21, 1, 27, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7407 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 21, 1, 28, 9) geometry-bounding_box_tree_build-cpp 13.9143 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 21, 1, 28, 42) common-progress-cpp 32.6686 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 21, 1, 29, 13) common-timing-cpp 30.6477 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 21, 1, 32, 39) fem-multicore-cpp 206.137 "Coloring mesh." (2013, 9, 21, 1, 35, 10) fem-assembly-cpp 151.23 "Assembly for various forms and backends" (2013, 9, 21, 1, 35, 24) fem-convergence-cpp 14.1815 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 21, 1, 35, 26) fem-jit-python 0.001017 "JIT compilation (in memory cache)" (2013, 9, 21, 1, 43, 29) mesh-refinement-cpp 20.0585 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 21, 1, 43, 48) mesh-topology-cpp 19.5444 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 21, 1, 44, 13) mesh-unitcube-cpp 24.2112 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 21, 1, 44, 51) mesh-iteration-cpp 35.4221 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 21, 1, 45, 12) function-evaluation-cpp 21.3082 "Evaluations of functions at arbitrary points." (2013, 9, 21, 1, 45, 12) function-evaluation-cpp 21.2201 "Evaluations of functions at arbitrary points." (2013, 9, 21, 1, 45, 15) function-extrapolation-python 3.43787 "BENCH: 1.0566368103" (2013, 9, 21, 1, 45, 15) function-extrapolation-python 1.05664 "BENCH: 1.0566368103" (2013, 9, 21, 1, 45, 17) function-interpolation-python 1.66554 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 21, 1, 45, 17) function-interpolation-python 0.969048 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 21, 1, 45, 46) la-vector-access-cpp 28.4473 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 21, 1, 46, 13) la-vector-assignment-cpp 27.0334 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 22, 1, 29, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2515 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 22, 1, 29, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5416 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 22, 1, 30, 13) geometry-bounding_box_tree_build-cpp 13.9462 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 22, 1, 30, 41) common-progress-cpp 27.6533 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 22, 1, 31, 12) common-timing-cpp 30.6471 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 22, 1, 34, 37) fem-multicore-cpp 205.059 "Coloring mesh." (2013, 9, 22, 1, 37, 8) fem-assembly-cpp 151.561 "Assembly for various forms and backends" (2013, 9, 22, 1, 37, 23) fem-convergence-cpp 14.2059 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 22, 1, 37, 24) fem-jit-python 0.00102489 "JIT compilation (in memory cache)" (2013, 9, 22, 1, 45, 25) mesh-refinement-cpp 20.0177 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 22, 1, 45, 44) mesh-topology-cpp 19.6154 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 22, 1, 46, 9) mesh-unitcube-cpp 24.2461 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 22, 1, 46, 47) mesh-iteration-cpp 35.5352 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 22, 1, 47, 8) function-evaluation-cpp 21.1677 "Evaluations of functions at arbitrary points." (2013, 9, 22, 1, 47, 8) function-evaluation-cpp 21.0685 "Evaluations of functions at arbitrary points." (2013, 9, 22, 1, 47, 11) function-extrapolation-python 3.47708 "BENCH: 1.06166815758" (2013, 9, 22, 1, 47, 11) function-extrapolation-python 1.06167 "BENCH: 1.06166815758" (2013, 9, 22, 1, 47, 13) function-interpolation-python 1.65907 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 22, 1, 47, 13) function-interpolation-python 0.970722 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 22, 1, 47, 38) la-vector-access-cpp 25.4446 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 22, 1, 48, 6) la-vector-assignment-cpp 27.0689 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 23, 1, 29, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1791 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 23, 1, 29, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6485 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 23, 1, 30, 13) geometry-bounding_box_tree_build-cpp 13.9134 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 23, 1, 30, 40) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 23, 1, 31, 11) common-timing-cpp 30.9794 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 23, 1, 34, 37) fem-multicore-cpp 205.36 "Coloring mesh." (2013, 9, 23, 1, 37, 8) fem-assembly-cpp 151.486 "Assembly for various forms and backends" (2013, 9, 23, 1, 37, 22) fem-convergence-cpp 14.194 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 23, 1, 37, 24) fem-jit-python 0.00102909 "JIT compilation (in memory cache)" (2013, 9, 23, 1, 45, 24) mesh-refinement-cpp 19.9843 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 23, 1, 45, 43) mesh-topology-cpp 19.6142 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 23, 1, 46, 8) mesh-unitcube-cpp 24.2098 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 23, 1, 46, 46) mesh-iteration-cpp 35.4938 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 23, 1, 47, 7) function-evaluation-cpp 21.1121 "Evaluations of functions at arbitrary points." (2013, 9, 23, 1, 47, 7) function-evaluation-cpp 21 "Evaluations of functions at arbitrary points." (2013, 9, 23, 1, 47, 10) function-extrapolation-python 3.52908 "BENCH: 1.06049919128" (2013, 9, 23, 1, 47, 10) function-extrapolation-python 1.0605 "BENCH: 1.06049919128" (2013, 9, 23, 1, 47, 12) function-interpolation-python 1.67787 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 23, 1, 47, 12) function-interpolation-python 0.969448 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 23, 1, 47, 37) la-vector-access-cpp 25.4436 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 23, 1, 48, 5) la-vector-assignment-cpp 27.0878 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 24, 1, 34, 17) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3622 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 24, 1, 34, 36) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6279 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 24, 1, 34, 53) geometry-bounding_box_tree_build-cpp 13.8999 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 24, 1, 35, 20) common-progress-cpp 27.6537 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 24, 1, 35, 51) common-timing-cpp 30.2772 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 24, 1, 39, 16) fem-multicore-cpp 205.146 "Coloring mesh." (2013, 9, 24, 1, 41, 47) fem-assembly-cpp 151.152 "Assembly for various forms and backends" (2013, 9, 24, 1, 42, 1) fem-convergence-cpp 14.1983 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 24, 1, 42, 3) fem-jit-python 0.00104001 "JIT compilation (in memory cache)" (2013, 9, 24, 1, 50, 7) mesh-refinement-cpp 20.0585 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 24, 1, 50, 27) mesh-topology-cpp 19.5446 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 24, 1, 50, 51) mesh-unitcube-cpp 24.1553 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 24, 1, 51, 29) mesh-iteration-cpp 35.4917 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 24, 1, 51, 50) function-evaluation-cpp 21.1105 "Evaluations of functions at arbitrary points." (2013, 9, 24, 1, 51, 50) function-evaluation-cpp 21.0285 "Evaluations of functions at arbitrary points." (2013, 9, 24, 1, 51, 54) function-extrapolation-python 3.55087 "BENCH: 1.06886100769" (2013, 9, 24, 1, 51, 54) function-extrapolation-python 1.06886 "BENCH: 1.06886100769" (2013, 9, 24, 1, 51, 55) function-interpolation-python 1.67705 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 24, 1, 51, 55) function-interpolation-python 0.972507 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 24, 1, 52, 24) la-vector-access-cpp 28.4463 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 24, 1, 52, 51) la-vector-assignment-cpp 27.0973 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 25, 1, 25, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2169 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 25, 1, 26, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7394 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 25, 1, 26, 19) geometry-bounding_box_tree_build-cpp 13.9305 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 25, 1, 26, 47) common-progress-cpp 27.6555 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 25, 1, 27, 17) common-timing-cpp 30.508 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 25, 1, 30, 43) fem-multicore-cpp 205.676 "Coloring mesh." (2013, 9, 25, 1, 33, 16) fem-assembly-cpp 153.005 "Assembly for various forms and backends" (2013, 9, 25, 1, 33, 30) fem-convergence-cpp 14.2226 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 25, 1, 33, 32) fem-jit-python 0.00101972 "JIT compilation (in memory cache)" (2013, 9, 25, 1, 41, 31) mesh-refinement-cpp 19.9764 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 25, 1, 41, 50) mesh-topology-cpp 19.4984 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 25, 1, 42, 14) mesh-unitcube-cpp 24.0983 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 25, 1, 42, 52) mesh-iteration-cpp 35.4973 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 25, 1, 43, 13) function-evaluation-cpp 21.1453 "Evaluations of functions at arbitrary points." (2013, 9, 25, 1, 43, 13) function-evaluation-cpp 21.0586 "Evaluations of functions at arbitrary points." (2013, 9, 25, 1, 43, 17) function-extrapolation-python 3.54581 "BENCH: 1.08921313286" (2013, 9, 25, 1, 43, 17) function-extrapolation-python 1.08921 "BENCH: 1.08921313286" (2013, 9, 25, 1, 43, 19) function-interpolation-python 1.65365 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 25, 1, 43, 19) function-interpolation-python 0.953854 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 25, 1, 43, 44) la-vector-access-cpp 25.4442 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 25, 1, 44, 11) la-vector-assignment-cpp 27.0409 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 26, 1, 23, 17) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2784 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 26, 1, 23, 36) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5226 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 26, 1, 23, 52) geometry-bounding_box_tree_build-cpp 13.9074 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 26, 1, 24, 20) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 26, 1, 24, 50) common-timing-cpp 29.8304 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 26, 1, 28, 15) fem-multicore-cpp 205.524 "Coloring mesh." (2013, 9, 26, 1, 30, 48) fem-assembly-cpp 152.683 "Assembly for various forms and backends" (2013, 9, 26, 1, 31, 2) fem-convergence-cpp 14.2046 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 26, 1, 31, 4) fem-jit-python 0.00102 "JIT compilation (in memory cache)" (2013, 9, 26, 1, 39, 3) mesh-refinement-cpp 19.9666 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 26, 1, 39, 22) mesh-topology-cpp 19.4873 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 26, 1, 39, 46) mesh-unitcube-cpp 24.0988 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 26, 1, 40, 28) mesh-iteration-cpp 39.1696 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 26, 1, 40, 49) function-evaluation-cpp 21.1318 "Evaluations of functions at arbitrary points." (2013, 9, 26, 1, 40, 49) function-evaluation-cpp 21.0351 "Evaluations of functions at arbitrary points." (2013, 9, 26, 1, 40, 53) function-extrapolation-python 3.70398 "BENCH: 1.08206582069" (2013, 9, 26, 1, 40, 53) function-extrapolation-python 1.08207 "BENCH: 1.08206582069" (2013, 9, 26, 1, 40, 55) function-interpolation-python 1.63508 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 26, 1, 40, 55) function-interpolation-python 0.966312 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 26, 1, 41, 20) la-vector-access-cpp 25.4728 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 26, 1, 41, 47) la-vector-assignment-cpp 27.0971 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 27, 1, 23, 2) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2051 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 27, 1, 23, 21) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7808 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 27, 1, 23, 38) geometry-bounding_box_tree_build-cpp 13.9336 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 27, 1, 24, 5) common-progress-cpp 27.6632 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 27, 1, 24, 35) common-timing-cpp 29.9394 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 27, 1, 28, 1) fem-multicore-cpp 205.8 "Coloring mesh." (2013, 9, 27, 1, 30, 34) fem-assembly-cpp 153.245 "Assembly for various forms and backends" (2013, 9, 27, 1, 30, 49) fem-convergence-cpp 14.2043 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 27, 1, 30, 50) fem-jit-python 0.0010273 "JIT compilation (in memory cache)" (2013, 9, 27, 1, 38, 53) mesh-refinement-cpp 19.9559 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 27, 1, 39, 13) mesh-topology-cpp 19.4859 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 27, 1, 39, 37) mesh-unitcube-cpp 24.1277 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 27, 1, 40, 15) mesh-iteration-cpp 35.4216 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 27, 1, 40, 36) function-evaluation-cpp 21.1238 "Evaluations of functions at arbitrary points." (2013, 9, 27, 1, 40, 36) function-evaluation-cpp 21.0154 "Evaluations of functions at arbitrary points." (2013, 9, 27, 1, 40, 40) function-extrapolation-python 3.47082 "BENCH: 1.06766915321" (2013, 9, 27, 1, 40, 40) function-extrapolation-python 1.06767 "BENCH: 1.06766915321" (2013, 9, 27, 1, 40, 41) function-interpolation-python 1.65261 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 27, 1, 40, 41) function-interpolation-python 0.966008 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 27, 1, 41, 7) la-vector-access-cpp 25.4445 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 27, 1, 41, 34) la-vector-assignment-cpp 27.0964 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 28, 1, 34, 5) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2037 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 28, 1, 34, 24) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6541 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 28, 1, 34, 41) geometry-bounding_box_tree_build-cpp 13.9105 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 28, 1, 35, 9) common-progress-cpp 27.6983 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 28, 1, 35, 38) common-timing-cpp 29.6619 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 28, 1, 39, 4) fem-multicore-cpp 205.708 "Coloring mesh." (2013, 9, 28, 1, 41, 37) fem-assembly-cpp 153.46 "Assembly for various forms and backends" (2013, 9, 28, 1, 41, 52) fem-convergence-cpp 14.1977 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 28, 1, 41, 54) fem-jit-python 0.0010283 "JIT compilation (in memory cache)" (2013, 9, 28, 1, 49, 55) mesh-refinement-cpp 19.9882 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 28, 1, 50, 14) mesh-topology-cpp 19.4742 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 28, 1, 50, 38) mesh-unitcube-cpp 24.1688 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 28, 1, 51, 25) mesh-iteration-cpp 44.1761 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 28, 1, 51, 46) function-evaluation-cpp 21.0949 "Evaluations of functions at arbitrary points." (2013, 9, 28, 1, 51, 46) function-evaluation-cpp 21.0094 "Evaluations of functions at arbitrary points." (2013, 9, 28, 1, 51, 50) function-extrapolation-python 3.57366 "BENCH: 1.08244895935" (2013, 9, 28, 1, 51, 50) function-extrapolation-python 1.08245 "BENCH: 1.08244895935" (2013, 9, 28, 1, 51, 52) function-interpolation-python 1.65361 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 28, 1, 51, 52) function-interpolation-python 0.964955 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 28, 1, 52, 17) la-vector-access-cpp 25.442 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 28, 1, 52, 44) la-vector-assignment-cpp 26.9872 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 29, 1, 30, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2405 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 29, 1, 30, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6477 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 29, 1, 30, 44) geometry-bounding_box_tree_build-cpp 13.9739 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 29, 1, 31, 11) common-progress-cpp 27.6535 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 29, 1, 31, 42) common-timing-cpp 30.2627 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 29, 1, 35, 8) fem-multicore-cpp 206.069 "Coloring mesh." (2013, 9, 29, 1, 37, 41) fem-assembly-cpp 153.107 "Assembly for various forms and backends" (2013, 9, 29, 1, 37, 55) fem-convergence-cpp 14.2171 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 29, 1, 37, 57) fem-jit-python 0.0010253 "JIT compilation (in memory cache)" (2013, 9, 29, 1, 45, 56) mesh-refinement-cpp 19.9574 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 29, 1, 46, 16) mesh-topology-cpp 19.5648 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 29, 1, 46, 40) mesh-unitcube-cpp 24.093 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 29, 1, 47, 18) mesh-iteration-cpp 35.4802 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 29, 1, 47, 39) function-evaluation-cpp 21.1159 "Evaluations of functions at arbitrary points." (2013, 9, 29, 1, 47, 39) function-evaluation-cpp 21.0217 "Evaluations of functions at arbitrary points." (2013, 9, 29, 1, 47, 43) function-extrapolation-python 3.66224 "BENCH: 1.06667804718" (2013, 9, 29, 1, 47, 43) function-extrapolation-python 1.06668 "BENCH: 1.06667804718" (2013, 9, 29, 1, 47, 45) function-interpolation-python 1.66283 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 29, 1, 47, 45) function-interpolation-python 0.964002 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 29, 1, 48, 10) la-vector-access-cpp 25.472 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 29, 1, 48, 37) la-vector-assignment-cpp 27.1015 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 9, 30, 1, 27, 28) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2359 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 30, 1, 27, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.551 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 9, 30, 1, 28, 4) geometry-bounding_box_tree_build-cpp 13.9624 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 9, 30, 1, 28, 31) common-progress-cpp 27.6526 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 9, 30, 1, 29, 2) common-timing-cpp 30.5294 "Timing access and registration of timings (10000000 repetitions)" (2013, 9, 30, 1, 32, 28) fem-multicore-cpp 205.816 "Coloring mesh." (2013, 9, 30, 1, 35, 1) fem-assembly-cpp 152.988 "Assembly for various forms and backends" (2013, 9, 30, 1, 35, 15) fem-convergence-cpp 14.2009 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 9, 30, 1, 35, 17) fem-jit-python 0.0010253 "JIT compilation (in memory cache)" (2013, 9, 30, 1, 43, 19) mesh-refinement-cpp 19.9378 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 9, 30, 1, 43, 38) mesh-topology-cpp 19.4735 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 9, 30, 1, 44, 3) mesh-unitcube-cpp 24.1112 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 9, 30, 1, 44, 49) mesh-iteration-cpp 44.1903 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 9, 30, 1, 45, 10) function-evaluation-cpp 21.1726 "Evaluations of functions at arbitrary points." (2013, 9, 30, 1, 45, 10) function-evaluation-cpp 21.0739 "Evaluations of functions at arbitrary points." (2013, 9, 30, 1, 45, 14) function-extrapolation-python 3.52768 "BENCH: 1.04921603203" (2013, 9, 30, 1, 45, 14) function-extrapolation-python 1.04922 "BENCH: 1.04921603203" (2013, 9, 30, 1, 45, 16) function-interpolation-python 1.65985 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 30, 1, 45, 16) function-interpolation-python 0.963018 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 9, 30, 1, 45, 44) la-vector-access-cpp 28.4764 "Accessing vector of size 10000000 (100 repetitions)" (2013, 9, 30, 1, 46, 11) la-vector-assignment-cpp 27.1333 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 1, 1, 36, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2179 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 1, 1, 37, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.738 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 1, 1, 37, 19) geometry-bounding_box_tree_build-cpp 13.953 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 1, 1, 37, 47) common-progress-cpp 27.6538 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 1, 1, 38, 17) common-timing-cpp 30.0495 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 1, 1, 41, 42) fem-multicore-cpp 205.832 "Coloring mesh." (2013, 10, 1, 1, 44, 16) fem-assembly-cpp 153.427 "Assembly for various forms and backends" (2013, 10, 1, 1, 44, 30) fem-convergence-cpp 14.2077 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 1, 1, 44, 32) fem-jit-python 0.00101299 "JIT compilation (in memory cache)" (2013, 10, 1, 1, 52, 30) mesh-refinement-cpp 19.9788 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 1, 1, 52, 50) mesh-topology-cpp 19.5295 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 1, 1, 53, 14) mesh-unitcube-cpp 24.0903 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 1, 1, 53, 52) mesh-iteration-cpp 35.4861 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 1, 1, 54, 13) function-evaluation-cpp 21.1186 "Evaluations of functions at arbitrary points." (2013, 10, 1, 1, 54, 13) function-evaluation-cpp 21.0132 "Evaluations of functions at arbitrary points." (2013, 10, 1, 1, 54, 16) function-extrapolation-python 3.67901 "BENCH: 1.07571601868" (2013, 10, 1, 1, 54, 16) function-extrapolation-python 1.07572 "BENCH: 1.07571601868" (2013, 10, 1, 1, 54, 18) function-interpolation-python 1.64451 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 1, 1, 54, 18) function-interpolation-python 0.956019 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 1, 1, 54, 47) la-vector-access-cpp 28.4633 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 1, 1, 55, 14) la-vector-assignment-cpp 27.0963 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 2, 1, 34, 12) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1837 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 2, 1, 34, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8518 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 2, 1, 34, 48) geometry-bounding_box_tree_build-cpp 13.9266 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 2, 1, 35, 16) common-progress-cpp 27.7078 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 2, 1, 35, 46) common-timing-cpp 29.9973 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 2, 1, 39, 12) fem-multicore-cpp 206.46 "Coloring mesh." (2013, 10, 2, 1, 41, 45) fem-assembly-cpp 152.871 "Assembly for various forms and backends" (2013, 10, 2, 1, 42, 0) fem-convergence-cpp 14.216 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 2, 1, 42, 1) fem-jit-python 0.00103109 "JIT compilation (in memory cache)" (2013, 10, 2, 1, 50, 4) mesh-refinement-cpp 19.9922 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 2, 1, 50, 23) mesh-topology-cpp 19.4925 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 2, 1, 50, 47) mesh-unitcube-cpp 24.1124 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 2, 1, 51, 29) mesh-iteration-cpp 39.1661 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 2, 1, 51, 50) function-evaluation-cpp 21.0991 "Evaluations of functions at arbitrary points." (2013, 10, 2, 1, 51, 50) function-evaluation-cpp 21.0148 "Evaluations of functions at arbitrary points." (2013, 10, 2, 1, 51, 54) function-extrapolation-python 3.55264 "BENCH: 1.10233402252" (2013, 10, 2, 1, 51, 54) function-extrapolation-python 1.10233 "BENCH: 1.10233402252" (2013, 10, 2, 1, 51, 56) function-interpolation-python 1.65173 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 2, 1, 51, 56) function-interpolation-python 0.968611 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 2, 1, 52, 24) la-vector-access-cpp 28.4477 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 2, 1, 52, 51) la-vector-assignment-cpp 27.0896 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 3, 1, 24, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1769 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 3, 1, 24, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6067 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 3, 1, 24, 58) geometry-bounding_box_tree_build-cpp 13.9311 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 3, 1, 25, 26) common-progress-cpp 27.6529 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 3, 1, 25, 55) common-timing-cpp 29.261 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 3, 1, 29, 21) fem-multicore-cpp 205.745 "Coloring mesh." (2013, 10, 3, 1, 31, 54) fem-assembly-cpp 152.919 "Assembly for various forms and backends" (2013, 10, 3, 1, 32, 8) fem-convergence-cpp 14.2125 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 3, 1, 32, 10) fem-jit-python 0.0010536 "JIT compilation (in memory cache)" (2013, 10, 3, 1, 40, 11) mesh-refinement-cpp 19.9858 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 3, 1, 40, 30) mesh-topology-cpp 19.5508 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 3, 1, 40, 54) mesh-unitcube-cpp 24.1076 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 3, 1, 41, 32) mesh-iteration-cpp 35.492 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 3, 1, 41, 54) function-evaluation-cpp 21.08 "Evaluations of functions at arbitrary points." (2013, 10, 3, 1, 41, 54) function-evaluation-cpp 20.996 "Evaluations of functions at arbitrary points." (2013, 10, 3, 1, 41, 57) function-extrapolation-python 3.61241 "BENCH: 1.07668590546" (2013, 10, 3, 1, 41, 57) function-extrapolation-python 1.07669 "BENCH: 1.07668590546" (2013, 10, 3, 1, 41, 59) function-interpolation-python 1.68845 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 3, 1, 41, 59) function-interpolation-python 0.959476 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 3, 1, 42, 24) la-vector-access-cpp 25.4449 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 3, 1, 42, 51) la-vector-assignment-cpp 27.0841 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 4, 1, 31, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2423 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 4, 1, 31, 30) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5403 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 4, 1, 31, 47) geometry-bounding_box_tree_build-cpp 13.9001 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 4, 1, 32, 15) common-progress-cpp 27.6538 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 4, 1, 32, 45) common-timing-cpp 30.4291 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 4, 1, 36, 11) fem-multicore-cpp 205.84 "Coloring mesh." (2013, 10, 4, 1, 38, 44) fem-assembly-cpp 153.415 "Assembly for various forms and backends" (2013, 10, 4, 1, 38, 58) fem-convergence-cpp 14.2057 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 4, 1, 39, 0) fem-jit-python 0.00105212 "JIT compilation (in memory cache)" (2013, 10, 4, 1, 47, 0) mesh-refinement-cpp 20.004 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 4, 1, 47, 20) mesh-topology-cpp 19.5044 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 4, 1, 47, 44) mesh-unitcube-cpp 24.1192 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 4, 1, 48, 22) mesh-iteration-cpp 35.4482 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 4, 1, 48, 43) function-evaluation-cpp 21.0934 "Evaluations of functions at arbitrary points." (2013, 10, 4, 1, 48, 43) function-evaluation-cpp 21.0024 "Evaluations of functions at arbitrary points." (2013, 10, 4, 1, 48, 46) function-extrapolation-python 3.55419 "BENCH: 1.08774518967" (2013, 10, 4, 1, 48, 46) function-extrapolation-python 1.08775 "BENCH: 1.08774518967" (2013, 10, 4, 1, 48, 48) function-interpolation-python 1.67038 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 4, 1, 48, 48) function-interpolation-python 0.964839 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 4, 1, 49, 14) la-vector-access-cpp 25.4455 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 4, 1, 49, 41) la-vector-assignment-cpp 27.0838 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 5, 1, 34, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.172 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 5, 1, 34, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5067 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 5, 1, 34, 56) geometry-bounding_box_tree_build-cpp 14.0038 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 5, 1, 35, 24) common-progress-cpp 27.6545 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 5, 1, 35, 54) common-timing-cpp 30.3125 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 5, 1, 39, 20) fem-multicore-cpp 205.686 "Coloring mesh." (2013, 10, 5, 1, 41, 53) fem-assembly-cpp 153.291 "Assembly for various forms and backends" (2013, 10, 5, 1, 42, 7) fem-convergence-cpp 14.2004 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 5, 1, 42, 9) fem-jit-python 0.00103581 "JIT compilation (in memory cache)" (2013, 10, 5, 1, 50, 10) mesh-refinement-cpp 20.0372 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 5, 1, 50, 30) mesh-topology-cpp 19.4921 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 5, 1, 50, 54) mesh-unitcube-cpp 24.1373 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 5, 1, 51, 32) mesh-iteration-cpp 35.4948 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 5, 1, 51, 53) function-evaluation-cpp 21.1026 "Evaluations of functions at arbitrary points." (2013, 10, 5, 1, 51, 53) function-evaluation-cpp 21.0112 "Evaluations of functions at arbitrary points." (2013, 10, 5, 1, 51, 57) function-extrapolation-python 3.52105 "BENCH: 1.07699298859" (2013, 10, 5, 1, 51, 57) function-extrapolation-python 1.07699 "BENCH: 1.07699298859" (2013, 10, 5, 1, 51, 59) function-interpolation-python 1.65767 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 5, 1, 51, 59) function-interpolation-python 0.953594 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 5, 1, 52, 24) la-vector-access-cpp 25.4458 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 5, 1, 52, 51) la-vector-assignment-cpp 27.087 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 6, 1, 31, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2236 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 6, 1, 32, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.793 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 6, 1, 32, 19) geometry-bounding_box_tree_build-cpp 13.8958 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 6, 1, 32, 47) common-progress-cpp 27.7017 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 6, 1, 33, 16) common-timing-cpp 29.3658 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 6, 1, 36, 42) fem-multicore-cpp 205.685 "Coloring mesh." (2013, 10, 6, 1, 39, 15) fem-assembly-cpp 152.715 "Assembly for various forms and backends" (2013, 10, 6, 1, 39, 29) fem-convergence-cpp 14.2049 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 6, 1, 39, 31) fem-jit-python 0.0010392 "JIT compilation (in memory cache)" (2013, 10, 6, 1, 47, 33) mesh-refinement-cpp 19.9816 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 6, 1, 47, 53) mesh-topology-cpp 19.5168 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 6, 1, 48, 17) mesh-unitcube-cpp 24.1788 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 6, 1, 48, 55) mesh-iteration-cpp 35.5056 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 6, 1, 49, 17) function-evaluation-cpp 21.9193 "Evaluations of functions at arbitrary points." (2013, 10, 6, 1, 49, 17) function-evaluation-cpp 21.8309 "Evaluations of functions at arbitrary points." (2013, 10, 6, 1, 49, 21) function-extrapolation-python 3.62091 "BENCH: 1.09147000313" (2013, 10, 6, 1, 49, 21) function-extrapolation-python 1.09147 "BENCH: 1.09147000313" (2013, 10, 6, 1, 49, 22) function-interpolation-python 1.64509 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 6, 1, 49, 22) function-interpolation-python 0.959383 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 6, 1, 49, 48) la-vector-access-cpp 25.4431 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 6, 1, 50, 15) la-vector-assignment-cpp 27.4613 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 7, 1, 22, 17) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1612 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 7, 1, 22, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5026 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 7, 1, 22, 52) geometry-bounding_box_tree_build-cpp 13.9024 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 7, 1, 23, 20) common-progress-cpp 27.6543 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 7, 1, 23, 50) common-timing-cpp 30.4938 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 7, 1, 27, 16) fem-multicore-cpp 205.74 "Coloring mesh." (2013, 10, 7, 1, 29, 50) fem-assembly-cpp 153.815 "Assembly for various forms and backends" (2013, 10, 7, 1, 30, 4) fem-convergence-cpp 14.21 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 7, 1, 30, 6) fem-jit-python 0.0010479 "JIT compilation (in memory cache)" (2013, 10, 7, 1, 38, 8) mesh-refinement-cpp 20.0396 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 7, 1, 38, 28) mesh-topology-cpp 19.5117 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 7, 1, 38, 52) mesh-unitcube-cpp 24.1223 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 7, 1, 39, 30) mesh-iteration-cpp 35.498 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 7, 1, 39, 51) function-evaluation-cpp 21.0898 "Evaluations of functions at arbitrary points." (2013, 10, 7, 1, 39, 51) function-evaluation-cpp 21.0068 "Evaluations of functions at arbitrary points." (2013, 10, 7, 1, 39, 55) function-extrapolation-python 3.54647 "BENCH: 1.07335305214" (2013, 10, 7, 1, 39, 55) function-extrapolation-python 1.07335 "BENCH: 1.07335305214" (2013, 10, 7, 1, 39, 56) function-interpolation-python 1.66153 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 7, 1, 39, 56) function-interpolation-python 0.966186 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 7, 1, 40, 22) la-vector-access-cpp 25.4471 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 7, 1, 40, 49) la-vector-assignment-cpp 27.3791 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 8, 1, 27, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1714 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 8, 1, 28, 17) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8123 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 8, 1, 28, 34) geometry-bounding_box_tree_build-cpp 13.8922 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 8, 1, 29, 2) common-progress-cpp 27.6544 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 8, 1, 29, 32) common-timing-cpp 30.1013 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 8, 1, 32, 57) fem-multicore-cpp 205.671 "Coloring mesh." (2013, 10, 8, 1, 35, 30) fem-assembly-cpp 153.068 "Assembly for various forms and backends" (2013, 10, 8, 1, 35, 45) fem-convergence-cpp 14.2023 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 8, 1, 35, 47) fem-jit-python 0.00103979 "JIT compilation (in memory cache)" (2013, 10, 8, 1, 43, 49) mesh-refinement-cpp 20.0194 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 8, 1, 44, 8) mesh-topology-cpp 19.5115 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 8, 1, 44, 32) mesh-unitcube-cpp 24.1516 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 8, 1, 45, 19) mesh-iteration-cpp 44.1916 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 8, 1, 45, 40) function-evaluation-cpp 21.248 "Evaluations of functions at arbitrary points." (2013, 10, 8, 1, 45, 40) function-evaluation-cpp 21.165 "Evaluations of functions at arbitrary points." (2013, 10, 8, 1, 45, 44) function-extrapolation-python 3.38204 "BENCH: 1.03664708138" (2013, 10, 8, 1, 45, 44) function-extrapolation-python 1.03665 "BENCH: 1.03664708138" (2013, 10, 8, 1, 45, 45) function-interpolation-python 1.65062 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 8, 1, 45, 45) function-interpolation-python 0.958467 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 8, 1, 46, 11) la-vector-access-cpp 25.4482 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 8, 1, 46, 38) la-vector-assignment-cpp 27.1013 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 9, 1, 24, 24) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1729 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 9, 1, 24, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4633 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 9, 1, 25, 0) geometry-bounding_box_tree_build-cpp 13.8902 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 9, 1, 25, 27) common-progress-cpp 27.6542 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 9, 1, 25, 59) common-timing-cpp 31.2178 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 9, 1, 29, 25) fem-multicore-cpp 205.904 "Coloring mesh." (2013, 10, 9, 1, 31, 58) fem-assembly-cpp 153.311 "Assembly for various forms and backends" (2013, 10, 9, 1, 32, 12) fem-convergence-cpp 14.2161 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 9, 1, 32, 14) fem-jit-python 0.0010448 "JIT compilation (in memory cache)" (2013, 10, 9, 1, 40, 16) mesh-refinement-cpp 19.9798 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 9, 1, 40, 36) mesh-topology-cpp 19.4669 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 9, 1, 41, 0) mesh-unitcube-cpp 24.1202 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 9, 1, 41, 38) mesh-iteration-cpp 35.4889 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 9, 1, 41, 59) function-evaluation-cpp 21.0781 "Evaluations of functions at arbitrary points." (2013, 10, 9, 1, 41, 59) function-evaluation-cpp 21.0003 "Evaluations of functions at arbitrary points." (2013, 10, 9, 1, 42, 3) function-extrapolation-python 3.41691 "BENCH: 1.052120924" (2013, 10, 9, 1, 42, 3) function-extrapolation-python 1.05212 "BENCH: 1.052120924" (2013, 10, 9, 1, 42, 4) function-interpolation-python 1.65973 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 9, 1, 42, 4) function-interpolation-python 0.96377 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 9, 1, 42, 30) la-vector-access-cpp 25.4125 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 9, 1, 42, 59) la-vector-assignment-cpp 29.1111 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 10, 1, 29, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2728 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 10, 1, 29, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4543 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 10, 1, 30, 9) geometry-bounding_box_tree_build-cpp 13.9127 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 10, 1, 30, 37) common-progress-cpp 27.654 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 10, 1, 31, 6) common-timing-cpp 29.799 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 10, 1, 34, 32) fem-multicore-cpp 205.965 "Coloring mesh." (2013, 10, 10, 1, 37, 6) fem-assembly-cpp 153.953 "Assembly for various forms and backends" (2013, 10, 10, 1, 37, 20) fem-convergence-cpp 14.2085 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 10, 1, 37, 22) fem-jit-python 0.00104251 "JIT compilation (in memory cache)" (2013, 10, 10, 1, 45, 22) mesh-refinement-cpp 19.9958 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 10, 1, 45, 42) mesh-topology-cpp 19.4907 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 10, 1, 46, 6) mesh-unitcube-cpp 24.1582 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 10, 1, 46, 44) mesh-iteration-cpp 35.4912 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 10, 1, 47, 5) function-evaluation-cpp 21.1344 "Evaluations of functions at arbitrary points." (2013, 10, 10, 1, 47, 5) function-evaluation-cpp 21.0501 "Evaluations of functions at arbitrary points." (2013, 10, 10, 1, 47, 8) function-extrapolation-python 3.42955 "BENCH: 1.04549312592" (2013, 10, 10, 1, 47, 8) function-extrapolation-python 1.04549 "BENCH: 1.04549312592" (2013, 10, 10, 1, 47, 10) function-interpolation-python 1.66636 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 10, 1, 47, 10) function-interpolation-python 0.963219 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 10, 1, 47, 35) la-vector-access-cpp 25.4454 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 10, 1, 48, 3) la-vector-assignment-cpp 27.0883 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 11, 1, 25, 52) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2517 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 11, 1, 26, 11) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4675 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 11, 1, 26, 28) geometry-bounding_box_tree_build-cpp 13.9087 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 11, 1, 26, 55) common-progress-cpp 27.654 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 11, 1, 27, 26) common-timing-cpp 30.3191 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 11, 1, 30, 51) fem-multicore-cpp 205.802 "Coloring mesh." (2013, 10, 11, 1, 33, 25) fem-assembly-cpp 153.561 "Assembly for various forms and backends" (2013, 10, 11, 1, 33, 39) fem-convergence-cpp 14.2147 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 11, 1, 33, 41) fem-jit-python 0.0010422 "JIT compilation (in memory cache)" (2013, 10, 11, 1, 41, 42) mesh-refinement-cpp 19.9884 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 11, 1, 42, 2) mesh-topology-cpp 19.4407 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 11, 1, 42, 26) mesh-unitcube-cpp 24.1511 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 11, 1, 43, 4) mesh-iteration-cpp 35.4242 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 11, 1, 43, 25) function-evaluation-cpp 21.5886 "Evaluations of functions at arbitrary points." (2013, 10, 11, 1, 43, 25) function-evaluation-cpp 21.4889 "Evaluations of functions at arbitrary points." (2013, 10, 11, 1, 43, 29) function-extrapolation-python 3.49587 "BENCH: 1.05149507523" (2013, 10, 11, 1, 43, 29) function-extrapolation-python 1.0515 "BENCH: 1.05149507523" (2013, 10, 11, 1, 43, 31) function-interpolation-python 1.66646 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 11, 1, 43, 31) function-interpolation-python 0.9587 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 11, 1, 43, 56) la-vector-access-cpp 25.4456 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 11, 1, 44, 23) la-vector-assignment-cpp 27.1223 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 12, 1, 23, 18) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3262 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 12, 1, 23, 37) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5781 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 12, 1, 23, 54) geometry-bounding_box_tree_build-cpp 13.9129 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 12, 1, 24, 22) common-progress-cpp 27.6994 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 12, 1, 24, 51) common-timing-cpp 29.6179 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 12, 1, 28, 17) fem-multicore-cpp 206.165 "Coloring mesh." (2013, 10, 12, 1, 30, 51) fem-assembly-cpp 153.099 "Assembly for various forms and backends" (2013, 10, 12, 1, 31, 5) fem-convergence-cpp 14.1997 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 12, 1, 31, 7) fem-jit-python 0.00104721 "JIT compilation (in memory cache)" (2013, 10, 12, 1, 39, 8) mesh-refinement-cpp 20.0286 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 12, 1, 39, 27) mesh-topology-cpp 19.5319 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 12, 1, 39, 51) mesh-unitcube-cpp 24.1438 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 12, 1, 40, 29) mesh-iteration-cpp 35.4232 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 12, 1, 40, 50) function-evaluation-cpp 21.1512 "Evaluations of functions at arbitrary points." (2013, 10, 12, 1, 40, 50) function-evaluation-cpp 21.0398 "Evaluations of functions at arbitrary points." (2013, 10, 12, 1, 40, 54) function-extrapolation-python 3.55272 "BENCH: 1.05189394951" (2013, 10, 12, 1, 40, 54) function-extrapolation-python 1.05189 "BENCH: 1.05189394951" (2013, 10, 12, 1, 40, 56) function-interpolation-python 1.65244 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 12, 1, 40, 56) function-interpolation-python 0.959537 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 12, 1, 41, 21) la-vector-access-cpp 25.444 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 12, 1, 41, 50) la-vector-assignment-cpp 29.1551 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 13, 1, 32, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3028 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 13, 1, 32, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5486 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 13, 1, 33, 9) geometry-bounding_box_tree_build-cpp 13.8936 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 13, 1, 33, 37) common-progress-cpp 27.6534 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 13, 1, 34, 7) common-timing-cpp 29.4836 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 13, 1, 37, 32) fem-multicore-cpp 205.716 "Coloring mesh." (2013, 10, 13, 1, 40, 6) fem-assembly-cpp 153.832 "Assembly for various forms and backends" (2013, 10, 13, 1, 40, 20) fem-convergence-cpp 14.2053 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 13, 1, 40, 22) fem-jit-python 0.0010504 "JIT compilation (in memory cache)" (2013, 10, 13, 1, 48, 24) mesh-refinement-cpp 19.9856 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 13, 1, 48, 43) mesh-topology-cpp 19.4784 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 13, 1, 49, 7) mesh-unitcube-cpp 24.2334 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 13, 1, 49, 54) mesh-iteration-cpp 44.1901 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 13, 1, 50, 15) function-evaluation-cpp 21.1017 "Evaluations of functions at arbitrary points." (2013, 10, 13, 1, 50, 15) function-evaluation-cpp 21.0228 "Evaluations of functions at arbitrary points." (2013, 10, 13, 1, 50, 19) function-extrapolation-python 3.50942 "BENCH: 1.059237957" (2013, 10, 13, 1, 50, 19) function-extrapolation-python 1.05924 "BENCH: 1.059237957" (2013, 10, 13, 1, 50, 20) function-interpolation-python 1.64345 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 13, 1, 50, 20) function-interpolation-python 0.957713 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 13, 1, 50, 46) la-vector-access-cpp 25.4443 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 13, 1, 51, 13) la-vector-assignment-cpp 27.0373 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 14, 1, 26, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.166 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 14, 1, 26, 30) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5309 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 14, 1, 26, 46) geometry-bounding_box_tree_build-cpp 13.9187 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 14, 1, 27, 14) common-progress-cpp 27.6534 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 14, 1, 27, 45) common-timing-cpp 30.4655 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 14, 1, 31, 10) fem-multicore-cpp 205.478 "Coloring mesh." (2013, 10, 14, 1, 33, 43) fem-assembly-cpp 153.22 "Assembly for various forms and backends" (2013, 10, 14, 1, 33, 57) fem-convergence-cpp 14.2167 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 14, 1, 33, 59) fem-jit-python 0.0010437 "JIT compilation (in memory cache)" (2013, 10, 14, 1, 42, 0) mesh-refinement-cpp 19.9629 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 14, 1, 42, 20) mesh-topology-cpp 19.4957 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 14, 1, 42, 44) mesh-unitcube-cpp 24.1358 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 14, 1, 43, 22) mesh-iteration-cpp 35.4821 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 14, 1, 43, 43) function-evaluation-cpp 21.0829 "Evaluations of functions at arbitrary points." (2013, 10, 14, 1, 43, 43) function-evaluation-cpp 21.0002 "Evaluations of functions at arbitrary points." (2013, 10, 14, 1, 43, 46) function-extrapolation-python 3.50349 "BENCH: 1.05115294456" (2013, 10, 14, 1, 43, 46) function-extrapolation-python 1.05115 "BENCH: 1.05115294456" (2013, 10, 14, 1, 43, 48) function-interpolation-python 1.70877 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 14, 1, 43, 48) function-interpolation-python 0.960066 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 14, 1, 44, 14) la-vector-access-cpp 25.4876 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 14, 1, 44, 41) la-vector-assignment-cpp 27.0381 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 15, 1, 26, 28) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2003 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 15, 1, 26, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4288 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 15, 1, 27, 4) geometry-bounding_box_tree_build-cpp 13.9256 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 15, 1, 27, 32) common-progress-cpp 27.6531 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 15, 1, 28, 2) common-timing-cpp 30.2115 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 15, 1, 31, 28) fem-multicore-cpp 206.349 "Coloring mesh." (2013, 10, 15, 1, 34, 1) fem-assembly-cpp 152.6 "Assembly for various forms and backends" (2013, 10, 15, 1, 34, 15) fem-convergence-cpp 14.2011 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 15, 1, 34, 17) fem-jit-python 0.00103641 "JIT compilation (in memory cache)" (2013, 10, 15, 1, 42, 14) mesh-refinement-cpp 19.9771 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 15, 1, 42, 34) mesh-topology-cpp 19.4941 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 15, 1, 42, 58) mesh-unitcube-cpp 24.2276 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 15, 1, 43, 36) mesh-iteration-cpp 35.421 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 15, 1, 43, 57) function-evaluation-cpp 21.1841 "Evaluations of functions at arbitrary points." (2013, 10, 15, 1, 43, 57) function-evaluation-cpp 21.0839 "Evaluations of functions at arbitrary points." (2013, 10, 15, 1, 44, 1) function-extrapolation-python 3.70392 "BENCH: 1.0477449894" (2013, 10, 15, 1, 44, 1) function-extrapolation-python 1.04774 "BENCH: 1.0477449894" (2013, 10, 15, 1, 44, 3) function-interpolation-python 1.63328 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 15, 1, 44, 3) function-interpolation-python 0.961099 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 15, 1, 44, 28) la-vector-access-cpp 25.4821 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 15, 1, 44, 55) la-vector-assignment-cpp 27.1022 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 16, 1, 36, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1894 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 16, 1, 36, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4606 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 16, 1, 37, 1) geometry-bounding_box_tree_build-cpp 13.9155 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 16, 1, 37, 29) common-progress-cpp 27.6539 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 16, 1, 37, 59) common-timing-cpp 30.342 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 16, 1, 41, 23) fem-multicore-cpp 204.023 "Coloring mesh." (2013, 10, 16, 1, 43, 55) fem-assembly-cpp 152.257 "Assembly for various forms and backends" (2013, 10, 16, 1, 44, 9) fem-convergence-cpp 14.2078 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 16, 1, 44, 11) fem-jit-python 0.001055 "JIT compilation (in memory cache)" (2013, 10, 16, 1, 52, 14) mesh-refinement-cpp 19.9869 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 16, 1, 52, 34) mesh-topology-cpp 19.5308 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 16, 1, 52, 58) mesh-unitcube-cpp 24.2922 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 16, 1, 53, 36) mesh-iteration-cpp 35.4795 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 16, 1, 53, 57) function-evaluation-cpp 21.1449 "Evaluations of functions at arbitrary points." (2013, 10, 16, 1, 53, 57) function-evaluation-cpp 21.0534 "Evaluations of functions at arbitrary points." (2013, 10, 16, 1, 54, 1) function-extrapolation-python 3.42836 "BENCH: 1.04853320122" (2013, 10, 16, 1, 54, 1) function-extrapolation-python 1.04853 "BENCH: 1.04853320122" (2013, 10, 16, 1, 54, 2) function-interpolation-python 1.67661 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 16, 1, 54, 2) function-interpolation-python 0.962554 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 16, 1, 54, 26) la-vector-access-cpp 23.4363 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 16, 1, 54, 53) la-vector-assignment-cpp 27.0872 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 17, 1, 29, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1932 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 17, 1, 29, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.583 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 17, 1, 29, 56) geometry-bounding_box_tree_build-cpp 13.8975 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 17, 1, 30, 24) common-progress-cpp 27.6539 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 17, 1, 30, 53) common-timing-cpp 29.8792 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 17, 1, 34, 17) fem-multicore-cpp 203.882 "Coloring mesh." (2013, 10, 17, 1, 36, 49) fem-assembly-cpp 151.94 "Assembly for various forms and backends" (2013, 10, 17, 1, 37, 4) fem-convergence-cpp 14.2185 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 17, 1, 37, 5) fem-jit-python 0.0010479 "JIT compilation (in memory cache)" (2013, 10, 17, 1, 45, 5) mesh-refinement-cpp 19.976 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 17, 1, 45, 25) mesh-topology-cpp 19.6033 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 17, 1, 45, 49) mesh-unitcube-cpp 24.1105 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 17, 1, 46, 27) mesh-iteration-cpp 35.6844 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 17, 1, 46, 49) function-evaluation-cpp 21.1123 "Evaluations of functions at arbitrary points." (2013, 10, 17, 1, 46, 49) function-evaluation-cpp 21.0183 "Evaluations of functions at arbitrary points." (2013, 10, 17, 1, 46, 52) function-extrapolation-python 3.51254 "BENCH: 1.04783797264" (2013, 10, 17, 1, 46, 52) function-extrapolation-python 1.04784 "BENCH: 1.04783797264" (2013, 10, 17, 1, 46, 54) function-interpolation-python 1.67046 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 17, 1, 46, 54) function-interpolation-python 0.975351 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 17, 1, 47, 17) la-vector-access-cpp 23.4541 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 17, 1, 47, 44) la-vector-assignment-cpp 27.0867 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 18, 1, 25, 15) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1458 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 18, 1, 25, 34) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9294 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 18, 1, 25, 51) geometry-bounding_box_tree_build-cpp 13.905 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 18, 1, 26, 18) common-progress-cpp 27.6538 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 18, 1, 26, 49) common-timing-cpp 30.5058 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 18, 1, 30, 13) fem-multicore-cpp 204.059 "Coloring mesh." (2013, 10, 18, 1, 32, 44) fem-assembly-cpp 151.656 "Assembly for various forms and backends" (2013, 10, 18, 1, 32, 59) fem-convergence-cpp 14.2242 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 18, 1, 33, 1) fem-jit-python 0.0010509 "JIT compilation (in memory cache)" (2013, 10, 18, 1, 41, 0) mesh-refinement-cpp 19.9802 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 18, 1, 41, 20) mesh-topology-cpp 19.4808 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 18, 1, 41, 44) mesh-unitcube-cpp 24.0913 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 18, 1, 42, 22) mesh-iteration-cpp 35.4891 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 18, 1, 42, 43) function-evaluation-cpp 21.1065 "Evaluations of functions at arbitrary points." (2013, 10, 18, 1, 42, 43) function-evaluation-cpp 21.0334 "Evaluations of functions at arbitrary points." (2013, 10, 18, 1, 42, 46) function-extrapolation-python 3.4294 "BENCH: 1.03152608871" (2013, 10, 18, 1, 42, 46) function-extrapolation-python 1.03153 "BENCH: 1.03152608871" (2013, 10, 18, 1, 42, 48) function-interpolation-python 1.67217 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 18, 1, 42, 48) function-interpolation-python 0.966518 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 18, 1, 43, 11) la-vector-access-cpp 23.4445 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 18, 1, 43, 38) la-vector-assignment-cpp 26.9759 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 19, 1, 24, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2409 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 19, 1, 24, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6008 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 19, 1, 24, 54) geometry-bounding_box_tree_build-cpp 13.8931 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 19, 1, 25, 22) common-progress-cpp 27.6532 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 19, 1, 25, 53) common-timing-cpp 30.8574 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 19, 1, 29, 17) fem-multicore-cpp 203.946 "Coloring mesh." (2013, 10, 19, 1, 31, 49) fem-assembly-cpp 152.208 "Assembly for various forms and backends" (2013, 10, 19, 1, 32, 3) fem-convergence-cpp 14.235 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 19, 1, 32, 5) fem-jit-python 0.0010391 "JIT compilation (in memory cache)" (2013, 10, 19, 1, 40, 7) mesh-refinement-cpp 19.9542 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 19, 1, 40, 26) mesh-topology-cpp 19.5557 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 19, 1, 40, 51) mesh-unitcube-cpp 24.1495 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 19, 1, 41, 29) mesh-iteration-cpp 35.5138 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 19, 1, 41, 50) function-evaluation-cpp 21.2203 "Evaluations of functions at arbitrary points." (2013, 10, 19, 1, 41, 50) function-evaluation-cpp 21.1362 "Evaluations of functions at arbitrary points." (2013, 10, 19, 1, 41, 53) function-extrapolation-python 3.47924 "BENCH: 1.05130505562" (2013, 10, 19, 1, 41, 53) function-extrapolation-python 1.05131 "BENCH: 1.05130505562" (2013, 10, 19, 1, 41, 55) function-interpolation-python 1.66018 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 19, 1, 41, 55) function-interpolation-python 0.971152 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 19, 1, 42, 19) la-vector-access-cpp 23.4636 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 19, 1, 42, 46) la-vector-assignment-cpp 27.0826 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 20, 1, 37, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2259 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 20, 1, 37, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5893 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 20, 1, 37, 54) geometry-bounding_box_tree_build-cpp 13.9742 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 20, 1, 38, 26) common-progress-cpp 31.4647 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 20, 1, 38, 56) common-timing-cpp 30.7248 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 20, 1, 42, 21) fem-multicore-cpp 204.23 "Coloring mesh." (2013, 10, 20, 1, 44, 52) fem-assembly-cpp 151.64 "Assembly for various forms and backends" (2013, 10, 20, 1, 45, 7) fem-convergence-cpp 14.1961 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 20, 1, 45, 9) fem-jit-python 0.0010421 "JIT compilation (in memory cache)" (2013, 10, 20, 1, 53, 10) mesh-refinement-cpp 19.9724 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 20, 1, 53, 29) mesh-topology-cpp 19.5091 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 20, 1, 53, 53) mesh-unitcube-cpp 24.0889 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 20, 1, 54, 31) mesh-iteration-cpp 35.4826 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 20, 1, 54, 52) function-evaluation-cpp 21.1203 "Evaluations of functions at arbitrary points." (2013, 10, 20, 1, 54, 52) function-evaluation-cpp 21.0471 "Evaluations of functions at arbitrary points." (2013, 10, 20, 1, 54, 56) function-extrapolation-python 3.46949 "BENCH: 1.04470419884" (2013, 10, 20, 1, 54, 56) function-extrapolation-python 1.0447 "BENCH: 1.04470419884" (2013, 10, 20, 1, 54, 58) function-interpolation-python 1.66814 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 20, 1, 54, 58) function-interpolation-python 0.965249 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 20, 1, 55, 23) la-vector-access-cpp 25.4452 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 20, 1, 55, 51) la-vector-assignment-cpp 28.1963 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 22, 1, 28, 4) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1973 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 22, 1, 28, 23) geometry-bounding_box_tree_compute_closest_entity-cpp 15.882 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 22, 1, 28, 40) geometry-bounding_box_tree_build-cpp 13.9339 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 22, 1, 29, 8) common-progress-cpp 27.7007 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 22, 1, 29, 38) common-timing-cpp 30.1005 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 22, 1, 33, 2) fem-multicore-cpp 204.082 "Coloring mesh." (2013, 10, 22, 1, 35, 35) fem-assembly-cpp 152.746 "Assembly for various forms and backends" (2013, 10, 22, 1, 35, 49) fem-convergence-cpp 14.2042 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 22, 1, 35, 51) fem-jit-python 0.00104568 "JIT compilation (in memory cache)" (2013, 10, 22, 1, 43, 52) mesh-refinement-cpp 20.0136 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 22, 1, 44, 11) mesh-topology-cpp 19.4639 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 22, 1, 44, 35) mesh-unitcube-cpp 24.1807 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 22, 1, 45, 13) mesh-iteration-cpp 35.4833 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 22, 1, 45, 35) function-evaluation-cpp 21.3886 "Evaluations of functions at arbitrary points." (2013, 10, 22, 1, 45, 35) function-evaluation-cpp 21.3155 "Evaluations of functions at arbitrary points." (2013, 10, 22, 1, 45, 38) function-extrapolation-python 3.52108 "BENCH: 1.06083893776" (2013, 10, 22, 1, 45, 38) function-extrapolation-python 1.06084 "BENCH: 1.06083893776" (2013, 10, 22, 1, 45, 40) function-interpolation-python 1.66047 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 22, 1, 45, 40) function-interpolation-python 0.968526 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 22, 1, 46, 3) la-vector-access-cpp 23.4463 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 22, 1, 46, 31) la-vector-assignment-cpp 27.1137 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 23, 1, 26, 5) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.044 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 23, 1, 26, 25) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9257 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 23, 1, 26, 41) geometry-bounding_box_tree_build-cpp 13.9294 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 23, 1, 27, 9) common-progress-cpp 27.664 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 23, 1, 27, 40) common-timing-cpp 31.1204 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 23, 1, 31, 4) fem-multicore-cpp 204.036 "Coloring mesh." (2013, 10, 23, 1, 33, 36) fem-assembly-cpp 151.929 "Assembly for various forms and backends" (2013, 10, 23, 1, 33, 50) fem-convergence-cpp 14.2205 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 23, 1, 33, 52) fem-jit-python 0.0010458 "JIT compilation (in memory cache)" (2013, 10, 23, 1, 41, 54) mesh-refinement-cpp 20.0746 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 23, 1, 42, 14) mesh-topology-cpp 19.9764 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 23, 1, 42, 39) mesh-unitcube-cpp 24.2103 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 23, 1, 43, 17) mesh-iteration-cpp 35.4828 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 23, 1, 43, 38) function-evaluation-cpp 21.0654 "Evaluations of functions at arbitrary points." (2013, 10, 23, 1, 43, 38) function-evaluation-cpp 20.9323 "Evaluations of functions at arbitrary points." (2013, 10, 23, 1, 43, 41) function-extrapolation-python 3.52907 "BENCH: 1.05461382866" (2013, 10, 23, 1, 43, 41) function-extrapolation-python 1.05461 "BENCH: 1.05461382866" (2013, 10, 23, 1, 43, 43) function-interpolation-python 1.65621 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 23, 1, 43, 43) function-interpolation-python 0.968356 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 23, 1, 44, 9) la-vector-access-cpp 25.4685 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 23, 1, 44, 36) la-vector-assignment-cpp 27.2208 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 24, 1, 37, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1101 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 24, 1, 38, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6399 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 24, 1, 38, 33) geometry-bounding_box_tree_build-cpp 13.9122 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 24, 1, 39, 1) common-progress-cpp 27.702 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 24, 1, 39, 33) common-timing-cpp 32.0949 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 24, 1, 42, 57) fem-multicore-cpp 204.202 "Coloring mesh." (2013, 10, 24, 1, 45, 28) fem-assembly-cpp 151.442 "Assembly for various forms and backends" (2013, 10, 24, 1, 45, 43) fem-convergence-cpp 14.215 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 24, 1, 45, 44) fem-jit-python 0.001051 "JIT compilation (in memory cache)" (2013, 10, 24, 1, 53, 45) mesh-refinement-cpp 20.0413 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 24, 1, 54, 5) mesh-topology-cpp 19.9657 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 24, 1, 54, 29) mesh-unitcube-cpp 24.2088 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 24, 1, 55, 9) mesh-iteration-cpp 37.2989 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 24, 1, 55, 30) function-evaluation-cpp 20.998 "Evaluations of functions at arbitrary points." (2013, 10, 24, 1, 55, 30) function-evaluation-cpp 20.9029 "Evaluations of functions at arbitrary points." (2013, 10, 24, 1, 55, 34) function-extrapolation-python 3.44526 "BENCH: 1.04851603508" (2013, 10, 24, 1, 55, 34) function-extrapolation-python 1.04852 "BENCH: 1.04851603508" (2013, 10, 24, 1, 55, 35) function-interpolation-python 1.6714 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 24, 1, 55, 35) function-interpolation-python 0.961992 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 24, 1, 55, 59) la-vector-access-cpp 23.4402 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 24, 1, 56, 27) la-vector-assignment-cpp 28.1198 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 25, 1, 38, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2149 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 25, 1, 38, 23) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9088 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 25, 1, 38, 39) geometry-bounding_box_tree_build-cpp 13.954 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 25, 1, 39, 7) common-progress-cpp 27.6534 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 25, 1, 39, 38) common-timing-cpp 31.2016 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 25, 1, 43, 2) fem-multicore-cpp 204.088 "Coloring mesh." (2013, 10, 25, 1, 45, 34) fem-assembly-cpp 151.257 "Assembly for various forms and backends" (2013, 10, 25, 1, 45, 48) fem-convergence-cpp 14.2057 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 25, 1, 45, 50) fem-jit-python 0.00104771 "JIT compilation (in memory cache)" (2013, 10, 25, 1, 53, 47) mesh-refinement-cpp 20.1168 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 25, 1, 54, 7) mesh-topology-cpp 19.8886 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 25, 1, 54, 32) mesh-unitcube-cpp 24.2103 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 25, 1, 55, 10) mesh-iteration-cpp 35.4605 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 25, 1, 55, 31) function-evaluation-cpp 21.0416 "Evaluations of functions at arbitrary points." (2013, 10, 25, 1, 55, 31) function-evaluation-cpp 20.9519 "Evaluations of functions at arbitrary points." (2013, 10, 25, 1, 55, 34) function-extrapolation-python 3.62083 "BENCH: 1.0487909317" (2013, 10, 25, 1, 55, 34) function-extrapolation-python 1.04879 "BENCH: 1.0487909317" (2013, 10, 25, 1, 55, 36) function-interpolation-python 1.64534 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 25, 1, 55, 36) function-interpolation-python 0.96404 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 25, 1, 55, 59) la-vector-access-cpp 23.4747 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 25, 1, 56, 27) la-vector-assignment-cpp 27.0934 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 26, 1, 35, 1) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0883 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 26, 1, 35, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5332 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 26, 1, 35, 36) geometry-bounding_box_tree_build-cpp 13.9515 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 26, 1, 36, 4) common-progress-cpp 27.653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 26, 1, 36, 36) common-timing-cpp 31.7032 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 26, 1, 40, 0) fem-multicore-cpp 204.038 "Coloring mesh." (2013, 10, 26, 1, 42, 32) fem-assembly-cpp 152.365 "Assembly for various forms and backends" (2013, 10, 26, 1, 42, 46) fem-convergence-cpp 14.2081 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 26, 1, 42, 59) fem-jit-python 0.00106812 "JIT compilation (in memory cache)" (2013, 10, 26, 1, 51, 1) mesh-refinement-cpp 19.9852 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 26, 1, 51, 21) mesh-topology-cpp 19.8565 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 26, 1, 51, 45) mesh-unitcube-cpp 24.1747 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 26, 1, 52, 31) mesh-iteration-cpp 43.5542 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 26, 1, 52, 52) function-evaluation-cpp 21.0777 "Evaluations of functions at arbitrary points." (2013, 10, 26, 1, 52, 52) function-evaluation-cpp 20.9776 "Evaluations of functions at arbitrary points." (2013, 10, 26, 1, 53, 39) function-extrapolation-python 47.5096 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 10, 26, 1, 53, 39) function-extrapolation-python 1.03434 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2013, 10, 26, 1, 53, 41) function-interpolation-python 1.64401 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 26, 1, 53, 41) function-interpolation-python 0.972739 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 26, 1, 54, 5) la-vector-access-cpp 23.4653 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 26, 1, 54, 32) la-vector-assignment-cpp 27.0979 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 27, 2, 23, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0541 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 27, 2, 24, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6206 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 27, 2, 24, 24) geometry-bounding_box_tree_build-cpp 13.8988 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 27, 2, 24, 51) common-progress-cpp 27.7002 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 27, 2, 25, 23) common-timing-cpp 31.956 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 27, 2, 28, 47) fem-multicore-cpp 204.099 "Coloring mesh." (2013, 10, 27, 2, 31, 19) fem-assembly-cpp 151.312 "Assembly for various forms and backends" (2013, 10, 27, 2, 31, 33) fem-convergence-cpp 14.2159 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 27, 2, 31, 35) fem-jit-python 0.00107372 "JIT compilation (in memory cache)" (2013, 10, 27, 2, 39, 35) mesh-refinement-cpp 20.0151 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 27, 2, 39, 55) mesh-topology-cpp 19.8809 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 27, 2, 40, 19) mesh-unitcube-cpp 24.1813 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 27, 2, 41, 6) mesh-iteration-cpp 44.1985 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 27, 2, 41, 27) function-evaluation-cpp 21.053 "Evaluations of functions at arbitrary points." (2013, 10, 27, 2, 41, 27) function-evaluation-cpp 20.958 "Evaluations of functions at arbitrary points." (2013, 10, 27, 2, 41, 31) function-extrapolation-python 3.52044 "BENCH: 1.04091596603" (2013, 10, 27, 2, 41, 31) function-extrapolation-python 1.04092 "BENCH: 1.04091596603" (2013, 10, 27, 2, 41, 32) function-interpolation-python 1.66706 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 27, 2, 41, 32) function-interpolation-python 0.980854 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 27, 2, 41, 56) la-vector-access-cpp 23.4359 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 27, 2, 42, 23) la-vector-assignment-cpp 27.103 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 28, 2, 41, 55) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0987 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 28, 2, 42, 14) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6389 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 28, 2, 42, 31) geometry-bounding_box_tree_build-cpp 13.9527 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 28, 2, 42, 59) common-progress-cpp 27.6535 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 28, 2, 43, 30) common-timing-cpp 31.1796 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 28, 2, 46, 54) fem-multicore-cpp 203.9 "Coloring mesh." (2013, 10, 28, 2, 49, 25) fem-assembly-cpp 151.718 "Assembly for various forms and backends" (2013, 10, 28, 2, 49, 40) fem-convergence-cpp 14.2156 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 28, 2, 49, 42) fem-jit-python 0.00105221 "JIT compilation (in memory cache)" (2013, 10, 28, 2, 57, 44) mesh-refinement-cpp 20.0544 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 28, 2, 58, 4) mesh-topology-cpp 19.9463 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 28, 2, 58, 28) mesh-unitcube-cpp 24.1807 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 28, 2, 59, 6) mesh-iteration-cpp 35.4874 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 28, 2, 59, 27) function-evaluation-cpp 21.0705 "Evaluations of functions at arbitrary points." (2013, 10, 28, 2, 59, 27) function-evaluation-cpp 20.936 "Evaluations of functions at arbitrary points." (2013, 10, 28, 2, 59, 31) function-extrapolation-python 3.52103 "BENCH: 1.06225013733" (2013, 10, 28, 2, 59, 31) function-extrapolation-python 1.06225 "BENCH: 1.06225013733" (2013, 10, 28, 2, 59, 32) function-interpolation-python 1.67158 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 28, 2, 59, 32) function-interpolation-python 0.970899 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 28, 2, 59, 56) la-vector-access-cpp 23.4428 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 28, 3, 0, 23) la-vector-assignment-cpp 27.0818 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 29, 2, 27, 9) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2762 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 29, 2, 27, 28) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6261 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 29, 2, 27, 44) geometry-bounding_box_tree_build-cpp 13.9128 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 29, 2, 28, 12) common-progress-cpp 27.6798 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 29, 2, 28, 43) common-timing-cpp 31.4459 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 29, 2, 32, 7) fem-multicore-cpp 203.962 "Coloring mesh." (2013, 10, 29, 2, 34, 39) fem-assembly-cpp 151.393 "Assembly for various forms and backends" (2013, 10, 29, 2, 34, 53) fem-convergence-cpp 14.2518 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 29, 2, 34, 55) fem-jit-python 0.0010577 "JIT compilation (in memory cache)" (2013, 10, 29, 2, 42, 56) mesh-refinement-cpp 20.0375 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 29, 2, 43, 16) mesh-topology-cpp 19.9066 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 29, 2, 43, 41) mesh-unitcube-cpp 24.2292 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 29, 2, 44, 19) mesh-iteration-cpp 35.4854 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 29, 2, 44, 40) function-evaluation-cpp 21.0342 "Evaluations of functions at arbitrary points." (2013, 10, 29, 2, 44, 40) function-evaluation-cpp 20.9165 "Evaluations of functions at arbitrary points." (2013, 10, 29, 2, 44, 43) function-extrapolation-python 3.71131 "BENCH: 1.06067013741" (2013, 10, 29, 2, 44, 43) function-extrapolation-python 1.06067 "BENCH: 1.06067013741" (2013, 10, 29, 2, 44, 45) function-interpolation-python 1.69406 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 29, 2, 44, 45) function-interpolation-python 0.971827 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 29, 2, 45, 8) la-vector-access-cpp 23.47 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 29, 2, 45, 37) la-vector-assignment-cpp 28.1183 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 30, 2, 38, 0) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1028 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 30, 2, 38, 19) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8771 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 30, 2, 38, 36) geometry-bounding_box_tree_build-cpp 13.8916 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 30, 2, 39, 3) common-progress-cpp 27.6634 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 30, 2, 39, 35) common-timing-cpp 31.6893 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 30, 2, 42, 59) fem-multicore-cpp 204.479 "Coloring mesh." (2013, 10, 30, 2, 45, 31) fem-assembly-cpp 151.532 "Assembly for various forms and backends" (2013, 10, 30, 2, 45, 45) fem-convergence-cpp 14.2044 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 30, 2, 45, 47) fem-jit-python 0.0010483 "JIT compilation (in memory cache)" (2013, 10, 30, 2, 53, 49) mesh-refinement-cpp 20.0422 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 30, 2, 54, 9) mesh-topology-cpp 19.9478 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 30, 2, 54, 33) mesh-unitcube-cpp 24.2041 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 30, 2, 55, 11) mesh-iteration-cpp 35.4793 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 30, 2, 55, 32) function-evaluation-cpp 21.0616 "Evaluations of functions at arbitrary points." (2013, 10, 30, 2, 55, 32) function-evaluation-cpp 20.9657 "Evaluations of functions at arbitrary points." (2013, 10, 30, 2, 55, 35) function-extrapolation-python 3.49502 "BENCH: 1.05853796005" (2013, 10, 30, 2, 55, 35) function-extrapolation-python 1.05854 "BENCH: 1.05853796005" (2013, 10, 30, 2, 55, 37) function-interpolation-python 1.65206 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 30, 2, 55, 37) function-interpolation-python 0.966297 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 30, 2, 56, 1) la-vector-access-cpp 23.4415 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 30, 2, 56, 29) la-vector-assignment-cpp 28.1158 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 10, 31, 2, 36, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.194 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 31, 2, 37, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4887 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 10, 31, 2, 37, 24) geometry-bounding_box_tree_build-cpp 13.9588 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 10, 31, 2, 37, 52) common-progress-cpp 27.7062 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 10, 31, 2, 38, 23) common-timing-cpp 31.2512 "Timing access and registration of timings (10000000 repetitions)" (2013, 10, 31, 2, 41, 47) fem-multicore-cpp 203.962 "Coloring mesh." (2013, 10, 31, 2, 44, 19) fem-assembly-cpp 151.988 "Assembly for various forms and backends" (2013, 10, 31, 2, 44, 33) fem-convergence-cpp 14.2106 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 10, 31, 2, 44, 35) fem-jit-python 0.00105848 "JIT compilation (in memory cache)" (2013, 10, 31, 2, 52, 37) mesh-refinement-cpp 20.0302 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 10, 31, 2, 52, 57) mesh-topology-cpp 19.8567 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 10, 31, 2, 53, 21) mesh-unitcube-cpp 24.2175 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 10, 31, 2, 54, 0) mesh-iteration-cpp 36.0563 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 10, 31, 2, 54, 21) function-evaluation-cpp 21.0515 "Evaluations of functions at arbitrary points." (2013, 10, 31, 2, 54, 21) function-evaluation-cpp 20.9254 "Evaluations of functions at arbitrary points." (2013, 10, 31, 2, 54, 25) function-extrapolation-python 3.53652 "BENCH: 1.05553793907" (2013, 10, 31, 2, 54, 25) function-extrapolation-python 1.05554 "BENCH: 1.05553793907" (2013, 10, 31, 2, 54, 26) function-interpolation-python 1.64321 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 31, 2, 54, 26) function-interpolation-python 0.969507 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 10, 31, 2, 54, 52) la-vector-access-cpp 25.4872 "Accessing vector of size 10000000 (100 repetitions)" (2013, 10, 31, 2, 55, 19) la-vector-assignment-cpp 27.1019 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 1, 2, 25, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.07 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 1, 2, 26, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5758 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 1, 2, 26, 24) geometry-bounding_box_tree_build-cpp 13.9167 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 1, 2, 26, 52) common-progress-cpp 27.699 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 1, 2, 27, 23) common-timing-cpp 30.8096 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 1, 2, 30, 47) fem-multicore-cpp 204.623 "Coloring mesh." (2013, 11, 1, 2, 33, 19) fem-assembly-cpp 151.966 "Assembly for various forms and backends" (2013, 11, 1, 2, 33, 33) fem-convergence-cpp 14.2001 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 1, 2, 33, 35) fem-jit-python 0.0010556 "JIT compilation (in memory cache)" (2013, 11, 1, 2, 41, 37) mesh-refinement-cpp 20.0394 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 1, 2, 41, 57) mesh-topology-cpp 19.8387 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 1, 2, 42, 21) mesh-unitcube-cpp 24.1916 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 1, 2, 42, 59) mesh-iteration-cpp 35.4874 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 1, 2, 43, 20) function-evaluation-cpp 21.0232 "Evaluations of functions at arbitrary points." (2013, 11, 1, 2, 43, 20) function-evaluation-cpp 20.9106 "Evaluations of functions at arbitrary points." (2013, 11, 1, 2, 43, 24) function-extrapolation-python 3.49661 "BENCH: 1.05543804169" (2013, 11, 1, 2, 43, 24) function-extrapolation-python 1.05544 "BENCH: 1.05543804169" (2013, 11, 1, 2, 43, 26) function-interpolation-python 1.66051 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 1, 2, 43, 26) function-interpolation-python 0.973091 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 1, 2, 43, 49) la-vector-access-cpp 23.4363 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 1, 2, 44, 16) la-vector-assignment-cpp 27.0848 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 2, 2, 29, 9) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1275 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 2, 2, 29, 28) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8684 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 2, 2, 29, 45) geometry-bounding_box_tree_build-cpp 13.9235 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 2, 2, 30, 18) common-progress-cpp 32.7266 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 2, 2, 30, 50) common-timing-cpp 31.9902 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 2, 2, 34, 14) fem-multicore-cpp 204.147 "Coloring mesh." (2013, 11, 2, 2, 36, 45) fem-assembly-cpp 151.731 "Assembly for various forms and backends" (2013, 11, 2, 2, 37, 0) fem-convergence-cpp 14.2216 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 2, 2, 37, 2) fem-jit-python 0.00104589 "JIT compilation (in memory cache)" (2013, 11, 2, 2, 45, 4) mesh-refinement-cpp 20.0365 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 2, 2, 45, 24) mesh-topology-cpp 19.8177 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 2, 2, 45, 48) mesh-unitcube-cpp 24.2727 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 2, 2, 46, 26) mesh-iteration-cpp 35.4854 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 2, 2, 46, 47) function-evaluation-cpp 21.0673 "Evaluations of functions at arbitrary points." (2013, 11, 2, 2, 46, 47) function-evaluation-cpp 20.9723 "Evaluations of functions at arbitrary points." (2013, 11, 2, 2, 46, 51) function-extrapolation-python 3.47945 "BENCH: 1.04890799522" (2013, 11, 2, 2, 46, 51) function-extrapolation-python 1.04891 "BENCH: 1.04890799522" (2013, 11, 2, 2, 46, 52) function-interpolation-python 1.66781 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 2, 2, 46, 52) function-interpolation-python 0.973919 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 2, 2, 47, 21) la-vector-access-cpp 28.4543 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 2, 2, 47, 48) la-vector-assignment-cpp 27.163 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 3, 2, 24, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0751 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 3, 2, 24, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5087 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 3, 2, 25, 9) geometry-bounding_box_tree_build-cpp 13.9049 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 3, 2, 25, 40) common-progress-cpp 31.4159 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 3, 2, 26, 11) common-timing-cpp 31.1207 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 3, 2, 29, 35) fem-multicore-cpp 204.213 "Coloring mesh." (2013, 11, 3, 2, 32, 7) fem-assembly-cpp 151.322 "Assembly for various forms and backends" (2013, 11, 3, 2, 32, 21) fem-convergence-cpp 14.2214 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 3, 2, 32, 23) fem-jit-python 0.0010494 "JIT compilation (in memory cache)" (2013, 11, 3, 2, 40, 24) mesh-refinement-cpp 20.1594 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 3, 2, 40, 44) mesh-topology-cpp 19.866 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 3, 2, 41, 8) mesh-unitcube-cpp 24.2032 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 3, 2, 41, 47) mesh-iteration-cpp 36.7267 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 3, 2, 42, 9) function-evaluation-cpp 21.0537 "Evaluations of functions at arbitrary points." (2013, 11, 3, 2, 42, 9) function-evaluation-cpp 20.9578 "Evaluations of functions at arbitrary points." (2013, 11, 3, 2, 42, 12) function-extrapolation-python 3.53771 "BENCH: 1.07924699783" (2013, 11, 3, 2, 42, 12) function-extrapolation-python 1.07925 "BENCH: 1.07924699783" (2013, 11, 3, 2, 42, 14) function-interpolation-python 1.68781 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 3, 2, 42, 14) function-interpolation-python 0.97136 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 3, 2, 42, 37) la-vector-access-cpp 23.4411 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 3, 2, 43, 5) la-vector-assignment-cpp 27.2244 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 4, 2, 32, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0128 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 4, 2, 32, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6417 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 4, 2, 33, 15) geometry-bounding_box_tree_build-cpp 13.9693 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 4, 2, 33, 42) common-progress-cpp 27.6588 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 4, 2, 34, 15) common-timing-cpp 32.4599 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 4, 2, 37, 39) fem-multicore-cpp 204.396 "Coloring mesh." (2013, 11, 4, 2, 40, 12) fem-assembly-cpp 152.316 "Assembly for various forms and backends" (2013, 11, 4, 2, 40, 26) fem-convergence-cpp 14.2039 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 4, 2, 40, 28) fem-jit-python 0.00106471 "JIT compilation (in memory cache)" (2013, 11, 4, 2, 48, 30) mesh-refinement-cpp 20.0573 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 4, 2, 48, 50) mesh-topology-cpp 19.9124 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 4, 2, 49, 14) mesh-unitcube-cpp 24.3509 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 4, 2, 50, 0) mesh-iteration-cpp 43.5606 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 4, 2, 50, 21) function-evaluation-cpp 21.0128 "Evaluations of functions at arbitrary points." (2013, 11, 4, 2, 50, 21) function-evaluation-cpp 20.9173 "Evaluations of functions at arbitrary points." (2013, 11, 4, 2, 50, 25) function-extrapolation-python 3.50523 "BENCH: 1.04606413841" (2013, 11, 4, 2, 50, 25) function-extrapolation-python 1.04606 "BENCH: 1.04606413841" (2013, 11, 4, 2, 50, 27) function-interpolation-python 1.69143 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 4, 2, 50, 27) function-interpolation-python 0.976129 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 4, 2, 50, 52) la-vector-access-cpp 25.4321 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 4, 2, 51, 19) la-vector-assignment-cpp 27.0416 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 5, 2, 22, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1363 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 5, 2, 22, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5872 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 5, 2, 22, 59) geometry-bounding_box_tree_build-cpp 13.9249 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 5, 2, 23, 27) common-progress-cpp 27.6552 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 5, 2, 23, 58) common-timing-cpp 31.3317 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 5, 2, 27, 22) fem-multicore-cpp 204.362 "Coloring mesh." (2013, 11, 5, 2, 29, 54) fem-assembly-cpp 151.695 "Assembly for various forms and backends" (2013, 11, 5, 2, 30, 8) fem-convergence-cpp 14.2175 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 5, 2, 30, 10) fem-jit-python 0.0010561 "JIT compilation (in memory cache)" (2013, 11, 5, 2, 38, 8) mesh-refinement-cpp 20.0312 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 5, 2, 38, 28) mesh-topology-cpp 19.8619 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 5, 2, 38, 52) mesh-unitcube-cpp 24.161 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 5, 2, 39, 30) mesh-iteration-cpp 35.4846 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 5, 2, 39, 51) function-evaluation-cpp 21.0648 "Evaluations of functions at arbitrary points." (2013, 11, 5, 2, 39, 51) function-evaluation-cpp 20.9739 "Evaluations of functions at arbitrary points." (2013, 11, 5, 2, 39, 55) function-extrapolation-python 3.52771 "BENCH: 1.04784202576" (2013, 11, 5, 2, 39, 55) function-extrapolation-python 1.04784 "BENCH: 1.04784202576" (2013, 11, 5, 2, 39, 57) function-interpolation-python 1.67427 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 5, 2, 39, 57) function-interpolation-python 0.967395 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 5, 2, 40, 20) la-vector-access-cpp 23.4703 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 5, 2, 40, 47) la-vector-assignment-cpp 27.096 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 6, 2, 26, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.146 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 6, 2, 27, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.85 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 6, 2, 27, 21) geometry-bounding_box_tree_build-cpp 13.9405 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 6, 2, 27, 49) common-progress-cpp 27.6666 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 6, 2, 28, 21) common-timing-cpp 31.7748 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 6, 2, 31, 44) fem-multicore-cpp 203.879 "Coloring mesh." (2013, 11, 6, 2, 34, 16) fem-assembly-cpp 151.773 "Assembly for various forms and backends" (2013, 11, 6, 2, 34, 30) fem-convergence-cpp 14.214 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 6, 2, 34, 32) fem-jit-python 0.00104961 "JIT compilation (in memory cache)" (2013, 11, 6, 2, 42, 35) mesh-refinement-cpp 20.0232 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 6, 2, 42, 56) mesh-topology-cpp 19.9816 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 6, 2, 43, 20) mesh-unitcube-cpp 24.2015 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 6, 2, 43, 58) mesh-iteration-cpp 35.4905 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 6, 2, 44, 19) function-evaluation-cpp 21.1803 "Evaluations of functions at arbitrary points." (2013, 11, 6, 2, 44, 19) function-evaluation-cpp 21.0873 "Evaluations of functions at arbitrary points." (2013, 11, 6, 2, 44, 23) function-extrapolation-python 3.48604 "BENCH: 1.02658700943" (2013, 11, 6, 2, 44, 23) function-extrapolation-python 1.02659 "BENCH: 1.02658700943" (2013, 11, 6, 2, 44, 24) function-interpolation-python 1.64104 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 6, 2, 44, 24) function-interpolation-python 0.969151 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 6, 2, 44, 48) la-vector-access-cpp 23.4568 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 6, 2, 45, 15) la-vector-assignment-cpp 27.1048 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 7, 2, 28, 27) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.083 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 7, 2, 28, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9419 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 7, 2, 29, 3) geometry-bounding_box_tree_build-cpp 13.9396 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 7, 2, 29, 31) common-progress-cpp 27.6653 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 7, 2, 30, 2) common-timing-cpp 31.0078 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 7, 2, 33, 26) fem-multicore-cpp 204.022 "Coloring mesh." (2013, 11, 7, 2, 35, 58) fem-assembly-cpp 152.049 "Assembly for various forms and backends" (2013, 11, 7, 2, 36, 12) fem-convergence-cpp 14.2119 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 7, 2, 36, 14) fem-jit-python 0.00104651 "JIT compilation (in memory cache)" (2013, 11, 7, 2, 44, 14) mesh-refinement-cpp 20.0308 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 7, 2, 44, 34) mesh-topology-cpp 19.9358 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 7, 2, 44, 59) mesh-unitcube-cpp 24.3146 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 7, 2, 45, 46) mesh-iteration-cpp 44.2042 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 7, 2, 46, 7) function-evaluation-cpp 21.0613 "Evaluations of functions at arbitrary points." (2013, 11, 7, 2, 46, 7) function-evaluation-cpp 20.9252 "Evaluations of functions at arbitrary points." (2013, 11, 7, 2, 46, 10) function-extrapolation-python 3.61894 "BENCH: 1.05936098099" (2013, 11, 7, 2, 46, 10) function-extrapolation-python 1.05936 "BENCH: 1.05936098099" (2013, 11, 7, 2, 46, 12) function-interpolation-python 1.66783 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 7, 2, 46, 12) function-interpolation-python 0.970193 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 7, 2, 46, 35) la-vector-access-cpp 23.4596 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 7, 2, 47, 3) la-vector-assignment-cpp 27.0996 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 8, 2, 34, 4) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1191 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 8, 2, 34, 24) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8712 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 8, 2, 34, 40) geometry-bounding_box_tree_build-cpp 13.9123 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 8, 2, 35, 8) common-progress-cpp 27.6682 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 8, 2, 35, 39) common-timing-cpp 30.9854 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 8, 2, 39, 3) fem-multicore-cpp 204.384 "Coloring mesh." (2013, 11, 8, 2, 41, 35) fem-assembly-cpp 151.628 "Assembly for various forms and backends" (2013, 11, 8, 2, 41, 49) fem-convergence-cpp 14.2191 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 8, 2, 41, 51) fem-jit-python 0.00104909 "JIT compilation (in memory cache)" (2013, 11, 8, 2, 49, 51) mesh-refinement-cpp 20.0348 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 8, 2, 50, 11) mesh-topology-cpp 19.8633 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 8, 2, 50, 35) mesh-unitcube-cpp 24.2126 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 8, 2, 51, 21) mesh-iteration-cpp 43.5683 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 8, 2, 51, 42) function-evaluation-cpp 21.0023 "Evaluations of functions at arbitrary points." (2013, 11, 8, 2, 51, 42) function-evaluation-cpp 20.9067 "Evaluations of functions at arbitrary points." (2013, 11, 8, 2, 51, 46) function-extrapolation-python 3.50103 "BENCH: 1.04474496841" (2013, 11, 8, 2, 51, 46) function-extrapolation-python 1.04474 "BENCH: 1.04474496841" (2013, 11, 8, 2, 51, 48) function-interpolation-python 1.65167 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 8, 2, 51, 48) function-interpolation-python 0.971233 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 8, 2, 52, 11) la-vector-access-cpp 23.4499 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 8, 2, 52, 38) la-vector-assignment-cpp 27.4007 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 9, 2, 27, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0884 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 9, 2, 27, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5868 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 9, 2, 28, 7) geometry-bounding_box_tree_build-cpp 13.9412 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 9, 2, 28, 35) common-progress-cpp 27.6679 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 9, 2, 29, 6) common-timing-cpp 31.4171 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 9, 2, 32, 30) fem-multicore-cpp 204.112 "Coloring mesh." (2013, 11, 9, 2, 35, 2) fem-assembly-cpp 151.47 "Assembly for various forms and backends" (2013, 11, 9, 2, 35, 16) fem-convergence-cpp 14.2269 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 9, 2, 35, 18) fem-jit-python 0.00105228 "JIT compilation (in memory cache)" (2013, 11, 9, 2, 43, 19) mesh-refinement-cpp 20.062 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 9, 2, 43, 39) mesh-topology-cpp 19.851 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 9, 2, 44, 3) mesh-unitcube-cpp 24.2165 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 9, 2, 44, 50) mesh-iteration-cpp 44.1985 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 9, 2, 45, 11) function-evaluation-cpp 21.0408 "Evaluations of functions at arbitrary points." (2013, 11, 9, 2, 45, 11) function-evaluation-cpp 20.9454 "Evaluations of functions at arbitrary points." (2013, 11, 9, 2, 45, 14) function-extrapolation-python 3.43958 "BENCH: 1.05045986176" (2013, 11, 9, 2, 45, 14) function-extrapolation-python 1.05046 "BENCH: 1.05045986176" (2013, 11, 9, 2, 45, 16) function-interpolation-python 1.67412 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 9, 2, 45, 16) function-interpolation-python 0.969179 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 9, 2, 45, 39) la-vector-access-cpp 23.4419 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 9, 2, 46, 6) la-vector-assignment-cpp 27.086 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 10, 2, 24, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0732 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 10, 2, 24, 45) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6512 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 10, 2, 25, 1) geometry-bounding_box_tree_build-cpp 13.9146 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 10, 2, 25, 29) common-progress-cpp 27.6655 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 10, 2, 26, 0) common-timing-cpp 30.7664 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 10, 2, 29, 24) fem-multicore-cpp 204.318 "Coloring mesh." (2013, 11, 10, 2, 31, 56) fem-assembly-cpp 152.211 "Assembly for various forms and backends" (2013, 11, 10, 2, 32, 10) fem-convergence-cpp 14.2278 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 10, 2, 32, 12) fem-jit-python 0.0010565 "JIT compilation (in memory cache)" (2013, 11, 10, 2, 40, 13) mesh-refinement-cpp 20.0813 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 10, 2, 40, 33) mesh-topology-cpp 19.865 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 10, 2, 40, 58) mesh-unitcube-cpp 24.208 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 10, 2, 41, 36) mesh-iteration-cpp 35.4223 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 10, 2, 41, 57) function-evaluation-cpp 21.1101 "Evaluations of functions at arbitrary points." (2013, 11, 10, 2, 41, 57) function-evaluation-cpp 21.0037 "Evaluations of functions at arbitrary points." (2013, 11, 10, 2, 42, 0) function-extrapolation-python 3.5694 "BENCH: 1.05070614815" (2013, 11, 10, 2, 42, 0) function-extrapolation-python 1.05071 "BENCH: 1.05070614815" (2013, 11, 10, 2, 42, 2) function-interpolation-python 1.69483 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 10, 2, 42, 2) function-interpolation-python 0.97506 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 10, 2, 42, 25) la-vector-access-cpp 23.4422 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 10, 2, 42, 53) la-vector-assignment-cpp 27.0875 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 11, 2, 42, 9) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0795 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 11, 2, 42, 28) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6182 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 11, 2, 42, 44) geometry-bounding_box_tree_build-cpp 13.89 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 11, 2, 43, 12) common-progress-cpp 27.7012 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 11, 2, 43, 43) common-timing-cpp 31.3255 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 11, 2, 47, 7) fem-multicore-cpp 203.826 "Coloring mesh." (2013, 11, 11, 2, 49, 39) fem-assembly-cpp 152.21 "Assembly for various forms and backends" (2013, 11, 11, 2, 49, 53) fem-convergence-cpp 14.2022 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 11, 2, 49, 55) fem-jit-python 0.0010504 "JIT compilation (in memory cache)" (2013, 11, 11, 2, 57, 55) mesh-refinement-cpp 20.054 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 11, 2, 58, 15) mesh-topology-cpp 19.8344 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 11, 2, 58, 39) mesh-unitcube-cpp 24.2141 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 11, 2, 59, 17) mesh-iteration-cpp 35.4805 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 11, 2, 59, 38) function-evaluation-cpp 21.0438 "Evaluations of functions at arbitrary points." (2013, 11, 11, 2, 59, 38) function-evaluation-cpp 20.9478 "Evaluations of functions at arbitrary points." (2013, 11, 11, 2, 59, 41) function-extrapolation-python 3.42945 "BENCH: 1.05228090286" (2013, 11, 11, 2, 59, 41) function-extrapolation-python 1.05228 "BENCH: 1.05228090286" (2013, 11, 11, 2, 59, 43) function-interpolation-python 1.65882 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 11, 2, 59, 43) function-interpolation-python 0.975693 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 11, 3, 0, 7) la-vector-access-cpp 23.4308 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 11, 3, 0, 34) la-vector-assignment-cpp 27.0493 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 12, 2, 28, 6) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1824 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 12, 2, 28, 25) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7069 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 12, 2, 28, 41) geometry-bounding_box_tree_build-cpp 13.9467 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 12, 2, 29, 9) common-progress-cpp 27.7012 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 12, 2, 29, 40) common-timing-cpp 31.0411 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 12, 2, 33, 4) fem-multicore-cpp 204.167 "Coloring mesh." (2013, 11, 12, 2, 35, 36) fem-assembly-cpp 151.626 "Assembly for various forms and backends" (2013, 11, 12, 2, 35, 50) fem-convergence-cpp 14.2098 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 12, 2, 35, 52) fem-jit-python 0.00106621 "JIT compilation (in memory cache)" (2013, 11, 12, 2, 43, 52) mesh-refinement-cpp 20.0192 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 12, 2, 44, 12) mesh-topology-cpp 19.8869 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 12, 2, 44, 37) mesh-unitcube-cpp 24.2521 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 12, 2, 45, 15) mesh-iteration-cpp 35.493 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 12, 2, 45, 36) function-evaluation-cpp 21.0607 "Evaluations of functions at arbitrary points." (2013, 11, 12, 2, 45, 36) function-evaluation-cpp 20.9563 "Evaluations of functions at arbitrary points." (2013, 11, 12, 2, 45, 39) function-extrapolation-python 3.52914 "BENCH: 1.04079508781" (2013, 11, 12, 2, 45, 39) function-extrapolation-python 1.0408 "BENCH: 1.04079508781" (2013, 11, 12, 2, 45, 41) function-interpolation-python 1.66768 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 12, 2, 45, 41) function-interpolation-python 0.973944 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 12, 2, 46, 5) la-vector-access-cpp 23.4468 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 12, 2, 46, 32) la-vector-assignment-cpp 27.0877 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 13, 2, 32, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1313 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 13, 2, 33, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5321 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 13, 2, 33, 21) geometry-bounding_box_tree_build-cpp 13.9165 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 13, 2, 33, 48) common-progress-cpp 27.7034 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 13, 2, 34, 20) common-timing-cpp 31.705 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 13, 2, 37, 44) fem-multicore-cpp 203.949 "Coloring mesh." (2013, 11, 13, 2, 40, 16) fem-assembly-cpp 151.425 "Assembly for various forms and backends" (2013, 11, 13, 2, 40, 30) fem-convergence-cpp 14.2117 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 13, 2, 40, 32) fem-jit-python 0.0010504 "JIT compilation (in memory cache)" (2013, 11, 13, 2, 48, 33) mesh-refinement-cpp 20.0361 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 13, 2, 48, 53) mesh-topology-cpp 19.8867 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 13, 2, 49, 17) mesh-unitcube-cpp 24.2487 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 13, 2, 50, 4) mesh-iteration-cpp 44.1841 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 13, 2, 50, 25) function-evaluation-cpp 21.0707 "Evaluations of functions at arbitrary points." (2013, 11, 13, 2, 50, 25) function-evaluation-cpp 20.9674 "Evaluations of functions at arbitrary points." (2013, 11, 13, 2, 50, 28) function-extrapolation-python 3.53923 "BENCH: 1.04507184029" (2013, 11, 13, 2, 50, 28) function-extrapolation-python 1.04507 "BENCH: 1.04507184029" (2013, 11, 13, 2, 50, 30) function-interpolation-python 1.70151 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 13, 2, 50, 30) function-interpolation-python 0.980131 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 13, 2, 50, 55) la-vector-access-cpp 25.4493 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 13, 2, 51, 24) la-vector-assignment-cpp 28.1173 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 14, 2, 35, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0542 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 14, 2, 35, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5163 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 14, 2, 36, 8) geometry-bounding_box_tree_build-cpp 13.9189 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 14, 2, 36, 35) common-progress-cpp 27.6665 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 14, 2, 37, 6) common-timing-cpp 30.8118 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 14, 2, 40, 30) fem-multicore-cpp 204.176 "Coloring mesh." (2013, 11, 14, 2, 43, 2) fem-assembly-cpp 151.949 "Assembly for various forms and backends" (2013, 11, 14, 2, 43, 16) fem-convergence-cpp 14.2085 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 14, 2, 43, 18) fem-jit-python 0.0010536 "JIT compilation (in memory cache)" (2013, 11, 14, 2, 51, 22) mesh-refinement-cpp 20.0292 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 14, 2, 51, 41) mesh-topology-cpp 19.8912 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 14, 2, 52, 6) mesh-unitcube-cpp 24.2423 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 14, 2, 52, 52) mesh-iteration-cpp 43.5676 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 14, 2, 53, 13) function-evaluation-cpp 21.1988 "Evaluations of functions at arbitrary points." (2013, 11, 14, 2, 53, 13) function-evaluation-cpp 21.1249 "Evaluations of functions at arbitrary points." (2013, 11, 14, 2, 53, 16) function-extrapolation-python 3.3364 "BENCH: 1.04505085945" (2013, 11, 14, 2, 53, 16) function-extrapolation-python 1.04505 "BENCH: 1.04505085945" (2013, 11, 14, 2, 53, 18) function-interpolation-python 1.67961 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 14, 2, 53, 18) function-interpolation-python 0.971674 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 14, 2, 53, 41) la-vector-access-cpp 23.4427 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 14, 2, 54, 9) la-vector-assignment-cpp 27.0833 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 15, 2, 26, 18) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1446 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 15, 2, 26, 37) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8595 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 15, 2, 26, 54) geometry-bounding_box_tree_build-cpp 13.9337 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 15, 2, 27, 21) common-progress-cpp 27.6656 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 15, 2, 27, 53) common-timing-cpp 31.9143 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 15, 2, 31, 18) fem-multicore-cpp 204.489 "Coloring mesh." (2013, 11, 15, 2, 33, 50) fem-assembly-cpp 152.038 "Assembly for various forms and backends" (2013, 11, 15, 2, 34, 4) fem-convergence-cpp 14.2097 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 15, 2, 34, 6) fem-jit-python 0.0010699 "JIT compilation (in memory cache)" (2013, 11, 15, 2, 42, 8) mesh-refinement-cpp 20.0424 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 15, 2, 42, 28) mesh-topology-cpp 19.8497 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 15, 2, 42, 52) mesh-unitcube-cpp 24.2827 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 15, 2, 43, 38) mesh-iteration-cpp 43.5616 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 15, 2, 43, 59) function-evaluation-cpp 21.0429 "Evaluations of functions at arbitrary points." (2013, 11, 15, 2, 43, 59) function-evaluation-cpp 20.9468 "Evaluations of functions at arbitrary points." (2013, 11, 15, 2, 44, 3) function-extrapolation-python 3.5061 "BENCH: 1.04563903809" (2013, 11, 15, 2, 44, 3) function-extrapolation-python 1.04564 "BENCH: 1.04563903809" (2013, 11, 15, 2, 44, 4) function-interpolation-python 1.67044 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 15, 2, 44, 4) function-interpolation-python 0.972305 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 15, 2, 44, 29) la-vector-access-cpp 24.9043 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 15, 2, 44, 58) la-vector-assignment-cpp 29.0686 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 16, 2, 32, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1574 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 16, 2, 32, 48) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8384 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 16, 2, 33, 5) geometry-bounding_box_tree_build-cpp 13.9222 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 16, 2, 33, 33) common-progress-cpp 28.307 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 16, 2, 34, 4) common-timing-cpp 31.1348 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 16, 2, 37, 29) fem-multicore-cpp 204.675 "Coloring mesh." (2013, 11, 16, 2, 40, 0) fem-assembly-cpp 151.583 "Assembly for various forms and backends" (2013, 11, 16, 2, 40, 15) fem-convergence-cpp 14.2079 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 16, 2, 40, 17) fem-jit-python 0.0010488 "JIT compilation (in memory cache)" (2013, 11, 16, 2, 48, 17) mesh-refinement-cpp 20.1198 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 16, 2, 48, 37) mesh-topology-cpp 19.9085 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 16, 2, 49, 1) mesh-unitcube-cpp 24.2244 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 16, 2, 49, 40) mesh-iteration-cpp 35.9709 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 16, 2, 50, 1) function-evaluation-cpp 21.385 "Evaluations of functions at arbitrary points." (2013, 11, 16, 2, 50, 1) function-evaluation-cpp 21.2795 "Evaluations of functions at arbitrary points." (2013, 11, 16, 2, 50, 5) function-extrapolation-python 3.57104 "BENCH: 1.05328798294" (2013, 11, 16, 2, 50, 5) function-extrapolation-python 1.05329 "BENCH: 1.05328798294" (2013, 11, 16, 2, 50, 7) function-interpolation-python 1.66673 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 16, 2, 50, 7) function-interpolation-python 0.971936 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 16, 2, 50, 30) la-vector-access-cpp 23.4464 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 16, 2, 50, 57) la-vector-assignment-cpp 27.081 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 17, 2, 28, 18) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2376 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 17, 2, 28, 37) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7833 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 17, 2, 28, 54) geometry-bounding_box_tree_build-cpp 13.9403 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 17, 2, 29, 21) common-progress-cpp 27.6565 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 17, 2, 29, 53) common-timing-cpp 31.5266 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 17, 2, 33, 17) fem-multicore-cpp 204.333 "Coloring mesh." (2013, 11, 17, 2, 35, 49) fem-assembly-cpp 151.735 "Assembly for various forms and backends" (2013, 11, 17, 2, 36, 3) fem-convergence-cpp 14.1984 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 17, 2, 36, 5) fem-jit-python 0.00104702 "JIT compilation (in memory cache)" (2013, 11, 17, 2, 44, 8) mesh-refinement-cpp 20.029 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 17, 2, 44, 28) mesh-topology-cpp 19.849 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 17, 2, 44, 52) mesh-unitcube-cpp 24.1579 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 17, 2, 45, 38) mesh-iteration-cpp 43.5552 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 17, 2, 45, 59) function-evaluation-cpp 21.0365 "Evaluations of functions at arbitrary points." (2013, 11, 17, 2, 45, 59) function-evaluation-cpp 20.9436 "Evaluations of functions at arbitrary points." (2013, 11, 17, 2, 46, 3) function-extrapolation-python 3.58052 "BENCH: 1.04013609886" (2013, 11, 17, 2, 46, 3) function-extrapolation-python 1.04014 "BENCH: 1.04013609886" (2013, 11, 17, 2, 46, 5) function-interpolation-python 1.65869 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 17, 2, 46, 5) function-interpolation-python 0.972991 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 17, 2, 46, 28) la-vector-access-cpp 23.4784 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 17, 2, 46, 56) la-vector-assignment-cpp 28.2309 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 18, 2, 32, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2366 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 18, 2, 32, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6157 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 18, 2, 32, 55) geometry-bounding_box_tree_build-cpp 13.9411 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 18, 2, 33, 23) common-progress-cpp 27.6666 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 18, 2, 33, 54) common-timing-cpp 31.1714 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 18, 2, 37, 19) fem-multicore-cpp 204.398 "Coloring mesh." (2013, 11, 18, 2, 39, 50) fem-assembly-cpp 151.792 "Assembly for various forms and backends" (2013, 11, 18, 2, 40, 5) fem-convergence-cpp 14.2037 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 18, 2, 40, 7) fem-jit-python 0.00104761 "JIT compilation (in memory cache)" (2013, 11, 18, 2, 48, 8) mesh-refinement-cpp 19.9929 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 18, 2, 48, 28) mesh-topology-cpp 19.8496 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 18, 2, 48, 53) mesh-unitcube-cpp 24.1785 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 18, 2, 49, 31) mesh-iteration-cpp 35.4885 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 18, 2, 49, 52) function-evaluation-cpp 21.1433 "Evaluations of functions at arbitrary points." (2013, 11, 18, 2, 49, 52) function-evaluation-cpp 21.0442 "Evaluations of functions at arbitrary points." (2013, 11, 18, 2, 49, 55) function-extrapolation-python 3.41244 "BENCH: 1.03689599037" (2013, 11, 18, 2, 49, 55) function-extrapolation-python 1.0369 "BENCH: 1.03689599037" (2013, 11, 18, 2, 49, 57) function-interpolation-python 1.65454 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 18, 2, 49, 57) function-interpolation-python 0.978387 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 18, 2, 50, 21) la-vector-access-cpp 23.4755 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 18, 2, 50, 48) la-vector-assignment-cpp 27.0103 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 19, 2, 25, 22) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1097 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 19, 2, 25, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9976 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 19, 2, 25, 58) geometry-bounding_box_tree_build-cpp 13.9148 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 19, 2, 26, 26) common-progress-cpp 27.6649 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 19, 2, 26, 58) common-timing-cpp 31.9418 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 19, 2, 30, 22) fem-multicore-cpp 204.005 "Coloring mesh." (2013, 11, 19, 2, 32, 54) fem-assembly-cpp 152.073 "Assembly for various forms and backends" (2013, 11, 19, 2, 33, 8) fem-convergence-cpp 14.2149 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 19, 2, 33, 10) fem-jit-python 0.0010484 "JIT compilation (in memory cache)" (2013, 11, 19, 2, 41, 12) mesh-refinement-cpp 20.1492 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 19, 2, 41, 31) mesh-topology-cpp 19.8813 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 19, 2, 41, 56) mesh-unitcube-cpp 24.4398 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 19, 2, 42, 34) mesh-iteration-cpp 35.4931 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 19, 2, 42, 55) function-evaluation-cpp 21.0096 "Evaluations of functions at arbitrary points." (2013, 11, 19, 2, 42, 55) function-evaluation-cpp 20.9135 "Evaluations of functions at arbitrary points." (2013, 11, 19, 2, 42, 58) function-extrapolation-python 3.5092 "BENCH: 1.06636595726" (2013, 11, 19, 2, 42, 58) function-extrapolation-python 1.06637 "BENCH: 1.06636595726" (2013, 11, 19, 2, 43, 0) function-interpolation-python 1.67739 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 19, 2, 43, 0) function-interpolation-python 0.967599 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 19, 2, 43, 24) la-vector-access-cpp 23.4344 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 19, 2, 43, 51) la-vector-assignment-cpp 27.0916 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 20, 2, 40, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1298 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 20, 2, 40, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6133 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 20, 2, 40, 57) geometry-bounding_box_tree_build-cpp 13.9228 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 20, 2, 41, 24) common-progress-cpp 27.666 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 20, 2, 41, 56) common-timing-cpp 31.3131 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 20, 2, 45, 20) fem-multicore-cpp 204.163 "Coloring mesh." (2013, 11, 20, 2, 47, 52) fem-assembly-cpp 151.902 "Assembly for various forms and backends" (2013, 11, 20, 2, 48, 6) fem-convergence-cpp 14.1959 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 20, 2, 48, 8) fem-jit-python 0.00106039 "JIT compilation (in memory cache)" (2013, 11, 20, 2, 56, 11) mesh-refinement-cpp 20.0212 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 20, 2, 56, 31) mesh-topology-cpp 19.8433 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 20, 2, 56, 55) mesh-unitcube-cpp 24.2406 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 20, 2, 57, 33) mesh-iteration-cpp 35.5059 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 20, 2, 57, 54) function-evaluation-cpp 21.0478 "Evaluations of functions at arbitrary points." (2013, 11, 20, 2, 57, 54) function-evaluation-cpp 20.9529 "Evaluations of functions at arbitrary points." (2013, 11, 20, 2, 57, 57) function-extrapolation-python 3.44614 "BENCH: 1.05194282532" (2013, 11, 20, 2, 57, 57) function-extrapolation-python 1.05194 "BENCH: 1.05194282532" (2013, 11, 20, 2, 57, 59) function-interpolation-python 1.67498 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 20, 2, 57, 59) function-interpolation-python 0.973174 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 20, 2, 58, 25) la-vector-access-cpp 25.4458 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 20, 2, 58, 52) la-vector-assignment-cpp 27.2393 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 21, 2, 24, 20) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1057 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 21, 2, 24, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6146 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 21, 2, 24, 56) geometry-bounding_box_tree_build-cpp 13.9242 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 21, 2, 25, 24) common-progress-cpp 27.6672 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 21, 2, 25, 55) common-timing-cpp 31.0778 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 21, 2, 29, 19) fem-multicore-cpp 204.161 "Coloring mesh." (2013, 11, 21, 2, 31, 51) fem-assembly-cpp 152.121 "Assembly for various forms and backends" (2013, 11, 21, 2, 32, 5) fem-convergence-cpp 14.22 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 21, 2, 32, 7) fem-jit-python 0.0010556 "JIT compilation (in memory cache)" (2013, 11, 21, 2, 40, 8) mesh-refinement-cpp 20.1132 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 21, 2, 40, 28) mesh-topology-cpp 19.8701 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 21, 2, 40, 52) mesh-unitcube-cpp 24.2193 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 21, 2, 41, 34) mesh-iteration-cpp 39.1731 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 21, 2, 41, 55) function-evaluation-cpp 21.0675 "Evaluations of functions at arbitrary points." (2013, 11, 21, 2, 41, 55) function-evaluation-cpp 20.9632 "Evaluations of functions at arbitrary points." (2013, 11, 21, 2, 41, 58) function-extrapolation-python 3.42943 "BENCH: 1.04349899292" (2013, 11, 21, 2, 41, 58) function-extrapolation-python 1.0435 "BENCH: 1.04349899292" (2013, 11, 21, 2, 42, 0) function-interpolation-python 1.68277 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 21, 2, 42, 0) function-interpolation-python 0.965812 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 21, 2, 42, 23) la-vector-access-cpp 23.4239 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 21, 2, 42, 51) la-vector-assignment-cpp 27.0914 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 22, 2, 26, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1144 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 22, 2, 27, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6123 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 22, 2, 27, 24) geometry-bounding_box_tree_build-cpp 13.9129 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 22, 2, 27, 52) common-progress-cpp 27.6663 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 22, 2, 28, 24) common-timing-cpp 31.5368 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 22, 2, 31, 48) fem-multicore-cpp 204.6 "Coloring mesh." (2013, 11, 22, 2, 34, 20) fem-assembly-cpp 151.457 "Assembly for various forms and backends" (2013, 11, 22, 2, 34, 34) fem-convergence-cpp 14.2149 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 22, 2, 34, 36) fem-jit-python 0.00105669 "JIT compilation (in memory cache)" (2013, 11, 22, 2, 42, 38) mesh-refinement-cpp 20.0123 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 22, 2, 42, 57) mesh-topology-cpp 19.8496 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 22, 2, 43, 22) mesh-unitcube-cpp 24.2328 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 22, 2, 44, 0) mesh-iteration-cpp 35.4895 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 22, 2, 44, 21) function-evaluation-cpp 21.0271 "Evaluations of functions at arbitrary points." (2013, 11, 22, 2, 44, 21) function-evaluation-cpp 20.9314 "Evaluations of functions at arbitrary points." (2013, 11, 22, 2, 44, 24) function-extrapolation-python 3.31815 "BENCH: 1.04382109642" (2013, 11, 22, 2, 44, 24) function-extrapolation-python 1.04382 "BENCH: 1.04382109642" (2013, 11, 22, 2, 44, 26) function-interpolation-python 1.65075 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 22, 2, 44, 26) function-interpolation-python 0.958864 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 22, 2, 44, 49) la-vector-access-cpp 23.4888 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 22, 2, 45, 17) la-vector-assignment-cpp 28.1142 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 23, 2, 28, 16) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1413 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 23, 2, 28, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6121 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 23, 2, 28, 52) geometry-bounding_box_tree_build-cpp 13.9208 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 23, 2, 29, 20) common-progress-cpp 27.6657 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 23, 2, 29, 51) common-timing-cpp 31.7788 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 23, 2, 33, 15) fem-multicore-cpp 203.99 "Coloring mesh." (2013, 11, 23, 2, 35, 47) fem-assembly-cpp 151.641 "Assembly for various forms and backends" (2013, 11, 23, 2, 36, 1) fem-convergence-cpp 14.1978 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 23, 2, 36, 3) fem-jit-python 0.001052 "JIT compilation (in memory cache)" (2013, 11, 23, 2, 44, 2) mesh-refinement-cpp 20.0403 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 23, 2, 44, 22) mesh-topology-cpp 19.8559 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 23, 2, 44, 46) mesh-unitcube-cpp 24.3186 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 23, 2, 45, 24) mesh-iteration-cpp 35.487 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 23, 2, 45, 45) function-evaluation-cpp 21.5045 "Evaluations of functions at arbitrary points." (2013, 11, 23, 2, 45, 45) function-evaluation-cpp 21.3998 "Evaluations of functions at arbitrary points." (2013, 11, 23, 2, 45, 49) function-extrapolation-python 3.47083 "BENCH: 1.06326293945" (2013, 11, 23, 2, 45, 49) function-extrapolation-python 1.06326 "BENCH: 1.06326293945" (2013, 11, 23, 2, 45, 51) function-interpolation-python 1.67477 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 23, 2, 45, 51) function-interpolation-python 0.970725 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 23, 2, 46, 16) la-vector-access-cpp 25.4465 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 23, 2, 46, 45) la-vector-assignment-cpp 29.1164 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 24, 2, 22, 2) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1417 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 24, 2, 22, 21) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9306 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 24, 2, 22, 38) geometry-bounding_box_tree_build-cpp 13.9119 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 24, 2, 23, 5) common-progress-cpp 27.6548 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 24, 2, 23, 36) common-timing-cpp 30.8113 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 24, 2, 27, 0) fem-multicore-cpp 204.032 "Coloring mesh." (2013, 11, 24, 2, 29, 32) fem-assembly-cpp 152.299 "Assembly for various forms and backends" (2013, 11, 24, 2, 29, 47) fem-convergence-cpp 14.2204 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 24, 2, 29, 49) fem-jit-python 0.00106931 "JIT compilation (in memory cache)" (2013, 11, 24, 2, 37, 54) mesh-refinement-cpp 20.1372 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 24, 2, 38, 14) mesh-topology-cpp 19.8709 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 24, 2, 38, 38) mesh-unitcube-cpp 24.1657 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 24, 2, 39, 16) mesh-iteration-cpp 35.4929 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 24, 2, 39, 37) function-evaluation-cpp 21.009 "Evaluations of functions at arbitrary points." (2013, 11, 24, 2, 39, 37) function-evaluation-cpp 20.917 "Evaluations of functions at arbitrary points." (2013, 11, 24, 2, 39, 41) function-extrapolation-python 3.52081 "BENCH: 1.03221297264" (2013, 11, 24, 2, 39, 41) function-extrapolation-python 1.03221 "BENCH: 1.03221297264" (2013, 11, 24, 2, 39, 42) function-interpolation-python 1.66349 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 24, 2, 39, 42) function-interpolation-python 0.970856 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 24, 2, 40, 8) la-vector-access-cpp 25.9655 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 24, 2, 40, 35) la-vector-assignment-cpp 27.1018 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 25, 2, 37, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1734 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 25, 2, 37, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6441 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 25, 2, 37, 58) geometry-bounding_box_tree_build-cpp 13.9273 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 25, 2, 38, 26) common-progress-cpp 27.6661 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 25, 2, 38, 58) common-timing-cpp 31.9567 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 25, 2, 42, 22) fem-multicore-cpp 204.425 "Coloring mesh." (2013, 11, 25, 2, 44, 54) fem-assembly-cpp 151.784 "Assembly for various forms and backends" (2013, 11, 25, 2, 45, 8) fem-convergence-cpp 14.1928 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 25, 2, 45, 10) fem-jit-python 0.001052 "JIT compilation (in memory cache)" (2013, 11, 25, 2, 53, 12) mesh-refinement-cpp 20.0296 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 25, 2, 53, 32) mesh-topology-cpp 19.8824 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 25, 2, 53, 56) mesh-unitcube-cpp 24.3423 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 25, 2, 54, 34) mesh-iteration-cpp 35.4888 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 25, 2, 54, 55) function-evaluation-cpp 21.0092 "Evaluations of functions at arbitrary points." (2013, 11, 25, 2, 54, 55) function-evaluation-cpp 20.9129 "Evaluations of functions at arbitrary points." (2013, 11, 25, 2, 54, 59) function-extrapolation-python 3.52712 "BENCH: 1.06823301315" (2013, 11, 25, 2, 54, 59) function-extrapolation-python 1.06823 "BENCH: 1.06823301315" (2013, 11, 25, 2, 55, 0) function-interpolation-python 1.66896 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 25, 2, 55, 0) function-interpolation-python 0.982672 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 25, 2, 55, 24) la-vector-access-cpp 23.4386 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 25, 2, 55, 53) la-vector-assignment-cpp 29.1133 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 26, 2, 34, 2) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1321 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 26, 2, 34, 21) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6575 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 26, 2, 34, 38) geometry-bounding_box_tree_build-cpp 13.9443 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 26, 2, 35, 6) common-progress-cpp 27.6658 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 26, 2, 35, 36) common-timing-cpp 30.8301 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 26, 2, 39, 1) fem-multicore-cpp 204.331 "Coloring mesh." (2013, 11, 26, 2, 41, 34) fem-assembly-cpp 152.692 "Assembly for various forms and backends" (2013, 11, 26, 2, 41, 48) fem-convergence-cpp 14.2685 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 26, 2, 41, 50) fem-jit-python 0.00109029 "JIT compilation (in memory cache)" (2013, 11, 26, 2, 49, 52) mesh-refinement-cpp 19.992 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 26, 2, 50, 12) mesh-topology-cpp 19.8687 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 26, 2, 50, 36) mesh-unitcube-cpp 24.195 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 26, 2, 51, 22) mesh-iteration-cpp 43.5638 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 26, 2, 51, 43) function-evaluation-cpp 21.0427 "Evaluations of functions at arbitrary points." (2013, 11, 26, 2, 51, 43) function-evaluation-cpp 20.9498 "Evaluations of functions at arbitrary points." (2013, 11, 26, 2, 51, 47) function-extrapolation-python 3.49615 "BENCH: 1.04934620857" (2013, 11, 26, 2, 51, 47) function-extrapolation-python 1.04935 "BENCH: 1.04934620857" (2013, 11, 26, 2, 51, 49) function-interpolation-python 1.64357 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 26, 2, 51, 49) function-interpolation-python 0.971371 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 26, 2, 52, 12) la-vector-access-cpp 23.46 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 26, 2, 52, 39) la-vector-assignment-cpp 27.0988 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 27, 2, 31, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1285 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 27, 2, 32, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.511 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 27, 2, 32, 17) geometry-bounding_box_tree_build-cpp 13.9401 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 27, 2, 32, 44) common-progress-cpp 27.6655 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 27, 2, 33, 16) common-timing-cpp 31.7784 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 27, 2, 36, 40) fem-multicore-cpp 204.171 "Coloring mesh." (2013, 11, 27, 2, 39, 13) fem-assembly-cpp 152.222 "Assembly for various forms and backends" (2013, 11, 27, 2, 39, 27) fem-convergence-cpp 14.267 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 27, 2, 39, 29) fem-jit-python 0.00104849 "JIT compilation (in memory cache)" (2013, 11, 27, 2, 47, 33) mesh-refinement-cpp 20.0079 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 27, 2, 47, 53) mesh-topology-cpp 19.8011 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 27, 2, 48, 17) mesh-unitcube-cpp 24.135 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 27, 2, 48, 55) mesh-iteration-cpp 35.4832 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 27, 2, 49, 17) function-evaluation-cpp 21.5628 "Evaluations of functions at arbitrary points." (2013, 11, 27, 2, 49, 17) function-evaluation-cpp 21.477 "Evaluations of functions at arbitrary points." (2013, 11, 27, 2, 49, 20) function-extrapolation-python 3.44595 "BENCH: 1.02978491783" (2013, 11, 27, 2, 49, 20) function-extrapolation-python 1.02978 "BENCH: 1.02978491783" (2013, 11, 27, 2, 49, 22) function-interpolation-python 1.6423 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 27, 2, 49, 22) function-interpolation-python 0.969616 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 27, 2, 49, 45) la-vector-access-cpp 23.449 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 27, 2, 50, 12) la-vector-assignment-cpp 27.0988 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 28, 2, 39, 54) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.181 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 28, 2, 40, 13) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4645 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 28, 2, 40, 30) geometry-bounding_box_tree_build-cpp 13.9943 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 28, 2, 40, 58) common-progress-cpp 27.7169 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 28, 2, 41, 30) common-timing-cpp 31.8142 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 28, 2, 44, 54) fem-multicore-cpp 204.198 "Coloring mesh." (2013, 11, 28, 2, 47, 25) fem-assembly-cpp 151.576 "Assembly for various forms and backends" (2013, 11, 28, 2, 47, 40) fem-convergence-cpp 14.207 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 28, 2, 47, 42) fem-jit-python 0.00105631 "JIT compilation (in memory cache)" (2013, 11, 28, 2, 55, 41) mesh-refinement-cpp 19.9669 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 28, 2, 56, 1) mesh-topology-cpp 19.841 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 28, 2, 56, 26) mesh-unitcube-cpp 24.2155 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 28, 2, 57, 4) mesh-iteration-cpp 35.4952 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 28, 2, 57, 25) function-evaluation-cpp 21.0928 "Evaluations of functions at arbitrary points." (2013, 11, 28, 2, 57, 25) function-evaluation-cpp 20.9608 "Evaluations of functions at arbitrary points." (2013, 11, 28, 2, 57, 28) function-extrapolation-python 3.49482 "BENCH: 1.03860902786" (2013, 11, 28, 2, 57, 28) function-extrapolation-python 1.03861 "BENCH: 1.03860902786" (2013, 11, 28, 2, 57, 30) function-interpolation-python 1.63964 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 28, 2, 57, 30) function-interpolation-python 0.967661 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 28, 2, 57, 53) la-vector-access-cpp 23.456 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 28, 2, 58, 21) la-vector-assignment-cpp 27.0962 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 29, 2, 41, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0635 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 29, 2, 42, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 16.1862 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 29, 2, 42, 26) geometry-bounding_box_tree_build-cpp 13.9665 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 29, 2, 42, 53) common-progress-cpp 27.667 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 29, 2, 43, 24) common-timing-cpp 30.9215 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 29, 2, 46, 49) fem-multicore-cpp 204.368 "Coloring mesh." (2013, 11, 29, 2, 49, 20) fem-assembly-cpp 151.699 "Assembly for various forms and backends" (2013, 11, 29, 2, 49, 35) fem-convergence-cpp 14.2139 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 29, 2, 49, 36) fem-jit-python 0.00106089 "JIT compilation (in memory cache)" (2013, 11, 29, 2, 57, 37) mesh-refinement-cpp 20.0503 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 29, 2, 57, 57) mesh-topology-cpp 19.9228 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 29, 2, 58, 22) mesh-unitcube-cpp 24.1819 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 29, 2, 59, 0) mesh-iteration-cpp 35.4965 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 29, 2, 59, 21) function-evaluation-cpp 21.0291 "Evaluations of functions at arbitrary points." (2013, 11, 29, 2, 59, 21) function-evaluation-cpp 20.8943 "Evaluations of functions at arbitrary points." (2013, 11, 29, 2, 59, 24) function-extrapolation-python 3.61987 "BENCH: 1.06337881088" (2013, 11, 29, 2, 59, 24) function-extrapolation-python 1.06338 "BENCH: 1.06337881088" (2013, 11, 29, 2, 59, 26) function-interpolation-python 1.66077 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 29, 2, 59, 26) function-interpolation-python 0.975817 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 29, 2, 59, 52) la-vector-access-cpp 26.0346 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 29, 3, 0, 19) la-vector-assignment-cpp 27.0896 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 11, 30, 2, 25, 16) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1443 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 30, 2, 25, 35) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5972 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 11, 30, 2, 25, 52) geometry-bounding_box_tree_build-cpp 13.9496 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 11, 30, 2, 26, 20) common-progress-cpp 27.6552 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 11, 30, 2, 26, 51) common-timing-cpp 31.5243 "Timing access and registration of timings (10000000 repetitions)" (2013, 11, 30, 2, 30, 15) fem-multicore-cpp 203.822 "Coloring mesh." (2013, 11, 30, 2, 32, 47) fem-assembly-cpp 151.801 "Assembly for various forms and backends" (2013, 11, 30, 2, 33, 1) fem-convergence-cpp 14.2145 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 11, 30, 2, 33, 3) fem-jit-python 0.00107179 "JIT compilation (in memory cache)" (2013, 11, 30, 2, 41, 4) mesh-refinement-cpp 20.0609 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 11, 30, 2, 41, 24) mesh-topology-cpp 19.8878 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 11, 30, 2, 41, 48) mesh-unitcube-cpp 24.2146 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 11, 30, 2, 42, 26) mesh-iteration-cpp 35.4347 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 11, 30, 2, 42, 47) function-evaluation-cpp 21.0376 "Evaluations of functions at arbitrary points." (2013, 11, 30, 2, 42, 47) function-evaluation-cpp 20.9419 "Evaluations of functions at arbitrary points." (2013, 11, 30, 2, 42, 50) function-extrapolation-python 3.48769 "BENCH: 1.0535941124" (2013, 11, 30, 2, 42, 50) function-extrapolation-python 1.05359 "BENCH: 1.0535941124" (2013, 11, 30, 2, 42, 52) function-interpolation-python 1.68338 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 30, 2, 42, 52) function-interpolation-python 0.968644 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 11, 30, 2, 43, 15) la-vector-access-cpp 23.4396 "Accessing vector of size 10000000 (100 repetitions)" (2013, 11, 30, 2, 43, 43) la-vector-assignment-cpp 27.0843 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 1, 2, 26, 53) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1328 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 1, 2, 27, 12) geometry-bounding_box_tree_compute_closest_entity-cpp 15.915 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 1, 2, 27, 28) geometry-bounding_box_tree_build-cpp 13.9498 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 1, 2, 27, 56) common-progress-cpp 27.6654 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 1, 2, 28, 27) common-timing-cpp 31.1224 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 1, 2, 31, 52) fem-multicore-cpp 204.485 "Coloring mesh." (2013, 12, 1, 2, 34, 24) fem-assembly-cpp 152.044 "Assembly for various forms and backends" (2013, 12, 1, 2, 34, 38) fem-convergence-cpp 14.2179 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 1, 2, 34, 40) fem-jit-python 0.00106142 "JIT compilation (in memory cache)" (2013, 12, 1, 2, 42, 44) mesh-refinement-cpp 19.9896 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 1, 2, 43, 3) mesh-topology-cpp 19.8575 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 1, 2, 43, 28) mesh-unitcube-cpp 24.2128 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 1, 2, 44, 6) mesh-iteration-cpp 35.4886 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 1, 2, 44, 27) function-evaluation-cpp 21.0736 "Evaluations of functions at arbitrary points." (2013, 12, 1, 2, 44, 27) function-evaluation-cpp 20.9788 "Evaluations of functions at arbitrary points." (2013, 12, 1, 2, 44, 30) function-extrapolation-python 3.48758 "BENCH: 1.05216908455" (2013, 12, 1, 2, 44, 30) function-extrapolation-python 1.05217 "BENCH: 1.05216908455" (2013, 12, 1, 2, 44, 32) function-interpolation-python 1.67526 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 1, 2, 44, 32) function-interpolation-python 0.975429 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 1, 2, 44, 56) la-vector-access-cpp 23.4687 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 1, 2, 45, 23) la-vector-assignment-cpp 27.2434 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 2, 2, 30, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1482 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 2, 2, 30, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.9859 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 2, 2, 30, 49) geometry-bounding_box_tree_build-cpp 13.8983 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 2, 2, 31, 21) common-progress-cpp 32.6692 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 2, 2, 31, 53) common-timing-cpp 31.3442 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 2, 2, 35, 17) fem-multicore-cpp 204.021 "Coloring mesh." (2013, 12, 2, 2, 37, 49) fem-assembly-cpp 151.803 "Assembly for various forms and backends" (2013, 12, 2, 2, 38, 3) fem-convergence-cpp 14.2129 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 2, 2, 38, 5) fem-jit-python 0.0010571 "JIT compilation (in memory cache)" (2013, 12, 2, 2, 46, 6) mesh-refinement-cpp 20.0066 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 2, 2, 46, 26) mesh-topology-cpp 19.8617 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 2, 2, 46, 51) mesh-unitcube-cpp 24.2151 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 2, 2, 47, 29) mesh-iteration-cpp 35.4835 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 2, 2, 47, 50) function-evaluation-cpp 21.0606 "Evaluations of functions at arbitrary points." (2013, 12, 2, 2, 47, 50) function-evaluation-cpp 20.9569 "Evaluations of functions at arbitrary points." (2013, 12, 2, 2, 47, 53) function-extrapolation-python 3.43774 "BENCH: 1.05160403252" (2013, 12, 2, 2, 47, 53) function-extrapolation-python 1.0516 "BENCH: 1.05160403252" (2013, 12, 2, 2, 47, 55) function-interpolation-python 1.64387 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 2, 2, 47, 55) function-interpolation-python 0.967753 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 2, 2, 48, 20) la-vector-access-cpp 24.9432 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 2, 2, 48, 47) la-vector-assignment-cpp 27.0871 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 3, 2, 23, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2029 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 3, 2, 23, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7367 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 3, 2, 24, 5) geometry-bounding_box_tree_build-cpp 13.9455 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 3, 2, 24, 33) common-progress-cpp 27.6543 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 3, 2, 25, 4) common-timing-cpp 31.501 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 3, 2, 28, 28) fem-multicore-cpp 203.745 "Coloring mesh." (2013, 12, 3, 2, 31, 0) fem-assembly-cpp 152.439 "Assembly for various forms and backends" (2013, 12, 3, 2, 31, 15) fem-convergence-cpp 14.2129 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 3, 2, 31, 17) fem-jit-python 0.00105081 "JIT compilation (in memory cache)" (2013, 12, 3, 2, 39, 20) mesh-refinement-cpp 20.0186 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 3, 2, 39, 40) mesh-topology-cpp 19.843 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 3, 2, 40, 5) mesh-unitcube-cpp 24.1698 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 3, 2, 40, 43) mesh-iteration-cpp 35.5197 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 3, 2, 41, 4) function-evaluation-cpp 21.7466 "Evaluations of functions at arbitrary points." (2013, 12, 3, 2, 41, 4) function-evaluation-cpp 21.645 "Evaluations of functions at arbitrary points." (2013, 12, 3, 2, 41, 8) function-extrapolation-python 3.48739 "BENCH: 1.0320110321" (2013, 12, 3, 2, 41, 8) function-extrapolation-python 1.03201 "BENCH: 1.0320110321" (2013, 12, 3, 2, 41, 10) function-interpolation-python 1.63149 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 3, 2, 41, 10) function-interpolation-python 0.967768 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 3, 2, 41, 33) la-vector-access-cpp 23.4725 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 3, 2, 42, 0) la-vector-assignment-cpp 27.0948 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 4, 2, 29, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1006 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 4, 2, 29, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5333 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 4, 2, 29, 58) geometry-bounding_box_tree_build-cpp 13.9283 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 4, 2, 30, 26) common-progress-cpp 27.6539 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 4, 2, 30, 59) common-timing-cpp 33.1281 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 4, 2, 34, 23) fem-multicore-cpp 204.079 "Coloring mesh." (2013, 12, 4, 2, 36, 55) fem-assembly-cpp 151.947 "Assembly for various forms and backends" (2013, 12, 4, 2, 37, 9) fem-convergence-cpp 14.1854 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 4, 2, 37, 11) fem-jit-python 0.00105569 "JIT compilation (in memory cache)" (2013, 12, 4, 2, 45, 15) mesh-refinement-cpp 20.0768 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 4, 2, 45, 35) mesh-topology-cpp 19.7484 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 4, 2, 45, 59) mesh-unitcube-cpp 24.2013 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 4, 2, 46, 37) mesh-iteration-cpp 35.492 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 4, 2, 46, 58) function-evaluation-cpp 21.0133 "Evaluations of functions at arbitrary points." (2013, 12, 4, 2, 46, 58) function-evaluation-cpp 20.9169 "Evaluations of functions at arbitrary points." (2013, 12, 4, 2, 47, 2) function-extrapolation-python 3.41167 "BENCH: 1.05474114418" (2013, 12, 4, 2, 47, 2) function-extrapolation-python 1.05474 "BENCH: 1.05474114418" (2013, 12, 4, 2, 47, 3) function-interpolation-python 1.65855 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 4, 2, 47, 3) function-interpolation-python 0.968401 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 4, 2, 47, 27) la-vector-access-cpp 23.443 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 4, 2, 47, 54) la-vector-assignment-cpp 27.0809 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 5, 2, 24, 0) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0158 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 5, 2, 24, 19) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7188 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 5, 2, 24, 36) geometry-bounding_box_tree_build-cpp 13.9445 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 5, 2, 25, 3) common-progress-cpp 27.6672 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 5, 2, 25, 35) common-timing-cpp 31.5123 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 5, 2, 28, 59) fem-multicore-cpp 204.085 "Coloring mesh." (2013, 12, 5, 2, 31, 31) fem-assembly-cpp 151.978 "Assembly for various forms and backends" (2013, 12, 5, 2, 31, 45) fem-convergence-cpp 14.2311 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 5, 2, 31, 47) fem-jit-python 0.00104101 "JIT compilation (in memory cache)" (2013, 12, 5, 2, 39, 47) mesh-refinement-cpp 20.0053 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 5, 2, 40, 7) mesh-topology-cpp 19.8799 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 5, 2, 40, 31) mesh-unitcube-cpp 24.1804 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 5, 2, 41, 9) mesh-iteration-cpp 35.5044 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 5, 2, 41, 30) function-evaluation-cpp 21.0796 "Evaluations of functions at arbitrary points." (2013, 12, 5, 2, 41, 30) function-evaluation-cpp 20.9362 "Evaluations of functions at arbitrary points." (2013, 12, 5, 2, 41, 34) function-extrapolation-python 3.53757 "BENCH: 1.06758499146" (2013, 12, 5, 2, 41, 34) function-extrapolation-python 1.06758 "BENCH: 1.06758499146" (2013, 12, 5, 2, 41, 36) function-interpolation-python 1.67493 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 5, 2, 41, 36) function-interpolation-python 0.974641 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 5, 2, 41, 59) la-vector-access-cpp 23.4603 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 5, 2, 42, 26) la-vector-assignment-cpp 27.2547 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 6, 2, 26, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.3322 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 6, 2, 26, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 16.2079 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 6, 2, 27, 8) geometry-bounding_box_tree_build-cpp 13.9598 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 6, 2, 27, 35) common-progress-cpp 27.6662 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 6, 2, 28, 6) common-timing-cpp 31.0271 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 6, 2, 31, 30) fem-multicore-cpp 203.899 "Coloring mesh." (2013, 12, 6, 2, 34, 3) fem-assembly-cpp 152.658 "Assembly for various forms and backends" (2013, 12, 6, 2, 34, 17) fem-convergence-cpp 14.2104 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 6, 2, 34, 19) fem-jit-python 0.0010649 "JIT compilation (in memory cache)" (2013, 12, 6, 2, 42, 20) mesh-refinement-cpp 20.1109 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 6, 2, 42, 40) mesh-topology-cpp 19.8517 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 6, 2, 43, 4) mesh-unitcube-cpp 24.2667 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 6, 2, 43, 46) mesh-iteration-cpp 39.1735 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 6, 2, 44, 7) function-evaluation-cpp 21.14 "Evaluations of functions at arbitrary points." (2013, 12, 6, 2, 44, 7) function-evaluation-cpp 21.0004 "Evaluations of functions at arbitrary points." (2013, 12, 6, 2, 44, 11) function-extrapolation-python 3.74559 "BENCH: 1.05666995049" (2013, 12, 6, 2, 44, 11) function-extrapolation-python 1.05667 "BENCH: 1.05666995049" (2013, 12, 6, 2, 44, 12) function-interpolation-python 1.65552 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 6, 2, 44, 12) function-interpolation-python 0.970658 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 6, 2, 44, 38) la-vector-access-cpp 25.4688 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 6, 2, 45, 5) la-vector-assignment-cpp 27.0926 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 7, 2, 28, 10) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2825 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 7, 2, 28, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6001 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 7, 2, 28, 46) geometry-bounding_box_tree_build-cpp 13.9226 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 7, 2, 29, 13) common-progress-cpp 27.6643 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 7, 2, 29, 46) common-timing-cpp 32.8103 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 7, 2, 33, 10) fem-multicore-cpp 203.927 "Coloring mesh." (2013, 12, 7, 2, 35, 43) fem-assembly-cpp 152.414 "Assembly for various forms and backends" (2013, 12, 7, 2, 35, 57) fem-convergence-cpp 14.2166 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 7, 2, 35, 59) fem-jit-python 0.00105691 "JIT compilation (in memory cache)" (2013, 12, 7, 2, 43, 58) mesh-refinement-cpp 20.0326 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 7, 2, 44, 18) mesh-topology-cpp 19.8747 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 7, 2, 44, 42) mesh-unitcube-cpp 24.1549 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 7, 2, 45, 20) mesh-iteration-cpp 35.4851 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 7, 2, 45, 41) function-evaluation-cpp 21.0078 "Evaluations of functions at arbitrary points." (2013, 12, 7, 2, 45, 41) function-evaluation-cpp 20.9116 "Evaluations of functions at arbitrary points." (2013, 12, 7, 2, 45, 45) function-extrapolation-python 3.48746 "BENCH: 1.0745651722" (2013, 12, 7, 2, 45, 45) function-extrapolation-python 1.07457 "BENCH: 1.0745651722" (2013, 12, 7, 2, 45, 47) function-interpolation-python 1.66493 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 7, 2, 45, 47) function-interpolation-python 0.96934 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 7, 2, 46, 10) la-vector-access-cpp 23.407 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 7, 2, 46, 37) la-vector-assignment-cpp 27.0601 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 8, 2, 35, 10) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1844 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 8, 2, 35, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5704 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 8, 2, 35, 46) geometry-bounding_box_tree_build-cpp 13.9216 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 8, 2, 36, 13) common-progress-cpp 27.6657 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 8, 2, 36, 44) common-timing-cpp 30.7988 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 8, 2, 40, 8) fem-multicore-cpp 204.301 "Coloring mesh." (2013, 12, 8, 2, 42, 40) fem-assembly-cpp 151.565 "Assembly for various forms and backends" (2013, 12, 8, 2, 42, 54) fem-convergence-cpp 14.2302 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 8, 2, 42, 56) fem-jit-python 0.00104921 "JIT compilation (in memory cache)" (2013, 12, 8, 2, 50, 57) mesh-refinement-cpp 20.0377 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 8, 2, 51, 17) mesh-topology-cpp 19.8608 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 8, 2, 51, 42) mesh-unitcube-cpp 24.266 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 8, 2, 52, 23) mesh-iteration-cpp 39.1041 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 8, 2, 52, 45) function-evaluation-cpp 21.2655 "Evaluations of functions at arbitrary points." (2013, 12, 8, 2, 52, 45) function-evaluation-cpp 21.1702 "Evaluations of functions at arbitrary points." (2013, 12, 8, 2, 52, 48) function-extrapolation-python 3.51954 "BENCH: 1.04911088943" (2013, 12, 8, 2, 52, 48) function-extrapolation-python 1.04911 "BENCH: 1.04911088943" (2013, 12, 8, 2, 52, 50) function-interpolation-python 1.65222 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 8, 2, 52, 50) function-interpolation-python 0.968558 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 8, 2, 53, 19) la-vector-access-cpp 28.9022 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 8, 2, 53, 47) la-vector-assignment-cpp 28.0837 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 9, 2, 24, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0604 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 9, 2, 24, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6247 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 9, 2, 25, 15) geometry-bounding_box_tree_build-cpp 13.9195 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 9, 2, 25, 43) common-progress-cpp 27.6656 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 9, 2, 26, 14) common-timing-cpp 31.4657 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 9, 2, 29, 38) fem-multicore-cpp 204.043 "Coloring mesh." (2013, 12, 9, 2, 32, 10) fem-assembly-cpp 152.053 "Assembly for various forms and backends" (2013, 12, 9, 2, 32, 25) fem-convergence-cpp 14.2225 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 9, 2, 32, 26) fem-jit-python 0.0010489 "JIT compilation (in memory cache)" (2013, 12, 9, 2, 40, 29) mesh-refinement-cpp 20.0745 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 9, 2, 40, 49) mesh-topology-cpp 19.9055 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 9, 2, 41, 13) mesh-unitcube-cpp 24.2344 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 9, 2, 41, 51) mesh-iteration-cpp 35.491 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 9, 2, 42, 12) function-evaluation-cpp 21.0556 "Evaluations of functions at arbitrary points." (2013, 12, 9, 2, 42, 12) function-evaluation-cpp 20.9507 "Evaluations of functions at arbitrary points." (2013, 12, 9, 2, 42, 15) function-extrapolation-python 3.46278 "BENCH: 1.04752492905" (2013, 12, 9, 2, 42, 15) function-extrapolation-python 1.04752 "BENCH: 1.04752492905" (2013, 12, 9, 2, 42, 17) function-interpolation-python 1.71003 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 9, 2, 42, 17) function-interpolation-python 0.969362 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 9, 2, 42, 41) la-vector-access-cpp 23.4626 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 9, 2, 43, 10) la-vector-assignment-cpp 29.1162 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 10, 2, 27, 55) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.2096 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 10, 2, 28, 15) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6607 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 10, 2, 28, 31) geometry-bounding_box_tree_build-cpp 13.9318 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 10, 2, 28, 59) common-progress-cpp 27.6663 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 10, 2, 29, 30) common-timing-cpp 31.2156 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 10, 2, 32, 54) fem-multicore-cpp 204.231 "Coloring mesh." (2013, 12, 10, 2, 35, 27) fem-assembly-cpp 152.315 "Assembly for various forms and backends" (2013, 12, 10, 2, 35, 41) fem-convergence-cpp 14.2107 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 10, 2, 35, 43) fem-jit-python 0.0010551 "JIT compilation (in memory cache)" (2013, 12, 10, 2, 43, 43) mesh-refinement-cpp 20.0575 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 10, 2, 44, 3) mesh-topology-cpp 19.9015 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 10, 2, 44, 27) mesh-unitcube-cpp 24.1952 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 10, 2, 45, 5) mesh-iteration-cpp 35.5027 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 10, 2, 45, 26) function-evaluation-cpp 21.067 "Evaluations of functions at arbitrary points." (2013, 12, 10, 2, 45, 26) function-evaluation-cpp 20.9397 "Evaluations of functions at arbitrary points." (2013, 12, 10, 2, 45, 30) function-extrapolation-python 3.53767 "BENCH: 1.04689908028" (2013, 12, 10, 2, 45, 30) function-extrapolation-python 1.0469 "BENCH: 1.04689908028" (2013, 12, 10, 2, 45, 32) function-interpolation-python 1.6594 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 10, 2, 45, 32) function-interpolation-python 0.960385 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 10, 2, 45, 55) la-vector-access-cpp 23.4583 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 10, 2, 46, 22) la-vector-assignment-cpp 26.9738 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 11, 2, 24, 28) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1124 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 11, 2, 24, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6448 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 11, 2, 25, 3) geometry-bounding_box_tree_build-cpp 13.92 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 11, 2, 25, 31) common-progress-cpp 27.6667 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 11, 2, 26, 2) common-timing-cpp 30.7792 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 11, 2, 29, 26) fem-multicore-cpp 204.544 "Coloring mesh." (2013, 12, 11, 2, 31, 58) fem-assembly-cpp 151.813 "Assembly for various forms and backends" (2013, 12, 11, 2, 32, 13) fem-convergence-cpp 14.2103 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 11, 2, 32, 14) fem-jit-python 0.00106249 "JIT compilation (in memory cache)" (2013, 12, 11, 2, 40, 16) mesh-refinement-cpp 20.0299 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 11, 2, 40, 35) mesh-topology-cpp 19.8482 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 11, 2, 41, 0) mesh-unitcube-cpp 24.1965 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 11, 2, 41, 38) mesh-iteration-cpp 35.49 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 11, 2, 41, 59) function-evaluation-cpp 21.2308 "Evaluations of functions at arbitrary points." (2013, 12, 11, 2, 41, 59) function-evaluation-cpp 21.1259 "Evaluations of functions at arbitrary points." (2013, 12, 11, 2, 42, 2) function-extrapolation-python 3.52911 "BENCH: 1.06168103218" (2013, 12, 11, 2, 42, 2) function-extrapolation-python 1.06168 "BENCH: 1.06168103218" (2013, 12, 11, 2, 42, 4) function-interpolation-python 1.67578 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 11, 2, 42, 4) function-interpolation-python 0.975324 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 11, 2, 42, 29) la-vector-access-cpp 24.9438 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 11, 2, 42, 56) la-vector-assignment-cpp 27.0071 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 12, 2, 25, 19) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0962 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 12, 2, 25, 38) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6015 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 12, 2, 25, 55) geometry-bounding_box_tree_build-cpp 13.9588 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 12, 2, 26, 22) common-progress-cpp 27.6662 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 12, 2, 26, 55) common-timing-cpp 32.334 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 12, 2, 30, 19) fem-multicore-cpp 204.246 "Coloring mesh." (2013, 12, 12, 2, 32, 51) fem-assembly-cpp 152.168 "Assembly for various forms and backends" (2013, 12, 12, 2, 33, 5) fem-convergence-cpp 14.2041 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 12, 2, 33, 7) fem-jit-python 0.0010679 "JIT compilation (in memory cache)" (2013, 12, 12, 2, 41, 9) mesh-refinement-cpp 19.9668 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 12, 2, 41, 29) mesh-topology-cpp 19.8618 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 12, 2, 41, 53) mesh-unitcube-cpp 24.2211 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 12, 2, 42, 31) mesh-iteration-cpp 35.4919 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 12, 2, 42, 52) function-evaluation-cpp 21.0819 "Evaluations of functions at arbitrary points." (2013, 12, 12, 2, 42, 52) function-evaluation-cpp 20.9472 "Evaluations of functions at arbitrary points." (2013, 12, 12, 2, 42, 56) function-extrapolation-python 3.47083 "BENCH: 1.05420804024" (2013, 12, 12, 2, 42, 56) function-extrapolation-python 1.05421 "BENCH: 1.05420804024" (2013, 12, 12, 2, 42, 58) function-interpolation-python 1.65233 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 12, 2, 42, 58) function-interpolation-python 0.972923 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 12, 2, 43, 23) la-vector-access-cpp 25.4816 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 12, 2, 43, 50) la-vector-assignment-cpp 27.0991 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 13, 2, 26, 53) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.092 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 13, 2, 27, 12) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6894 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 13, 2, 27, 29) geometry-bounding_box_tree_build-cpp 13.9437 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 13, 2, 27, 57) common-progress-cpp 27.6664 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 13, 2, 28, 28) common-timing-cpp 31.3424 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 13, 2, 31, 52) fem-multicore-cpp 204.421 "Coloring mesh." (2013, 12, 13, 2, 34, 24) fem-assembly-cpp 151.759 "Assembly for various forms and backends" (2013, 12, 13, 2, 34, 38) fem-convergence-cpp 14.2198 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 13, 2, 34, 40) fem-jit-python 0.0010488 "JIT compilation (in memory cache)" (2013, 12, 13, 2, 42, 42) mesh-refinement-cpp 20.0278 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 13, 2, 43, 2) mesh-topology-cpp 19.8834 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 13, 2, 43, 26) mesh-unitcube-cpp 24.2237 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 13, 2, 44, 4) mesh-iteration-cpp 35.4878 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 13, 2, 44, 26) function-evaluation-cpp 22.167 "Evaluations of functions at arbitrary points." (2013, 12, 13, 2, 44, 26) function-evaluation-cpp 22.0323 "Evaluations of functions at arbitrary points." (2013, 12, 13, 2, 44, 30) function-extrapolation-python 3.64889 "BENCH: 1.06616711617" (2013, 12, 13, 2, 44, 30) function-extrapolation-python 1.06617 "BENCH: 1.06616711617" (2013, 12, 13, 2, 44, 32) function-interpolation-python 1.65178 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 13, 2, 44, 32) function-interpolation-python 0.968548 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 13, 2, 44, 55) la-vector-access-cpp 23.4589 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 13, 2, 45, 22) la-vector-assignment-cpp 27.0993 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 14, 2, 33, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0843 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 14, 2, 33, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4994 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 14, 2, 34, 14) geometry-bounding_box_tree_build-cpp 13.9778 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 14, 2, 34, 41) common-progress-cpp 27.6679 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 14, 2, 35, 12) common-timing-cpp 31.059 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 14, 2, 38, 37) fem-multicore-cpp 204.225 "Coloring mesh." (2013, 12, 14, 2, 41, 9) fem-assembly-cpp 152.584 "Assembly for various forms and backends" (2013, 12, 14, 2, 41, 23) fem-convergence-cpp 14.2123 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 14, 2, 41, 25) fem-jit-python 0.00104721 "JIT compilation (in memory cache)" (2013, 12, 14, 2, 49, 27) mesh-refinement-cpp 19.9799 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 14, 2, 49, 47) mesh-topology-cpp 19.8787 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 14, 2, 50, 11) mesh-unitcube-cpp 24.1565 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 14, 2, 50, 49) mesh-iteration-cpp 35.4932 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 14, 2, 51, 10) function-evaluation-cpp 21.1028 "Evaluations of functions at arbitrary points." (2013, 12, 14, 2, 51, 10) function-evaluation-cpp 21.0007 "Evaluations of functions at arbitrary points." (2013, 12, 14, 2, 51, 13) function-extrapolation-python 3.41264 "BENCH: 1.04101395607" (2013, 12, 14, 2, 51, 13) function-extrapolation-python 1.04101 "BENCH: 1.04101395607" (2013, 12, 14, 2, 51, 15) function-interpolation-python 1.63382 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 14, 2, 51, 15) function-interpolation-python 0.961303 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 14, 2, 51, 38) la-vector-access-cpp 23.4369 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 14, 2, 52, 8) la-vector-assignment-cpp 29.0137 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 15, 2, 30, 0) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.1239 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 15, 2, 30, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.7447 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 15, 2, 30, 36) geometry-bounding_box_tree_build-cpp 13.9429 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 15, 2, 31, 4) common-progress-cpp 27.6675 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 15, 2, 31, 35) common-timing-cpp 31.1223 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 15, 2, 34, 59) fem-multicore-cpp 204.198 "Coloring mesh." (2013, 12, 15, 2, 37, 31) fem-assembly-cpp 152.254 "Assembly for various forms and backends" (2013, 12, 15, 2, 37, 46) fem-convergence-cpp 14.2229 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 15, 2, 37, 48) fem-jit-python 0.0010452 "JIT compilation (in memory cache)" (2013, 12, 15, 2, 45, 48) mesh-refinement-cpp 20.0653 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 15, 2, 46, 8) mesh-topology-cpp 19.9068 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 15, 2, 46, 32) mesh-unitcube-cpp 24.1908 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 15, 2, 47, 10) mesh-iteration-cpp 35.5202 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 15, 2, 47, 32) function-evaluation-cpp 21.3665 "Evaluations of functions at arbitrary points." (2013, 12, 15, 2, 47, 32) function-evaluation-cpp 21.2652 "Evaluations of functions at arbitrary points." (2013, 12, 15, 2, 47, 35) function-extrapolation-python 3.58744 "BENCH: 1.03307199478" (2013, 12, 15, 2, 47, 35) function-extrapolation-python 1.03307 "BENCH: 1.03307199478" (2013, 12, 15, 2, 47, 37) function-interpolation-python 1.66843 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 15, 2, 47, 37) function-interpolation-python 0.981521 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 15, 2, 48, 1) la-vector-access-cpp 23.4565 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 15, 2, 48, 28) la-vector-assignment-cpp 27.0971 "Assigning to vector of size 10000000 (100 repetitions)" (2013, 12, 16, 2, 27, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.0753 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 16, 2, 27, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5092 "Computed bounding box tree with 3145727 nodes for 1572864 entities." (2013, 12, 16, 2, 28, 8) geometry-bounding_box_tree_build-cpp 13.9193 "Computed bounding box tree with 25165823 nodes for 12582912 entities." (2013, 12, 16, 2, 28, 36) common-progress-cpp 27.6677 "Creating progress bar with 500000000 steps (5 repetitions)" (2013, 12, 16, 2, 29, 7) common-timing-cpp 31.4475 "Timing access and registration of timings (10000000 repetitions)" (2013, 12, 16, 2, 32, 31) fem-multicore-cpp 203.899 "Coloring mesh." (2013, 12, 16, 2, 35, 3) fem-assembly-cpp 152.171 "Assembly for various forms and backends" (2013, 12, 16, 2, 35, 17) fem-convergence-cpp 14.1967 "Solving Poisson's equation in 2D for q = 1, n = 2." (2013, 12, 16, 2, 35, 19) fem-jit-python 0.0010586 "JIT compilation (in memory cache)" (2013, 12, 16, 2, 43, 20) mesh-refinement-cpp 20.0753 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2013, 12, 16, 2, 43, 40) mesh-topology-cpp 19.9107 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2013, 12, 16, 2, 44, 4) mesh-unitcube-cpp 24.209 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2013, 12, 16, 2, 44, 42) mesh-iteration-cpp 35.4916 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2013, 12, 16, 2, 45, 3) function-evaluation-cpp 21.0484 "Evaluations of functions at arbitrary points." (2013, 12, 16, 2, 45, 3) function-evaluation-cpp 20.9522 "Evaluations of functions at arbitrary points." (2013, 12, 16, 2, 45, 7) function-extrapolation-python 3.4461 "BENCH: 1.04169797897" (2013, 12, 16, 2, 45, 7) function-extrapolation-python 1.0417 "BENCH: 1.04169797897" (2013, 12, 16, 2, 45, 8) function-interpolation-python 1.66678 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 16, 2, 45, 8) function-interpolation-python 0.972675 "Computed bounding box tree with 111131 nodes for 55566 entities." (2013, 12, 16, 2, 45, 32) la-vector-access-cpp 23.4437 "Accessing vector of size 10000000 (100 repetitions)" (2013, 12, 16, 2, 45, 59) la-vector-assignment-cpp 27.0857 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 15, 15, 37, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9512 "BENCH 10.9512" (2014, 1, 15, 15, 38, 17) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2343 "Building point search tree to accelerate distance queries." (2014, 1, 15, 15, 38, 34) geometry-bounding_box_tree_build-cpp 14.2419 "BENCH 14.2419" (2014, 1, 15, 15, 39, 2) common-progress-cpp 27.9688 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 15, 15, 39, 34) common-timing-cpp 32.4573 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 15, 15, 42, 57) fem-multicore-cpp 203.19 "Coloring mesh." (2014, 1, 15, 15, 45, 25) fem-assembly-cpp 147.176 "Assembly for various forms and backends" (2014, 1, 15, 15, 45, 39) fem-convergence-cpp 14.1108 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 15, 15, 45, 41) fem-jit-python 0.0010133 "JIT compilation (in memory cache)" (2014, 1, 15, 15, 53, 5) mesh-refinement-cpp 10.4608 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 15, 15, 53, 27) mesh-topology-cpp 21.8558 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 15, 15, 53, 51) mesh-unitcube-cpp 24.3154 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 15, 15, 54, 37) mesh-iteration-cpp 43.5951 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 15, 15, 54, 58) function-evaluation-cpp 20.9954 "Evaluations of functions at arbitrary points." (2014, 1, 15, 15, 54, 58) function-evaluation-cpp 20.9156 "Evaluations of functions at arbitrary points." (2014, 1, 15, 15, 55, 2) function-extrapolation-python 4.14469 "BENCH: 1.99085402489" (2014, 1, 15, 15, 55, 2) function-extrapolation-python 1.99085 "BENCH: 1.99085402489" (2014, 1, 15, 15, 55, 4) function-interpolation-python 1.48756 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 15, 15, 55, 4) function-interpolation-python 0.791098 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 15, 15, 55, 29) la-vector-access-cpp 25.4301 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 15, 15, 55, 57) la-vector-assignment-cpp 27.1269 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 16, 2, 25, 18) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0877 "BENCH 11.0877" (2014, 1, 16, 2, 25, 36) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0364 "Building point search tree to accelerate distance queries." (2014, 1, 16, 2, 25, 52) geometry-bounding_box_tree_build-cpp 13.9516 "BENCH 13.9516" (2014, 1, 16, 2, 26, 20) common-progress-cpp 27.6185 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 16, 2, 26, 52) common-timing-cpp 32.1613 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 16, 2, 30, 16) fem-multicore-cpp 203.767 "Coloring mesh." (2014, 1, 16, 2, 32, 46) fem-assembly-cpp 149.751 "Assembly for various forms and backends" (2014, 1, 16, 2, 33, 0) fem-convergence-cpp 14.1014 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 16, 2, 33, 2) fem-jit-python 0.0010288 "JIT compilation (in memory cache)" (2014, 1, 16, 2, 40, 39) mesh-refinement-cpp 10.2775 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 16, 2, 41, 1) mesh-topology-cpp 21.7882 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 16, 2, 41, 25) mesh-unitcube-cpp 23.5057 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 16, 2, 42, 3) mesh-iteration-cpp 35.5101 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 16, 2, 42, 24) function-evaluation-cpp 20.939 "Evaluations of functions at arbitrary points." (2014, 1, 16, 2, 42, 24) function-evaluation-cpp 20.8532 "Evaluations of functions at arbitrary points." (2014, 1, 16, 2, 42, 28) function-extrapolation-python 4.12487 "BENCH: 2.00645303726" (2014, 1, 16, 2, 42, 28) function-extrapolation-python 2.00645 "BENCH: 2.00645303726" (2014, 1, 16, 2, 42, 29) function-interpolation-python 1.53639 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 16, 2, 42, 29) function-interpolation-python 0.840103 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 16, 2, 42, 56) la-vector-access-cpp 26.4941 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 16, 2, 43, 30) la-vector-assignment-cpp 33.9831 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 17, 2, 24, 56) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2582 "BENCH 11.2582" (2014, 1, 17, 2, 25, 15) geometry-bounding_box_tree_compute_closest_entity-cpp 15.107 "Building point search tree to accelerate distance queries." (2014, 1, 17, 2, 25, 31) geometry-bounding_box_tree_build-cpp 13.9052 "BENCH 13.9052" (2014, 1, 17, 2, 25, 59) common-progress-cpp 27.6181 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 17, 2, 26, 31) common-timing-cpp 31.7952 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 17, 2, 29, 54) fem-multicore-cpp 202.892 "Coloring mesh." (2014, 1, 17, 2, 32, 23) fem-assembly-cpp 148.945 "Assembly for various forms and backends" (2014, 1, 17, 2, 32, 37) fem-convergence-cpp 14.0928 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 17, 2, 32, 39) fem-jit-python 0.00102639 "JIT compilation (in memory cache)" (2014, 1, 17, 2, 40, 10) mesh-refinement-cpp 10.2611 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 17, 2, 40, 32) mesh-topology-cpp 21.6839 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 17, 2, 40, 55) mesh-unitcube-cpp 23.4812 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 17, 2, 41, 33) mesh-iteration-cpp 35.6531 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 17, 2, 41, 54) function-evaluation-cpp 20.9125 "Evaluations of functions at arbitrary points." (2014, 1, 17, 2, 41, 54) function-evaluation-cpp 20.8323 "Evaluations of functions at arbitrary points." (2014, 1, 17, 2, 41, 59) function-extrapolation-python 4.17272 "BENCH: 2.01546216011" (2014, 1, 17, 2, 41, 59) function-extrapolation-python 2.01546 "BENCH: 2.01546216011" (2014, 1, 17, 2, 42, 0) function-interpolation-python 1.53046 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 17, 2, 42, 0) function-interpolation-python 0.839257 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 17, 2, 42, 27) la-vector-access-cpp 26.5073 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 17, 2, 43, 0) la-vector-assignment-cpp 33.9273 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 18, 2, 39, 6) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.4363 "BENCH 11.4363" (2014, 1, 18, 2, 39, 25) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0315 "Building point search tree to accelerate distance queries." (2014, 1, 18, 2, 39, 41) geometry-bounding_box_tree_build-cpp 13.9031 "BENCH 13.9031" (2014, 1, 18, 2, 40, 9) common-progress-cpp 27.6186 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 18, 2, 40, 41) common-timing-cpp 32.4759 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 18, 2, 44, 4) fem-multicore-cpp 202.98 "Coloring mesh." (2014, 1, 18, 2, 46, 33) fem-assembly-cpp 148.112 "Assembly for various forms and backends" (2014, 1, 18, 2, 46, 47) fem-convergence-cpp 14.0864 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 18, 2, 46, 48) fem-jit-python 0.00102012 "JIT compilation (in memory cache)" (2014, 1, 18, 2, 54, 21) mesh-refinement-cpp 10.2569 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 18, 2, 54, 43) mesh-topology-cpp 21.8375 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 18, 2, 55, 7) mesh-unitcube-cpp 23.6159 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 18, 2, 55, 45) mesh-iteration-cpp 35.4824 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 18, 2, 56, 6) function-evaluation-cpp 20.9861 "Evaluations of functions at arbitrary points." (2014, 1, 18, 2, 56, 6) function-evaluation-cpp 20.8708 "Evaluations of functions at arbitrary points." (2014, 1, 18, 2, 56, 10) function-extrapolation-python 4.13156 "BENCH: 2.00491189957" (2014, 1, 18, 2, 56, 10) function-extrapolation-python 2.00491 "BENCH: 2.00491189957" (2014, 1, 18, 2, 56, 11) function-interpolation-python 1.53641 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 18, 2, 56, 11) function-interpolation-python 0.847156 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 18, 2, 56, 36) la-vector-access-cpp 24.8002 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 18, 2, 57, 10) la-vector-assignment-cpp 33.9716 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 19, 2, 37, 7) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.6788 "BENCH 11.6788" (2014, 1, 19, 2, 37, 26) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1043 "Building point search tree to accelerate distance queries." (2014, 1, 19, 2, 37, 42) geometry-bounding_box_tree_build-cpp 13.9194 "BENCH 13.9194" (2014, 1, 19, 2, 38, 10) common-progress-cpp 27.6183 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 19, 2, 38, 42) common-timing-cpp 31.8808 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 19, 2, 42, 5) fem-multicore-cpp 203.021 "Coloring mesh." (2014, 1, 19, 2, 44, 33) fem-assembly-cpp 148.626 "Assembly for various forms and backends" (2014, 1, 19, 2, 44, 48) fem-convergence-cpp 14.0958 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 19, 2, 44, 49) fem-jit-python 0.0010247 "JIT compilation (in memory cache)" (2014, 1, 19, 2, 52, 25) mesh-refinement-cpp 10.2562 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 19, 2, 52, 47) mesh-topology-cpp 21.8621 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 19, 2, 53, 10) mesh-unitcube-cpp 23.576 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 19, 2, 53, 48) mesh-iteration-cpp 35.4844 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 19, 2, 54, 9) function-evaluation-cpp 20.9459 "Evaluations of functions at arbitrary points." (2014, 1, 19, 2, 54, 9) function-evaluation-cpp 20.8395 "Evaluations of functions at arbitrary points." (2014, 1, 19, 2, 54, 13) function-extrapolation-python 4.13796 "BENCH: 2.00580501556" (2014, 1, 19, 2, 54, 13) function-extrapolation-python 2.00581 "BENCH: 2.00580501556" (2014, 1, 19, 2, 54, 15) function-interpolation-python 1.53034 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 19, 2, 54, 15) function-interpolation-python 0.839177 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 19, 2, 54, 40) la-vector-access-cpp 24.8406 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 19, 2, 55, 14) la-vector-assignment-cpp 33.9841 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 20, 2, 38, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1122 "BENCH 11.1122" (2014, 1, 20, 2, 39, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3124 "Building point search tree to accelerate distance queries." (2014, 1, 20, 2, 39, 22) geometry-bounding_box_tree_build-cpp 14.0116 "BENCH 14.0116" (2014, 1, 20, 2, 39, 50) common-progress-cpp 27.6524 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 20, 2, 40, 19) common-timing-cpp 29.2958 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 20, 2, 43, 42) fem-multicore-cpp 202.767 "Coloring mesh." (2014, 1, 20, 2, 46, 11) fem-assembly-cpp 148.565 "Assembly for various forms and backends" (2014, 1, 20, 2, 46, 25) fem-convergence-cpp 14.0867 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 20, 2, 46, 27) fem-jit-python 0.0010318 "JIT compilation (in memory cache)" (2014, 1, 20, 2, 54, 0) mesh-refinement-cpp 10.2603 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 20, 2, 54, 22) mesh-topology-cpp 21.6092 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 20, 2, 54, 45) mesh-unitcube-cpp 23.594 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 20, 2, 55, 23) mesh-iteration-cpp 35.4787 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 20, 2, 55, 44) function-evaluation-cpp 20.9903 "Evaluations of functions at arbitrary points." (2014, 1, 20, 2, 55, 44) function-evaluation-cpp 20.8859 "Evaluations of functions at arbitrary points." (2014, 1, 20, 2, 55, 48) function-extrapolation-python 4.15949 "BENCH: 2.01744294167" (2014, 1, 20, 2, 55, 48) function-extrapolation-python 2.01744 "BENCH: 2.01744294167" (2014, 1, 20, 2, 55, 50) function-interpolation-python 1.50444 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 20, 2, 55, 50) function-interpolation-python 0.812313 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 20, 2, 56, 20) la-vector-access-cpp 29.9914 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 20, 2, 56, 52) la-vector-assignment-cpp 31.9187 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 21, 2, 40, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9924 "BENCH 10.9924" (2014, 1, 21, 2, 40, 41) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2025 "Building point search tree to accelerate distance queries." (2014, 1, 21, 2, 40, 58) geometry-bounding_box_tree_build-cpp 14.0279 "BENCH 14.0279" (2014, 1, 21, 2, 41, 26) common-progress-cpp 27.6549 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 21, 2, 41, 55) common-timing-cpp 29.7597 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 21, 2, 45, 20) fem-multicore-cpp 204.834 "Coloring mesh." (2014, 1, 21, 2, 47, 48) fem-assembly-cpp 147.535 "Assembly for various forms and backends" (2014, 1, 21, 2, 48, 2) fem-convergence-cpp 14.0709 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 21, 2, 48, 4) fem-jit-python 0.0010221 "JIT compilation (in memory cache)" (2014, 1, 21, 2, 55, 39) mesh-refinement-cpp 10.3604 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 21, 2, 56, 1) mesh-topology-cpp 22.1511 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 21, 2, 56, 26) mesh-unitcube-cpp 24.591 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 21, 2, 57, 13) mesh-iteration-cpp 44.1666 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 21, 2, 57, 34) function-evaluation-cpp 21.5867 "Evaluations of functions at arbitrary points." (2014, 1, 21, 2, 57, 34) function-evaluation-cpp 21.4917 "Evaluations of functions at arbitrary points." (2014, 1, 21, 2, 57, 38) function-extrapolation-python 4.29282 "BENCH: 2.00982284546" (2014, 1, 21, 2, 57, 38) function-extrapolation-python 2.00982 "BENCH: 2.00982284546" (2014, 1, 21, 2, 57, 40) function-interpolation-python 1.48564 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 21, 2, 57, 40) function-interpolation-python 0.798807 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 21, 2, 58, 7) la-vector-access-cpp 26.9942 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 21, 2, 58, 43) la-vector-assignment-cpp 35.9288 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 22, 2, 26, 10) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0606 "BENCH 11.0606" (2014, 1, 22, 2, 26, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2837 "Building point search tree to accelerate distance queries." (2014, 1, 22, 2, 26, 45) geometry-bounding_box_tree_build-cpp 13.903 "BENCH 13.903" (2014, 1, 22, 2, 27, 13) common-progress-cpp 27.6164 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 22, 2, 27, 44) common-timing-cpp 30.884 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 22, 2, 31, 12) fem-multicore-cpp 208.191 "Coloring mesh." (2014, 1, 22, 2, 33, 45) fem-assembly-cpp 152.808 "Assembly for various forms and backends" (2014, 1, 22, 2, 33, 59) fem-convergence-cpp 14.09 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 22, 2, 34, 1) fem-jit-python 0.00102119 "JIT compilation (in memory cache)" (2014, 1, 22, 2, 41, 34) mesh-refinement-cpp 10.376 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 22, 2, 41, 56) mesh-topology-cpp 21.7187 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 22, 2, 42, 20) mesh-unitcube-cpp 24.4275 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 22, 2, 42, 58) mesh-iteration-cpp 35.5339 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 22, 2, 43, 20) function-evaluation-cpp 21.0845 "Evaluations of functions at arbitrary points." (2014, 1, 22, 2, 43, 20) function-evaluation-cpp 20.9691 "Evaluations of functions at arbitrary points." (2014, 1, 22, 2, 43, 24) function-extrapolation-python 4.10016 "BENCH: 2.01358008385" (2014, 1, 22, 2, 43, 24) function-extrapolation-python 2.01358 "BENCH: 2.01358008385" (2014, 1, 22, 2, 43, 25) function-interpolation-python 1.49253 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 22, 2, 43, 25) function-interpolation-python 0.809683 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 22, 2, 43, 50) la-vector-access-cpp 24.8502 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 22, 2, 44, 22) la-vector-assignment-cpp 31.9205 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 23, 2, 28, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0559 "BENCH 11.0559" (2014, 1, 23, 2, 28, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5543 "Building point search tree to accelerate distance queries." (2014, 1, 23, 2, 28, 48) geometry-bounding_box_tree_build-cpp 14.0371 "BENCH 14.0371" (2014, 1, 23, 2, 29, 16) common-progress-cpp 27.6591 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 23, 2, 29, 48) common-timing-cpp 31.5902 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 23, 2, 33, 17) fem-multicore-cpp 208.801 "Coloring mesh." (2014, 1, 23, 2, 35, 48) fem-assembly-cpp 151.335 "Assembly for various forms and backends" (2014, 1, 23, 2, 36, 2) fem-convergence-cpp 14.1213 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 23, 2, 36, 4) fem-jit-python 0.0010361 "JIT compilation (in memory cache)" (2014, 1, 23, 2, 43, 42) mesh-refinement-cpp 10.4052 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 23, 2, 44, 4) mesh-topology-cpp 21.9404 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 23, 2, 44, 28) mesh-unitcube-cpp 24.08 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 23, 2, 45, 6) mesh-iteration-cpp 35.4865 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 23, 2, 45, 27) function-evaluation-cpp 21.0149 "Evaluations of functions at arbitrary points." (2014, 1, 23, 2, 45, 27) function-evaluation-cpp 20.9051 "Evaluations of functions at arbitrary points." (2014, 1, 23, 2, 45, 32) function-extrapolation-python 4.14087 "BENCH: 2.01658511162" (2014, 1, 23, 2, 45, 32) function-extrapolation-python 2.01659 "BENCH: 2.01658511162" (2014, 1, 23, 2, 45, 33) function-interpolation-python 1.49715 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 23, 2, 45, 33) function-interpolation-python 0.814686 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 23, 2, 46, 0) la-vector-access-cpp 27.0048 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 23, 2, 46, 34) la-vector-assignment-cpp 33.4811 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 24, 2, 33, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0937 "BENCH 11.0937" (2014, 1, 24, 2, 33, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9468 "Building point search tree to accelerate distance queries." (2014, 1, 24, 2, 33, 46) geometry-bounding_box_tree_build-cpp 13.9493 "BENCH 13.9493" (2014, 1, 24, 2, 34, 13) common-progress-cpp 27.6856 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 24, 2, 34, 43) common-timing-cpp 29.9066 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 24, 2, 38, 11) fem-multicore-cpp 208.396 "Coloring mesh." (2014, 1, 24, 2, 40, 42) fem-assembly-cpp 150.226 "Assembly for various forms and backends" (2014, 1, 24, 2, 40, 56) fem-convergence-cpp 14.1239 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 24, 2, 40, 58) fem-jit-python 0.0010217 "JIT compilation (in memory cache)" (2014, 1, 24, 2, 48, 36) mesh-refinement-cpp 10.3527 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 24, 2, 48, 57) mesh-topology-cpp 21.8798 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 24, 2, 49, 21) mesh-unitcube-cpp 23.9441 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 24, 2, 49, 59) mesh-iteration-cpp 35.487 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 24, 2, 50, 20) function-evaluation-cpp 21.0412 "Evaluations of functions at arbitrary points." (2014, 1, 24, 2, 50, 20) function-evaluation-cpp 20.9227 "Evaluations of functions at arbitrary points." (2014, 1, 24, 2, 50, 25) function-extrapolation-python 4.13858 "BENCH: 2.02727198601" (2014, 1, 24, 2, 50, 25) function-extrapolation-python 2.02727 "BENCH: 2.02727198601" (2014, 1, 24, 2, 50, 26) function-interpolation-python 1.48759 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 24, 2, 50, 26) function-interpolation-python 0.796274 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 24, 2, 50, 53) la-vector-access-cpp 26.5933 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 24, 2, 51, 26) la-vector-assignment-cpp 33.5474 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 25, 2, 35, 17) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.9783 "BENCH 11.9783" (2014, 1, 25, 2, 35, 36) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3416 "Building point search tree to accelerate distance queries." (2014, 1, 25, 2, 35, 52) geometry-bounding_box_tree_build-cpp 13.8975 "BENCH 13.8975" (2014, 1, 25, 2, 36, 20) common-progress-cpp 27.6859 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 25, 2, 36, 51) common-timing-cpp 30.7044 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 25, 2, 40, 15) fem-multicore-cpp 204.228 "Coloring mesh." (2014, 1, 25, 2, 42, 41) fem-assembly-cpp 146.323 "Assembly for various forms and backends" (2014, 1, 25, 2, 42, 55) fem-convergence-cpp 14.0739 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 25, 2, 42, 57) fem-jit-python 0.00102668 "JIT compilation (in memory cache)" (2014, 1, 25, 2, 50, 29) mesh-refinement-cpp 10.5274 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 25, 2, 50, 51) mesh-topology-cpp 21.7013 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 25, 2, 51, 15) mesh-unitcube-cpp 24.4922 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 25, 2, 51, 53) mesh-iteration-cpp 35.5404 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 25, 2, 52, 14) function-evaluation-cpp 21.0292 "Evaluations of functions at arbitrary points." (2014, 1, 25, 2, 52, 14) function-evaluation-cpp 20.9129 "Evaluations of functions at arbitrary points." (2014, 1, 25, 2, 52, 19) function-extrapolation-python 4.14919 "BENCH: 2.0251019001" (2014, 1, 25, 2, 52, 19) function-extrapolation-python 2.0251 "BENCH: 2.0251019001" (2014, 1, 25, 2, 52, 20) function-interpolation-python 1.50835 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 25, 2, 52, 20) function-interpolation-python 0.823975 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 25, 2, 52, 45) la-vector-access-cpp 24.9177 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 25, 2, 53, 17) la-vector-assignment-cpp 31.951 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 26, 2, 26, 2) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.9514 "BENCH 11.9514" (2014, 1, 26, 2, 26, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2094 "Building point search tree to accelerate distance queries." (2014, 1, 26, 2, 26, 37) geometry-bounding_box_tree_build-cpp 13.9236 "BENCH 13.9236" (2014, 1, 26, 2, 27, 4) common-progress-cpp 27.626 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 26, 2, 27, 36) common-timing-cpp 31.1299 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 26, 2, 30, 59) fem-multicore-cpp 203.438 "Coloring mesh." (2014, 1, 26, 2, 33, 26) fem-assembly-cpp 147.075 "Assembly for various forms and backends" (2014, 1, 26, 2, 33, 40) fem-convergence-cpp 14.0641 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 26, 2, 33, 42) fem-jit-python 0.00102148 "JIT compilation (in memory cache)" (2014, 1, 26, 2, 41, 15) mesh-refinement-cpp 10.5487 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 26, 2, 41, 36) mesh-topology-cpp 21.6187 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 26, 2, 42, 1) mesh-unitcube-cpp 24.4409 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 26, 2, 42, 47) mesh-iteration-cpp 43.5822 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 26, 2, 43, 8) function-evaluation-cpp 21.1064 "Evaluations of functions at arbitrary points." (2014, 1, 26, 2, 43, 8) function-evaluation-cpp 20.9909 "Evaluations of functions at arbitrary points." (2014, 1, 26, 2, 43, 12) function-extrapolation-python 4.14615 "BENCH: 2.01171588898" (2014, 1, 26, 2, 43, 12) function-extrapolation-python 2.01172 "BENCH: 2.01171588898" (2014, 1, 26, 2, 43, 13) function-interpolation-python 1.49893 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 26, 2, 43, 13) function-interpolation-python 0.81606 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 26, 2, 43, 38) la-vector-access-cpp 24.9007 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 26, 2, 44, 10) la-vector-assignment-cpp 31.9596 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 28, 2, 39, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.96 "BENCH 11.96" (2014, 1, 28, 2, 40, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9661 "Building point search tree to accelerate distance queries." (2014, 1, 28, 2, 40, 24) geometry-bounding_box_tree_build-cpp 13.9708 "BENCH 13.9708" (2014, 1, 28, 2, 40, 52) common-progress-cpp 27.6867 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 28, 2, 41, 22) common-timing-cpp 29.7707 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 28, 2, 43, 30) fem-multicore-cpp 128.187 "Coloring mesh." (2014, 1, 28, 2, 46, 0) fem-assembly-cpp 150.539 "Assembly for various forms and backends" (2014, 1, 28, 2, 46, 15) fem-convergence-cpp 14.1272 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 28, 2, 46, 16) fem-jit-python 0.0010134 "JIT compilation (in memory cache)" (2014, 1, 28, 2, 53, 53) mesh-refinement-cpp 10.2192 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 28, 2, 54, 15) mesh-topology-cpp 21.5145 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 28, 2, 54, 38) mesh-unitcube-cpp 23.3338 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 28, 2, 55, 16) mesh-iteration-cpp 35.5276 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 28, 2, 55, 39) function-evaluation-cpp 22.5328 "Evaluations of functions at arbitrary points." (2014, 1, 28, 2, 55, 39) function-evaluation-cpp 22.4137 "Evaluations of functions at arbitrary points." (2014, 1, 28, 2, 55, 43) function-extrapolation-python 4.13268 "BENCH: 2.03891706467" (2014, 1, 28, 2, 55, 43) function-extrapolation-python 2.03892 "BENCH: 2.03891706467" (2014, 1, 28, 2, 55, 44) function-interpolation-python 1.51555 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 28, 2, 55, 44) function-interpolation-python 0.822274 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 28, 2, 56, 9) la-vector-access-cpp 24.7856 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 28, 2, 56, 42) la-vector-assignment-cpp 32.9275 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 29, 2, 26, 12) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.7165 "BENCH 11.7165" (2014, 1, 29, 2, 26, 31) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4288 "Building point search tree to accelerate distance queries." (2014, 1, 29, 2, 26, 47) geometry-bounding_box_tree_build-cpp 13.8807 "BENCH 13.8807" (2014, 1, 29, 2, 27, 15) common-progress-cpp 27.6539 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 29, 2, 27, 47) common-timing-cpp 32.0411 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 29, 2, 29, 55) fem-multicore-cpp 127.874 "Coloring mesh." (2014, 1, 29, 2, 32, 26) fem-assembly-cpp 151.082 "Assembly for various forms and backends" (2014, 1, 29, 2, 32, 40) fem-convergence-cpp 14.1306 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 29, 2, 32, 42) fem-jit-python 0.00102539 "JIT compilation (in memory cache)" (2014, 1, 29, 2, 40, 15) mesh-refinement-cpp 10.3281 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 29, 2, 40, 37) mesh-topology-cpp 21.5167 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 29, 2, 41, 1) mesh-unitcube-cpp 24.4291 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 29, 2, 41, 43) mesh-iteration-cpp 39.152 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 29, 2, 42, 4) function-evaluation-cpp 21.0387 "Evaluations of functions at arbitrary points." (2014, 1, 29, 2, 42, 4) function-evaluation-cpp 20.9262 "Evaluations of functions at arbitrary points." (2014, 1, 29, 2, 42, 8) function-extrapolation-python 4.13379 "BENCH: 2.03488993645" (2014, 1, 29, 2, 42, 8) function-extrapolation-python 2.03489 "BENCH: 2.03488993645" (2014, 1, 29, 2, 42, 10) function-interpolation-python 1.51036 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 29, 2, 42, 10) function-interpolation-python 0.824071 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 29, 2, 42, 36) la-vector-access-cpp 25.9897 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 29, 2, 43, 8) la-vector-assignment-cpp 32.2278 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 30, 2, 39, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.7523 "BENCH 11.7523" (2014, 1, 30, 2, 39, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9561 "Building point search tree to accelerate distance queries." (2014, 1, 30, 2, 40, 13) geometry-bounding_box_tree_build-cpp 13.9674 "BENCH 13.9674" (2014, 1, 30, 2, 40, 41) common-progress-cpp 27.6539 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 30, 2, 41, 11) common-timing-cpp 30.4635 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 30, 2, 43, 21) fem-multicore-cpp 129.713 "Coloring mesh." (2014, 1, 30, 2, 45, 51) fem-assembly-cpp 150.233 "Assembly for various forms and backends" (2014, 1, 30, 2, 46, 6) fem-convergence-cpp 14.1467 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 30, 2, 46, 7) fem-jit-python 0.0010371 "JIT compilation (in memory cache)" (2014, 1, 30, 2, 53, 46) mesh-refinement-cpp 10.3367 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 30, 2, 54, 7) mesh-topology-cpp 21.3854 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 30, 2, 54, 32) mesh-unitcube-cpp 24.7038 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 30, 2, 55, 10) mesh-iteration-cpp 35.5132 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 30, 2, 55, 31) function-evaluation-cpp 21.2958 "Evaluations of functions at arbitrary points." (2014, 1, 30, 2, 55, 31) function-evaluation-cpp 21.1892 "Evaluations of functions at arbitrary points." (2014, 1, 30, 2, 55, 35) function-extrapolation-python 4.21072 "BENCH: 2.02427196503" (2014, 1, 30, 2, 55, 35) function-extrapolation-python 2.02427 "BENCH: 2.02427196503" (2014, 1, 30, 2, 55, 37) function-interpolation-python 1.52789 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 30, 2, 55, 37) function-interpolation-python 0.839809 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 30, 2, 56, 2) la-vector-access-cpp 24.9087 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 30, 2, 56, 34) la-vector-assignment-cpp 31.922 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 1, 31, 2, 26, 51) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1103 "BENCH 11.1103" (2014, 1, 31, 2, 27, 10) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2151 "Building point search tree to accelerate distance queries." (2014, 1, 31, 2, 27, 26) geometry-bounding_box_tree_build-cpp 13.9359 "BENCH 13.9359" (2014, 1, 31, 2, 27, 54) common-progress-cpp 27.6391 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 1, 31, 2, 28, 24) common-timing-cpp 30.7703 "Timing access and registration of timings (10000000 repetitions)" (2014, 1, 31, 2, 30, 32) fem-multicore-cpp 127.927 "Coloring mesh." (2014, 1, 31, 2, 33, 0) fem-assembly-cpp 147.253 "Assembly for various forms and backends" (2014, 1, 31, 2, 33, 14) fem-convergence-cpp 14.1893 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 1, 31, 2, 33, 16) fem-jit-python 0.00102489 "JIT compilation (in memory cache)" (2014, 1, 31, 2, 40, 44) mesh-refinement-cpp 8.63186 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 1, 31, 2, 41, 5) mesh-topology-cpp 21.6185 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 1, 31, 2, 41, 29) mesh-unitcube-cpp 23.3489 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 1, 31, 2, 42, 15) mesh-iteration-cpp 44.1695 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 1, 31, 2, 42, 36) function-evaluation-cpp 20.989 "Evaluations of functions at arbitrary points." (2014, 1, 31, 2, 42, 36) function-evaluation-cpp 20.8714 "Evaluations of functions at arbitrary points." (2014, 1, 31, 2, 42, 40) function-extrapolation-python 4.20617 "BENCH: 2.03970885277" (2014, 1, 31, 2, 42, 40) function-extrapolation-python 2.03971 "BENCH: 2.03970885277" (2014, 1, 31, 2, 42, 42) function-interpolation-python 1.4866 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 31, 2, 42, 42) function-interpolation-python 0.812988 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 1, 31, 2, 43, 8) la-vector-access-cpp 26.4921 "Accessing vector of size 10000000 (100 repetitions)" (2014, 1, 31, 2, 43, 42) la-vector-assignment-cpp 33.4886 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 1, 2, 27, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.4747 "BENCH 11.4747" (2014, 2, 1, 2, 27, 22) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2751 "Building point search tree to accelerate distance queries." (2014, 2, 1, 2, 27, 38) geometry-bounding_box_tree_build-cpp 14.0163 "BENCH 14.0163" (2014, 2, 1, 2, 28, 6) common-progress-cpp 27.651 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 1, 2, 28, 40) common-timing-cpp 34.5283 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 1, 2, 30, 48) fem-multicore-cpp 127.399 "Coloring mesh." (2014, 2, 1, 2, 33, 16) fem-assembly-cpp 147.874 "Assembly for various forms and backends" (2014, 2, 1, 2, 33, 30) fem-convergence-cpp 14.1923 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 1, 2, 33, 32) fem-jit-python 0.00102789 "JIT compilation (in memory cache)" (2014, 2, 1, 2, 41, 6) mesh-refinement-cpp 8.55332 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 1, 2, 41, 28) mesh-topology-cpp 21.6848 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 1, 2, 41, 51) mesh-unitcube-cpp 23.3207 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 1, 2, 42, 29) mesh-iteration-cpp 35.4651 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 1, 2, 42, 50) function-evaluation-cpp 20.9784 "Evaluations of functions at arbitrary points." (2014, 2, 1, 2, 42, 50) function-evaluation-cpp 20.8659 "Evaluations of functions at arbitrary points." (2014, 2, 1, 2, 42, 54) function-extrapolation-python 4.25899 "BENCH: 2.00344491005" (2014, 2, 1, 2, 42, 54) function-extrapolation-python 2.00344 "BENCH: 2.00344491005" (2014, 2, 1, 2, 42, 56) function-interpolation-python 1.50501 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 1, 2, 42, 56) function-interpolation-python 0.824445 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 1, 2, 43, 21) la-vector-access-cpp 24.9185 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 1, 2, 43, 54) la-vector-assignment-cpp 33.4806 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 2, 2, 25, 5) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1557 "BENCH 11.1557" (2014, 2, 2, 2, 25, 24) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2377 "Building point search tree to accelerate distance queries." (2014, 2, 2, 2, 25, 40) geometry-bounding_box_tree_build-cpp 13.9366 "BENCH 13.9366" (2014, 2, 2, 2, 26, 12) common-progress-cpp 31.4097 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 2, 2, 26, 42) common-timing-cpp 30.9458 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 2, 2, 28, 50) fem-multicore-cpp 127.615 "Coloring mesh." (2014, 2, 2, 2, 31, 17) fem-assembly-cpp 146.733 "Assembly for various forms and backends" (2014, 2, 2, 2, 31, 31) fem-convergence-cpp 14.1744 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 2, 2, 31, 33) fem-jit-python 0.00103571 "JIT compilation (in memory cache)" (2014, 2, 2, 2, 39, 7) mesh-refinement-cpp 8.553 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 2, 2, 39, 28) mesh-topology-cpp 21.5969 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 2, 2, 39, 52) mesh-unitcube-cpp 23.2511 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 2, 2, 40, 29) mesh-iteration-cpp 35.563 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 2, 2, 40, 50) function-evaluation-cpp 20.9805 "Evaluations of functions at arbitrary points." (2014, 2, 2, 2, 40, 50) function-evaluation-cpp 20.8714 "Evaluations of functions at arbitrary points." (2014, 2, 2, 2, 40, 55) function-extrapolation-python 4.1105 "BENCH: 2.01057386398" (2014, 2, 2, 2, 40, 55) function-extrapolation-python 2.01057 "BENCH: 2.01057386398" (2014, 2, 2, 2, 40, 56) function-interpolation-python 1.48431 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 2, 2, 40, 56) function-interpolation-python 0.808568 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 2, 2, 41, 26) la-vector-access-cpp 30.0492 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 2, 2, 42, 0) la-vector-assignment-cpp 33.4829 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 3, 2, 35, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2224 "BENCH 11.2224" (2014, 2, 3, 2, 36, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2988 "Building point search tree to accelerate distance queries." (2014, 2, 3, 2, 36, 32) geometry-bounding_box_tree_build-cpp 13.9391 "BENCH 13.9391" (2014, 2, 3, 2, 37, 0) common-progress-cpp 27.6434 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 3, 2, 37, 31) common-timing-cpp 31.1442 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 3, 2, 39, 40) fem-multicore-cpp 128.856 "Coloring mesh." (2014, 2, 3, 2, 42, 7) fem-assembly-cpp 147.219 "Assembly for various forms and backends" (2014, 2, 3, 2, 42, 21) fem-convergence-cpp 14.2224 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 3, 2, 42, 23) fem-jit-python 0.00102181 "JIT compilation (in memory cache)" (2014, 2, 3, 2, 49, 57) mesh-refinement-cpp 8.57177 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 3, 2, 50, 18) mesh-topology-cpp 21.5131 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 3, 2, 50, 42) mesh-unitcube-cpp 23.2338 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 3, 2, 51, 20) mesh-iteration-cpp 35.4699 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 3, 2, 51, 41) function-evaluation-cpp 21.0771 "Evaluations of functions at arbitrary points." (2014, 2, 3, 2, 51, 41) function-evaluation-cpp 20.9471 "Evaluations of functions at arbitrary points." (2014, 2, 3, 2, 51, 45) function-extrapolation-python 4.13928 "BENCH: 2.02389383316" (2014, 2, 3, 2, 51, 45) function-extrapolation-python 2.02389 "BENCH: 2.02389383316" (2014, 2, 3, 2, 51, 46) function-interpolation-python 1.49282 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 3, 2, 51, 46) function-interpolation-python 0.808365 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 3, 2, 52, 11) la-vector-access-cpp 24.8726 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 3, 2, 52, 45) la-vector-assignment-cpp 33.468 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 4, 2, 27, 54) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1451 "BENCH 11.1451" (2014, 2, 4, 2, 28, 12) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3818 "Building point search tree to accelerate distance queries." (2014, 2, 4, 2, 28, 29) geometry-bounding_box_tree_build-cpp 13.9423 "BENCH 13.9423" (2014, 2, 4, 2, 29, 0) common-progress-cpp 31.407 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 4, 2, 29, 31) common-timing-cpp 30.8856 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 4, 2, 31, 40) fem-multicore-cpp 128.476 "Coloring mesh." (2014, 2, 4, 2, 34, 4) fem-assembly-cpp 144.421 "Assembly for various forms and backends" (2014, 2, 4, 2, 34, 18) fem-convergence-cpp 14.194 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 4, 2, 34, 20) fem-jit-python 0.0010278 "JIT compilation (in memory cache)" (2014, 2, 4, 2, 41, 53) mesh-refinement-cpp 8.65397 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 4, 2, 42, 14) mesh-topology-cpp 21.7049 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 4, 2, 42, 38) mesh-unitcube-cpp 23.2986 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 4, 2, 43, 17) mesh-iteration-cpp 36.4868 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 4, 2, 43, 38) function-evaluation-cpp 21.0365 "Evaluations of functions at arbitrary points." (2014, 2, 4, 2, 43, 38) function-evaluation-cpp 20.9242 "Evaluations of functions at arbitrary points." (2014, 2, 4, 2, 43, 42) function-extrapolation-python 4.1236 "BENCH: 2.01024198532" (2014, 2, 4, 2, 43, 42) function-extrapolation-python 2.01024 "BENCH: 2.01024198532" (2014, 2, 4, 2, 43, 43) function-interpolation-python 1.50191 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 4, 2, 43, 43) function-interpolation-python 0.806589 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 4, 2, 44, 7) la-vector-access-cpp 23.8154 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 4, 2, 44, 41) la-vector-assignment-cpp 33.9897 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 5, 2, 32, 56) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0274 "BENCH 11.0274" (2014, 2, 5, 2, 33, 15) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2162 "Building point search tree to accelerate distance queries." (2014, 2, 5, 2, 33, 31) geometry-bounding_box_tree_build-cpp 13.9636 "BENCH 13.9636" (2014, 2, 5, 2, 33, 59) common-progress-cpp 27.6341 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 5, 2, 34, 30) common-timing-cpp 31.2916 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 5, 2, 36, 38) fem-multicore-cpp 128.404 "Coloring mesh." (2014, 2, 5, 2, 39, 3) fem-assembly-cpp 144.391 "Assembly for various forms and backends" (2014, 2, 5, 2, 39, 17) fem-convergence-cpp 14.1907 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 5, 2, 39, 19) fem-jit-python 0.00102279 "JIT compilation (in memory cache)" (2014, 2, 5, 2, 46, 49) mesh-refinement-cpp 8.53868 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 5, 2, 47, 11) mesh-topology-cpp 21.6395 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 5, 2, 47, 34) mesh-unitcube-cpp 23.3238 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 5, 2, 48, 12) mesh-iteration-cpp 35.469 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 5, 2, 48, 34) function-evaluation-cpp 22.1981 "Evaluations of functions at arbitrary points." (2014, 2, 5, 2, 48, 34) function-evaluation-cpp 22.0708 "Evaluations of functions at arbitrary points." (2014, 2, 5, 2, 48, 38) function-extrapolation-python 4.17364 "BENCH: 1.99095797539" (2014, 2, 5, 2, 48, 38) function-extrapolation-python 1.99096 "BENCH: 1.99095797539" (2014, 2, 5, 2, 48, 40) function-interpolation-python 1.48685 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 5, 2, 48, 40) function-interpolation-python 0.807773 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 5, 2, 49, 5) la-vector-access-cpp 24.973 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 5, 2, 49, 39) la-vector-assignment-cpp 34.0565 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 6, 2, 30, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0587 "BENCH 11.0587" (2014, 2, 6, 2, 30, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6703 "Building point search tree to accelerate distance queries." (2014, 2, 6, 2, 31, 16) geometry-bounding_box_tree_build-cpp 13.9458 "BENCH 13.9458" (2014, 2, 6, 2, 31, 43) common-progress-cpp 27.6536 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 6, 2, 32, 14) common-timing-cpp 30.9606 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 6, 2, 34, 21) fem-multicore-cpp 126.463 "Coloring mesh." (2014, 2, 6, 2, 36, 45) fem-assembly-cpp 144.437 "Assembly for various forms and backends" (2014, 2, 6, 2, 36, 59) fem-convergence-cpp 14.1005 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 6, 2, 37, 1) fem-jit-python 0.00102301 "JIT compilation (in memory cache)" (2014, 2, 6, 2, 44, 32) mesh-refinement-cpp 8.58761 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 6, 2, 44, 53) mesh-topology-cpp 21.5833 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 6, 2, 45, 16) mesh-unitcube-cpp 23.3295 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 6, 2, 45, 55) mesh-iteration-cpp 36.5064 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 6, 2, 46, 16) function-evaluation-cpp 20.9848 "Evaluations of functions at arbitrary points." (2014, 2, 6, 2, 46, 16) function-evaluation-cpp 20.8777 "Evaluations of functions at arbitrary points." (2014, 2, 6, 2, 46, 20) function-extrapolation-python 4.1197 "BENCH: 2.01532387733" (2014, 2, 6, 2, 46, 20) function-extrapolation-python 2.01532 "BENCH: 2.01532387733" (2014, 2, 6, 2, 46, 22) function-interpolation-python 1.47883 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 6, 2, 46, 22) function-interpolation-python 0.806746 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 6, 2, 46, 48) la-vector-access-cpp 25.9954 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 6, 2, 47, 22) la-vector-assignment-cpp 33.9801 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 7, 2, 38, 50) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9128 "BENCH 10.9128" (2014, 2, 7, 2, 39, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5373 "Building point search tree to accelerate distance queries." (2014, 2, 7, 2, 39, 26) geometry-bounding_box_tree_build-cpp 13.9607 "BENCH 13.9607" (2014, 2, 7, 2, 39, 53) common-progress-cpp 27.6483 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 7, 2, 40, 26) common-timing-cpp 32.3849 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 7, 2, 42, 33) fem-multicore-cpp 126.909 "Coloring mesh." (2014, 2, 7, 2, 45, 0) fem-assembly-cpp 147.615 "Assembly for various forms and backends" (2014, 2, 7, 2, 45, 14) fem-convergence-cpp 14.074 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 7, 2, 45, 33) fem-jit-python 0.000377989 "JIT compilation (in memory cache)" (2014, 2, 7, 2, 53, 8) mesh-refinement-cpp 8.4859 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 7, 2, 53, 29) mesh-topology-cpp 21.5361 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 7, 2, 53, 52) mesh-unitcube-cpp 23.1907 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 7, 2, 54, 30) mesh-iteration-cpp 35.4917 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 7, 2, 54, 51) function-evaluation-cpp 20.9772 "Evaluations of functions at arbitrary points." (2014, 2, 7, 2, 54, 51) function-evaluation-cpp 20.8695 "Evaluations of functions at arbitrary points." (2014, 2, 7, 2, 55, 44) function-extrapolation-python 52.572 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2014, 2, 7, 2, 55, 44) function-extrapolation-python 2.01246 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2014, 2, 7, 2, 55, 45) function-interpolation-python 1.48531 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 7, 2, 55, 45) function-interpolation-python 0.799276 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 7, 2, 56, 10) la-vector-access-cpp 24.7867 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 7, 2, 56, 42) la-vector-assignment-cpp 32.4186 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 2, 8, 2, 27, 24) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0254 "BENCH 11.0254" (2014, 2, 8, 2, 27, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2307 "Building point search tree to accelerate distance queries." (2014, 2, 8, 2, 28, 0) geometry-bounding_box_tree_build-cpp 13.9672 "BENCH 13.9672" (2014, 2, 8, 2, 28, 27) common-progress-cpp 27.6139 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 2, 8, 2, 28, 56) common-timing-cpp 29.2142 "Timing access and registration of timings (10000000 repetitions)" (2014, 2, 8, 2, 31, 2) fem-multicore-cpp 126.11 "Coloring mesh." (2014, 2, 8, 2, 33, 27) fem-assembly-cpp 144.201 "Assembly for various forms and backends" (2014, 2, 8, 2, 33, 41) fem-convergence-cpp 14.0413 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 2, 8, 2, 33, 43) fem-jit-python 0.000353193 "JIT compilation (in memory cache)" (2014, 2, 8, 2, 41, 18) mesh-refinement-cpp 8.50042 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 2, 8, 2, 41, 40) mesh-topology-cpp 21.9878 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 2, 8, 2, 42, 3) mesh-unitcube-cpp 23 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 2, 8, 2, 42, 45) mesh-iteration-cpp 39.119 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 2, 8, 2, 43, 6) function-evaluation-cpp 20.9739 "Evaluations of functions at arbitrary points." (2014, 2, 8, 2, 43, 6) function-evaluation-cpp 20.8693 "Evaluations of functions at arbitrary points." (2014, 2, 8, 2, 43, 10) function-extrapolation-python 4.12897 "BENCH: 2.01829910278" (2014, 2, 8, 2, 43, 10) function-extrapolation-python 2.0183 "BENCH: 2.01829910278" (2014, 2, 8, 2, 43, 11) function-interpolation-python 1.48256 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 8, 2, 43, 11) function-interpolation-python 0.79725 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 2, 8, 2, 43, 38) la-vector-access-cpp 27.0878 "Accessing vector of size 10000000 (100 repetitions)" (2014, 2, 8, 2, 44, 11) la-vector-assignment-cpp 32.4739 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 2, 10, 18, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.3047 "BENCH 11.3047" (2014, 7, 2, 10, 18, 39) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2294 "Building point search tree to accelerate distance queries." (2014, 7, 2, 10, 18, 57) geometry-bounding_box_tree_build-cpp 14.4811 "BENCH 14.4811" (2014, 7, 2, 10, 19, 25) common-progress-cpp 28.0973 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 2, 10, 19, 56) common-timing-cpp 31.0175 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 2, 10, 21, 30) fem-convergence-cpp 3.95093 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 2, 10, 21, 32) fem-jit-python 0.000343704 "JIT compilation (in memory cache)" (2014, 7, 2, 10, 46, 4) mesh-refinement-cpp 8.59842 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 2, 10, 46, 27) mesh-topology-cpp 22.6657 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 2, 10, 46, 50) mesh-unitcube-cpp 23.4783 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 2, 10, 47, 32) mesh-iteration-cpp 39.2779 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 2, 10, 47, 55) function-evaluation-cpp 23.3481 "Evaluations of functions at arbitrary points." (2014, 7, 2, 10, 47, 55) function-evaluation-cpp 23.2492 "Evaluations of functions at arbitrary points." (2014, 7, 2, 10, 48, 0) function-extrapolation-python 4.62164 "Size of local-to-local: 10431" (2014, 7, 2, 10, 48, 0) function-extrapolation-python 2.0234 "Size of local-to-local: 10431" (2014, 7, 2, 10, 48, 2) function-interpolation-python 1.89533 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 2, 10, 48, 2) function-interpolation-python 0.907394 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 2, 10, 50, 17) la-vector-access-cpp 134.991 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 2, 10, 50, 49) la-vector-assignment-cpp 32.112 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 3, 1, 26, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.3127 "BENCH 11.3127" (2014, 7, 3, 1, 27, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0643 "Building point search tree to accelerate distance queries." (2014, 7, 3, 1, 27, 22) geometry-bounding_box_tree_build-cpp 13.9784 "BENCH 13.9784" (2014, 7, 3, 1, 27, 49) common-progress-cpp 27.6228 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 3, 1, 28, 18) common-timing-cpp 28.8784 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 3, 1, 29, 50) fem-convergence-cpp 3.91488 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 3, 1, 29, 52) fem-jit-python 0.000348091 "JIT compilation (in memory cache)" (2014, 7, 3, 5, 6, 33) mesh-refinement-cpp 8.84145 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 3, 5, 6, 56) mesh-topology-cpp 22.7719 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 3, 5, 7, 19) mesh-unitcube-cpp 23.5724 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 3, 5, 8, 1) mesh-iteration-cpp 39.1655 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 3, 5, 8, 24) function-evaluation-cpp 22.8668 "Evaluations of functions at arbitrary points." (2014, 7, 3, 5, 8, 24) function-evaluation-cpp 22.768 "Evaluations of functions at arbitrary points." (2014, 7, 3, 5, 8, 29) function-extrapolation-python 4.7125 "Size of local-to-local: 10431" (2014, 7, 3, 5, 8, 29) function-extrapolation-python 2.04281 "Size of local-to-local: 10431" (2014, 7, 3, 5, 8, 31) function-interpolation-python 1.90006 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 3, 5, 8, 31) function-interpolation-python 0.899753 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 3, 5, 10, 44) la-vector-access-cpp 133.643 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 3, 5, 11, 16) la-vector-assignment-cpp 32.0402 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 4, 1, 29, 1) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.3187 "BENCH 11.3187" (2014, 7, 4, 1, 29, 20) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1377 "Building point search tree to accelerate distance queries." (2014, 7, 4, 1, 29, 36) geometry-bounding_box_tree_build-cpp 13.9265 "BENCH 13.9265" (2014, 7, 4, 1, 30, 4) common-progress-cpp 27.6636 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 4, 1, 30, 32) common-timing-cpp 28.4233 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 4, 1, 32, 5) fem-convergence-cpp 3.90253 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 4, 1, 32, 6) fem-jit-python 0.000353599 "JIT compilation (in memory cache)" (2014, 7, 4, 2, 11, 56) mesh-refinement-cpp 8.58864 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 4, 2, 12, 19) mesh-topology-cpp 22.5968 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 4, 2, 12, 43) mesh-unitcube-cpp 23.5129 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 4, 2, 13, 24) mesh-iteration-cpp 39.1708 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 4, 2, 13, 47) function-evaluation-cpp 22.6914 "Evaluations of functions at arbitrary points." (2014, 7, 4, 2, 13, 47) function-evaluation-cpp 22.5926 "Evaluations of functions at arbitrary points." (2014, 7, 4, 2, 13, 52) function-extrapolation-python 4.46566 "Size of local-to-local: 10431" (2014, 7, 4, 2, 13, 52) function-extrapolation-python 2.04701 "Size of local-to-local: 10431" (2014, 7, 4, 2, 13, 53) function-interpolation-python 1.8706 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 4, 2, 13, 53) function-interpolation-python 0.90085 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 4, 2, 16, 7) la-vector-access-cpp 133.399 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 4, 2, 16, 39) la-vector-assignment-cpp 32.0477 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 5, 1, 26, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.6891 "BENCH 11.6891" (2014, 7, 5, 1, 27, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0682 "Building point search tree to accelerate distance queries." (2014, 7, 5, 1, 27, 21) geometry-bounding_box_tree_build-cpp 13.9382 "BENCH 13.9382" (2014, 7, 5, 1, 27, 49) common-progress-cpp 27.6574 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 5, 1, 28, 18) common-timing-cpp 29.2292 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 5, 1, 29, 50) fem-convergence-cpp 3.86247 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 5, 1, 29, 52) fem-jit-python 0.000353193 "JIT compilation (in memory cache)" (2014, 7, 5, 5, 4, 43) mesh-refinement-cpp 8.96663 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 5, 5, 5, 6) mesh-topology-cpp 22.5666 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 5, 5, 5, 29) mesh-unitcube-cpp 23.4949 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 5, 5, 6, 11) mesh-iteration-cpp 39.1615 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 5, 5, 6, 34) function-evaluation-cpp 22.6459 "Evaluations of functions at arbitrary points." (2014, 7, 5, 5, 6, 34) function-evaluation-cpp 22.5423 "Evaluations of functions at arbitrary points." (2014, 7, 5, 5, 6, 38) function-extrapolation-python 4.68126 "Size of local-to-local: 10431" (2014, 7, 5, 5, 6, 38) function-extrapolation-python 2.0386 "Size of local-to-local: 10431" (2014, 7, 5, 5, 6, 40) function-interpolation-python 1.89517 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 5, 5, 6, 40) function-interpolation-python 0.912955 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 5, 5, 8, 56) la-vector-access-cpp 136.108 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 5, 5, 9, 29) la-vector-assignment-cpp 33.067 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 6, 1, 21, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2509 "BENCH 11.2509" (2014, 7, 6, 1, 22, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1458 "Building point search tree to accelerate distance queries." (2014, 7, 6, 1, 22, 18) geometry-bounding_box_tree_build-cpp 13.9784 "BENCH 13.9784" (2014, 7, 6, 1, 22, 45) common-progress-cpp 27.6584 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 6, 1, 23, 14) common-timing-cpp 28.7272 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 6, 1, 24, 47) fem-convergence-cpp 3.92311 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 6, 1, 24, 49) fem-jit-python 0.000357008 "JIT compilation (in memory cache)" (2014, 7, 6, 5, 9, 58) mesh-refinement-cpp 9.06574 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 6, 5, 10, 22) mesh-topology-cpp 23.2399 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 6, 5, 10, 46) mesh-unitcube-cpp 23.7118 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 6, 5, 11, 27) mesh-iteration-cpp 39.1798 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 6, 5, 11, 50) function-evaluation-cpp 22.9826 "Evaluations of functions at arbitrary points." (2014, 7, 6, 5, 11, 50) function-evaluation-cpp 22.879 "Evaluations of functions at arbitrary points." (2014, 7, 6, 5, 11, 55) function-extrapolation-python 4.77623 "Size of local-to-local: 10431" (2014, 7, 6, 5, 11, 55) function-extrapolation-python 2.04514 "Size of local-to-local: 10431" (2014, 7, 6, 5, 11, 57) function-interpolation-python 1.8745 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 6, 5, 11, 57) function-interpolation-python 0.891722 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 6, 5, 14, 11) la-vector-access-cpp 133.554 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 6, 5, 14, 43) la-vector-assignment-cpp 32.0162 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 7, 7, 1, 22, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0498 "BENCH 11.0498" (2014, 7, 7, 1, 22, 30) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1739 "Building point search tree to accelerate distance queries." (2014, 7, 7, 1, 22, 46) geometry-bounding_box_tree_build-cpp 13.9542 "BENCH 13.9542" (2014, 7, 7, 1, 23, 14) common-progress-cpp 27.6619 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 7, 7, 1, 23, 44) common-timing-cpp 29.9119 "Timing access and registration of timings (10000000 repetitions)" (2014, 7, 7, 1, 25, 16) fem-convergence-cpp 3.91938 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 7, 7, 1, 25, 18) fem-jit-python 0.000354791 "JIT compilation (in memory cache)" (2014, 7, 7, 4, 55, 21) mesh-refinement-cpp 8.70565 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 7, 7, 4, 55, 44) mesh-topology-cpp 22.221 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 7, 7, 4, 56, 7) mesh-unitcube-cpp 23.3569 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 7, 7, 4, 56, 46) mesh-iteration-cpp 36.2743 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 7, 7, 4, 57, 9) function-evaluation-cpp 23.5237 "Evaluations of functions at arbitrary points." (2014, 7, 7, 4, 57, 9) function-evaluation-cpp 23.4148 "Evaluations of functions at arbitrary points." (2014, 7, 7, 4, 57, 14) function-extrapolation-python 4.40324 "Size of local-to-local: 10431" (2014, 7, 7, 4, 57, 14) function-extrapolation-python 2.01151 "Size of local-to-local: 10431" (2014, 7, 7, 4, 57, 16) function-interpolation-python 1.83829 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 7, 4, 57, 16) function-interpolation-python 0.872781 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 7, 7, 4, 59, 33) la-vector-access-cpp 137.597 "Accessing vector of size 10000000 (100 repetitions)" (2014, 7, 7, 5, 0, 5) la-vector-assignment-cpp 32.0332 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 19, 11, 48, 14) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.077 "BENCH 11.077" (2014, 8, 19, 11, 48, 33) geometry-bounding_box_tree_compute_closest_entity-cpp 15.285 "Building point search tree to accelerate distance queries." (2014, 8, 19, 11, 48, 49) geometry-bounding_box_tree_build-cpp 14.1294 "BENCH 14.1294" (2014, 8, 19, 11, 49, 17) common-progress-cpp 27.6725 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 19, 11, 49, 48) common-timing-cpp 31.2013 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 19, 11, 51, 22) fem-convergence-cpp 3.86397 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 19, 11, 51, 44) fem-jit-python 0.000450301 "JIT compilation (in memory cache)" (2014, 8, 19, 12, 8, 18) mesh-refinement-cpp 8.49906 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 19, 12, 8, 40) mesh-topology-cpp 21.5914 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 19, 12, 9, 4) mesh-unitcube-cpp 23.42 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 19, 12, 9, 50) mesh-iteration-cpp 43.7055 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 19, 12, 9, 50) function-evaluation-cpp 0.053781 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 19, 12, 11, 2) function-extrapolation-python 71.9837 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2014, 8, 19, 12, 11, 2) function-extrapolation-python 2.00071 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2014, 8, 19, 12, 11, 10) function-interpolation-python 8.03047 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 19, 12, 11, 10) function-interpolation-python 0.913345 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 19, 12, 13, 41) la-vector-access-cpp 151.196 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 19, 12, 14, 23) la-vector-assignment-cpp 42.1399 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 20, 1, 8, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8741 "BENCH 10.8741" (2014, 8, 20, 1, 8, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9806 "Building point search tree to accelerate distance queries." (2014, 8, 20, 1, 9, 13) geometry-bounding_box_tree_build-cpp 14.1011 "BENCH 14.1011" (2014, 8, 20, 1, 9, 40) common-progress-cpp 27.8524 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 20, 1, 10, 12) common-timing-cpp 31.1595 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 20, 1, 11, 47) fem-convergence-cpp 3.9314 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 20, 1, 11, 49) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2014, 8, 20, 4, 19, 46) mesh-refinement-cpp 8.48749 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 20, 4, 20, 8) mesh-topology-cpp 21.8703 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 20, 4, 20, 31) mesh-unitcube-cpp 23.4506 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 20, 4, 21, 10) mesh-iteration-cpp 36.0472 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 20, 4, 21, 10) function-evaluation-cpp 0.0671489 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 20, 4, 21, 16) function-extrapolation-python 5.95647 "BENCH: 1.99171614647" (2014, 8, 20, 4, 21, 16) function-extrapolation-python 1.99172 "BENCH: 1.99171614647" (2014, 8, 20, 4, 21, 18) function-interpolation-python 2.22188 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 20, 4, 21, 18) function-interpolation-python 0.894065 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 20, 4, 23, 56) la-vector-access-cpp 158.179 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 20, 4, 24, 34) la-vector-assignment-cpp 38.0037 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 21, 1, 8, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0166 "BENCH 11.0166" (2014, 8, 21, 1, 8, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.033 "Building point search tree to accelerate distance queries." (2014, 8, 21, 1, 9, 13) geometry-bounding_box_tree_build-cpp 14.1668 "BENCH 14.1668" (2014, 8, 21, 1, 9, 41) common-progress-cpp 27.9021 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 21, 1, 10, 13) common-timing-cpp 31.4008 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 21, 1, 11, 47) fem-convergence-cpp 3.86568 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 21, 1, 11, 49) fem-jit-python 0.000415516 "JIT compilation (in memory cache)" (2014, 8, 21, 4, 25, 53) mesh-refinement-cpp 8.46743 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 21, 4, 26, 15) mesh-topology-cpp 21.6883 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 21, 4, 26, 38) mesh-unitcube-cpp 23.6333 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 21, 4, 27, 17) mesh-iteration-cpp 36.0312 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 21, 4, 27, 17) function-evaluation-cpp 0.07534 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 21, 4, 27, 23) function-extrapolation-python 5.86548 "BENCH: 1.98863577843" (2014, 8, 21, 4, 27, 23) function-extrapolation-python 1.98864 "BENCH: 1.98863577843" (2014, 8, 21, 4, 27, 25) function-interpolation-python 2.22035 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 21, 4, 27, 25) function-interpolation-python 0.899141 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 21, 4, 30, 3) la-vector-access-cpp 158.174 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 21, 4, 30, 41) la-vector-assignment-cpp 37.9964 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 22, 1, 8, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.904 "BENCH 10.904" (2014, 8, 22, 1, 9, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2122 "Building point search tree to accelerate distance queries." (2014, 8, 22, 1, 9, 24) geometry-bounding_box_tree_build-cpp 13.9089 "BENCH 13.9089" (2014, 8, 22, 1, 9, 51) common-progress-cpp 27.6201 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 22, 1, 10, 22) common-timing-cpp 31.2708 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 22, 1, 11, 56) fem-convergence-cpp 3.80037 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 22, 1, 11, 58) fem-jit-python 0.000435209 "JIT compilation (in memory cache)" (2014, 8, 22, 4, 19, 34) mesh-refinement-cpp 8.48611 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 22, 4, 19, 56) mesh-topology-cpp 21.708 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 22, 4, 20, 19) mesh-unitcube-cpp 23.3928 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 22, 4, 20, 58) mesh-iteration-cpp 36.0517 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 22, 4, 20, 58) function-evaluation-cpp 0.0837071 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 22, 4, 21, 4) function-extrapolation-python 5.68663 "BENCH: 1.99803900719" (2014, 8, 22, 4, 21, 4) function-extrapolation-python 1.99804 "BENCH: 1.99803900719" (2014, 8, 22, 4, 21, 6) function-interpolation-python 2.21084 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 22, 4, 21, 6) function-interpolation-python 0.891272 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 22, 4, 23, 44) la-vector-access-cpp 158.212 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 22, 4, 24, 22) la-vector-assignment-cpp 37.9906 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 23, 1, 8, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.929 "BENCH 10.929" (2014, 8, 23, 1, 8, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9172 "Building point search tree to accelerate distance queries." (2014, 8, 23, 1, 9, 13) geometry-bounding_box_tree_build-cpp 14.3342 "BENCH 14.3342" (2014, 8, 23, 1, 9, 41) common-progress-cpp 27.874 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 23, 1, 10, 12) common-timing-cpp 31.0914 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 23, 1, 11, 47) fem-convergence-cpp 3.82958 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 23, 1, 11, 48) fem-jit-python 0.000421405 "JIT compilation (in memory cache)" (2014, 8, 23, 4, 31, 9) mesh-refinement-cpp 8.4711 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 23, 4, 31, 31) mesh-topology-cpp 21.6672 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 23, 4, 31, 54) mesh-unitcube-cpp 23.4117 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 23, 4, 32, 33) mesh-iteration-cpp 36.0319 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 23, 4, 32, 33) function-evaluation-cpp 0.0753469 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 23, 4, 32, 39) function-extrapolation-python 5.92421 "BENCH: 2.01829004288" (2014, 8, 23, 4, 32, 39) function-extrapolation-python 2.01829 "BENCH: 2.01829004288" (2014, 8, 23, 4, 32, 41) function-interpolation-python 2.21605 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 23, 4, 32, 41) function-interpolation-python 0.896607 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 23, 4, 35, 17) la-vector-access-cpp 156.218 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 23, 4, 35, 55) la-vector-assignment-cpp 37.9969 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 24, 1, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8986 "BENCH 10.8986" (2014, 8, 24, 1, 8, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9513 "Building point search tree to accelerate distance queries." (2014, 8, 24, 1, 9, 14) geometry-bounding_box_tree_build-cpp 13.973 "BENCH 13.973" (2014, 8, 24, 1, 9, 42) common-progress-cpp 27.9071 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 24, 1, 10, 12) common-timing-cpp 30.6658 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 24, 1, 11, 47) fem-convergence-cpp 3.88126 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 24, 1, 11, 48) fem-jit-python 0.000416899 "JIT compilation (in memory cache)" (2014, 8, 24, 4, 19, 1) mesh-refinement-cpp 8.43317 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 24, 4, 19, 23) mesh-topology-cpp 21.7043 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 24, 4, 19, 47) mesh-unitcube-cpp 23.4283 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 24, 4, 20, 25) mesh-iteration-cpp 36.0563 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 24, 4, 20, 25) function-evaluation-cpp 0.075469 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 24, 4, 20, 31) function-extrapolation-python 5.66587 "BENCH: 1.98955583572" (2014, 8, 24, 4, 20, 31) function-extrapolation-python 1.98956 "BENCH: 1.98955583572" (2014, 8, 24, 4, 20, 33) function-interpolation-python 2.21552 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 24, 4, 20, 33) function-interpolation-python 0.895287 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 24, 4, 23, 11) la-vector-access-cpp 158.152 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 24, 4, 23, 49) la-vector-assignment-cpp 38.0358 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 25, 1, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9642 "BENCH 10.9642" (2014, 8, 25, 1, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3169 "Building point search tree to accelerate distance queries." (2014, 8, 25, 1, 9, 15) geometry-bounding_box_tree_build-cpp 14.0211 "BENCH 14.0211" (2014, 8, 25, 1, 9, 43) common-progress-cpp 27.8728 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 25, 1, 10, 14) common-timing-cpp 31.9251 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 25, 1, 11, 49) fem-convergence-cpp 3.83493 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 25, 1, 11, 50) fem-jit-python 0.000431108 "JIT compilation (in memory cache)" (2014, 8, 25, 4, 23, 1) mesh-refinement-cpp 8.48825 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 25, 4, 23, 23) mesh-topology-cpp 21.6512 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 25, 4, 23, 47) mesh-unitcube-cpp 23.4021 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 25, 4, 24, 25) mesh-iteration-cpp 36.028 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 25, 4, 24, 25) function-evaluation-cpp 0.050108 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 25, 4, 24, 31) function-extrapolation-python 5.76555 "BENCH: 2.00843095779" (2014, 8, 25, 4, 24, 31) function-extrapolation-python 2.00843 "BENCH: 2.00843095779" (2014, 8, 25, 4, 24, 33) function-interpolation-python 2.22132 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 25, 4, 24, 33) function-interpolation-python 0.892987 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 25, 4, 27, 10) la-vector-access-cpp 156.214 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 25, 4, 27, 48) la-vector-assignment-cpp 37.9736 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 26, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8956 "BENCH 10.8956" (2014, 8, 26, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1347 "Building point search tree to accelerate distance queries." (2014, 8, 26, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.1684 "BENCH 14.1684" (2014, 8, 26, 1, 9, 46) common-progress-cpp 27.8921 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 26, 1, 10, 17) common-timing-cpp 30.9387 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 26, 1, 11, 51) fem-convergence-cpp 3.81667 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 26, 1, 11, 53) fem-jit-python 0.000411701 "JIT compilation (in memory cache)" (2014, 8, 26, 4, 29, 11) mesh-refinement-cpp 8.5057 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 26, 4, 29, 33) mesh-topology-cpp 21.6696 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 26, 4, 29, 57) mesh-unitcube-cpp 23.433 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 26, 4, 30, 35) mesh-iteration-cpp 36.0279 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 26, 4, 30, 35) function-evaluation-cpp 0.0584321 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 26, 4, 30, 52) function-extrapolation-python 16.6677 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 26, 4, 30, 52) function-extrapolation-python 2.00544 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 26, 4, 31, 0) function-interpolation-python 7.6663 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 26, 4, 31, 0) function-interpolation-python 0.905526 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2014, 8, 26, 4, 33, 34) la-vector-access-cpp 154.256 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 26, 4, 34, 16) la-vector-assignment-cpp 41.9977 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 27, 1, 8, 50) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9746 "BENCH 10.9746" (2014, 8, 27, 1, 9, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2658 "Building point search tree to accelerate distance queries." (2014, 8, 27, 1, 9, 25) geometry-bounding_box_tree_build-cpp 13.9547 "BENCH 13.9547" (2014, 8, 27, 1, 9, 53) common-progress-cpp 27.6262 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 27, 1, 10, 24) common-timing-cpp 30.945 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 27, 1, 11, 58) fem-convergence-cpp 3.82194 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 27, 1, 12, 0) fem-jit-python 0.000418401 "JIT compilation (in memory cache)" (2014, 8, 27, 4, 24, 49) mesh-refinement-cpp 8.48804 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 27, 4, 25, 11) mesh-topology-cpp 21.7373 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 27, 4, 25, 34) mesh-unitcube-cpp 23.4172 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 27, 4, 26, 13) mesh-iteration-cpp 36.1167 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 27, 4, 26, 13) function-evaluation-cpp 0.0784979 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 27, 4, 26, 19) function-extrapolation-python 6.42418 "BENCH: 2.09120702744" (2014, 8, 27, 4, 26, 19) function-extrapolation-python 2.09121 "BENCH: 2.09120702744" (2014, 8, 27, 4, 26, 22) function-interpolation-python 2.31158 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 27, 4, 26, 22) function-interpolation-python 0.946009 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 27, 4, 28, 57) la-vector-access-cpp 155.509 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 27, 4, 29, 35) la-vector-assignment-cpp 37.9954 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 28, 1, 8, 50) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0549 "BENCH 11.0549" (2014, 8, 28, 1, 9, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1792 "Building point search tree to accelerate distance queries." (2014, 8, 28, 1, 9, 25) geometry-bounding_box_tree_build-cpp 14.3099 "BENCH 14.3099" (2014, 8, 28, 1, 9, 53) common-progress-cpp 27.888 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 28, 1, 10, 24) common-timing-cpp 31.384 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 28, 1, 11, 59) fem-convergence-cpp 3.88893 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 28, 1, 12, 0) fem-jit-python 0.000419188 "JIT compilation (in memory cache)" (2014, 8, 28, 4, 27, 58) mesh-refinement-cpp 8.62345 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 28, 4, 28, 20) mesh-topology-cpp 21.9155 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 28, 4, 28, 44) mesh-unitcube-cpp 23.6162 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 28, 4, 29, 22) mesh-iteration-cpp 36.2655 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 28, 4, 29, 22) function-evaluation-cpp 0.0813129 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 28, 4, 29, 29) function-extrapolation-python 6.01153 "BENCH: 2.04151010513" (2014, 8, 28, 4, 29, 29) function-extrapolation-python 2.04151 "BENCH: 2.04151010513" (2014, 8, 28, 4, 29, 31) function-interpolation-python 2.30388 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 28, 4, 29, 31) function-interpolation-python 0.919988 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 28, 4, 32, 7) la-vector-access-cpp 156.549 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 28, 4, 32, 45) la-vector-assignment-cpp 37.9682 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 29, 1, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9203 "BENCH 10.9203" (2014, 8, 29, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8842 "Building point search tree to accelerate distance queries." (2014, 8, 29, 1, 9, 20) geometry-bounding_box_tree_build-cpp 13.9697 "BENCH 13.9697" (2014, 8, 29, 1, 9, 48) common-progress-cpp 27.8818 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 29, 1, 10, 18) common-timing-cpp 30.6499 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 29, 1, 11, 53) fem-convergence-cpp 3.85991 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 29, 1, 12, 0) fem-jit-python 0.000456786 "JIT compilation (in memory cache)" (2014, 8, 29, 4, 22, 45) mesh-refinement-cpp 8.51531 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 29, 4, 23, 7) mesh-topology-cpp 21.4879 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 29, 4, 23, 30) mesh-unitcube-cpp 22.6354 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 29, 4, 24, 8) mesh-iteration-cpp 35.5387 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 29, 4, 24, 8) function-evaluation-cpp 0.0533762 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 29, 4, 24, 14) function-extrapolation-python 5.93574 "BENCH: 2.02293300629" (2014, 8, 29, 4, 24, 14) function-extrapolation-python 2.02293 "BENCH: 2.02293300629" (2014, 8, 29, 4, 24, 16) function-interpolation-python 2.23636 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 29, 4, 24, 16) function-interpolation-python 0.87529 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 29, 4, 26, 58) la-vector-access-cpp 161.785 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 29, 4, 27, 40) la-vector-assignment-cpp 42.0398 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 30, 1, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9434 "BENCH 10.9434" (2014, 8, 30, 1, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.105 "Building point search tree to accelerate distance queries." (2014, 8, 30, 1, 9, 22) geometry-bounding_box_tree_build-cpp 14.0379 "BENCH 14.0379" (2014, 8, 30, 1, 9, 50) common-progress-cpp 27.8936 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 30, 1, 10, 20) common-timing-cpp 30.3724 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 30, 1, 11, 56) fem-convergence-cpp 3.87327 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 30, 1, 11, 58) fem-jit-python 0.000426698 "JIT compilation (in memory cache)" (2014, 8, 30, 4, 24, 13) mesh-refinement-cpp 8.48145 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 30, 4, 24, 35) mesh-topology-cpp 21.4934 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 30, 4, 24, 58) mesh-unitcube-cpp 22.6508 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 30, 4, 25, 36) mesh-iteration-cpp 35.5615 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 30, 4, 25, 36) function-evaluation-cpp 0.0640409 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 30, 4, 25, 42) function-extrapolation-python 5.94789 "BENCH: 2.00775980949" (2014, 8, 30, 4, 25, 42) function-extrapolation-python 2.00776 "BENCH: 2.00775980949" (2014, 8, 30, 4, 25, 44) function-interpolation-python 2.25067 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 30, 4, 25, 44) function-interpolation-python 0.904744 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 30, 4, 28, 22) la-vector-access-cpp 158.142 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 30, 4, 29, 7) la-vector-assignment-cpp 44.2976 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 8, 31, 1, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8723 "BENCH 10.8723" (2014, 8, 31, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1068 "Building point search tree to accelerate distance queries." (2014, 8, 31, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.3833 "BENCH 14.3833" (2014, 8, 31, 1, 9, 45) common-progress-cpp 27.931 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 8, 31, 1, 10, 16) common-timing-cpp 31.0883 "Timing access and registration of timings (10000000 repetitions)" (2014, 8, 31, 1, 11, 52) fem-convergence-cpp 3.86391 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 8, 31, 1, 11, 53) fem-jit-python 0.000422096 "JIT compilation (in memory cache)" (2014, 8, 31, 4, 30, 39) mesh-refinement-cpp 8.45525 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 8, 31, 4, 31, 1) mesh-topology-cpp 21.3585 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 8, 31, 4, 31, 24) mesh-unitcube-cpp 22.6825 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 8, 31, 4, 32, 2) mesh-iteration-cpp 35.5453 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 8, 31, 4, 32, 2) function-evaluation-cpp 0.053719 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 8, 31, 4, 32, 8) function-extrapolation-python 5.98229 "BENCH: 2.00886392593" (2014, 8, 31, 4, 32, 8) function-extrapolation-python 2.00886 "BENCH: 2.00886392593" (2014, 8, 31, 4, 32, 10) function-interpolation-python 2.21536 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 31, 4, 32, 10) function-interpolation-python 0.884962 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 8, 31, 4, 34, 47) la-vector-access-cpp 157.489 "Accessing vector of size 10000000 (100 repetitions)" (2014, 8, 31, 4, 35, 30) la-vector-assignment-cpp 42.0686 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 1, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9115 "BENCH 10.9115" (2014, 9, 1, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5028 "Building point search tree to accelerate distance queries." (2014, 9, 1, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.195 "BENCH 14.195" (2014, 9, 1, 1, 9, 45) common-progress-cpp 27.8993 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 1, 1, 10, 16) common-timing-cpp 31.0683 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 1, 1, 11, 52) fem-convergence-cpp 3.83639 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 1, 1, 11, 53) fem-jit-python 0.000415611 "JIT compilation (in memory cache)" (2014, 9, 1, 4, 47, 2) mesh-refinement-cpp 8.60175 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 1, 4, 47, 24) mesh-topology-cpp 21.5571 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 1, 4, 47, 47) mesh-unitcube-cpp 22.9359 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 1, 4, 48, 25) mesh-iteration-cpp 35.7878 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 1, 4, 48, 25) function-evaluation-cpp 0.078711 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 1, 4, 48, 32) function-extrapolation-python 6.07803 "BENCH: 2.1369228363" (2014, 9, 1, 4, 48, 32) function-extrapolation-python 2.13692 "BENCH: 2.1369228363" (2014, 9, 1, 4, 48, 34) function-interpolation-python 2.30394 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 1, 4, 48, 34) function-interpolation-python 0.914327 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 1, 4, 51, 8) la-vector-access-cpp 154.595 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 1, 4, 51, 50) la-vector-assignment-cpp 42.0277 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 2, 1, 8, 52) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0015 "BENCH 11.0015" (2014, 9, 2, 1, 9, 10) geometry-bounding_box_tree_compute_closest_entity-cpp 14.979 "Building point search tree to accelerate distance queries." (2014, 9, 2, 1, 9, 27) geometry-bounding_box_tree_build-cpp 14.2437 "BENCH 14.2437" (2014, 9, 2, 1, 9, 55) common-progress-cpp 27.917 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 2, 1, 10, 26) common-timing-cpp 31.0079 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 2, 1, 12, 1) fem-convergence-cpp 3.86938 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 2, 1, 12, 2) fem-jit-python 0.000417185 "JIT compilation (in memory cache)" (2014, 9, 2, 4, 28, 49) mesh-refinement-cpp 8.47656 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 2, 4, 29, 11) mesh-topology-cpp 21.4633 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 2, 4, 29, 34) mesh-unitcube-cpp 23.38 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 2, 4, 30, 12) mesh-iteration-cpp 35.5757 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 2, 4, 30, 13) function-evaluation-cpp 0.0771639 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 2, 4, 30, 18) function-extrapolation-python 5.81751 "BENCH: 2.0208530426" (2014, 9, 2, 4, 30, 18) function-extrapolation-python 2.02085 "BENCH: 2.0208530426" (2014, 9, 2, 4, 30, 21) function-interpolation-python 2.26008 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 2, 4, 30, 21) function-interpolation-python 0.913586 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 2, 4, 32, 57) la-vector-access-cpp 155.822 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 2, 4, 33, 42) la-vector-assignment-cpp 45.2544 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 3, 1, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8367 "BENCH 10.8367" (2014, 9, 3, 1, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3025 "Building point search tree to accelerate distance queries." (2014, 9, 3, 1, 9, 22) geometry-bounding_box_tree_build-cpp 14.1915 "BENCH 14.1915" (2014, 9, 3, 1, 9, 50) common-progress-cpp 27.8836 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 3, 1, 10, 20) common-timing-cpp 30.1277 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 3, 1, 11, 55) fem-convergence-cpp 3.88529 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 3, 1, 11, 57) fem-jit-python 0.000422812 "JIT compilation (in memory cache)" (2014, 9, 3, 4, 26, 13) mesh-refinement-cpp 8.47785 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 3, 4, 26, 35) mesh-topology-cpp 21.411 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 3, 4, 26, 58) mesh-unitcube-cpp 23.0924 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 3, 4, 27, 36) mesh-iteration-cpp 35.5674 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 3, 4, 27, 36) function-evaluation-cpp 0.0721509 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 3, 4, 27, 42) function-extrapolation-python 5.7285 "BENCH: 2.01886510849" (2014, 9, 3, 4, 27, 42) function-extrapolation-python 2.01887 "BENCH: 2.01886510849" (2014, 9, 3, 4, 27, 44) function-interpolation-python 2.24199 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 3, 4, 27, 44) function-interpolation-python 0.912348 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 3, 4, 30, 18) la-vector-access-cpp 154.246 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 3, 4, 31, 5) la-vector-assignment-cpp 46.0905 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 4, 1, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0112 "BENCH 11.0112" (2014, 9, 4, 1, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0598 "Building point search tree to accelerate distance queries." (2014, 9, 4, 1, 9, 16) geometry-bounding_box_tree_build-cpp 14.0399 "BENCH 14.0399" (2014, 9, 4, 1, 9, 44) common-progress-cpp 27.8849 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 4, 1, 10, 14) common-timing-cpp 30.5947 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 4, 1, 11, 51) fem-convergence-cpp 3.85542 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 4, 1, 11, 52) fem-jit-python 0.00042069 "JIT compilation (in memory cache)" (2014, 9, 4, 4, 22, 17) mesh-refinement-cpp 8.50664 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 4, 4, 22, 39) mesh-topology-cpp 21.4017 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 4, 4, 23, 2) mesh-unitcube-cpp 23.0456 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 4, 4, 23, 48) mesh-iteration-cpp 44.2171 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 4, 4, 23, 48) function-evaluation-cpp 0.0501351 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 4, 4, 23, 54) function-extrapolation-python 5.80395 "BENCH: 2.00869512558" (2014, 9, 4, 4, 23, 54) function-extrapolation-python 2.0087 "BENCH: 2.00869512558" (2014, 9, 4, 4, 23, 57) function-interpolation-python 2.25807 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 4, 4, 23, 57) function-interpolation-python 0.903686 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 4, 4, 26, 31) la-vector-access-cpp 154.298 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 4, 4, 27, 13) la-vector-assignment-cpp 42.0208 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 5, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.764 "BENCH 10.764" (2014, 9, 5, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2216 "Building point search tree to accelerate distance queries." (2014, 9, 5, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.1082 "BENCH 14.1082" (2014, 9, 5, 1, 9, 46) common-progress-cpp 27.8915 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 5, 1, 10, 17) common-timing-cpp 30.9337 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 5, 1, 11, 51) fem-convergence-cpp 3.85862 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 5, 1, 11, 52) fem-jit-python 0.000414109 "JIT compilation (in memory cache)" (2014, 9, 5, 4, 22, 23) mesh-refinement-cpp 8.46208 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 5, 4, 22, 45) mesh-topology-cpp 21.4841 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 5, 4, 23, 8) mesh-unitcube-cpp 22.9852 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 5, 4, 23, 46) mesh-iteration-cpp 36.2857 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 5, 4, 23, 46) function-evaluation-cpp 0.062017 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 5, 4, 23, 52) function-extrapolation-python 5.80298 "BENCH: 2.01900601387" (2014, 9, 5, 4, 23, 52) function-extrapolation-python 2.01901 "BENCH: 2.01900601387" (2014, 9, 5, 4, 23, 55) function-interpolation-python 2.49063 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 5, 4, 23, 55) function-interpolation-python 0.911128 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 5, 4, 26, 29) la-vector-access-cpp 154.273 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 5, 4, 27, 11) la-vector-assignment-cpp 42.0408 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 6, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8047 "BENCH 10.8047" (2014, 9, 6, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1886 "Building point search tree to accelerate distance queries." (2014, 9, 6, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.2227 "BENCH 14.2227" (2014, 9, 6, 1, 9, 47) common-progress-cpp 27.8941 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 6, 1, 10, 18) common-timing-cpp 31.3185 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 6, 1, 11, 53) fem-convergence-cpp 3.85491 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 6, 1, 11, 55) fem-jit-python 0.000408816 "JIT compilation (in memory cache)" (2014, 9, 6, 4, 31, 7) mesh-refinement-cpp 8.47211 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 6, 4, 31, 29) mesh-topology-cpp 21.5082 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 6, 4, 31, 52) mesh-unitcube-cpp 23.2232 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 6, 4, 32, 30) mesh-iteration-cpp 35.5478 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 6, 4, 32, 30) function-evaluation-cpp 0.0516791 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 6, 4, 32, 36) function-extrapolation-python 6.01284 "BENCH: 2.00429582596" (2014, 9, 6, 4, 32, 36) function-extrapolation-python 2.0043 "BENCH: 2.00429582596" (2014, 9, 6, 4, 32, 38) function-interpolation-python 2.22167 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 6, 4, 32, 38) function-interpolation-python 0.900598 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 6, 4, 35, 12) la-vector-access-cpp 153.945 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 6, 4, 35, 54) la-vector-assignment-cpp 42.0276 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 7, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8879 "BENCH 10.8879" (2014, 9, 7, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0942 "Building point search tree to accelerate distance queries." (2014, 9, 7, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.072 "BENCH 14.072" (2014, 9, 7, 1, 9, 46) common-progress-cpp 27.898 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 7, 1, 10, 17) common-timing-cpp 31.0605 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 7, 1, 11, 51) fem-convergence-cpp 3.84389 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 7, 1, 11, 52) fem-jit-python 0.000417495 "JIT compilation (in memory cache)" (2014, 9, 7, 4, 30, 50) mesh-refinement-cpp 8.46327 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 7, 4, 31, 11) mesh-topology-cpp 21.3922 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 7, 4, 31, 34) mesh-unitcube-cpp 22.9951 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 7, 4, 32, 12) mesh-iteration-cpp 35.5474 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 7, 4, 32, 13) function-evaluation-cpp 0.075016 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 7, 4, 32, 18) function-extrapolation-python 5.7426 "BENCH: 2.02323198318" (2014, 9, 7, 4, 32, 18) function-extrapolation-python 2.02323 "BENCH: 2.02323198318" (2014, 9, 7, 4, 32, 21) function-interpolation-python 2.25956 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 7, 4, 32, 21) function-interpolation-python 0.905533 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 7, 4, 34, 55) la-vector-access-cpp 154.281 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 7, 4, 35, 41) la-vector-assignment-cpp 46.0512 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 8, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9712 "BENCH 10.9712" (2014, 9, 8, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9414 "Building point search tree to accelerate distance queries." (2014, 9, 8, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.1928 "BENCH 14.1928" (2014, 9, 8, 1, 9, 45) common-progress-cpp 27.8832 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 8, 1, 10, 17) common-timing-cpp 32.0855 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 8, 1, 11, 51) fem-convergence-cpp 3.89564 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 8, 1, 11, 52) fem-jit-python 0.000423908 "JIT compilation (in memory cache)" (2014, 9, 8, 4, 24, 23) mesh-refinement-cpp 8.45608 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 8, 4, 24, 45) mesh-topology-cpp 21.6336 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 8, 4, 25, 8) mesh-unitcube-cpp 23.1143 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 8, 4, 25, 46) mesh-iteration-cpp 35.5826 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 8, 4, 25, 46) function-evaluation-cpp 0.049273 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 8, 4, 25, 52) function-extrapolation-python 5.65838 "BENCH: 2.01732492447" (2014, 9, 8, 4, 25, 52) function-extrapolation-python 2.01732 "BENCH: 2.01732492447" (2014, 9, 8, 4, 25, 54) function-interpolation-python 2.23275 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 8, 4, 25, 54) function-interpolation-python 0.903293 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 8, 4, 28, 28) la-vector-access-cpp 154.207 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 8, 4, 29, 11) la-vector-assignment-cpp 42.0417 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 9, 1, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9074 "BENCH 10.9074" (2014, 9, 9, 1, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0337 "Building point search tree to accelerate distance queries." (2014, 9, 9, 1, 9, 20) geometry-bounding_box_tree_build-cpp 14.2708 "BENCH 14.2708" (2014, 9, 9, 1, 9, 48) common-progress-cpp 27.8971 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 9, 1, 10, 18) common-timing-cpp 29.921 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 9, 1, 11, 54) fem-convergence-cpp 3.85837 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 9, 1, 11, 55) fem-jit-python 0.000415301 "JIT compilation (in memory cache)" (2014, 9, 9, 4, 32, 46) mesh-refinement-cpp 8.44559 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 9, 4, 33, 7) mesh-topology-cpp 21.5361 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 9, 4, 33, 30) mesh-unitcube-cpp 23.0574 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 9, 4, 34, 11) mesh-iteration-cpp 38.5622 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 9, 4, 34, 12) function-evaluation-cpp 0.0723112 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 9, 4, 34, 17) function-extrapolation-python 5.68205 "BENCH: 2.03897309303" (2014, 9, 9, 4, 34, 17) function-extrapolation-python 2.03897 "BENCH: 2.03897309303" (2014, 9, 9, 4, 34, 20) function-interpolation-python 2.22627 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 9, 4, 34, 20) function-interpolation-python 0.905261 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 9, 4, 36, 54) la-vector-access-cpp 154.239 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 9, 4, 37, 36) la-vector-assignment-cpp 42.0299 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 10, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.087 "BENCH 11.087" (2014, 9, 10, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0756 "Building point search tree to accelerate distance queries." (2014, 9, 10, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2406 "BENCH 14.2406" (2014, 9, 10, 1, 9, 46) common-progress-cpp 27.8986 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 10, 1, 10, 17) common-timing-cpp 30.6666 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 10, 1, 11, 52) fem-convergence-cpp 3.84558 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 10, 1, 11, 53) fem-jit-python 0.000425386 "JIT compilation (in memory cache)" (2014, 9, 10, 4, 30, 26) mesh-refinement-cpp 8.48355 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 10, 4, 30, 48) mesh-topology-cpp 21.4691 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 10, 4, 31, 11) mesh-unitcube-cpp 23.0309 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 10, 4, 31, 52) mesh-iteration-cpp 39.3577 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 10, 4, 31, 53) function-evaluation-cpp 0.0497038 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 10, 4, 31, 59) function-extrapolation-python 5.94594 "BENCH: 2.01752090454" (2014, 9, 10, 4, 31, 59) function-extrapolation-python 2.01752 "BENCH: 2.01752090454" (2014, 9, 10, 4, 32, 1) function-interpolation-python 2.27198 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 10, 4, 32, 1) function-interpolation-python 0.917033 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 10, 4, 34, 36) la-vector-access-cpp 154.723 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 10, 4, 35, 18) la-vector-assignment-cpp 42.0062 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 11, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0399 "BENCH 11.0399" (2014, 9, 11, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.186 "Building point search tree to accelerate distance queries." (2014, 9, 11, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.3375 "BENCH 14.3375" (2014, 9, 11, 1, 9, 46) common-progress-cpp 27.8976 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 11, 1, 10, 16) common-timing-cpp 30.7362 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 11, 1, 11, 52) fem-convergence-cpp 3.86909 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 11, 1, 11, 54) fem-jit-python 0.000418401 "JIT compilation (in memory cache)" (2014, 9, 11, 4, 33, 28) mesh-refinement-cpp 8.48814 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 11, 4, 33, 50) mesh-topology-cpp 21.497 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 11, 4, 34, 13) mesh-unitcube-cpp 23.1856 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 11, 4, 34, 59) mesh-iteration-cpp 43.5618 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 11, 4, 34, 59) function-evaluation-cpp 0.0638158 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 11, 4, 35, 5) function-extrapolation-python 5.85155 "BENCH: 2.01931405067" (2014, 9, 11, 4, 35, 5) function-extrapolation-python 2.01931 "BENCH: 2.01931405067" (2014, 9, 11, 4, 35, 7) function-interpolation-python 2.23355 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 11, 4, 35, 7) function-interpolation-python 0.903938 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 11, 4, 37, 42) la-vector-access-cpp 154.736 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 11, 4, 38, 24) la-vector-assignment-cpp 42.0671 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 12, 1, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8273 "BENCH 10.8273" (2014, 9, 12, 1, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1261 "Building point search tree to accelerate distance queries." (2014, 9, 12, 1, 9, 21) geometry-bounding_box_tree_build-cpp 14.2071 "BENCH 14.2071" (2014, 9, 12, 1, 9, 49) common-progress-cpp 27.8936 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 12, 1, 10, 20) common-timing-cpp 31.1874 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 12, 1, 11, 54) fem-convergence-cpp 3.91883 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 12, 1, 11, 55) fem-jit-python 0.000412393 "JIT compilation (in memory cache)" (2014, 9, 12, 4, 35, 36) mesh-refinement-cpp 8.46094 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 12, 4, 35, 58) mesh-topology-cpp 21.4469 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 12, 4, 36, 21) mesh-unitcube-cpp 23.1699 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 12, 4, 36, 59) mesh-iteration-cpp 35.5497 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 12, 4, 36, 59) function-evaluation-cpp 0.0518649 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 12, 4, 37, 5) function-extrapolation-python 5.87377 "BENCH: 2.04101991653" (2014, 9, 12, 4, 37, 5) function-extrapolation-python 2.04102 "BENCH: 2.04101991653" (2014, 9, 12, 4, 37, 7) function-interpolation-python 2.22415 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 12, 4, 37, 7) function-interpolation-python 0.90332 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 12, 4, 39, 41) la-vector-access-cpp 154.286 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 12, 4, 40, 23) la-vector-assignment-cpp 42.0293 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 13, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8967 "BENCH 10.8967" (2014, 9, 13, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2407 "Building point search tree to accelerate distance queries." (2014, 9, 13, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.3111 "BENCH 14.3111" (2014, 9, 13, 1, 9, 47) common-progress-cpp 27.8827 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 13, 1, 10, 19) common-timing-cpp 32.1116 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 13, 1, 11, 53) fem-convergence-cpp 3.8763 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 13, 1, 11, 54) fem-jit-python 0.000419998 "JIT compilation (in memory cache)" (2014, 9, 13, 4, 31, 0) mesh-refinement-cpp 8.45984 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 13, 4, 31, 22) mesh-topology-cpp 21.3931 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 13, 4, 31, 45) mesh-unitcube-cpp 23.0035 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 13, 4, 32, 23) mesh-iteration-cpp 35.5684 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 13, 4, 32, 23) function-evaluation-cpp 0.070559 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 13, 4, 32, 29) function-extrapolation-python 5.71352 "BENCH: 2.0042989254" (2014, 9, 13, 4, 32, 29) function-extrapolation-python 2.0043 "BENCH: 2.0042989254" (2014, 9, 13, 4, 32, 31) function-interpolation-python 2.23088 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 13, 4, 32, 31) function-interpolation-python 0.901292 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 13, 4, 35, 5) la-vector-access-cpp 154.263 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 13, 4, 35, 47) la-vector-assignment-cpp 41.9548 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 14, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.999 "BENCH 10.999" (2014, 9, 14, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5079 "Building point search tree to accelerate distance queries." (2014, 9, 14, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.1384 "BENCH 14.1384" (2014, 9, 14, 1, 9, 47) common-progress-cpp 27.8918 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 14, 1, 10, 19) common-timing-cpp 31.4969 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 14, 1, 11, 53) fem-convergence-cpp 3.88005 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 14, 1, 11, 55) fem-jit-python 0.000421786 "JIT compilation (in memory cache)" (2014, 9, 14, 4, 22, 25) mesh-refinement-cpp 8.50049 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 14, 4, 22, 46) mesh-topology-cpp 21.3652 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 14, 4, 23, 10) mesh-unitcube-cpp 23.4214 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 14, 4, 23, 48) mesh-iteration-cpp 36.0728 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 14, 4, 23, 48) function-evaluation-cpp 0.064131 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 14, 4, 23, 54) function-extrapolation-python 5.73508 "BENCH: 1.99808907509" (2014, 9, 14, 4, 23, 54) function-extrapolation-python 1.99809 "BENCH: 1.99808907509" (2014, 9, 14, 4, 23, 56) function-interpolation-python 2.25231 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 14, 4, 23, 56) function-interpolation-python 0.902024 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 14, 4, 26, 32) la-vector-access-cpp 155.278 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 14, 4, 27, 14) la-vector-assignment-cpp 42.0296 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 15, 1, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.7953 "BENCH 10.7953" (2014, 9, 15, 1, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2086 "Building point search tree to accelerate distance queries." (2014, 9, 15, 1, 9, 16) geometry-bounding_box_tree_build-cpp 14.1424 "BENCH 14.1424" (2014, 9, 15, 1, 9, 44) common-progress-cpp 27.8856 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 15, 1, 10, 15) common-timing-cpp 31.203 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 15, 1, 11, 50) fem-convergence-cpp 3.85298 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 15, 1, 11, 51) fem-jit-python 0.000429606 "JIT compilation (in memory cache)" (2014, 9, 15, 4, 35, 24) mesh-refinement-cpp 8.50251 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 15, 4, 35, 45) mesh-topology-cpp 21.3698 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 15, 4, 36, 9) mesh-unitcube-cpp 23.4559 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 15, 4, 36, 47) mesh-iteration-cpp 36.0467 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 15, 4, 36, 47) function-evaluation-cpp 0.07511 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 15, 4, 36, 53) function-extrapolation-python 5.88011 "BENCH: 1.98558187485" (2014, 9, 15, 4, 36, 53) function-extrapolation-python 1.98558 "BENCH: 1.98558187485" (2014, 9, 15, 4, 36, 56) function-interpolation-python 2.24582 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 15, 4, 36, 56) function-interpolation-python 0.907002 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 15, 4, 39, 31) la-vector-access-cpp 155.798 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 15, 4, 40, 14) la-vector-assignment-cpp 42.0389 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 16, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0602 "BENCH 11.0602" (2014, 9, 16, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3187 "Building point search tree to accelerate distance queries." (2014, 9, 16, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.2834 "BENCH 14.2834" (2014, 9, 16, 1, 9, 47) common-progress-cpp 27.8961 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 16, 1, 10, 17) common-timing-cpp 30.8638 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 16, 1, 11, 53) fem-convergence-cpp 3.89368 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 16, 1, 11, 54) fem-jit-python 0.000425601 "JIT compilation (in memory cache)" (2014, 9, 16, 4, 30, 7) mesh-refinement-cpp 8.49763 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 16, 4, 30, 29) mesh-topology-cpp 21.4045 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 16, 4, 30, 53) mesh-unitcube-cpp 23.6097 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 16, 4, 31, 31) mesh-iteration-cpp 36.0477 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 16, 4, 31, 31) function-evaluation-cpp 0.053659 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 16, 4, 31, 37) function-extrapolation-python 5.71606 "BENCH: 1.99019193649" (2014, 9, 16, 4, 31, 37) function-extrapolation-python 1.99019 "BENCH: 1.99019193649" (2014, 9, 16, 4, 31, 39) function-interpolation-python 2.24231 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 16, 4, 31, 39) function-interpolation-python 0.904181 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 16, 4, 34, 15) la-vector-access-cpp 155.321 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 16, 4, 34, 57) la-vector-assignment-cpp 42.0513 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 17, 1, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9969 "BENCH 10.9969" (2014, 9, 17, 1, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2115 "Building point search tree to accelerate distance queries." (2014, 9, 17, 1, 9, 16) geometry-bounding_box_tree_build-cpp 14.0336 "BENCH 14.0336" (2014, 9, 17, 1, 9, 44) common-progress-cpp 27.9423 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 17, 1, 10, 15) common-timing-cpp 31.2551 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 17, 1, 11, 51) fem-convergence-cpp 3.85725 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 17, 1, 11, 52) fem-jit-python 0.000427699 "JIT compilation (in memory cache)" (2014, 9, 17, 4, 45, 55) mesh-refinement-cpp 8.69792 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 17, 4, 46, 17) mesh-topology-cpp 21.7025 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 17, 4, 46, 41) mesh-unitcube-cpp 23.7121 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 17, 4, 47, 22) mesh-iteration-cpp 38.7907 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 17, 4, 47, 22) function-evaluation-cpp 0.0828941 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 17, 4, 47, 28) function-extrapolation-python 5.97779 "BENCH: 2.10019922256" (2014, 9, 17, 4, 47, 28) function-extrapolation-python 2.1002 "BENCH: 2.10019922256" (2014, 9, 17, 4, 47, 31) function-interpolation-python 2.33556 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 17, 4, 47, 31) function-interpolation-python 0.942898 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 17, 4, 50, 45) la-vector-access-cpp 194.017 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 17, 4, 51, 31) la-vector-assignment-cpp 46.0424 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 18, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.101 "BENCH 11.101" (2014, 9, 18, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2089 "Building point search tree to accelerate distance queries." (2014, 9, 18, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2114 "BENCH 14.2114" (2014, 9, 18, 1, 9, 46) common-progress-cpp 27.8847 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 18, 1, 10, 17) common-timing-cpp 31.1032 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 18, 1, 11, 51) fem-convergence-cpp 3.89368 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 18, 1, 11, 52) fem-jit-python 0.000413084 "JIT compilation (in memory cache)" (2014, 9, 18, 4, 41, 50) mesh-refinement-cpp 8.64996 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 18, 4, 42, 12) mesh-topology-cpp 21.8171 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 18, 4, 42, 37) mesh-unitcube-cpp 24.9379 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 18, 4, 43, 16) mesh-iteration-cpp 36.2505 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 18, 4, 43, 16) function-evaluation-cpp 0.089798 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 18, 4, 43, 22) function-extrapolation-python 5.71488 "BENCH: 2.1001329422" (2014, 9, 18, 4, 43, 22) function-extrapolation-python 2.10013 "BENCH: 2.1001329422" (2014, 9, 18, 4, 43, 24) function-interpolation-python 2.35624 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 18, 4, 43, 24) function-interpolation-python 0.974304 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 18, 4, 46, 1) la-vector-access-cpp 156.459 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 18, 4, 46, 43) la-vector-assignment-cpp 42.0549 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 19, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0143 "BENCH 11.0143" (2014, 9, 19, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0658 "Building point search tree to accelerate distance queries." (2014, 9, 19, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2031 "BENCH 14.2031" (2014, 9, 19, 1, 9, 46) common-progress-cpp 27.8976 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 19, 1, 10, 16) common-timing-cpp 30.2126 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 19, 1, 11, 51) fem-convergence-cpp 3.91275 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 19, 1, 11, 52) fem-jit-python 0.000416279 "JIT compilation (in memory cache)" (2014, 9, 19, 4, 30, 3) mesh-refinement-cpp 8.49221 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 19, 4, 30, 25) mesh-topology-cpp 21.415 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 19, 4, 30, 48) mesh-unitcube-cpp 23.485 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 19, 4, 31, 29) mesh-iteration-cpp 38.5588 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 19, 4, 31, 29) function-evaluation-cpp 0.050014 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 19, 4, 31, 35) function-extrapolation-python 5.86136 "BENCH: 2.04458999634" (2014, 9, 19, 4, 31, 35) function-extrapolation-python 2.04459 "BENCH: 2.04458999634" (2014, 9, 19, 4, 31, 37) function-interpolation-python 2.25768 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 19, 4, 31, 37) function-interpolation-python 0.919307 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 19, 4, 34, 16) la-vector-access-cpp 158.013 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 19, 4, 35, 2) la-vector-assignment-cpp 46.2198 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 20, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8409 "BENCH 10.8409" (2014, 9, 20, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0705 "Building point search tree to accelerate distance queries." (2014, 9, 20, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.4091 "BENCH 14.4091" (2014, 9, 20, 1, 9, 45) common-progress-cpp 27.8971 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 20, 1, 10, 17) common-timing-cpp 31.3716 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 20, 1, 11, 52) fem-convergence-cpp 3.88396 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 20, 1, 11, 53) fem-jit-python 0.000415111 "JIT compilation (in memory cache)" (2014, 9, 20, 4, 27, 53) mesh-refinement-cpp 8.55761 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 20, 4, 28, 15) mesh-topology-cpp 21.4002 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 20, 4, 28, 38) mesh-unitcube-cpp 23.459 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 20, 4, 29, 17) mesh-iteration-cpp 36.0529 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 20, 4, 29, 17) function-evaluation-cpp 0.0768311 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 20, 4, 29, 22) function-extrapolation-python 5.56265 "BENCH: 2.00479102135" (2014, 9, 20, 4, 29, 22) function-extrapolation-python 2.00479 "BENCH: 2.00479102135" (2014, 9, 20, 4, 29, 25) function-interpolation-python 2.27146 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 20, 4, 29, 25) function-interpolation-python 0.916429 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 20, 4, 32, 2) la-vector-access-cpp 156.823 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 20, 4, 32, 44) la-vector-assignment-cpp 42.0132 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 21, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9414 "BENCH 10.9414" (2014, 9, 21, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.348 "Building point search tree to accelerate distance queries." (2014, 9, 21, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2593 "BENCH 14.2593" (2014, 9, 21, 1, 9, 45) common-progress-cpp 27.8775 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 21, 1, 10, 17) common-timing-cpp 31.2306 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 21, 1, 11, 53) fem-convergence-cpp 3.87029 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 21, 1, 11, 54) fem-jit-python 0.000414419 "JIT compilation (in memory cache)" (2014, 9, 21, 4, 26, 52) mesh-refinement-cpp 8.52229 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 21, 4, 27, 14) mesh-topology-cpp 21.4348 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 21, 4, 27, 37) mesh-unitcube-cpp 23.4083 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 21, 4, 28, 16) mesh-iteration-cpp 36.1512 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 21, 4, 28, 16) function-evaluation-cpp 0.0704591 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 21, 4, 28, 23) function-extrapolation-python 6.79436 "BENCH: 2.13737201691" (2014, 9, 21, 4, 28, 23) function-extrapolation-python 2.13737 "BENCH: 2.13737201691" (2014, 9, 21, 4, 28, 25) function-interpolation-python 2.36722 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 21, 4, 28, 25) function-interpolation-python 0.974815 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 21, 4, 31, 4) la-vector-access-cpp 158.909 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 21, 4, 31, 46) la-vector-assignment-cpp 42.0413 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 22, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.951 "BENCH 10.951" (2014, 9, 22, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2064 "Building point search tree to accelerate distance queries." (2014, 9, 22, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2948 "BENCH 14.2948" (2014, 9, 22, 1, 9, 46) common-progress-cpp 27.8922 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 22, 1, 10, 17) common-timing-cpp 30.7481 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 22, 1, 11, 53) fem-convergence-cpp 3.93826 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 22, 1, 11, 55) fem-jit-python 0.000423789 "JIT compilation (in memory cache)" (2014, 9, 22, 4, 26, 55) mesh-refinement-cpp 8.54175 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 22, 4, 27, 17) mesh-topology-cpp 21.346 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 22, 4, 27, 41) mesh-unitcube-cpp 23.4687 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 22, 4, 28, 19) mesh-iteration-cpp 36.0898 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 22, 4, 28, 19) function-evaluation-cpp 0.0639369 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 22, 4, 28, 25) function-extrapolation-python 5.77948 "BENCH: 1.9955329895" (2014, 9, 22, 4, 28, 25) function-extrapolation-python 1.99553 "BENCH: 1.9955329895" (2014, 9, 22, 4, 28, 27) function-interpolation-python 2.25586 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 22, 4, 28, 27) function-interpolation-python 0.917332 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 22, 4, 31, 3) la-vector-access-cpp 155.302 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 22, 4, 31, 45) la-vector-assignment-cpp 42.0406 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 23, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8492 "BENCH 10.8492" (2014, 9, 23, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1892 "Building point search tree to accelerate distance queries." (2014, 9, 23, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.1414 "BENCH 14.1414" (2014, 9, 23, 1, 9, 46) common-progress-cpp 27.8846 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 23, 1, 10, 17) common-timing-cpp 31.7835 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 23, 1, 11, 52) fem-convergence-cpp 3.8623 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 23, 1, 11, 53) fem-jit-python 0.00042212 "JIT compilation (in memory cache)" (2014, 9, 23, 4, 28, 13) mesh-refinement-cpp 8.50321 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 23, 4, 28, 35) mesh-topology-cpp 21.3576 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 23, 4, 28, 58) mesh-unitcube-cpp 23.4227 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 23, 4, 29, 36) mesh-iteration-cpp 35.528 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 23, 4, 29, 36) function-evaluation-cpp 0.0537109 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 23, 4, 29, 42) function-extrapolation-python 5.93524 "BENCH: 2.01120114326" (2014, 9, 23, 4, 29, 42) function-extrapolation-python 2.0112 "BENCH: 2.01120114326" (2014, 9, 23, 4, 29, 44) function-interpolation-python 2.23306 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 23, 4, 29, 44) function-interpolation-python 0.894264 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 23, 4, 32, 19) la-vector-access-cpp 154.302 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 23, 4, 33, 1) la-vector-assignment-cpp 42.0595 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 24, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1491 "BENCH 11.1491" (2014, 9, 24, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2092 "Building point search tree to accelerate distance queries." (2014, 9, 24, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.3528 "BENCH 14.3528" (2014, 9, 24, 1, 9, 47) common-progress-cpp 27.9283 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 24, 1, 10, 19) common-timing-cpp 31.217 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 24, 1, 11, 53) fem-convergence-cpp 3.88184 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 24, 1, 11, 54) fem-jit-python 0.000418901 "JIT compilation (in memory cache)" (2014, 9, 24, 4, 30, 21) mesh-refinement-cpp 8.49878 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 24, 4, 30, 43) mesh-topology-cpp 21.5534 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 24, 4, 31, 6) mesh-unitcube-cpp 23.3418 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 24, 4, 31, 44) mesh-iteration-cpp 35.588 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 24, 4, 31, 45) function-evaluation-cpp 0.049747 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 24, 4, 31, 51) function-extrapolation-python 5.96101 "BENCH: 2.00972104073" (2014, 9, 24, 4, 31, 51) function-extrapolation-python 2.00972 "BENCH: 2.00972104073" (2014, 9, 24, 4, 31, 53) function-interpolation-python 2.23352 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 24, 4, 31, 53) function-interpolation-python 0.894531 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 24, 4, 34, 27) la-vector-access-cpp 154.268 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 24, 4, 35, 9) la-vector-assignment-cpp 42.0282 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 25, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.7908 "BENCH 10.7908" (2014, 9, 25, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1314 "Building point search tree to accelerate distance queries." (2014, 9, 25, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.2859 "BENCH 14.2859" (2014, 9, 25, 1, 9, 45) common-progress-cpp 27.883 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 25, 1, 10, 17) common-timing-cpp 31.3564 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 25, 1, 11, 52) fem-convergence-cpp 3.88491 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 25, 1, 11, 53) fem-jit-python 0.00042181 "JIT compilation (in memory cache)" (2014, 9, 25, 4, 25, 21) mesh-refinement-cpp 8.50017 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 25, 4, 25, 42) mesh-topology-cpp 21.4533 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 25, 4, 26, 6) mesh-unitcube-cpp 23.3197 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 25, 4, 26, 47) mesh-iteration-cpp 38.5635 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 25, 4, 26, 47) function-evaluation-cpp 0.0521839 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 25, 4, 26, 52) function-extrapolation-python 5.54495 "BENCH: 2.0075750351" (2014, 9, 25, 4, 26, 52) function-extrapolation-python 2.00758 "BENCH: 2.0075750351" (2014, 9, 25, 4, 26, 54) function-interpolation-python 2.22203 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 25, 4, 26, 54) function-interpolation-python 0.892605 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 25, 4, 29, 29) la-vector-access-cpp 154.291 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 25, 4, 30, 15) la-vector-assignment-cpp 45.9802 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 26, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9056 "BENCH 10.9056" (2014, 9, 26, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1094 "Building point search tree to accelerate distance queries." (2014, 9, 26, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.3074 "BENCH 14.3074" (2014, 9, 26, 1, 9, 47) common-progress-cpp 27.8892 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 26, 1, 10, 18) common-timing-cpp 31.0198 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 26, 1, 11, 52) fem-convergence-cpp 3.86583 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 26, 1, 11, 53) fem-jit-python 0.000421906 "JIT compilation (in memory cache)" (2014, 9, 26, 4, 39, 22) mesh-refinement-cpp 8.81858 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 26, 4, 39, 44) mesh-topology-cpp 21.718 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 26, 4, 40, 8) mesh-unitcube-cpp 23.5064 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 26, 4, 40, 46) mesh-iteration-cpp 35.7745 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 26, 4, 40, 46) function-evaluation-cpp 0.0752182 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 26, 4, 40, 52) function-extrapolation-python 5.77899 "BENCH: 2.06900191307" (2014, 9, 26, 4, 40, 52) function-extrapolation-python 2.069 "BENCH: 2.06900191307" (2014, 9, 26, 4, 40, 54) function-interpolation-python 2.34204 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 26, 4, 40, 54) function-interpolation-python 0.915697 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 26, 4, 43, 30) la-vector-access-cpp 155.617 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 26, 4, 44, 12) la-vector-assignment-cpp 42.0274 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 27, 1, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8425 "BENCH 10.8425" (2014, 9, 27, 1, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2715 "Building point search tree to accelerate distance queries." (2014, 9, 27, 1, 9, 16) geometry-bounding_box_tree_build-cpp 14.0672 "BENCH 14.0672" (2014, 9, 27, 1, 9, 47) common-progress-cpp 31.6567 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 27, 1, 10, 19) common-timing-cpp 31.3865 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 27, 1, 11, 54) fem-convergence-cpp 3.90212 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 27, 1, 11, 55) fem-jit-python 0.000434899 "JIT compilation (in memory cache)" (2014, 9, 27, 4, 30, 12) mesh-refinement-cpp 8.51362 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 27, 4, 30, 34) mesh-topology-cpp 21.4867 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 27, 4, 30, 58) mesh-unitcube-cpp 23.3 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 27, 4, 31, 39) mesh-iteration-cpp 39.1668 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 27, 4, 31, 39) function-evaluation-cpp 0.0582652 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 27, 4, 31, 45) function-extrapolation-python 5.73513 "BENCH: 2.00963401794" (2014, 9, 27, 4, 31, 45) function-extrapolation-python 2.00963 "BENCH: 2.00963401794" (2014, 9, 27, 4, 31, 47) function-interpolation-python 2.25838 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 27, 4, 31, 47) function-interpolation-python 0.894807 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 27, 4, 34, 22) la-vector-access-cpp 154.152 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 27, 4, 35, 4) la-vector-assignment-cpp 41.9971 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 28, 1, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0839 "BENCH 11.0839" (2014, 9, 28, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3657 "Building point search tree to accelerate distance queries." (2014, 9, 28, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.3299 "BENCH 14.3299" (2014, 9, 28, 1, 9, 45) common-progress-cpp 27.8965 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 28, 1, 10, 16) common-timing-cpp 31.3245 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 28, 1, 11, 51) fem-convergence-cpp 3.83967 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 28, 1, 11, 52) fem-jit-python 0.000418496 "JIT compilation (in memory cache)" (2014, 9, 28, 4, 28, 26) mesh-refinement-cpp 8.51343 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 28, 4, 28, 48) mesh-topology-cpp 21.3599 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 28, 4, 29, 11) mesh-unitcube-cpp 23.2552 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 28, 4, 29, 49) mesh-iteration-cpp 35.5422 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 28, 4, 29, 49) function-evaluation-cpp 0.0555959 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 28, 4, 29, 55) function-extrapolation-python 5.91994 "BENCH: 2.01455712318" (2014, 9, 28, 4, 29, 55) function-extrapolation-python 2.01456 "BENCH: 2.01455712318" (2014, 9, 28, 4, 29, 57) function-interpolation-python 2.22802 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 28, 4, 29, 57) function-interpolation-python 0.897801 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 28, 4, 32, 33) la-vector-access-cpp 156.169 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 28, 4, 33, 16) la-vector-assignment-cpp 42.0193 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 29, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0543 "BENCH 11.0543" (2014, 9, 29, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.099 "Building point search tree to accelerate distance queries." (2014, 9, 29, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.2272 "BENCH 14.2272" (2014, 9, 29, 1, 9, 45) common-progress-cpp 27.8845 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 29, 1, 10, 16) common-timing-cpp 30.8714 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 29, 1, 11, 50) fem-convergence-cpp 3.89073 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 29, 1, 11, 52) fem-jit-python 0.000421691 "JIT compilation (in memory cache)" (2014, 9, 29, 4, 26, 47) mesh-refinement-cpp 8.49733 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 29, 4, 27, 9) mesh-topology-cpp 21.5463 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 29, 4, 27, 32) mesh-unitcube-cpp 23.2916 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 29, 4, 28, 13) mesh-iteration-cpp 38.5636 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 29, 4, 28, 13) function-evaluation-cpp 0.076966 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 29, 4, 28, 19) function-extrapolation-python 5.60594 "BENCH: 1.99918317795" (2014, 9, 29, 4, 28, 19) function-extrapolation-python 1.99918 "BENCH: 1.99918317795" (2014, 9, 29, 4, 28, 21) function-interpolation-python 2.23976 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 29, 4, 28, 21) function-interpolation-python 0.901228 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 29, 4, 30, 56) la-vector-access-cpp 155.194 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 29, 4, 31, 38) la-vector-assignment-cpp 42.0154 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 9, 30, 1, 8, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0721 "BENCH 11.0721" (2014, 9, 30, 1, 9, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1258 "Building point search tree to accelerate distance queries." (2014, 9, 30, 1, 9, 24) geometry-bounding_box_tree_build-cpp 14.3291 "BENCH 14.3291" (2014, 9, 30, 1, 9, 52) common-progress-cpp 27.9029 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 9, 30, 1, 10, 23) common-timing-cpp 31.4779 "Timing access and registration of timings (10000000 repetitions)" (2014, 9, 30, 1, 11, 57) fem-convergence-cpp 3.87395 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 9, 30, 1, 11, 58) fem-jit-python 0.000417209 "JIT compilation (in memory cache)" (2014, 9, 30, 4, 38, 4) mesh-refinement-cpp 8.67036 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 9, 30, 4, 38, 26) mesh-topology-cpp 21.6809 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 9, 30, 4, 38, 50) mesh-unitcube-cpp 23.5122 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 9, 30, 4, 39, 31) mesh-iteration-cpp 38.8064 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 9, 30, 4, 39, 31) function-evaluation-cpp 0.0811729 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 9, 30, 4, 39, 37) function-extrapolation-python 5.61372 "BENCH: 2.05579996109" (2014, 9, 30, 4, 39, 37) function-extrapolation-python 2.0558 "BENCH: 2.05579996109" (2014, 9, 30, 4, 39, 39) function-interpolation-python 2.30629 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 30, 4, 39, 39) function-interpolation-python 0.9172 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 9, 30, 4, 42, 14) la-vector-access-cpp 154.508 "Accessing vector of size 10000000 (100 repetitions)" (2014, 9, 30, 4, 42, 57) la-vector-assignment-cpp 43.4938 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 1, 1, 8, 50) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8781 "BENCH 10.8781" (2014, 10, 1, 1, 9, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2013 "Building point search tree to accelerate distance queries." (2014, 10, 1, 1, 9, 25) geometry-bounding_box_tree_build-cpp 14.3034 "BENCH 14.3034" (2014, 10, 1, 1, 9, 53) common-progress-cpp 27.8803 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 1, 1, 10, 24) common-timing-cpp 31.088 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 1, 1, 11, 59) fem-convergence-cpp 3.8645 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 1, 1, 12, 0) fem-jit-python 0.000415301 "JIT compilation (in memory cache)" (2014, 10, 1, 4, 27, 35) mesh-refinement-cpp 8.49695 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 1, 4, 27, 56) mesh-topology-cpp 21.4234 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 1, 4, 28, 19) mesh-unitcube-cpp 23.3324 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 1, 4, 29, 0) mesh-iteration-cpp 38.5604 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 1, 4, 29, 1) function-evaluation-cpp 0.0557079 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 1, 4, 29, 6) function-extrapolation-python 5.75855 "BENCH: 2.00493192673" (2014, 10, 1, 4, 29, 6) function-extrapolation-python 2.00493 "BENCH: 2.00493192673" (2014, 10, 1, 4, 29, 9) function-interpolation-python 2.23496 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 1, 4, 29, 9) function-interpolation-python 0.895412 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 1, 4, 31, 44) la-vector-access-cpp 155.219 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 1, 4, 32, 26) la-vector-assignment-cpp 42.0296 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 2, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1719 "BENCH 11.1719" (2014, 10, 2, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.155 "Building point search tree to accelerate distance queries." (2014, 10, 2, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.3138 "BENCH 14.3138" (2014, 10, 2, 1, 9, 46) common-progress-cpp 27.89 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 2, 1, 10, 17) common-timing-cpp 31.186 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 2, 1, 11, 52) fem-convergence-cpp 3.91019 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 2, 1, 11, 53) fem-jit-python 0.000414896 "JIT compilation (in memory cache)" (2014, 10, 2, 4, 26, 34) mesh-refinement-cpp 8.48326 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 2, 4, 26, 55) mesh-topology-cpp 21.384 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 2, 4, 27, 19) mesh-unitcube-cpp 23.5556 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 2, 4, 28, 0) mesh-iteration-cpp 39.1712 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 2, 4, 28, 0) function-evaluation-cpp 0.0510559 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 2, 4, 28, 6) function-extrapolation-python 5.67373 "BENCH: 2.01869916916" (2014, 10, 2, 4, 28, 6) function-extrapolation-python 2.0187 "BENCH: 2.01869916916" (2014, 10, 2, 4, 28, 8) function-interpolation-python 2.23501 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 2, 4, 28, 8) function-interpolation-python 0.896465 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 2, 4, 30, 43) la-vector-access-cpp 154.184 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 2, 4, 31, 25) la-vector-assignment-cpp 41.9595 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 3, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9665 "BENCH 10.9665" (2014, 10, 3, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1822 "Building point search tree to accelerate distance queries." (2014, 10, 3, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.3665 "BENCH 14.3665" (2014, 10, 3, 1, 9, 50) common-progress-cpp 31.656 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 3, 1, 10, 21) common-timing-cpp 31.0636 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 3, 1, 11, 55) fem-convergence-cpp 3.87488 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 3, 1, 11, 57) fem-jit-python 0.000423121 "JIT compilation (in memory cache)" (2014, 10, 3, 4, 32, 16) mesh-refinement-cpp 8.52139 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 3, 4, 32, 37) mesh-topology-cpp 21.3468 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 3, 4, 33, 0) mesh-unitcube-cpp 23.0375 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 3, 4, 33, 41) mesh-iteration-cpp 38.5625 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 3, 4, 33, 42) function-evaluation-cpp 0.055589 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 3, 4, 33, 47) function-extrapolation-python 5.70589 "BENCH: 2.01905012131" (2014, 10, 3, 4, 33, 47) function-extrapolation-python 2.01905 "BENCH: 2.01905012131" (2014, 10, 3, 4, 33, 50) function-interpolation-python 2.22781 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 3, 4, 33, 50) function-interpolation-python 0.897971 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 3, 4, 36, 24) la-vector-access-cpp 154.236 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 3, 4, 37, 6) la-vector-assignment-cpp 42.0846 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 4, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.893 "BENCH 10.893" (2014, 10, 4, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1858 "Building point search tree to accelerate distance queries." (2014, 10, 4, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.4122 "BENCH 14.4122" (2014, 10, 4, 1, 9, 45) common-progress-cpp 27.8866 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 4, 1, 10, 16) common-timing-cpp 31.0169 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 4, 1, 11, 50) fem-convergence-cpp 3.93432 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 4, 1, 11, 51) fem-jit-python 0.000430393 "JIT compilation (in memory cache)" (2014, 10, 4, 4, 25, 37) mesh-refinement-cpp 8.48516 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 4, 4, 25, 59) mesh-topology-cpp 21.3893 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 4, 4, 26, 22) mesh-unitcube-cpp 23.0891 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 4, 4, 27, 0) mesh-iteration-cpp 35.5529 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 4, 4, 27, 0) function-evaluation-cpp 0.053648 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 4, 4, 27, 6) function-extrapolation-python 5.93343 "BENCH: 2.01114201546" (2014, 10, 4, 4, 27, 6) function-extrapolation-python 2.01114 "BENCH: 2.01114201546" (2014, 10, 4, 4, 27, 9) function-interpolation-python 2.59183 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 4, 4, 27, 9) function-interpolation-python 0.916569 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 4, 4, 29, 44) la-vector-access-cpp 155.226 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 4, 4, 30, 26) la-vector-assignment-cpp 42.0174 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 5, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9155 "BENCH 10.9155" (2014, 10, 5, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0557 "Building point search tree to accelerate distance queries." (2014, 10, 5, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.2879 "BENCH 14.2879" (2014, 10, 5, 1, 9, 47) common-progress-cpp 27.8931 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 5, 1, 10, 18) common-timing-cpp 31.15 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 5, 1, 11, 52) fem-convergence-cpp 3.8545 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 5, 1, 11, 53) fem-jit-python 0.000417304 "JIT compilation (in memory cache)" (2014, 10, 5, 4, 40, 46) mesh-refinement-cpp 8.60625 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 5, 4, 41, 8) mesh-topology-cpp 21.6281 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 5, 4, 41, 31) mesh-unitcube-cpp 23.3003 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 5, 4, 42, 12) mesh-iteration-cpp 38.8076 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 5, 4, 42, 12) function-evaluation-cpp 0.101288 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 5, 4, 42, 18) function-extrapolation-python 5.82829 "BENCH: 2.0464630127" (2014, 10, 5, 4, 42, 18) function-extrapolation-python 2.04646 "BENCH: 2.0464630127" (2014, 10, 5, 4, 42, 20) function-interpolation-python 2.28717 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 5, 4, 42, 20) function-interpolation-python 0.912151 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 5, 4, 44, 55) la-vector-access-cpp 154.576 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 5, 4, 45, 41) la-vector-assignment-cpp 46.0407 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 6, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0669 "BENCH 11.0669" (2014, 10, 6, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1671 "Building point search tree to accelerate distance queries." (2014, 10, 6, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.3451 "BENCH 14.3451" (2014, 10, 6, 1, 9, 46) common-progress-cpp 27.9049 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 6, 1, 10, 18) common-timing-cpp 31.1473 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 6, 1, 11, 53) fem-convergence-cpp 3.92093 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 6, 1, 11, 54) fem-jit-python 0.000416183 "JIT compilation (in memory cache)" (2014, 10, 6, 4, 47, 16) mesh-refinement-cpp 8.62842 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 6, 4, 47, 39) mesh-topology-cpp 22.2265 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 6, 4, 48, 2) mesh-unitcube-cpp 23.3149 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 6, 4, 48, 40) mesh-iteration-cpp 35.7799 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 6, 4, 48, 40) function-evaluation-cpp 0.0833149 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 6, 4, 48, 46) function-extrapolation-python 5.9871 "BENCH: 2.08976006508" (2014, 10, 6, 4, 48, 46) function-extrapolation-python 2.08976 "BENCH: 2.08976006508" (2014, 10, 6, 4, 48, 49) function-interpolation-python 2.31442 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 6, 4, 48, 49) function-interpolation-python 0.920124 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 6, 4, 51, 23) la-vector-access-cpp 154.605 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 6, 4, 52, 5) la-vector-assignment-cpp 42.033 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 7, 1, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9612 "BENCH 10.9612" (2014, 10, 7, 1, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1082 "Building point search tree to accelerate distance queries." (2014, 10, 7, 1, 9, 21) geometry-bounding_box_tree_build-cpp 14.0918 "BENCH 14.0918" (2014, 10, 7, 1, 9, 49) common-progress-cpp 27.961 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 7, 1, 10, 21) common-timing-cpp 31.1998 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 7, 1, 11, 56) fem-convergence-cpp 3.93426 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 7, 1, 11, 57) fem-jit-python 0.000424695 "JIT compilation (in memory cache)" (2014, 10, 7, 4, 12, 54) mesh-refinement-cpp 8.47257 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 7, 4, 13, 16) mesh-topology-cpp 21.3798 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 7, 4, 13, 39) mesh-unitcube-cpp 23.114 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 7, 4, 14, 17) mesh-iteration-cpp 35.5535 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 7, 4, 14, 17) function-evaluation-cpp 0.0519001 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 7, 4, 14, 23) function-extrapolation-python 5.61906 "BENCH: 2.01215291023" (2014, 10, 7, 4, 14, 23) function-extrapolation-python 2.01215 "BENCH: 2.01215291023" (2014, 10, 7, 4, 14, 25) function-interpolation-python 2.20827 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 7, 4, 14, 25) function-interpolation-python 0.886221 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 7, 4, 16, 59) la-vector-access-cpp 154.18 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 7, 4, 17, 42) la-vector-assignment-cpp 42.0608 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 8, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9253 "BENCH 10.9253" (2014, 10, 8, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1144 "Building point search tree to accelerate distance queries." (2014, 10, 8, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.169 "BENCH 14.169" (2014, 10, 8, 1, 9, 47) common-progress-cpp 27.8872 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 8, 1, 10, 18) common-timing-cpp 31.0389 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 8, 1, 11, 52) fem-convergence-cpp 3.85443 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 8, 1, 11, 54) fem-jit-python 0.000423217 "JIT compilation (in memory cache)" (2014, 10, 8, 4, 24, 24) mesh-refinement-cpp 8.4788 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 8, 4, 24, 46) mesh-topology-cpp 21.5302 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 8, 4, 25, 9) mesh-unitcube-cpp 23.093 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 8, 4, 25, 50) mesh-iteration-cpp 38.5634 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 8, 4, 25, 50) function-evaluation-cpp 0.052043 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 8, 4, 25, 56) function-extrapolation-python 5.69608 "BENCH: 1.98846483231" (2014, 10, 8, 4, 25, 56) function-extrapolation-python 1.98846 "BENCH: 1.98846483231" (2014, 10, 8, 4, 25, 58) function-interpolation-python 2.21073 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 8, 4, 25, 58) function-interpolation-python 0.88885 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 8, 4, 28, 32) la-vector-access-cpp 154.193 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 8, 4, 29, 15) la-vector-assignment-cpp 42.0177 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 9, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9985 "BENCH 10.9985" (2014, 10, 9, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9919 "Building point search tree to accelerate distance queries." (2014, 10, 9, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.3308 "BENCH 14.3308" (2014, 10, 9, 1, 9, 47) common-progress-cpp 27.8888 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 9, 1, 10, 18) common-timing-cpp 31.0812 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 9, 1, 11, 53) fem-convergence-cpp 3.88196 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 9, 1, 11, 54) fem-jit-python 0.000424194 "JIT compilation (in memory cache)" (2014, 10, 9, 4, 37, 30) mesh-refinement-cpp 8.46553 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 9, 4, 37, 51) mesh-topology-cpp 21.469 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 9, 4, 38, 14) mesh-unitcube-cpp 23.0453 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 9, 4, 38, 52) mesh-iteration-cpp 35.5717 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 9, 4, 38, 53) function-evaluation-cpp 0.0513761 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 9, 4, 38, 58) function-extrapolation-python 5.7404 "BENCH: 2.00910282135" (2014, 10, 9, 4, 38, 58) function-extrapolation-python 2.0091 "BENCH: 2.00910282135" (2014, 10, 9, 4, 39, 1) function-interpolation-python 2.22021 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 9, 4, 39, 1) function-interpolation-python 0.890134 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 9, 4, 41, 35) la-vector-access-cpp 154.183 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 9, 4, 42, 17) la-vector-assignment-cpp 42.0269 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 10, 1, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1485 "BENCH 11.1485" (2014, 10, 10, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2242 "Building point search tree to accelerate distance queries." (2014, 10, 10, 1, 9, 20) geometry-bounding_box_tree_build-cpp 14.4198 "BENCH 14.4198" (2014, 10, 10, 1, 9, 48) common-progress-cpp 27.9462 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 10, 1, 10, 19) common-timing-cpp 31.2092 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 10, 1, 11, 55) fem-convergence-cpp 3.98971 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 10, 1, 11, 56) fem-jit-python 0.000413895 "JIT compilation (in memory cache)" (2014, 10, 10, 4, 34, 21) mesh-refinement-cpp 8.63973 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 10, 4, 34, 43) mesh-topology-cpp 21.7594 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 10, 4, 35, 8) mesh-unitcube-cpp 24.1944 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 10, 4, 35, 48) mesh-iteration-cpp 36.9437 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 10, 4, 35, 48) function-evaluation-cpp 0.0942171 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 10, 4, 35, 53) function-extrapolation-python 5.71667 "BENCH: 2.08676409721" (2014, 10, 10, 4, 35, 53) function-extrapolation-python 2.08676 "BENCH: 2.08676409721" (2014, 10, 10, 4, 35, 56) function-interpolation-python 2.31748 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 10, 4, 35, 56) function-interpolation-python 0.924802 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 10, 4, 38, 32) la-vector-access-cpp 156.261 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 10, 4, 39, 18) la-vector-assignment-cpp 46.045 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 11, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0916 "BENCH 11.0916" (2014, 10, 11, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2207 "Building point search tree to accelerate distance queries." (2014, 10, 11, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.3936 "BENCH 14.3936" (2014, 10, 11, 1, 9, 46) common-progress-cpp 27.8975 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 11, 1, 10, 17) common-timing-cpp 31.4182 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 11, 1, 11, 52) fem-convergence-cpp 3.92906 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 11, 1, 11, 54) fem-jit-python 0.000420594 "JIT compilation (in memory cache)" (2014, 10, 11, 4, 36, 22) mesh-refinement-cpp 8.47047 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 11, 4, 36, 44) mesh-topology-cpp 21.365 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 11, 4, 37, 7) mesh-unitcube-cpp 23.0508 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 11, 4, 37, 45) mesh-iteration-cpp 35.5549 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 11, 4, 37, 45) function-evaluation-cpp 0.0501201 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 11, 4, 37, 51) function-extrapolation-python 5.95774 "BENCH: 2.06594109535" (2014, 10, 11, 4, 37, 51) function-extrapolation-python 2.06594 "BENCH: 2.06594109535" (2014, 10, 11, 4, 37, 53) function-interpolation-python 2.22619 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 11, 4, 37, 53) function-interpolation-python 0.887264 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 11, 4, 40, 29) la-vector-access-cpp 155.543 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 11, 4, 41, 11) la-vector-assignment-cpp 42.0037 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 12, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.932 "BENCH 10.932" (2014, 10, 12, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2913 "Building point search tree to accelerate distance queries." (2014, 10, 12, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.2362 "BENCH 14.2362" (2014, 10, 12, 1, 9, 47) common-progress-cpp 27.891 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 12, 1, 10, 18) common-timing-cpp 31.199 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 12, 1, 11, 53) fem-convergence-cpp 3.90146 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 12, 1, 11, 54) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2014, 10, 12, 4, 33, 49) mesh-refinement-cpp 8.4891 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 12, 4, 34, 10) mesh-topology-cpp 21.4451 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 12, 4, 34, 33) mesh-unitcube-cpp 23.0461 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 12, 4, 35, 11) mesh-iteration-cpp 35.544 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 12, 4, 35, 12) function-evaluation-cpp 0.070313 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 12, 4, 35, 17) function-extrapolation-python 5.68862 "BENCH: 2.00841999054" (2014, 10, 12, 4, 35, 17) function-extrapolation-python 2.00842 "BENCH: 2.00841999054" (2014, 10, 12, 4, 35, 19) function-interpolation-python 2.224 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 12, 4, 35, 19) function-interpolation-python 0.893331 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 12, 4, 37, 54) la-vector-access-cpp 154.209 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 12, 4, 38, 36) la-vector-assignment-cpp 41.9819 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 13, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.125 "BENCH 11.125" (2014, 10, 13, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2195 "Building point search tree to accelerate distance queries." (2014, 10, 13, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.1867 "BENCH 14.1867" (2014, 10, 13, 1, 9, 45) common-progress-cpp 27.8875 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 13, 1, 10, 16) common-timing-cpp 31.0396 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 13, 1, 11, 50) fem-convergence-cpp 3.92416 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 13, 1, 11, 51) fem-jit-python 0.00041759 "JIT compilation (in memory cache)" (2014, 10, 13, 4, 28, 9) mesh-refinement-cpp 8.65918 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 13, 4, 28, 32) mesh-topology-cpp 22.2379 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 13, 4, 28, 55) mesh-unitcube-cpp 23.3666 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 13, 4, 29, 33) mesh-iteration-cpp 35.7702 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 13, 4, 29, 34) function-evaluation-cpp 0.0925412 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 13, 4, 29, 40) function-extrapolation-python 5.95963 "BENCH: 2.04638409615" (2014, 10, 13, 4, 29, 40) function-extrapolation-python 2.04638 "BENCH: 2.04638409615" (2014, 10, 13, 4, 29, 42) function-interpolation-python 2.29892 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 13, 4, 29, 42) function-interpolation-python 0.914397 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 13, 4, 32, 16) la-vector-access-cpp 154.581 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 13, 4, 32, 59) la-vector-assignment-cpp 42.0291 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 14, 1, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8625 "BENCH 10.8625" (2014, 10, 14, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2436 "Building point search tree to accelerate distance queries." (2014, 10, 14, 1, 9, 20) geometry-bounding_box_tree_build-cpp 14.0115 "BENCH 14.0115" (2014, 10, 14, 1, 9, 48) common-progress-cpp 27.9409 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 14, 1, 10, 19) common-timing-cpp 31.037 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 14, 1, 11, 52) fem-convergence-cpp 3.89751 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 14, 1, 11, 53) fem-jit-python 0.000419092 "JIT compilation (in memory cache)" (2014, 10, 14, 4, 35, 26) mesh-refinement-cpp 8.47226 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 14, 4, 35, 48) mesh-topology-cpp 21.3715 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 14, 4, 36, 11) mesh-unitcube-cpp 23.1417 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 14, 4, 36, 49) mesh-iteration-cpp 35.5484 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 14, 4, 36, 49) function-evaluation-cpp 0.0518708 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 14, 4, 36, 55) function-extrapolation-python 5.76596 "BENCH: 2.00197720528" (2014, 10, 14, 4, 36, 55) function-extrapolation-python 2.00198 "BENCH: 2.00197720528" (2014, 10, 14, 4, 36, 57) function-interpolation-python 2.23528 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 14, 4, 36, 57) function-interpolation-python 0.888572 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 14, 4, 39, 32) la-vector-access-cpp 155.036 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 14, 4, 40, 14) la-vector-assignment-cpp 42.0827 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 15, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9191 "BENCH 10.9191" (2014, 10, 15, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2391 "Building point search tree to accelerate distance queries." (2014, 10, 15, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2395 "BENCH 14.2395" (2014, 10, 15, 1, 9, 45) common-progress-cpp 27.8935 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 15, 1, 10, 17) common-timing-cpp 31.2458 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 15, 1, 11, 51) fem-convergence-cpp 3.87559 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 15, 1, 11, 52) fem-jit-python 0.000420189 "JIT compilation (in memory cache)" (2014, 10, 15, 4, 30, 33) mesh-refinement-cpp 8.46886 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 15, 4, 30, 55) mesh-topology-cpp 21.517 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 15, 4, 31, 18) mesh-unitcube-cpp 23.0825 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 15, 4, 31, 56) mesh-iteration-cpp 35.5596 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 15, 4, 31, 56) function-evaluation-cpp 0.0762911 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 15, 4, 32, 2) function-extrapolation-python 5.85747 "BENCH: 1.98217606544" (2014, 10, 15, 4, 32, 2) function-extrapolation-python 1.98218 "BENCH: 1.98217606544" (2014, 10, 15, 4, 32, 4) function-interpolation-python 2.21926 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 15, 4, 32, 4) function-interpolation-python 0.888716 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 15, 4, 34, 38) la-vector-access-cpp 154.229 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 15, 4, 35, 24) la-vector-assignment-cpp 46.0459 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 16, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0624 "BENCH 11.0624" (2014, 10, 16, 1, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9969 "Building point search tree to accelerate distance queries." (2014, 10, 16, 1, 9, 20) geometry-bounding_box_tree_build-cpp 14.3147 "BENCH 14.3147" (2014, 10, 16, 1, 9, 48) common-progress-cpp 27.8836 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 16, 1, 10, 18) common-timing-cpp 30.6228 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 16, 1, 11, 53) fem-convergence-cpp 3.89952 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 16, 1, 11, 55) fem-jit-python 0.00043571 "JIT compilation (in memory cache)" (2014, 10, 16, 4, 27, 5) mesh-refinement-cpp 8.49134 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 16, 4, 27, 27) mesh-topology-cpp 21.4104 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 16, 4, 27, 50) mesh-unitcube-cpp 23.1098 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 16, 4, 28, 28) mesh-iteration-cpp 35.5425 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 16, 4, 28, 28) function-evaluation-cpp 0.053473 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 16, 4, 28, 34) function-extrapolation-python 5.72271 "BENCH: 2.00569415092" (2014, 10, 16, 4, 28, 34) function-extrapolation-python 2.00569 "BENCH: 2.00569415092" (2014, 10, 16, 4, 28, 36) function-interpolation-python 2.22002 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 16, 4, 28, 36) function-interpolation-python 0.8883 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 16, 4, 31, 10) la-vector-access-cpp 154.197 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 16, 4, 31, 56) la-vector-assignment-cpp 46.0274 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 17, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9121 "BENCH 10.9121" (2014, 10, 17, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.137 "Building point search tree to accelerate distance queries." (2014, 10, 17, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.2048 "BENCH 14.2048" (2014, 10, 17, 1, 9, 46) common-progress-cpp 27.9011 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 17, 1, 10, 17) common-timing-cpp 31.2122 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 17, 1, 11, 51) fem-convergence-cpp 3.86669 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 17, 1, 11, 53) fem-jit-python 0.000417399 "JIT compilation (in memory cache)" (2014, 10, 17, 4, 32, 58) mesh-refinement-cpp 8.48145 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 17, 4, 33, 19) mesh-topology-cpp 21.5264 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 17, 4, 33, 42) mesh-unitcube-cpp 23.0192 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 17, 4, 34, 24) mesh-iteration-cpp 39.1933 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 17, 4, 34, 24) function-evaluation-cpp 0.058466 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 17, 4, 34, 30) function-extrapolation-python 5.70768 "BENCH: 1.99677300453" (2014, 10, 17, 4, 34, 30) function-extrapolation-python 1.99677 "BENCH: 1.99677300453" (2014, 10, 17, 4, 34, 32) function-interpolation-python 2.22259 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 17, 4, 34, 32) function-interpolation-python 0.891714 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 17, 4, 37, 7) la-vector-access-cpp 154.829 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 17, 4, 37, 49) la-vector-assignment-cpp 42.3622 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 18, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8581 "BENCH 10.8581" (2014, 10, 18, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1227 "Building point search tree to accelerate distance queries." (2014, 10, 18, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.3789 "BENCH 14.3789" (2014, 10, 18, 1, 9, 45) common-progress-cpp 27.9011 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 18, 1, 10, 17) common-timing-cpp 31.2991 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 18, 1, 11, 51) fem-convergence-cpp 3.92525 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 18, 1, 11, 53) fem-jit-python 0.000423813 "JIT compilation (in memory cache)" (2014, 10, 18, 4, 28, 30) mesh-refinement-cpp 8.50549 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 18, 4, 28, 51) mesh-topology-cpp 21.3034 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 18, 4, 29, 15) mesh-unitcube-cpp 23.279 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 18, 4, 29, 56) mesh-iteration-cpp 38.5593 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 18, 4, 29, 56) function-evaluation-cpp 0.058557 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 18, 4, 30, 1) function-extrapolation-python 5.6628 "BENCH: 2.01583719254" (2014, 10, 18, 4, 30, 1) function-extrapolation-python 2.01584 "BENCH: 2.01583719254" (2014, 10, 18, 4, 30, 4) function-interpolation-python 2.23246 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 18, 4, 30, 4) function-interpolation-python 0.901038 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 18, 4, 32, 38) la-vector-access-cpp 154.178 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 18, 4, 33, 24) la-vector-assignment-cpp 46.0251 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 19, 1, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9403 "BENCH 10.9403" (2014, 10, 19, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0535 "Building point search tree to accelerate distance queries." (2014, 10, 19, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.0825 "BENCH 14.0825" (2014, 10, 19, 1, 9, 47) common-progress-cpp 27.8804 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 19, 1, 10, 18) common-timing-cpp 31.0802 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 19, 1, 11, 52) fem-convergence-cpp 3.9351 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 19, 1, 11, 53) fem-jit-python 0.000415778 "JIT compilation (in memory cache)" (2014, 10, 19, 4, 32, 59) mesh-refinement-cpp 8.46614 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 19, 4, 33, 20) mesh-topology-cpp 21.4803 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 19, 4, 33, 44) mesh-unitcube-cpp 23.0745 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 19, 4, 34, 22) mesh-iteration-cpp 35.543 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 19, 4, 34, 22) function-evaluation-cpp 0.0605161 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 19, 4, 34, 27) function-extrapolation-python 5.64239 "BENCH: 1.99154186249" (2014, 10, 19, 4, 34, 27) function-extrapolation-python 1.99154 "BENCH: 1.99154186249" (2014, 10, 19, 4, 34, 30) function-interpolation-python 2.20988 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 19, 4, 34, 30) function-interpolation-python 0.887558 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 19, 4, 37, 8) la-vector-access-cpp 158.771 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 19, 4, 37, 51) la-vector-assignment-cpp 42.292 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 20, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.8894 "BENCH 10.8894" (2014, 10, 20, 1, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1307 "Building point search tree to accelerate distance queries." (2014, 10, 20, 1, 9, 17) geometry-bounding_box_tree_build-cpp 14.2916 "BENCH 14.2916" (2014, 10, 20, 1, 9, 45) common-progress-cpp 27.9585 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 20, 1, 10, 16) common-timing-cpp 31.3228 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 20, 1, 11, 51) fem-convergence-cpp 3.88984 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 20, 1, 11, 52) fem-jit-python 0.000408101 "JIT compilation (in memory cache)" (2014, 10, 20, 4, 31, 48) mesh-refinement-cpp 8.46638 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 20, 4, 32, 9) mesh-topology-cpp 21.4107 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 20, 4, 32, 32) mesh-unitcube-cpp 23.0575 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 20, 4, 33, 14) mesh-iteration-cpp 39.178 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 20, 4, 33, 14) function-evaluation-cpp 0.060257 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 20, 4, 33, 20) function-extrapolation-python 5.94623 "BENCH: 1.99621105194" (2014, 10, 20, 4, 33, 20) function-extrapolation-python 1.99621 "BENCH: 1.99621105194" (2014, 10, 20, 4, 33, 22) function-interpolation-python 2.23853 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 20, 4, 33, 22) function-interpolation-python 0.891514 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 20, 4, 35, 57) la-vector-access-cpp 154.186 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 20, 4, 36, 39) la-vector-assignment-cpp 42.0194 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 21, 1, 8, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.6956 "BENCH 11.6956" (2014, 10, 21, 1, 9, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6925 "Building point search tree to accelerate distance queries." (2014, 10, 21, 1, 9, 24) geometry-bounding_box_tree_build-cpp 14.1688 "BENCH 14.1688" (2014, 10, 21, 1, 9, 52) common-progress-cpp 27.8783 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 21, 1, 10, 23) common-timing-cpp 30.3759 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 21, 1, 11, 57) fem-convergence-cpp 3.91842 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 21, 1, 11, 58) fem-jit-python 0.000419617 "JIT compilation (in memory cache)" (2014, 10, 21, 4, 21, 45) mesh-refinement-cpp 8.54341 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 21, 4, 22, 7) mesh-topology-cpp 21.7309 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 21, 4, 22, 30) mesh-unitcube-cpp 23.1977 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 21, 4, 23, 16) mesh-iteration-cpp 43.5747 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 21, 4, 23, 16) function-evaluation-cpp 0.058279 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 21, 4, 23, 22) function-extrapolation-python 5.63363 "BENCH: 2.00619387627" (2014, 10, 21, 4, 23, 22) function-extrapolation-python 2.00619 "BENCH: 2.00619387627" (2014, 10, 21, 4, 23, 24) function-interpolation-python 2.29013 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 21, 4, 23, 24) function-interpolation-python 0.934132 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 21, 4, 25, 56) la-vector-access-cpp 151.256 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 21, 4, 26, 34) la-vector-assignment-cpp 38.0545 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 22, 1, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.6706 "BENCH 11.6706" (2014, 10, 22, 1, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5235 "Building point search tree to accelerate distance queries." (2014, 10, 22, 1, 9, 21) geometry-bounding_box_tree_build-cpp 14.2244 "BENCH 14.2244" (2014, 10, 22, 1, 9, 48) common-progress-cpp 27.8821 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 22, 1, 10, 19) common-timing-cpp 30.1797 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 22, 1, 11, 54) fem-convergence-cpp 3.85106 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 22, 1, 11, 55) fem-jit-python 0.000421906 "JIT compilation (in memory cache)" (2014, 10, 22, 4, 20, 8) mesh-refinement-cpp 8.57119 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 22, 4, 20, 30) mesh-topology-cpp 21.7798 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 22, 4, 20, 53) mesh-unitcube-cpp 23.1814 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 22, 4, 21, 35) mesh-iteration-cpp 39.18 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 22, 4, 21, 35) function-evaluation-cpp 0.0869849 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 22, 4, 21, 40) function-extrapolation-python 5.656 "BENCH: 1.99994492531" (2014, 10, 22, 4, 21, 40) function-extrapolation-python 1.99994 "BENCH: 1.99994492531" (2014, 10, 22, 4, 21, 43) function-interpolation-python 2.27017 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 22, 4, 21, 43) function-interpolation-python 0.930895 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 22, 4, 24, 14) la-vector-access-cpp 151.174 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 22, 4, 24, 52) la-vector-assignment-cpp 38.0086 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 23, 1, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0354 "BENCH 11.0354" (2014, 10, 23, 1, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1097 "Building point search tree to accelerate distance queries." (2014, 10, 23, 1, 9, 21) geometry-bounding_box_tree_build-cpp 14.2176 "BENCH 14.2176" (2014, 10, 23, 1, 9, 49) common-progress-cpp 27.9537 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 23, 1, 10, 20) common-timing-cpp 30.4108 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 23, 1, 11, 54) fem-convergence-cpp 3.82471 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 23, 1, 11, 56) fem-jit-python 0.000419998 "JIT compilation (in memory cache)" (2014, 10, 23, 4, 38, 39) mesh-refinement-cpp 8.52561 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 23, 4, 39, 1) mesh-topology-cpp 21.6209 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 23, 4, 39, 24) mesh-unitcube-cpp 22.8523 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 23, 4, 40, 6) mesh-iteration-cpp 39.1798 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 23, 4, 40, 6) function-evaluation-cpp 0.0722249 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 23, 4, 40, 11) function-extrapolation-python 5.5987 "BENCH: 2.00957489014" (2014, 10, 23, 4, 40, 11) function-extrapolation-python 2.00957 "BENCH: 2.00957489014" (2014, 10, 23, 4, 40, 14) function-interpolation-python 2.24004 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 23, 4, 40, 14) function-interpolation-python 0.908606 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 23, 4, 42, 45) la-vector-access-cpp 151.594 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 23, 4, 43, 24) la-vector-assignment-cpp 38.2895 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 24, 1, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1593 "BENCH 11.1593" (2014, 10, 24, 1, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0552 "Building point search tree to accelerate distance queries." (2014, 10, 24, 1, 9, 18) geometry-bounding_box_tree_build-cpp 14.322 "BENCH 14.322" (2014, 10, 24, 1, 9, 45) common-progress-cpp 27.9016 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 24, 1, 10, 16) common-timing-cpp 30.8148 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 24, 1, 11, 51) fem-convergence-cpp 3.89832 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 24, 1, 11, 52) fem-jit-python 0.000407004 "JIT compilation (in memory cache)" (2014, 10, 24, 4, 28, 34) mesh-refinement-cpp 8.57309 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 24, 4, 28, 55) mesh-topology-cpp 21.574 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 24, 4, 29, 19) mesh-unitcube-cpp 23.7722 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 24, 4, 30, 1) mesh-iteration-cpp 39.1757 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 24, 4, 30, 1) function-evaluation-cpp 0.0622101 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 24, 4, 30, 7) function-extrapolation-python 5.99373 "BENCH: 1.99651503563" (2014, 10, 24, 4, 30, 7) function-extrapolation-python 1.99652 "BENCH: 1.99651503563" (2014, 10, 24, 4, 30, 9) function-interpolation-python 2.25934 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 24, 4, 30, 9) function-interpolation-python 0.902858 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 24, 4, 32, 41) la-vector-access-cpp 151.814 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 24, 4, 33, 19) la-vector-assignment-cpp 38.0103 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 25, 1, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.159 "BENCH 11.159" (2014, 10, 25, 1, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3135 "Building point search tree to accelerate distance queries." (2014, 10, 25, 1, 9, 19) geometry-bounding_box_tree_build-cpp 14.436 "BENCH 14.436" (2014, 10, 25, 1, 9, 52) common-progress-cpp 32.9022 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 25, 1, 10, 22) common-timing-cpp 30.2973 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 25, 1, 11, 58) fem-convergence-cpp 3.90044 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 25, 1, 11, 59) fem-jit-python 0.000406313 "JIT compilation (in memory cache)" (2014, 10, 25, 4, 29, 47) mesh-refinement-cpp 8.55928 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 25, 4, 30, 8) mesh-topology-cpp 21.55 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 25, 4, 30, 32) mesh-unitcube-cpp 23.468 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 25, 4, 31, 18) mesh-iteration-cpp 43.5757 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 25, 4, 31, 18) function-evaluation-cpp 0.0745301 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 25, 4, 31, 24) function-extrapolation-python 5.99599 "BENCH: 2.0088031292" (2014, 10, 25, 4, 31, 24) function-extrapolation-python 2.0088 "BENCH: 2.0088031292" (2014, 10, 25, 4, 31, 26) function-interpolation-python 2.24296 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 25, 4, 31, 26) function-interpolation-python 0.895253 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 25, 4, 33, 57) la-vector-access-cpp 150.731 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 25, 4, 34, 35) la-vector-assignment-cpp 38.014 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 26, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.062 "BENCH 11.062" (2014, 10, 26, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.989 "Building point search tree to accelerate distance queries." (2014, 10, 26, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.2302 "BENCH 14.2302" (2014, 10, 26, 2, 9, 46) common-progress-cpp 28.0124 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 26, 2, 10, 15) common-timing-cpp 29.7158 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 26, 2, 11, 49) fem-convergence-cpp 3.85475 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 26, 2, 11, 51) fem-jit-python 0.000421906 "JIT compilation (in memory cache)" (2014, 10, 26, 5, 30, 50) mesh-refinement-cpp 8.69131 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 26, 5, 31, 12) mesh-topology-cpp 21.7343 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 26, 5, 31, 36) mesh-unitcube-cpp 23.679 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 26, 5, 32, 18) mesh-iteration-cpp 39.4166 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 26, 5, 32, 18) function-evaluation-cpp 0.089154 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 26, 5, 32, 24) function-extrapolation-python 5.89083 "BENCH: 2.03053402901" (2014, 10, 26, 5, 32, 24) function-extrapolation-python 2.03053 "BENCH: 2.03053402901" (2014, 10, 26, 5, 32, 26) function-interpolation-python 2.29373 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 26, 5, 32, 26) function-interpolation-python 0.921347 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 26, 5, 34, 57) la-vector-access-cpp 150.99 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 26, 5, 35, 39) la-vector-assignment-cpp 42.0274 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 27, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0295 "BENCH 11.0295" (2014, 10, 27, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.12 "Building point search tree to accelerate distance queries." (2014, 10, 27, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.2951 "BENCH 14.2951" (2014, 10, 27, 2, 9, 46) common-progress-cpp 27.8832 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 27, 2, 10, 16) common-timing-cpp 29.8866 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 27, 2, 11, 49) fem-convergence-cpp 3.86232 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 27, 2, 11, 50) fem-jit-python 0.000419497 "JIT compilation (in memory cache)" (2014, 10, 27, 5, 25, 20) mesh-refinement-cpp 8.55113 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 27, 5, 25, 41) mesh-topology-cpp 21.5124 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 27, 5, 26, 5) mesh-unitcube-cpp 23.5818 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 27, 5, 26, 47) mesh-iteration-cpp 39.1717 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 27, 5, 26, 47) function-evaluation-cpp 0.0619938 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 27, 5, 26, 53) function-extrapolation-python 5.69118 "BENCH: 1.99518585205" (2014, 10, 27, 5, 26, 53) function-extrapolation-python 1.99519 "BENCH: 1.99518585205" (2014, 10, 27, 5, 26, 55) function-interpolation-python 2.21938 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 27, 5, 26, 55) function-interpolation-python 0.893302 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 27, 5, 29, 26) la-vector-access-cpp 150.711 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 27, 5, 30, 4) la-vector-assignment-cpp 38.0112 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 28, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9708 "BENCH 10.9708" (2014, 10, 28, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1407 "Building point search tree to accelerate distance queries." (2014, 10, 28, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.2398 "BENCH 14.2398" (2014, 10, 28, 2, 9, 45) common-progress-cpp 27.922 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 28, 2, 10, 15) common-timing-cpp 30.1472 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 28, 2, 11, 50) fem-convergence-cpp 3.81522 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 28, 2, 11, 51) fem-jit-python 0.000424004 "JIT compilation (in memory cache)" (2014, 10, 28, 5, 47, 1) mesh-refinement-cpp 8.83603 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 28, 5, 47, 23) mesh-topology-cpp 21.7899 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 28, 5, 47, 47) mesh-unitcube-cpp 23.6861 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 28, 5, 48, 33) mesh-iteration-cpp 43.5884 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 28, 5, 48, 33) function-evaluation-cpp 0.0724461 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 28, 5, 48, 39) function-extrapolation-python 5.46461 "BENCH: 1.9933218956" (2014, 10, 28, 5, 48, 39) function-extrapolation-python 1.99332 "BENCH: 1.9933218956" (2014, 10, 28, 5, 48, 41) function-interpolation-python 2.23247 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 28, 5, 48, 41) function-interpolation-python 0.891896 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 28, 5, 51, 12) la-vector-access-cpp 150.7 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 28, 5, 51, 54) la-vector-assignment-cpp 42.0218 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 29, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1712 "BENCH 11.1712" (2014, 10, 29, 2, 9, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1633 "Building point search tree to accelerate distance queries." (2014, 10, 29, 2, 9, 23) geometry-bounding_box_tree_build-cpp 14.0887 "BENCH 14.0887" (2014, 10, 29, 2, 9, 50) common-progress-cpp 27.6201 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 29, 2, 10, 20) common-timing-cpp 30.2474 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 29, 2, 11, 55) fem-convergence-cpp 3.81475 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 29, 2, 11, 56) fem-jit-python 0.000425887 "JIT compilation (in memory cache)" (2014, 10, 29, 5, 33, 11) mesh-refinement-cpp 8.56165 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 29, 5, 33, 33) mesh-topology-cpp 21.6458 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 29, 5, 33, 56) mesh-unitcube-cpp 23.4395 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 29, 5, 34, 38) mesh-iteration-cpp 39.1111 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 29, 5, 34, 38) function-evaluation-cpp 0.0744588 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 29, 5, 34, 44) function-extrapolation-python 5.90783 "BENCH: 2.0017850399" (2014, 10, 29, 5, 34, 44) function-extrapolation-python 2.00179 "BENCH: 2.0017850399" (2014, 10, 29, 5, 34, 46) function-interpolation-python 2.25268 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 29, 5, 34, 46) function-interpolation-python 0.904835 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 29, 5, 37, 17) la-vector-access-cpp 150.484 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 29, 5, 37, 55) la-vector-assignment-cpp 38.0123 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 30, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0848 "BENCH 11.0848" (2014, 10, 30, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0471 "Building point search tree to accelerate distance queries." (2014, 10, 30, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.207 "BENCH 14.207" (2014, 10, 30, 2, 9, 45) common-progress-cpp 27.8812 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 30, 2, 10, 15) common-timing-cpp 30.0858 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 30, 2, 11, 50) fem-convergence-cpp 3.85671 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 30, 2, 11, 52) fem-jit-python 0.000422883 "JIT compilation (in memory cache)" (2014, 10, 30, 5, 31, 26) mesh-refinement-cpp 8.57116 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 30, 5, 31, 48) mesh-topology-cpp 21.6542 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 30, 5, 32, 12) mesh-unitcube-cpp 23.4339 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 30, 5, 32, 53) mesh-iteration-cpp 39.1871 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 30, 5, 32, 53) function-evaluation-cpp 0.070245 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 30, 5, 32, 59) function-extrapolation-python 5.8043 "BENCH: 1.99066901207" (2014, 10, 30, 5, 32, 59) function-extrapolation-python 1.99067 "BENCH: 1.99066901207" (2014, 10, 30, 5, 33, 2) function-interpolation-python 2.25158 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 30, 5, 33, 2) function-interpolation-python 0.895503 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 30, 5, 35, 33) la-vector-access-cpp 151.24 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 30, 5, 36, 11) la-vector-assignment-cpp 38.0111 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 10, 31, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1768 "BENCH 11.1768" (2014, 10, 31, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3583 "Building point search tree to accelerate distance queries." (2014, 10, 31, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.343 "BENCH 14.343" (2014, 10, 31, 2, 9, 48) common-progress-cpp 27.8879 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 10, 31, 2, 10, 18) common-timing-cpp 30.6418 "Timing access and registration of timings (10000000 repetitions)" (2014, 10, 31, 2, 11, 53) fem-convergence-cpp 3.84455 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 10, 31, 2, 11, 54) fem-jit-python 0.000427485 "JIT compilation (in memory cache)" (2014, 10, 31, 5, 34, 56) mesh-refinement-cpp 8.59252 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 10, 31, 5, 35, 18) mesh-topology-cpp 21.4965 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 10, 31, 5, 35, 42) mesh-unitcube-cpp 23.7136 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 10, 31, 5, 36, 23) mesh-iteration-cpp 39.1813 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 10, 31, 5, 36, 24) function-evaluation-cpp 0.063935 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 10, 31, 5, 36, 29) function-extrapolation-python 5.77328 "BENCH: 2.01375484467" (2014, 10, 31, 5, 36, 29) function-extrapolation-python 2.01375 "BENCH: 2.01375484467" (2014, 10, 31, 5, 36, 32) function-interpolation-python 2.24669 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 31, 5, 36, 32) function-interpolation-python 0.898741 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 10, 31, 5, 39, 2) la-vector-access-cpp 150.684 "Accessing vector of size 10000000 (100 repetitions)" (2014, 10, 31, 5, 39, 40) la-vector-assignment-cpp 38.019 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 1, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1329 "BENCH 11.1329" (2014, 11, 1, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1576 "Building point search tree to accelerate distance queries." (2014, 11, 1, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.1864 "BENCH 14.1864" (2014, 11, 1, 2, 9, 50) common-progress-cpp 31.6389 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 1, 2, 10, 21) common-timing-cpp 30.9122 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 1, 2, 11, 55) fem-convergence-cpp 3.86266 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 1, 2, 11, 57) fem-jit-python 0.000414205 "JIT compilation (in memory cache)" (2014, 11, 1, 5, 25, 19) mesh-refinement-cpp 8.61724 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 1, 5, 25, 41) mesh-topology-cpp 21.5759 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 1, 5, 26, 4) mesh-unitcube-cpp 23.4414 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 1, 5, 26, 46) mesh-iteration-cpp 39.1791 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 1, 5, 26, 46) function-evaluation-cpp 0.0769939 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 1, 5, 26, 52) function-extrapolation-python 5.64524 "BENCH: 1.99228000641" (2014, 11, 1, 5, 26, 52) function-extrapolation-python 1.99228 "BENCH: 1.99228000641" (2014, 11, 1, 5, 26, 54) function-interpolation-python 2.2298 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 1, 5, 26, 54) function-interpolation-python 0.896246 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 1, 5, 29, 25) la-vector-access-cpp 150.686 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 1, 5, 30, 3) la-vector-assignment-cpp 38.0279 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 2, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1125 "BENCH 11.1125" (2014, 11, 2, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0944 "Building point search tree to accelerate distance queries." (2014, 11, 2, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.0655 "BENCH 14.0655" (2014, 11, 2, 2, 9, 46) common-progress-cpp 27.8922 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 2, 2, 10, 17) common-timing-cpp 30.7812 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 2, 2, 11, 52) fem-convergence-cpp 3.83019 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 2, 2, 11, 53) fem-jit-python 0.000413513 "JIT compilation (in memory cache)" (2014, 11, 2, 5, 33, 54) mesh-refinement-cpp 8.73721 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 2, 5, 34, 16) mesh-topology-cpp 21.8735 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 2, 5, 34, 40) mesh-unitcube-cpp 23.6877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 2, 5, 35, 26) mesh-iteration-cpp 43.8435 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 2, 5, 35, 26) function-evaluation-cpp 0.0747271 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 2, 5, 35, 32) function-extrapolation-python 5.68925 "BENCH: 2.06611704826" (2014, 11, 2, 5, 35, 32) function-extrapolation-python 2.06612 "BENCH: 2.06611704826" (2014, 11, 2, 5, 35, 34) function-interpolation-python 2.28669 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 2, 5, 35, 34) function-interpolation-python 0.91682 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 2, 5, 38, 5) la-vector-access-cpp 151.003 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 2, 5, 38, 43) la-vector-assignment-cpp 38.0242 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 3, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1897 "BENCH 11.1897" (2014, 11, 3, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2746 "Building point search tree to accelerate distance queries." (2014, 11, 3, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.1962 "BENCH 14.1962" (2014, 11, 3, 2, 9, 46) common-progress-cpp 27.8841 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 3, 2, 10, 17) common-timing-cpp 30.6664 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 3, 2, 11, 52) fem-convergence-cpp 3.8923 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 3, 2, 11, 53) fem-jit-python 0.000409484 "JIT compilation (in memory cache)" (2014, 11, 3, 5, 28, 4) mesh-refinement-cpp 8.57199 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 3, 5, 28, 26) mesh-topology-cpp 21.5977 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 3, 5, 28, 49) mesh-unitcube-cpp 23.4697 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 3, 5, 29, 31) mesh-iteration-cpp 39.176 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 3, 5, 29, 31) function-evaluation-cpp 0.0745251 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 3, 5, 29, 37) function-extrapolation-python 5.71608 "BENCH: 1.99472284317" (2014, 11, 3, 5, 29, 37) function-extrapolation-python 1.99472 "BENCH: 1.99472284317" (2014, 11, 3, 5, 29, 39) function-interpolation-python 2.25196 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 3, 5, 29, 39) function-interpolation-python 0.904003 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 3, 5, 32, 10) la-vector-access-cpp 150.724 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 3, 5, 32, 52) la-vector-assignment-cpp 42.2564 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 4, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2981 "BENCH 11.2981" (2014, 11, 4, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.029 "Building point search tree to accelerate distance queries." (2014, 11, 4, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.4299 "BENCH 14.4299" (2014, 11, 4, 2, 9, 47) common-progress-cpp 27.9014 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 4, 2, 10, 17) common-timing-cpp 30.5036 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 4, 2, 11, 52) fem-convergence-cpp 3.86769 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 4, 2, 11, 53) fem-jit-python 0.00042119 "JIT compilation (in memory cache)" (2014, 11, 4, 5, 33, 14) mesh-refinement-cpp 8.83908 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 4, 5, 33, 36) mesh-topology-cpp 21.8505 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 4, 5, 33, 59) mesh-unitcube-cpp 23.6559 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 4, 5, 34, 41) mesh-iteration-cpp 39.3895 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 4, 5, 34, 41) function-evaluation-cpp 0.0769849 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 4, 5, 34, 47) function-extrapolation-python 5.87353 "BENCH: 2.0394718647" (2014, 11, 4, 5, 34, 47) function-extrapolation-python 2.03947 "BENCH: 2.0394718647" (2014, 11, 4, 5, 34, 50) function-interpolation-python 2.32688 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 4, 5, 34, 50) function-interpolation-python 0.926297 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 4, 5, 37, 22) la-vector-access-cpp 152.659 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 4, 5, 38, 0) la-vector-assignment-cpp 37.9671 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 5, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0927 "BENCH 11.0927" (2014, 11, 5, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1851 "Building point search tree to accelerate distance queries." (2014, 11, 5, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.1325 "BENCH 14.1325" (2014, 11, 5, 2, 9, 45) common-progress-cpp 27.8923 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 5, 2, 10, 16) common-timing-cpp 30.5506 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 5, 2, 11, 51) fem-convergence-cpp 3.84255 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 5, 2, 11, 52) fem-jit-python 0.0004143 "JIT compilation (in memory cache)" (2014, 11, 5, 5, 33, 27) mesh-refinement-cpp 8.57944 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 5, 5, 33, 49) mesh-topology-cpp 21.564 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 5, 5, 34, 12) mesh-unitcube-cpp 23.4395 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 5, 5, 34, 54) mesh-iteration-cpp 39.1757 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 5, 5, 34, 54) function-evaluation-cpp 0.07692 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 5, 5, 35, 0) function-extrapolation-python 5.76433 "BENCH: 2.01263093948" (2014, 11, 5, 5, 35, 0) function-extrapolation-python 2.01263 "BENCH: 2.01263093948" (2014, 11, 5, 5, 35, 2) function-interpolation-python 2.2562 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 5, 5, 35, 2) function-interpolation-python 0.916118 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 5, 5, 37, 35) la-vector-access-cpp 153.074 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 5, 5, 38, 14) la-vector-assignment-cpp 38.282 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 6, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9808 "BENCH 10.9808" (2014, 11, 6, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1164 "Building point search tree to accelerate distance queries." (2014, 11, 6, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3504 "BENCH 14.3504" (2014, 11, 6, 2, 9, 46) common-progress-cpp 27.8809 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 6, 2, 10, 16) common-timing-cpp 29.8311 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 6, 2, 11, 52) fem-convergence-cpp 3.88443 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 6, 2, 11, 53) fem-jit-python 0.000427794 "JIT compilation (in memory cache)" (2014, 11, 6, 5, 32, 15) mesh-refinement-cpp 8.71488 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 6, 5, 32, 37) mesh-topology-cpp 21.6479 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 6, 5, 33, 1) mesh-unitcube-cpp 23.8873 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 6, 5, 33, 43) mesh-iteration-cpp 39.4135 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 6, 5, 33, 43) function-evaluation-cpp 0.079735 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 6, 5, 33, 48) function-extrapolation-python 5.52255 "BENCH: 2.04936504364" (2014, 11, 6, 5, 33, 48) function-extrapolation-python 2.04937 "BENCH: 2.04936504364" (2014, 11, 6, 5, 33, 51) function-interpolation-python 2.2765 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 6, 5, 33, 51) function-interpolation-python 0.91461 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 6, 5, 36, 22) la-vector-access-cpp 151.541 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 6, 5, 37, 4) la-vector-assignment-cpp 41.9956 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 7, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.973 "BENCH 10.973" (2014, 11, 7, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.6656 "Building point search tree to accelerate distance queries." (2014, 11, 7, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.1323 "BENCH 14.1323" (2014, 11, 7, 2, 9, 48) common-progress-cpp 27.9404 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 7, 2, 10, 18) common-timing-cpp 29.7348 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 7, 2, 11, 51) fem-convergence-cpp 3.8358 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 7, 2, 11, 52) fem-jit-python 0.000423598 "JIT compilation (in memory cache)" (2014, 11, 7, 5, 19, 5) mesh-refinement-cpp 8.55839 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 7, 5, 19, 27) mesh-topology-cpp 21.5156 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 7, 5, 19, 50) mesh-unitcube-cpp 23.4877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 7, 5, 20, 32) mesh-iteration-cpp 39.1805 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 7, 5, 20, 32) function-evaluation-cpp 0.0762701 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 7, 5, 20, 38) function-extrapolation-python 5.73122 "BENCH: 2.02365708351" (2014, 11, 7, 5, 20, 38) function-extrapolation-python 2.02366 "BENCH: 2.02365708351" (2014, 11, 7, 5, 20, 40) function-interpolation-python 2.22803 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 7, 5, 20, 40) function-interpolation-python 0.896808 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 7, 5, 23, 12) la-vector-access-cpp 151.916 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 7, 5, 23, 50) la-vector-assignment-cpp 38.0204 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 8, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0432 "BENCH 11.0432" (2014, 11, 8, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9913 "Building point search tree to accelerate distance queries." (2014, 11, 8, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.0684 "BENCH 14.0684" (2014, 11, 8, 2, 9, 44) common-progress-cpp 27.8908 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 8, 2, 10, 15) common-timing-cpp 30.1833 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 8, 2, 11, 49) fem-convergence-cpp 3.83 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 8, 2, 11, 50) fem-jit-python 0.00042181 "JIT compilation (in memory cache)" (2014, 11, 8, 5, 28, 25) mesh-refinement-cpp 8.56076 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 8, 5, 28, 47) mesh-topology-cpp 21.6926 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 8, 5, 29, 11) mesh-unitcube-cpp 23.6028 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 8, 5, 29, 52) mesh-iteration-cpp 39.0982 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 8, 5, 29, 52) function-evaluation-cpp 0.0870249 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 8, 5, 29, 58) function-extrapolation-python 5.83516 "BENCH: 2.05952310562" (2014, 11, 8, 5, 29, 58) function-extrapolation-python 2.05952 "BENCH: 2.05952310562" (2014, 11, 8, 5, 30, 1) function-interpolation-python 2.35402 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 8, 5, 30, 1) function-interpolation-python 0.952389 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 8, 5, 32, 34) la-vector-access-cpp 153.36 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 8, 5, 33, 16) la-vector-assignment-cpp 42.0217 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 9, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1599 "BENCH 11.1599" (2014, 11, 9, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1473 "Building point search tree to accelerate distance queries." (2014, 11, 9, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.1587 "BENCH 14.1587" (2014, 11, 9, 2, 9, 44) common-progress-cpp 27.8856 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 9, 2, 10, 15) common-timing-cpp 30.962 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 9, 2, 11, 50) fem-convergence-cpp 3.83735 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 9, 2, 11, 51) fem-jit-python 0.000421691 "JIT compilation (in memory cache)" (2014, 11, 9, 5, 33, 43) mesh-refinement-cpp 8.5665 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 9, 5, 34, 4) mesh-topology-cpp 21.5765 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 9, 5, 34, 28) mesh-unitcube-cpp 23.5025 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 9, 5, 35, 10) mesh-iteration-cpp 39.1712 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 9, 5, 35, 10) function-evaluation-cpp 0.052187 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 9, 5, 35, 15) function-extrapolation-python 5.728 "BENCH: 2.00523686409" (2014, 11, 9, 5, 35, 15) function-extrapolation-python 2.00524 "BENCH: 2.00523686409" (2014, 11, 9, 5, 35, 18) function-interpolation-python 2.22628 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 9, 5, 35, 18) function-interpolation-python 0.893958 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 9, 5, 37, 48) la-vector-access-cpp 150.694 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 9, 5, 38, 26) la-vector-assignment-cpp 37.979 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 10, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2474 "BENCH 11.2474" (2014, 11, 10, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1376 "Building point search tree to accelerate distance queries." (2014, 11, 10, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.1706 "BENCH 14.1706" (2014, 11, 10, 2, 9, 44) common-progress-cpp 27.8843 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 10, 2, 10, 15) common-timing-cpp 30.8137 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 10, 2, 11, 49) fem-convergence-cpp 3.86626 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 10, 2, 11, 51) fem-jit-python 0.000417185 "JIT compilation (in memory cache)" (2014, 11, 10, 5, 27, 31) mesh-refinement-cpp 8.56199 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 10, 5, 27, 52) mesh-topology-cpp 21.589 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 10, 5, 28, 16) mesh-unitcube-cpp 23.4664 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 10, 5, 28, 58) mesh-iteration-cpp 39.1773 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 10, 5, 28, 58) function-evaluation-cpp 0.051223 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 10, 5, 29, 3) function-extrapolation-python 5.53876 "BENCH: 1.99187994003" (2014, 11, 10, 5, 29, 3) function-extrapolation-python 1.99188 "BENCH: 1.99187994003" (2014, 11, 10, 5, 29, 6) function-interpolation-python 2.22736 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 10, 5, 29, 6) function-interpolation-python 0.896078 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 10, 5, 31, 36) la-vector-access-cpp 150.664 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 10, 5, 32, 14) la-vector-assignment-cpp 38.0202 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 11, 2, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0118 "BENCH 11.0118" (2014, 11, 11, 2, 8, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3467 "Building point search tree to accelerate distance queries." (2014, 11, 11, 2, 9, 14) geometry-bounding_box_tree_build-cpp 14.2835 "BENCH 14.2835" (2014, 11, 11, 2, 9, 42) common-progress-cpp 27.877 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 11, 2, 10, 13) common-timing-cpp 30.5448 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 11, 2, 11, 48) fem-convergence-cpp 3.83798 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 11, 2, 11, 49) fem-jit-python 0.000419903 "JIT compilation (in memory cache)" (2014, 11, 11, 5, 30, 26) mesh-refinement-cpp 8.57733 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 11, 5, 30, 48) mesh-topology-cpp 21.577 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 11, 5, 31, 11) mesh-unitcube-cpp 23.6135 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 11, 5, 31, 53) mesh-iteration-cpp 39.1773 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 11, 5, 31, 53) function-evaluation-cpp 0.061244 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 11, 5, 31, 59) function-extrapolation-python 5.94534 "BENCH: 1.9957818985" (2014, 11, 11, 5, 31, 59) function-extrapolation-python 1.99578 "BENCH: 1.9957818985" (2014, 11, 11, 5, 32, 1) function-interpolation-python 2.30012 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 11, 5, 32, 1) function-interpolation-python 0.893837 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 11, 5, 34, 32) la-vector-access-cpp 150.71 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 11, 5, 35, 10) la-vector-assignment-cpp 37.955 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 12, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1893 "BENCH 11.1893" (2014, 11, 12, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9574 "Building point search tree to accelerate distance queries." (2014, 11, 12, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2366 "BENCH 14.2366" (2014, 11, 12, 2, 9, 48) common-progress-cpp 27.9002 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 12, 2, 10, 18) common-timing-cpp 30.43 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 12, 2, 11, 53) fem-convergence-cpp 3.88116 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 12, 2, 11, 54) fem-jit-python 0.000415182 "JIT compilation (in memory cache)" (2014, 11, 12, 5, 25, 53) mesh-refinement-cpp 8.59727 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 12, 5, 26, 15) mesh-topology-cpp 21.7704 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 12, 5, 26, 38) mesh-unitcube-cpp 23.6679 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 12, 5, 27, 30) mesh-iteration-cpp 48.8458 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 12, 5, 27, 30) function-evaluation-cpp 0.0789721 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 12, 5, 27, 35) function-extrapolation-python 5.64251 "BENCH: 2.06761288643" (2014, 11, 12, 5, 27, 35) function-extrapolation-python 2.06761 "BENCH: 2.06761288643" (2014, 11, 12, 5, 27, 38) function-interpolation-python 2.34344 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 12, 5, 27, 38) function-interpolation-python 0.92622 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 12, 5, 30, 9) la-vector-access-cpp 151.144 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 12, 5, 30, 47) la-vector-assignment-cpp 38.0224 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 13, 2, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0856 "BENCH 11.0856" (2014, 11, 13, 2, 8, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1592 "Building point search tree to accelerate distance queries." (2014, 11, 13, 2, 9, 14) geometry-bounding_box_tree_build-cpp 14.334 "BENCH 14.334" (2014, 11, 13, 2, 9, 42) common-progress-cpp 27.87 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 13, 2, 10, 13) common-timing-cpp 30.7049 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 13, 2, 11, 46) fem-convergence-cpp 3.83172 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 13, 2, 11, 48) fem-jit-python 0.000420499 "JIT compilation (in memory cache)" (2014, 11, 13, 5, 39, 29) mesh-refinement-cpp 8.56523 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 13, 5, 39, 51) mesh-topology-cpp 21.7378 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 13, 5, 40, 14) mesh-unitcube-cpp 23.4337 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 13, 5, 40, 56) mesh-iteration-cpp 39.1773 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 13, 5, 40, 56) function-evaluation-cpp 0.0721881 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 13, 5, 41, 2) function-extrapolation-python 5.66101 "BENCH: 2.00613808632" (2014, 11, 13, 5, 41, 2) function-extrapolation-python 2.00614 "BENCH: 2.00613808632" (2014, 11, 13, 5, 41, 4) function-interpolation-python 2.26246 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 13, 5, 41, 4) function-interpolation-python 0.914194 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 13, 5, 43, 35) la-vector-access-cpp 151.179 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 13, 5, 44, 13) la-vector-assignment-cpp 38.0234 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 14, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9115 "BENCH 10.9115" (2014, 11, 14, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2506 "Building point search tree to accelerate distance queries." (2014, 11, 14, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.293 "BENCH 14.293" (2014, 11, 14, 2, 9, 48) common-progress-cpp 27.8781 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 14, 2, 10, 18) common-timing-cpp 30.0494 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 14, 2, 11, 52) fem-convergence-cpp 3.93225 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 14, 2, 11, 53) fem-jit-python 0.000420403 "JIT compilation (in memory cache)" (2014, 11, 14, 5, 26, 7) mesh-refinement-cpp 8.58126 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 14, 5, 26, 29) mesh-topology-cpp 21.714 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 14, 5, 26, 52) mesh-unitcube-cpp 23.5037 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 14, 5, 27, 44) mesh-iteration-cpp 48.6059 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 14, 5, 27, 44) function-evaluation-cpp 0.074435 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 14, 5, 27, 49) function-extrapolation-python 5.64376 "BENCH: 2.02567696571" (2014, 11, 14, 5, 27, 49) function-extrapolation-python 2.02568 "BENCH: 2.02567696571" (2014, 11, 14, 5, 27, 52) function-interpolation-python 2.25691 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 14, 5, 27, 52) function-interpolation-python 0.916077 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 14, 5, 30, 22) la-vector-access-cpp 150.757 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 14, 5, 31, 0) la-vector-assignment-cpp 38.006 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 15, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.087 "BENCH 11.087" (2014, 11, 15, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0689 "Building point search tree to accelerate distance queries." (2014, 11, 15, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.192 "BENCH 14.192" (2014, 11, 15, 2, 9, 47) common-progress-cpp 27.8543 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 15, 2, 10, 18) common-timing-cpp 30.55 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 15, 2, 11, 52) fem-convergence-cpp 3.84475 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 15, 2, 11, 53) fem-jit-python 0.0004246 "JIT compilation (in memory cache)" (2014, 11, 15, 5, 32, 49) mesh-refinement-cpp 8.58526 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 15, 5, 33, 11) mesh-topology-cpp 21.7255 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 15, 5, 33, 34) mesh-unitcube-cpp 23.4851 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 15, 5, 34, 16) mesh-iteration-cpp 39.1772 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 15, 5, 34, 16) function-evaluation-cpp 0.074549 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 15, 5, 34, 22) function-extrapolation-python 5.69328 "BENCH: 2.02185893059" (2014, 11, 15, 5, 34, 22) function-extrapolation-python 2.02186 "BENCH: 2.02185893059" (2014, 11, 15, 5, 34, 24) function-interpolation-python 2.24235 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 15, 5, 34, 24) function-interpolation-python 0.89334 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 15, 5, 36, 55) la-vector-access-cpp 150.67 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 15, 5, 37, 33) la-vector-assignment-cpp 38.0204 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 16, 2, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.004 "BENCH 11.004" (2014, 11, 16, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.123 "Building point search tree to accelerate distance queries." (2014, 11, 16, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.1946 "BENCH 14.1946" (2014, 11, 16, 2, 9, 43) common-progress-cpp 27.9543 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 16, 2, 10, 13) common-timing-cpp 30.5193 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 16, 2, 11, 48) fem-convergence-cpp 3.90808 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 16, 2, 11, 49) fem-jit-python 0.000424409 "JIT compilation (in memory cache)" (2014, 11, 16, 5, 25, 48) mesh-refinement-cpp 8.58584 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 16, 5, 26, 9) mesh-topology-cpp 21.6329 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 16, 5, 26, 33) mesh-unitcube-cpp 23.5097 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 16, 5, 27, 19) mesh-iteration-cpp 43.573 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 16, 5, 27, 19) function-evaluation-cpp 0.0525801 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 16, 5, 27, 25) function-extrapolation-python 5.83663 "BENCH: 1.9994969368" (2014, 11, 16, 5, 27, 25) function-extrapolation-python 1.9995 "BENCH: 1.9994969368" (2014, 11, 16, 5, 27, 27) function-interpolation-python 2.27689 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 16, 5, 27, 27) function-interpolation-python 0.890873 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 16, 5, 29, 58) la-vector-access-cpp 151.263 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 16, 5, 30, 41) la-vector-assignment-cpp 42.0294 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 17, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.036 "BENCH 11.036" (2014, 11, 17, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1217 "Building point search tree to accelerate distance queries." (2014, 11, 17, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.1482 "BENCH 14.1482" (2014, 11, 17, 2, 9, 45) common-progress-cpp 27.8894 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 17, 2, 10, 16) common-timing-cpp 30.9943 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 17, 2, 11, 50) fem-convergence-cpp 3.82643 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 17, 2, 11, 52) fem-jit-python 0.000437403 "JIT compilation (in memory cache)" (2014, 11, 17, 5, 28, 47) mesh-refinement-cpp 8.66925 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 17, 5, 29, 9) mesh-topology-cpp 22.0489 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 17, 5, 29, 33) mesh-unitcube-cpp 23.486 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 17, 5, 30, 15) mesh-iteration-cpp 39.3997 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 17, 5, 30, 15) function-evaluation-cpp 0.081877 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 17, 5, 30, 21) function-extrapolation-python 5.91871 "BENCH: 2.08673191071" (2014, 11, 17, 5, 30, 21) function-extrapolation-python 2.08673 "BENCH: 2.08673191071" (2014, 11, 17, 5, 30, 23) function-interpolation-python 2.30621 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 17, 5, 30, 23) function-interpolation-python 0.9142 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 17, 5, 32, 54) la-vector-access-cpp 151.086 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 17, 5, 33, 36) la-vector-assignment-cpp 42.0217 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 18, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1254 "BENCH 11.1254" (2014, 11, 18, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2841 "Building point search tree to accelerate distance queries." (2014, 11, 18, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.4065 "BENCH 14.4065" (2014, 11, 18, 2, 9, 53) common-progress-cpp 32.9163 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 18, 2, 10, 24) common-timing-cpp 31.3074 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 18, 2, 11, 58) fem-convergence-cpp 3.86259 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 18, 2, 11, 59) fem-jit-python 0.000422192 "JIT compilation (in memory cache)" (2014, 11, 18, 5, 27, 11) mesh-refinement-cpp 8.83404 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 18, 5, 27, 33) mesh-topology-cpp 22.1794 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 18, 5, 27, 57) mesh-unitcube-cpp 23.8075 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 18, 5, 28, 39) mesh-iteration-cpp 39.4131 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 18, 5, 28, 39) function-evaluation-cpp 0.0959661 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 18, 5, 28, 45) function-extrapolation-python 5.56272 "BENCH: 2.11515712738" (2014, 11, 18, 5, 28, 45) function-extrapolation-python 2.11516 "BENCH: 2.11515712738" (2014, 11, 18, 5, 28, 47) function-interpolation-python 2.29952 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 18, 5, 28, 47) function-interpolation-python 0.92317 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 18, 5, 31, 18) la-vector-access-cpp 151.127 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 18, 5, 31, 56) la-vector-assignment-cpp 38.0277 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 19, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0342 "BENCH 11.0342" (2014, 11, 19, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.544 "Building point search tree to accelerate distance queries." (2014, 11, 19, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.2308 "BENCH 14.2308" (2014, 11, 19, 2, 9, 49) common-progress-cpp 27.892 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 19, 2, 10, 20) common-timing-cpp 30.8986 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 19, 2, 11, 55) fem-convergence-cpp 3.83568 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 19, 2, 11, 56) fem-jit-python 0.000417686 "JIT compilation (in memory cache)" (2014, 11, 19, 5, 31, 54) mesh-refinement-cpp 8.57422 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 19, 5, 32, 16) mesh-topology-cpp 21.7366 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 19, 5, 32, 39) mesh-unitcube-cpp 23.4858 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 19, 5, 33, 21) mesh-iteration-cpp 39.4001 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 19, 5, 33, 21) function-evaluation-cpp 0.0863519 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 19, 5, 33, 27) function-extrapolation-python 5.98273 "BENCH: 2.08429694176" (2014, 11, 19, 5, 33, 27) function-extrapolation-python 2.0843 "BENCH: 2.08429694176" (2014, 11, 19, 5, 33, 30) function-interpolation-python 2.32928 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 19, 5, 33, 30) function-interpolation-python 0.911104 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 19, 5, 36, 1) la-vector-access-cpp 151.457 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 19, 5, 36, 39) la-vector-assignment-cpp 38.0183 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 20, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0335 "BENCH 11.0335" (2014, 11, 20, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1808 "Building point search tree to accelerate distance queries." (2014, 11, 20, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.0261 "BENCH 14.0261" (2014, 11, 20, 2, 9, 50) common-progress-cpp 32.9025 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 20, 2, 10, 20) common-timing-cpp 30.1239 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 20, 2, 11, 54) fem-convergence-cpp 3.84419 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 20, 2, 11, 55) fem-jit-python 0.000416613 "JIT compilation (in memory cache)" (2014, 11, 20, 5, 27, 21) mesh-refinement-cpp 8.45026 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 20, 5, 27, 43) mesh-topology-cpp 21.4819 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 20, 5, 28, 6) mesh-unitcube-cpp 23.1853 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 20, 5, 28, 52) mesh-iteration-cpp 43.5634 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 20, 5, 28, 52) function-evaluation-cpp 0.078639 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 20, 5, 28, 58) function-extrapolation-python 5.6746 "BENCH: 2.0331017971" (2014, 11, 20, 5, 28, 58) function-extrapolation-python 2.0331 "BENCH: 2.0331017971" (2014, 11, 20, 5, 29, 0) function-interpolation-python 2.2375 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 20, 5, 29, 0) function-interpolation-python 0.880509 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 20, 5, 31, 31) la-vector-access-cpp 151.229 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 20, 5, 32, 13) la-vector-assignment-cpp 42.001 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 21, 2, 8, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.155 "BENCH 11.155" (2014, 11, 21, 2, 8, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2205 "Building point search tree to accelerate distance queries." (2014, 11, 21, 2, 9, 14) geometry-bounding_box_tree_build-cpp 14.2611 "BENCH 14.2611" (2014, 11, 21, 2, 9, 42) common-progress-cpp 27.8924 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 21, 2, 10, 12) common-timing-cpp 30.5561 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 21, 2, 11, 47) fem-convergence-cpp 3.85588 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 21, 2, 11, 49) fem-jit-python 0.000424194 "JIT compilation (in memory cache)" (2014, 11, 21, 5, 40, 13) mesh-refinement-cpp 8.51906 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 21, 5, 40, 35) mesh-topology-cpp 21.7448 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 21, 5, 40, 59) mesh-unitcube-cpp 23.4332 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 21, 5, 41, 41) mesh-iteration-cpp 39.4074 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 21, 5, 41, 41) function-evaluation-cpp 0.109499 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 21, 5, 41, 47) function-extrapolation-python 5.69102 "BENCH: 2.08780217171" (2014, 11, 21, 5, 41, 47) function-extrapolation-python 2.0878 "BENCH: 2.08780217171" (2014, 11, 21, 5, 41, 49) function-interpolation-python 2.28101 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 21, 5, 41, 49) function-interpolation-python 0.904316 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 21, 5, 44, 20) la-vector-access-cpp 151.489 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 21, 5, 44, 58) la-vector-assignment-cpp 38.0209 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 22, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0283 "BENCH 11.0283" (2014, 11, 22, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0228 "Building point search tree to accelerate distance queries." (2014, 11, 22, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.1958 "BENCH 14.1958" (2014, 11, 22, 2, 9, 47) common-progress-cpp 27.8488 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 22, 2, 10, 17) common-timing-cpp 30.6715 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 22, 2, 11, 53) fem-convergence-cpp 3.9171 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 22, 2, 11, 54) fem-jit-python 0.00042448 "JIT compilation (in memory cache)" (2014, 11, 22, 5, 39, 43) mesh-refinement-cpp 8.59384 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 22, 5, 40, 5) mesh-topology-cpp 21.8222 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 22, 5, 40, 29) mesh-unitcube-cpp 23.8658 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 22, 5, 41, 11) mesh-iteration-cpp 39.4028 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 22, 5, 41, 11) function-evaluation-cpp 0.079587 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 22, 5, 41, 17) function-extrapolation-python 5.81155 "BENCH: 2.11507296562" (2014, 11, 22, 5, 41, 17) function-extrapolation-python 2.11507 "BENCH: 2.11507296562" (2014, 11, 22, 5, 41, 20) function-interpolation-python 2.31685 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 22, 5, 41, 20) function-interpolation-python 0.907344 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 22, 5, 43, 51) la-vector-access-cpp 151.516 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 22, 5, 44, 29) la-vector-assignment-cpp 38.0251 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 23, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9392 "BENCH 10.9392" (2014, 11, 23, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8783 "Building point search tree to accelerate distance queries." (2014, 11, 23, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.3036 "BENCH 14.3036" (2014, 11, 23, 2, 9, 47) common-progress-cpp 27.8971 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 23, 2, 10, 17) common-timing-cpp 30.4252 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 23, 2, 11, 52) fem-convergence-cpp 3.89475 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 23, 2, 11, 53) fem-jit-python 0.000417113 "JIT compilation (in memory cache)" (2014, 11, 23, 5, 36, 26) mesh-refinement-cpp 8.46508 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 23, 5, 36, 48) mesh-topology-cpp 21.4844 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 23, 5, 37, 11) mesh-unitcube-cpp 23.1917 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 23, 5, 37, 52) mesh-iteration-cpp 39.1774 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 23, 5, 37, 52) function-evaluation-cpp 0.0744219 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 23, 5, 37, 58) function-extrapolation-python 5.81166 "BENCH: 2.03416991234" (2014, 11, 23, 5, 37, 58) function-extrapolation-python 2.03417 "BENCH: 2.03416991234" (2014, 11, 23, 5, 38, 1) function-interpolation-python 2.22093 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 23, 5, 38, 1) function-interpolation-python 0.880612 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 23, 5, 40, 32) la-vector-access-cpp 151.184 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 23, 5, 41, 10) la-vector-assignment-cpp 37.9549 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 24, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9971 "BENCH 10.9971" (2014, 11, 24, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5678 "Building point search tree to accelerate distance queries." (2014, 11, 24, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3415 "BENCH 14.3415" (2014, 11, 24, 2, 9, 46) common-progress-cpp 27.8817 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 24, 2, 10, 16) common-timing-cpp 30.0517 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 24, 2, 11, 50) fem-convergence-cpp 3.8862 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 24, 2, 11, 51) fem-jit-python 0.000428391 "JIT compilation (in memory cache)" (2014, 11, 24, 5, 28, 21) mesh-refinement-cpp 8.48427 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 24, 5, 28, 43) mesh-topology-cpp 21.462 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 24, 5, 29, 6) mesh-unitcube-cpp 23.2037 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 24, 5, 29, 48) mesh-iteration-cpp 39.1804 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 24, 5, 29, 48) function-evaluation-cpp 0.0750339 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 24, 5, 29, 54) function-extrapolation-python 5.64656 "BENCH: 2.02073216438" (2014, 11, 24, 5, 29, 54) function-extrapolation-python 2.02073 "BENCH: 2.02073216438" (2014, 11, 24, 5, 29, 56) function-interpolation-python 2.25768 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 24, 5, 29, 56) function-interpolation-python 0.884494 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 24, 5, 32, 27) la-vector-access-cpp 151.206 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 24, 5, 33, 5) la-vector-assignment-cpp 37.9962 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 25, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9472 "BENCH 10.9472" (2014, 11, 25, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0149 "Building point search tree to accelerate distance queries." (2014, 11, 25, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.2869 "BENCH 14.2869" (2014, 11, 25, 2, 9, 45) common-progress-cpp 27.8959 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 25, 2, 10, 16) common-timing-cpp 30.1409 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 25, 2, 11, 50) fem-convergence-cpp 3.87457 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 25, 2, 11, 52) fem-jit-python 0.000413322 "JIT compilation (in memory cache)" (2014, 11, 25, 5, 32, 4) mesh-refinement-cpp 8.44344 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 25, 5, 32, 26) mesh-topology-cpp 21.3319 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 25, 5, 32, 49) mesh-unitcube-cpp 23.2974 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 25, 5, 33, 30) mesh-iteration-cpp 39.1706 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 25, 5, 33, 31) function-evaluation-cpp 0.0742581 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 25, 5, 33, 36) function-extrapolation-python 5.79533 "BENCH: 2.02150583267" (2014, 11, 25, 5, 33, 36) function-extrapolation-python 2.02151 "BENCH: 2.02150583267" (2014, 11, 25, 5, 33, 39) function-interpolation-python 2.21199 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 25, 5, 33, 39) function-interpolation-python 0.879973 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 25, 5, 36, 10) la-vector-access-cpp 151.17 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 25, 5, 36, 48) la-vector-assignment-cpp 38.0043 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 26, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2882 "BENCH 11.2882" (2014, 11, 26, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5724 "Building point search tree to accelerate distance queries." (2014, 11, 26, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3579 "BENCH 14.3579" (2014, 11, 26, 2, 9, 46) common-progress-cpp 27.9743 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 26, 2, 10, 16) common-timing-cpp 30.6618 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 26, 2, 11, 52) fem-convergence-cpp 3.92183 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 26, 2, 11, 54) fem-jit-python 0.000416613 "JIT compilation (in memory cache)" (2014, 11, 26, 5, 27, 14) mesh-refinement-cpp 8.42394 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 26, 5, 27, 35) mesh-topology-cpp 21.4659 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 26, 5, 27, 58) mesh-unitcube-cpp 23.0631 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 26, 5, 28, 36) mesh-iteration-cpp 35.5572 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 26, 5, 28, 36) function-evaluation-cpp 0.0495212 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 26, 5, 28, 42) function-extrapolation-python 5.58798 "BENCH: 2.0147550106" (2014, 11, 26, 5, 28, 42) function-extrapolation-python 2.01476 "BENCH: 2.0147550106" (2014, 11, 26, 5, 28, 44) function-interpolation-python 2.2327 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 26, 5, 28, 44) function-interpolation-python 0.900616 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 26, 5, 31, 16) la-vector-access-cpp 151.215 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 26, 5, 31, 58) la-vector-assignment-cpp 42.0126 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 27, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.2077 "BENCH 11.2077" (2014, 11, 27, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0056 "Building point search tree to accelerate distance queries." (2014, 11, 27, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3457 "BENCH 14.3457" (2014, 11, 27, 2, 9, 51) common-progress-cpp 32.9151 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 27, 2, 10, 21) common-timing-cpp 30.1639 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 27, 2, 11, 56) fem-convergence-cpp 3.88184 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 27, 2, 11, 57) fem-jit-python 0.000427699 "JIT compilation (in memory cache)" (2014, 11, 27, 5, 23, 30) mesh-refinement-cpp 8.55183 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 27, 5, 23, 51) mesh-topology-cpp 21.4173 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 27, 5, 24, 15) mesh-unitcube-cpp 23.5162 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 27, 5, 24, 53) mesh-iteration-cpp 36.0379 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 27, 5, 24, 54) function-evaluation-cpp 0.0579078 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 27, 5, 24, 59) function-extrapolation-python 5.73823 "BENCH: 2.04011201859" (2014, 11, 27, 5, 24, 59) function-extrapolation-python 2.04011 "BENCH: 2.04011201859" (2014, 11, 27, 5, 25, 2) function-interpolation-python 2.28077 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 27, 5, 25, 2) function-interpolation-python 0.911958 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 27, 5, 27, 33) la-vector-access-cpp 151.071 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 27, 5, 28, 11) la-vector-assignment-cpp 38.0186 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 28, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1795 "BENCH 11.1795" (2014, 11, 28, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3544 "Building point search tree to accelerate distance queries." (2014, 11, 28, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.3571 "BENCH 14.3571" (2014, 11, 28, 2, 9, 47) common-progress-cpp 27.8828 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 28, 2, 10, 17) common-timing-cpp 29.6392 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 28, 2, 11, 50) fem-convergence-cpp 3.82646 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 28, 2, 11, 51) fem-jit-python 0.000423193 "JIT compilation (in memory cache)" (2014, 11, 28, 5, 19, 11) mesh-refinement-cpp 8.44101 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 28, 5, 19, 33) mesh-topology-cpp 21.5348 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 28, 5, 19, 56) mesh-unitcube-cpp 23.4426 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 28, 5, 20, 35) mesh-iteration-cpp 36.05 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 28, 5, 20, 35) function-evaluation-cpp 0.060262 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 28, 5, 20, 41) function-extrapolation-python 5.98987 "BENCH: 2.0201189518" (2014, 11, 28, 5, 20, 41) function-extrapolation-python 2.02012 "BENCH: 2.0201189518" (2014, 11, 28, 5, 20, 43) function-interpolation-python 2.25485 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 28, 5, 20, 43) function-interpolation-python 0.889753 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 28, 5, 23, 15) la-vector-access-cpp 152.218 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 28, 5, 23, 55) la-vector-assignment-cpp 39.5606 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 29, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1398 "BENCH 11.1398" (2014, 11, 29, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.5481 "Building point search tree to accelerate distance queries." (2014, 11, 29, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.267 "BENCH 14.267" (2014, 11, 29, 2, 9, 47) common-progress-cpp 27.8978 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 29, 2, 10, 17) common-timing-cpp 29.9774 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 29, 2, 11, 51) fem-convergence-cpp 3.83514 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 29, 2, 11, 52) fem-jit-python 0.000418687 "JIT compilation (in memory cache)" (2014, 11, 29, 5, 26, 59) mesh-refinement-cpp 8.41353 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 29, 5, 27, 21) mesh-topology-cpp 21.5866 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 29, 5, 27, 44) mesh-unitcube-cpp 23.2291 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 29, 5, 28, 25) mesh-iteration-cpp 39.1754 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 29, 5, 28, 25) function-evaluation-cpp 0.0584619 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 29, 5, 28, 31) function-extrapolation-python 5.84035 "BENCH: 2.02479100227" (2014, 11, 29, 5, 28, 31) function-extrapolation-python 2.02479 "BENCH: 2.02479100227" (2014, 11, 29, 5, 28, 34) function-interpolation-python 2.23139 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 29, 5, 28, 34) function-interpolation-python 0.891395 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 29, 5, 31, 5) la-vector-access-cpp 151.218 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 29, 5, 31, 43) la-vector-assignment-cpp 38.0125 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 11, 30, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1433 "BENCH 11.1433" (2014, 11, 30, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9586 "Building point search tree to accelerate distance queries." (2014, 11, 30, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2624 "BENCH 14.2624" (2014, 11, 30, 2, 9, 44) common-progress-cpp 27.9769 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 11, 30, 2, 10, 14) common-timing-cpp 30.4883 "Timing access and registration of timings (10000000 repetitions)" (2014, 11, 30, 2, 11, 48) fem-convergence-cpp 3.87806 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 11, 30, 2, 11, 49) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2014, 11, 30, 5, 30, 9) mesh-refinement-cpp 8.42986 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 11, 30, 5, 30, 31) mesh-topology-cpp 21.5223 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 11, 30, 5, 30, 54) mesh-unitcube-cpp 23.1856 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 11, 30, 5, 31, 32) mesh-iteration-cpp 35.5686 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 11, 30, 5, 31, 32) function-evaluation-cpp 0.0887389 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 11, 30, 5, 31, 39) function-extrapolation-python 6.09071 "BENCH: 2.0510430336" (2014, 11, 30, 5, 31, 39) function-extrapolation-python 2.05104 "BENCH: 2.0510430336" (2014, 11, 30, 5, 31, 41) function-interpolation-python 2.22844 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 30, 5, 31, 41) function-interpolation-python 0.896044 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 11, 30, 5, 34, 12) la-vector-access-cpp 151.219 "Accessing vector of size 10000000 (100 repetitions)" (2014, 11, 30, 5, 34, 50) la-vector-assignment-cpp 38.0233 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 1, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1623 "BENCH 11.1623" (2014, 12, 1, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0995 "Building point search tree to accelerate distance queries." (2014, 12, 1, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.1981 "BENCH 14.1981" (2014, 12, 1, 2, 9, 44) common-progress-cpp 27.9516 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 1, 2, 10, 15) common-timing-cpp 30.7541 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 1, 2, 11, 50) fem-convergence-cpp 3.89599 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 1, 2, 11, 51) fem-jit-python 0.00042851 "JIT compilation (in memory cache)" (2014, 12, 1, 5, 24, 3) mesh-refinement-cpp 8.43002 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 1, 5, 24, 25) mesh-topology-cpp 21.3613 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 1, 5, 24, 48) mesh-unitcube-cpp 23.2172 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 1, 5, 25, 26) mesh-iteration-cpp 35.5725 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 1, 5, 25, 26) function-evaluation-cpp 0.072073 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 1, 5, 25, 32) function-extrapolation-python 5.53547 "BENCH: 2.01897788048" (2014, 12, 1, 5, 25, 32) function-extrapolation-python 2.01898 "BENCH: 2.01897788048" (2014, 12, 1, 5, 25, 34) function-interpolation-python 2.21438 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 1, 5, 25, 34) function-interpolation-python 0.891385 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 1, 5, 28, 7) la-vector-access-cpp 153.215 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 1, 5, 28, 49) la-vector-assignment-cpp 42.0255 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 2, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1611 "BENCH 11.1611" (2014, 12, 2, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1738 "Building point search tree to accelerate distance queries." (2014, 12, 2, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.2546 "BENCH 14.2546" (2014, 12, 2, 2, 9, 49) common-progress-cpp 27.8803 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 2, 2, 10, 20) common-timing-cpp 30.6836 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 2, 2, 11, 55) fem-convergence-cpp 3.87538 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 2, 2, 11, 56) fem-jit-python 0.000425696 "JIT compilation (in memory cache)" (2014, 12, 2, 5, 26, 1) mesh-refinement-cpp 8.44052 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 2, 5, 26, 23) mesh-topology-cpp 21.5855 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 2, 5, 26, 46) mesh-unitcube-cpp 23.1677 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 2, 5, 27, 24) mesh-iteration-cpp 35.5527 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 2, 5, 27, 24) function-evaluation-cpp 0.06847 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 2, 5, 27, 30) function-extrapolation-python 5.71011 "BENCH: 2.02131605148" (2014, 12, 2, 5, 27, 30) function-extrapolation-python 2.02132 "BENCH: 2.02131605148" (2014, 12, 2, 5, 27, 32) function-interpolation-python 2.24553 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 2, 5, 27, 32) function-interpolation-python 0.894265 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 2, 5, 30, 2) la-vector-access-cpp 150.528 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 2, 5, 30, 40) la-vector-assignment-cpp 38.017 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 3, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9466 "BENCH 10.9466" (2014, 12, 3, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0225 "Building point search tree to accelerate distance queries." (2014, 12, 3, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.3543 "BENCH 14.3543" (2014, 12, 3, 2, 9, 45) common-progress-cpp 27.8943 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 3, 2, 10, 15) common-timing-cpp 30.0983 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 3, 2, 11, 50) fem-convergence-cpp 3.83692 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 3, 2, 11, 51) fem-jit-python 0.000436497 "JIT compilation (in memory cache)" (2014, 12, 3, 5, 30, 45) mesh-refinement-cpp 8.57648 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 3, 5, 31, 6) mesh-topology-cpp 21.2971 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 3, 5, 31, 30) mesh-unitcube-cpp 23.8189 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 3, 5, 32, 8) mesh-iteration-cpp 35.5158 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 3, 5, 32, 8) function-evaluation-cpp 0.0638831 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 3, 5, 32, 14) function-extrapolation-python 6.07975 "BENCH: 2.04424977303" (2014, 12, 3, 5, 32, 14) function-extrapolation-python 2.04425 "BENCH: 2.04424977303" (2014, 12, 3, 5, 32, 16) function-interpolation-python 2.24729 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 3, 5, 32, 16) function-interpolation-python 0.92166 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 3, 5, 35, 5) la-vector-access-cpp 168.557 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 3, 5, 35, 43) la-vector-assignment-cpp 38.0319 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 4, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0513 "BENCH 11.0513" (2014, 12, 4, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2148 "Building point search tree to accelerate distance queries." (2014, 12, 4, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.4316 "BENCH 14.4316" (2014, 12, 4, 2, 9, 47) common-progress-cpp 27.8767 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 4, 2, 10, 18) common-timing-cpp 30.3181 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 4, 2, 11, 51) fem-convergence-cpp 3.83863 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 4, 2, 11, 52) fem-jit-python 0.000419307 "JIT compilation (in memory cache)" (2014, 12, 4, 5, 32, 28) mesh-refinement-cpp 8.53671 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 4, 5, 32, 50) mesh-topology-cpp 21.3068 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 4, 5, 33, 14) mesh-unitcube-cpp 23.9496 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 4, 5, 33, 52) mesh-iteration-cpp 35.5017 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 4, 5, 33, 52) function-evaluation-cpp 0.080543 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 4, 5, 33, 58) function-extrapolation-python 6.09157 "BENCH: 2.20002579689" (2014, 12, 4, 5, 33, 58) function-extrapolation-python 2.20003 "BENCH: 2.20002579689" (2014, 12, 4, 5, 34, 0) function-interpolation-python 2.42382 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 4, 5, 34, 0) function-interpolation-python 1.00143 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 4, 5, 36, 39) la-vector-access-cpp 158.871 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 4, 5, 37, 17) la-vector-assignment-cpp 38.028 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 5, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0552 "BENCH 11.0552" (2014, 12, 5, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0921 "Building point search tree to accelerate distance queries." (2014, 12, 5, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2181 "BENCH 14.2181" (2014, 12, 5, 2, 9, 47) common-progress-cpp 27.8756 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 5, 2, 10, 18) common-timing-cpp 31.0291 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 5, 2, 11, 52) fem-convergence-cpp 3.90746 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 5, 2, 11, 54) fem-jit-python 0.000413585 "JIT compilation (in memory cache)" (2014, 12, 5, 5, 29, 58) mesh-refinement-cpp 8.57406 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 5, 5, 30, 19) mesh-topology-cpp 21.3319 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 5, 5, 30, 43) mesh-unitcube-cpp 23.8515 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 5, 5, 31, 25) mesh-iteration-cpp 39.1826 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 5, 5, 31, 25) function-evaluation-cpp 0.051332 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 5, 5, 31, 30) function-extrapolation-python 5.64393 "BENCH: 2.02772808075" (2014, 12, 5, 5, 31, 30) function-extrapolation-python 2.02773 "BENCH: 2.02772808075" (2014, 12, 5, 5, 31, 33) function-interpolation-python 2.26315 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 5, 5, 31, 33) function-interpolation-python 0.926614 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 5, 5, 34, 6) la-vector-access-cpp 153.202 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 5, 5, 34, 44) la-vector-assignment-cpp 38.0257 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 6, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.0331 "BENCH 11.0331" (2014, 12, 6, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.003 "Building point search tree to accelerate distance queries." (2014, 12, 6, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2856 "BENCH 14.2856" (2014, 12, 6, 2, 9, 48) common-progress-cpp 27.8982 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 6, 2, 10, 19) common-timing-cpp 30.8003 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 6, 2, 11, 54) fem-convergence-cpp 3.9381 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 6, 2, 11, 55) fem-jit-python 0.000418901 "JIT compilation (in memory cache)" (2014, 12, 6, 5, 26, 14) mesh-refinement-cpp 8.57738 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 6, 5, 26, 36) mesh-topology-cpp 21.5417 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 6, 5, 26, 59) mesh-unitcube-cpp 23.8586 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 6, 5, 27, 37) mesh-iteration-cpp 35.4949 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 6, 5, 27, 37) function-evaluation-cpp 0.0511379 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 6, 5, 27, 43) function-extrapolation-python 5.74341 "BENCH: 2.01074385643" (2014, 12, 6, 5, 27, 43) function-extrapolation-python 2.01074 "BENCH: 2.01074385643" (2014, 12, 6, 5, 27, 46) function-interpolation-python 2.26593 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 6, 5, 27, 46) function-interpolation-python 0.921959 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 6, 5, 30, 23) la-vector-access-cpp 157.206 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 6, 5, 31, 1) la-vector-assignment-cpp 38.0292 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 7, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 10.9062 "BENCH 10.9062" (2014, 12, 7, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.404 "Building point search tree to accelerate distance queries." (2014, 12, 7, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2632 "BENCH 14.2632" (2014, 12, 7, 2, 9, 44) common-progress-cpp 27.8752 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 7, 2, 10, 14) common-timing-cpp 30.1152 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 7, 2, 11, 49) fem-convergence-cpp 3.83022 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 7, 2, 11, 51) fem-jit-python 0.000415301 "JIT compilation (in memory cache)" (2014, 12, 7, 5, 45, 30) mesh-refinement-cpp 8.76469 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 7, 5, 45, 52) mesh-topology-cpp 21.5272 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 7, 5, 46, 16) mesh-unitcube-cpp 24.0883 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 7, 5, 46, 57) mesh-iteration-cpp 38.8052 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 7, 5, 46, 57) function-evaluation-cpp 0.0768728 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 7, 5, 47, 3) function-extrapolation-python 5.75214 "BENCH: 2.06273508072" (2014, 12, 7, 5, 47, 3) function-extrapolation-python 2.06274 "BENCH: 2.06273508072" (2014, 12, 7, 5, 47, 6) function-interpolation-python 2.37832 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 7, 5, 47, 6) function-interpolation-python 0.940044 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 7, 5, 49, 39) la-vector-access-cpp 153.685 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 7, 5, 50, 21) la-vector-assignment-cpp 42.0184 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 8, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1775 "BENCH 11.1775" (2014, 12, 8, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4396 "Building point search tree to accelerate distance queries." (2014, 12, 8, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2997 "BENCH 14.2997" (2014, 12, 8, 2, 9, 46) common-progress-cpp 27.8902 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 8, 2, 10, 16) common-timing-cpp 29.6516 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 8, 2, 11, 51) fem-convergence-cpp 3.8878 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 8, 2, 11, 52) fem-jit-python 0.000425696 "JIT compilation (in memory cache)" (2014, 12, 8, 5, 32, 5) mesh-refinement-cpp 8.59314 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 8, 5, 32, 26) mesh-topology-cpp 21.2677 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 8, 5, 32, 50) mesh-unitcube-cpp 23.8049 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 8, 5, 33, 28) mesh-iteration-cpp 35.5715 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 8, 5, 33, 28) function-evaluation-cpp 0.0513871 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 8, 5, 33, 34) function-extrapolation-python 5.79644 "BENCH: 2.00842189789" (2014, 12, 8, 5, 33, 34) function-extrapolation-python 2.00842 "BENCH: 2.00842189789" (2014, 12, 8, 5, 33, 36) function-interpolation-python 2.27048 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 8, 5, 33, 36) function-interpolation-python 0.926154 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 8, 5, 36, 14) la-vector-access-cpp 157.006 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 8, 5, 36, 52) la-vector-assignment-cpp 38.0143 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 9, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 11.1356 "BENCH 11.1356" (2014, 12, 9, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1201 "Building point search tree to accelerate distance queries." (2014, 12, 9, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3785 "BENCH 14.3785" (2014, 12, 9, 2, 9, 46) common-progress-cpp 27.8935 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 9, 2, 10, 16) common-timing-cpp 30.0126 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 9, 2, 11, 51) fem-convergence-cpp 3.85427 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 9, 2, 11, 52) fem-jit-python 0.000422192 "JIT compilation (in memory cache)" (2014, 12, 9, 5, 33, 2) mesh-refinement-cpp 8.72281 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 9, 5, 33, 23) mesh-topology-cpp 21.5446 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 9, 5, 33, 48) mesh-unitcube-cpp 24.0808 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 9, 5, 34, 26) mesh-iteration-cpp 35.9119 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 9, 5, 34, 26) function-evaluation-cpp 0.0855582 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 9, 5, 34, 32) function-extrapolation-python 5.89859 "BENCH: 2.13737511635" (2014, 12, 9, 5, 34, 32) function-extrapolation-python 2.13738 "BENCH: 2.13737511635" (2014, 12, 9, 5, 34, 34) function-interpolation-python 2.36377 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 9, 5, 34, 34) function-interpolation-python 0.972647 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 9, 5, 37, 8) la-vector-access-cpp 153.706 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 9, 5, 37, 46) la-vector-assignment-cpp 38.0243 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 10, 2, 8, 51) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.9057 "BENCH 13.9057" (2014, 12, 10, 2, 9, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1701 "Building point search tree to accelerate distance queries." (2014, 12, 10, 2, 9, 26) geometry-bounding_box_tree_build-cpp 14.2647 "BENCH 14.2647" (2014, 12, 10, 2, 9, 54) common-progress-cpp 27.8819 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 10, 2, 10, 23) common-timing-cpp 29.186 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 10, 2, 11, 57) fem-convergence-cpp 3.90364 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 10, 2, 11, 58) fem-jit-python 0.000419903 "JIT compilation (in memory cache)" (2014, 12, 10, 5, 28, 49) mesh-refinement-cpp 8.60041 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 10, 5, 29, 10) mesh-topology-cpp 21.3144 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 10, 5, 29, 34) mesh-unitcube-cpp 23.8885 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 10, 5, 30, 13) mesh-iteration-cpp 36.0084 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 10, 5, 30, 13) function-evaluation-cpp 0.051332 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 10, 5, 30, 19) function-extrapolation-python 5.83498 "BENCH: 2.05190706253" (2014, 12, 10, 5, 30, 19) function-extrapolation-python 2.05191 "BENCH: 2.05190706253" (2014, 12, 10, 5, 30, 21) function-interpolation-python 2.28131 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 10, 5, 30, 21) function-interpolation-python 0.935288 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 10, 5, 32, 56) la-vector-access-cpp 155.26 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 10, 5, 33, 34) la-vector-assignment-cpp 38.0555 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 11, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8314 "BENCH 12.8314" (2014, 12, 11, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9006 "Building point search tree to accelerate distance queries." (2014, 12, 11, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.2316 "BENCH 14.2316" (2014, 12, 11, 2, 9, 50) common-progress-cpp 27.8976 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 11, 2, 10, 20) common-timing-cpp 29.7156 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 11, 2, 11, 53) fem-convergence-cpp 3.88637 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 11, 2, 11, 55) fem-jit-python 0.000425005 "JIT compilation (in memory cache)" (2014, 12, 11, 5, 36, 47) mesh-refinement-cpp 8.51818 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 11, 5, 37, 8) mesh-topology-cpp 21.4174 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 11, 5, 37, 32) mesh-unitcube-cpp 23.8422 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 11, 5, 38, 23) mesh-iteration-cpp 48.5165 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 11, 5, 38, 23) function-evaluation-cpp 0.0513809 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 11, 5, 38, 29) function-extrapolation-python 5.93456 "BENCH: 1.99134087563" (2014, 12, 11, 5, 38, 29) function-extrapolation-python 1.99134 "BENCH: 1.99134087563" (2014, 12, 11, 5, 38, 31) function-interpolation-python 2.25299 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 11, 5, 38, 31) function-interpolation-python 0.910212 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 11, 5, 41, 7) la-vector-access-cpp 155.317 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 11, 5, 41, 45) la-vector-assignment-cpp 38.0423 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 12, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1017 "BENCH 13.1017" (2014, 12, 12, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4417 "Building point search tree to accelerate distance queries." (2014, 12, 12, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2022 "BENCH 14.2022" (2014, 12, 12, 2, 9, 48) common-progress-cpp 27.9017 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 12, 2, 10, 19) common-timing-cpp 30.9786 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 12, 2, 11, 53) fem-convergence-cpp 3.88432 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 12, 2, 11, 54) fem-jit-python 0.000429106 "JIT compilation (in memory cache)" (2014, 12, 12, 5, 24, 57) mesh-refinement-cpp 8.47242 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 12, 5, 25, 19) mesh-topology-cpp 21.8559 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 12, 5, 25, 42) mesh-unitcube-cpp 22.8273 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 12, 5, 26, 28) mesh-iteration-cpp 43.5774 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 12, 5, 26, 28) function-evaluation-cpp 0.053828 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 12, 5, 26, 33) function-extrapolation-python 5.49019 "BENCH: 2.01706314087" (2014, 12, 12, 5, 26, 33) function-extrapolation-python 2.01706 "BENCH: 2.01706314087" (2014, 12, 12, 5, 26, 36) function-interpolation-python 2.27918 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 12, 5, 26, 36) function-interpolation-python 0.953322 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 12, 5, 29, 8) la-vector-access-cpp 152.701 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 12, 5, 29, 46) la-vector-assignment-cpp 38.0115 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 13, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0859 "BENCH 13.0859" (2014, 12, 13, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4561 "Building point search tree to accelerate distance queries." (2014, 12, 13, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.1995 "BENCH 14.1995" (2014, 12, 13, 2, 9, 48) common-progress-cpp 27.9003 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 13, 2, 10, 18) common-timing-cpp 30.6068 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 13, 2, 11, 53) fem-convergence-cpp 3.88772 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 13, 2, 11, 55) fem-jit-python 0.000417399 "JIT compilation (in memory cache)" (2014, 12, 13, 5, 28, 57) mesh-refinement-cpp 8.40802 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 13, 5, 29, 18) mesh-topology-cpp 21.6505 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 13, 5, 29, 41) mesh-unitcube-cpp 22.8536 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 13, 5, 30, 23) mesh-iteration-cpp 39.1799 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 13, 5, 30, 23) function-evaluation-cpp 0.0537529 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 13, 5, 30, 29) function-extrapolation-python 5.78319 "BENCH: 2.02463197708" (2014, 12, 13, 5, 30, 29) function-extrapolation-python 2.02463 "BENCH: 2.02463197708" (2014, 12, 13, 5, 30, 31) function-interpolation-python 2.27945 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 13, 5, 30, 31) function-interpolation-python 0.953687 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 13, 5, 33, 7) la-vector-access-cpp 155.699 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 13, 5, 33, 49) la-vector-assignment-cpp 42.0067 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 14, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0771 "BENCH 13.0771" (2014, 12, 14, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3546 "Building point search tree to accelerate distance queries." (2014, 12, 14, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2997 "BENCH 14.2997" (2014, 12, 14, 2, 9, 48) common-progress-cpp 27.9107 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 14, 2, 10, 19) common-timing-cpp 30.9396 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 14, 2, 11, 54) fem-convergence-cpp 3.93471 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 14, 2, 11, 56) fem-jit-python 0.000420117 "JIT compilation (in memory cache)" (2014, 12, 14, 5, 17, 31) mesh-refinement-cpp 8.45236 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 14, 5, 17, 53) mesh-topology-cpp 21.8024 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 14, 5, 18, 16) mesh-unitcube-cpp 22.7846 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 14, 5, 18, 57) mesh-iteration-cpp 39.176 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 14, 5, 18, 58) function-evaluation-cpp 0.074486 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 14, 5, 19, 3) function-extrapolation-python 5.62811 "BENCH: 2.0052549839" (2014, 12, 14, 5, 19, 3) function-extrapolation-python 2.00525 "BENCH: 2.0052549839" (2014, 12, 14, 5, 19, 6) function-interpolation-python 2.30022 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 14, 5, 19, 6) function-interpolation-python 0.957675 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 14, 5, 21, 39) la-vector-access-cpp 153.766 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 14, 5, 22, 17) la-vector-assignment-cpp 38.01 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 15, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1915 "BENCH 13.1915" (2014, 12, 15, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1045 "Building point search tree to accelerate distance queries." (2014, 12, 15, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2413 "BENCH 14.2413" (2014, 12, 15, 2, 9, 48) common-progress-cpp 27.9807 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 15, 2, 10, 18) common-timing-cpp 30.7174 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 15, 2, 11, 53) fem-convergence-cpp 3.847 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 15, 2, 11, 54) fem-jit-python 0.000411701 "JIT compilation (in memory cache)" (2014, 12, 15, 5, 28, 13) mesh-refinement-cpp 8.43813 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 15, 5, 28, 35) mesh-topology-cpp 21.5852 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 15, 5, 28, 58) mesh-unitcube-cpp 22.8495 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 15, 5, 29, 39) mesh-iteration-cpp 39.1754 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 15, 5, 29, 39) function-evaluation-cpp 0.053679 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 15, 5, 29, 45) function-extrapolation-python 5.98334 "BENCH: 2.00072407722" (2014, 12, 15, 5, 29, 45) function-extrapolation-python 2.00072 "BENCH: 2.00072407722" (2014, 12, 15, 5, 29, 48) function-interpolation-python 2.26344 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 15, 5, 29, 48) function-interpolation-python 0.928461 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 15, 5, 32, 20) la-vector-access-cpp 152.714 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 15, 5, 33, 2) la-vector-assignment-cpp 42.0198 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 16, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1309 "BENCH 13.1309" (2014, 12, 16, 2, 9, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0919 "Building point search tree to accelerate distance queries." (2014, 12, 16, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.2994 "BENCH 14.2994" (2014, 12, 16, 2, 9, 50) common-progress-cpp 27.8915 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 16, 2, 10, 21) common-timing-cpp 30.5716 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 16, 2, 11, 56) fem-convergence-cpp 3.87463 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 16, 2, 11, 57) fem-jit-python 0.000426102 "JIT compilation (in memory cache)" (2014, 12, 16, 5, 38, 39) mesh-refinement-cpp 8.57738 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 16, 5, 39, 1) mesh-topology-cpp 21.8224 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 16, 5, 39, 24) mesh-unitcube-cpp 23.0424 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 16, 5, 40, 7) mesh-iteration-cpp 40.6312 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 16, 5, 40, 7) function-evaluation-cpp 0.106404 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 16, 5, 40, 13) function-extrapolation-python 5.64746 "BENCH: 2.09751391411" (2014, 12, 16, 5, 40, 13) function-extrapolation-python 2.09751 "BENCH: 2.09751391411" (2014, 12, 16, 5, 40, 15) function-interpolation-python 2.37509 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 16, 5, 40, 15) function-interpolation-python 0.954701 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 16, 5, 42, 49) la-vector-access-cpp 154.045 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 16, 5, 43, 31) la-vector-assignment-cpp 41.9887 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 17, 2, 8, 53) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0108 "BENCH 13.0108" (2014, 12, 17, 2, 9, 12) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2991 "Building point search tree to accelerate distance queries." (2014, 12, 17, 2, 9, 29) geometry-bounding_box_tree_build-cpp 14.2865 "BENCH 14.2865" (2014, 12, 17, 2, 9, 57) common-progress-cpp 27.8872 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 17, 2, 10, 27) common-timing-cpp 30.4421 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 17, 2, 12, 1) fem-convergence-cpp 3.88998 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 17, 2, 12, 2) fem-jit-python 0.000418687 "JIT compilation (in memory cache)" (2014, 12, 17, 5, 40, 1) mesh-refinement-cpp 8.47739 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 17, 5, 40, 23) mesh-topology-cpp 21.6157 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 17, 5, 40, 47) mesh-unitcube-cpp 23.2545 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 17, 5, 41, 28) mesh-iteration-cpp 39.1765 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 17, 5, 41, 28) function-evaluation-cpp 0.049916 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 17, 5, 41, 34) function-extrapolation-python 5.80313 "BENCH: 2.00367093086" (2014, 12, 17, 5, 41, 34) function-extrapolation-python 2.00367 "BENCH: 2.00367093086" (2014, 12, 17, 5, 41, 36) function-interpolation-python 2.2558 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 17, 5, 41, 36) function-interpolation-python 0.930046 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 17, 5, 44, 10) la-vector-access-cpp 153.955 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 17, 5, 44, 48) la-vector-assignment-cpp 38.1429 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 18, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9899 "BENCH 12.9899" (2014, 12, 18, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3152 "Building point search tree to accelerate distance queries." (2014, 12, 18, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.347 "BENCH 14.347" (2014, 12, 18, 2, 9, 48) common-progress-cpp 27.8795 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 18, 2, 10, 19) common-timing-cpp 30.7719 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 18, 2, 11, 53) fem-convergence-cpp 3.86956 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 18, 2, 11, 54) fem-jit-python 0.000414109 "JIT compilation (in memory cache)" (2014, 12, 18, 5, 23, 42) mesh-refinement-cpp 8.4328 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 18, 5, 24, 5) mesh-topology-cpp 21.8284 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 18, 5, 24, 28) mesh-unitcube-cpp 23.1051 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 18, 5, 25, 9) mesh-iteration-cpp 39.1977 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 18, 5, 25, 10) function-evaluation-cpp 0.0723219 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 18, 5, 25, 15) function-extrapolation-python 5.59039 "BENCH: 2.02850008011" (2014, 12, 18, 5, 25, 15) function-extrapolation-python 2.0285 "BENCH: 2.02850008011" (2014, 12, 18, 5, 25, 17) function-interpolation-python 2.26601 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 18, 5, 25, 17) function-interpolation-python 0.923468 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 18, 5, 27, 51) la-vector-access-cpp 153.461 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 18, 5, 28, 33) la-vector-assignment-cpp 42.3102 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 19, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0998 "BENCH 13.0998" (2014, 12, 19, 2, 9, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1642 "Building point search tree to accelerate distance queries." (2014, 12, 19, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.1554 "BENCH 14.1554" (2014, 12, 19, 2, 9, 50) common-progress-cpp 27.8847 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 19, 2, 10, 21) common-timing-cpp 30.4001 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 19, 2, 11, 55) fem-convergence-cpp 3.86711 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 19, 2, 11, 56) fem-jit-python 0.000420117 "JIT compilation (in memory cache)" (2014, 12, 19, 5, 32, 13) mesh-refinement-cpp 8.44807 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 19, 5, 32, 35) mesh-topology-cpp 21.8598 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 19, 5, 32, 58) mesh-unitcube-cpp 23.1617 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 19, 5, 33, 40) mesh-iteration-cpp 39.1825 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 19, 5, 33, 40) function-evaluation-cpp 0.0514779 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 19, 5, 33, 46) function-extrapolation-python 5.69784 "BENCH: 2.00138998032" (2014, 12, 19, 5, 33, 46) function-extrapolation-python 2.00139 "BENCH: 2.00138998032" (2014, 12, 19, 5, 33, 48) function-interpolation-python 2.25231 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 19, 5, 33, 48) function-interpolation-python 0.925456 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 19, 5, 36, 23) la-vector-access-cpp 154.753 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 19, 5, 37, 5) la-vector-assignment-cpp 42.1489 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 23, 2, 8, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0205 "BENCH 13.0205" (2014, 12, 23, 2, 8, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9105 "Building point search tree to accelerate distance queries." (2014, 12, 23, 2, 9, 11) geometry-bounding_box_tree_build-cpp 14.1741 "BENCH 14.1741" (2014, 12, 23, 2, 9, 38) common-progress-cpp 27.8771 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 23, 2, 10, 10) common-timing-cpp 31.1484 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 23, 2, 11, 44) fem-convergence-cpp 3.86662 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 23, 2, 11, 46) fem-jit-python 0.000421095 "JIT compilation (in memory cache)" (2014, 12, 23, 5, 32, 31) mesh-refinement-cpp 8.57416 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 23, 5, 32, 53) mesh-topology-cpp 21.4062 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 23, 5, 33, 16) mesh-unitcube-cpp 23.3596 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 23, 5, 33, 55) mesh-iteration-cpp 36.7639 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 23, 5, 33, 55) function-evaluation-cpp 0.0537641 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 23, 5, 34, 1) function-extrapolation-python 5.63767 "BENCH: 2.00522613525" (2014, 12, 23, 5, 34, 1) function-extrapolation-python 2.00523 "BENCH: 2.00522613525" (2014, 12, 23, 5, 34, 3) function-interpolation-python 2.2847 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 23, 5, 34, 3) function-interpolation-python 0.95027 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 23, 5, 36, 41) la-vector-access-cpp 157.199 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 23, 5, 37, 19) la-vector-assignment-cpp 38.026 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 24, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.4929 "BENCH 13.4929" (2014, 12, 24, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3121 "Building point search tree to accelerate distance queries." (2014, 12, 24, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.222 "BENCH 14.222" (2014, 12, 24, 2, 9, 50) common-progress-cpp 27.8882 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 24, 2, 10, 21) common-timing-cpp 31.0581 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 24, 2, 11, 54) fem-convergence-cpp 3.84017 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 24, 2, 11, 56) fem-jit-python 0.000421405 "JIT compilation (in memory cache)" (2014, 12, 24, 5, 20, 7) mesh-refinement-cpp 8.43344 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 24, 5, 20, 29) mesh-topology-cpp 21.3469 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 24, 5, 20, 52) mesh-unitcube-cpp 23.3858 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 24, 5, 21, 30) mesh-iteration-cpp 36.0824 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 24, 5, 21, 31) function-evaluation-cpp 0.0537429 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 24, 5, 21, 36) function-extrapolation-python 5.52536 "BENCH: 2.00918698311" (2014, 12, 24, 5, 21, 36) function-extrapolation-python 2.00919 "BENCH: 2.00918698311" (2014, 12, 24, 5, 21, 38) function-interpolation-python 2.25565 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 24, 5, 21, 38) function-interpolation-python 0.921512 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 24, 5, 24, 10) la-vector-access-cpp 151.65 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 24, 5, 24, 48) la-vector-assignment-cpp 38.0048 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 25, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0325 "BENCH 13.0325" (2014, 12, 25, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1388 "Building point search tree to accelerate distance queries." (2014, 12, 25, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.4462 "BENCH 14.4462" (2014, 12, 25, 2, 9, 43) common-progress-cpp 27.8902 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 25, 2, 10, 14) common-timing-cpp 30.8919 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 25, 2, 11, 48) fem-convergence-cpp 3.83714 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 25, 2, 11, 50) fem-jit-python 0.00042119 "JIT compilation (in memory cache)" (2014, 12, 25, 5, 27, 15) mesh-refinement-cpp 8.3942 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 25, 5, 27, 37) mesh-topology-cpp 21.6328 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 25, 5, 28, 0) mesh-unitcube-cpp 22.8113 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 25, 5, 28, 38) mesh-iteration-cpp 35.5434 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 25, 5, 28, 38) function-evaluation-cpp 0.0523801 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 25, 5, 28, 44) function-extrapolation-python 5.8692 "BENCH: 2.01356601715" (2014, 12, 25, 5, 28, 44) function-extrapolation-python 2.01357 "BENCH: 2.01356601715" (2014, 12, 25, 5, 28, 46) function-interpolation-python 2.27188 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 25, 5, 28, 46) function-interpolation-python 0.928945 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 25, 5, 31, 18) la-vector-access-cpp 152.156 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 25, 5, 31, 56) la-vector-assignment-cpp 38.0173 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 26, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.043 "BENCH 13.043" (2014, 12, 26, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1618 "Building point search tree to accelerate distance queries." (2014, 12, 26, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2187 "BENCH 14.2187" (2014, 12, 26, 2, 9, 44) common-progress-cpp 27.8859 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 26, 2, 10, 15) common-timing-cpp 30.6585 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 26, 2, 11, 50) fem-convergence-cpp 3.87689 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 26, 2, 11, 51) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2014, 12, 26, 5, 14, 5) mesh-refinement-cpp 8.36464 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 26, 5, 14, 26) mesh-topology-cpp 21.3147 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 26, 5, 14, 49) mesh-unitcube-cpp 22.8014 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 26, 5, 15, 27) mesh-iteration-cpp 35.5059 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 26, 5, 15, 27) function-evaluation-cpp 0.0761781 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 26, 5, 15, 33) function-extrapolation-python 5.6102 "BENCH: 2.00827407837" (2014, 12, 26, 5, 15, 33) function-extrapolation-python 2.00827 "BENCH: 2.00827407837" (2014, 12, 26, 5, 15, 35) function-interpolation-python 2.26896 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 26, 5, 15, 35) function-interpolation-python 0.926316 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 26, 5, 18, 7) la-vector-access-cpp 152.149 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 26, 5, 18, 45) la-vector-assignment-cpp 38.0188 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 27, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9544 "BENCH 12.9544" (2014, 12, 27, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2534 "Building point search tree to accelerate distance queries." (2014, 12, 27, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.1478 "BENCH 14.1478" (2014, 12, 27, 2, 9, 43) common-progress-cpp 27.8693 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 27, 2, 10, 15) common-timing-cpp 31.483 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 27, 2, 11, 50) fem-convergence-cpp 3.84296 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 27, 2, 11, 51) fem-jit-python 0.000421095 "JIT compilation (in memory cache)" (2014, 12, 27, 5, 21, 10) mesh-refinement-cpp 8.37553 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 27, 5, 21, 32) mesh-topology-cpp 21.412 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 27, 5, 21, 54) mesh-unitcube-cpp 22.7872 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 27, 5, 22, 32) mesh-iteration-cpp 35.5673 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 27, 5, 22, 32) function-evaluation-cpp 0.0704529 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 27, 5, 22, 38) function-extrapolation-python 5.79081 "BENCH: 1.9982919693" (2014, 12, 27, 5, 22, 38) function-extrapolation-python 1.99829 "BENCH: 1.9982919693" (2014, 12, 27, 5, 22, 41) function-interpolation-python 2.29557 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 27, 5, 22, 41) function-interpolation-python 0.929562 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 27, 5, 25, 13) la-vector-access-cpp 152.055 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 27, 5, 25, 52) la-vector-assignment-cpp 39.5414 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 28, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9989 "BENCH 12.9989" (2014, 12, 28, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0488 "Building point search tree to accelerate distance queries." (2014, 12, 28, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.2363 "BENCH 14.2363" (2014, 12, 28, 2, 9, 43) common-progress-cpp 27.9004 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 28, 2, 10, 13) common-timing-cpp 30.1166 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 28, 2, 11, 47) fem-convergence-cpp 3.84924 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 28, 2, 11, 49) fem-jit-python 0.000420213 "JIT compilation (in memory cache)" (2014, 12, 28, 5, 21, 52) mesh-refinement-cpp 8.38026 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 28, 5, 22, 13) mesh-topology-cpp 21.3829 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 28, 5, 22, 36) mesh-unitcube-cpp 22.7971 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 28, 5, 23, 14) mesh-iteration-cpp 35.5507 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 28, 5, 23, 14) function-evaluation-cpp 0.074311 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 28, 5, 23, 20) function-extrapolation-python 5.86704 "BENCH: 2.00494098663" (2014, 12, 28, 5, 23, 20) function-extrapolation-python 2.00494 "BENCH: 2.00494098663" (2014, 12, 28, 5, 23, 22) function-interpolation-python 2.26242 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 28, 5, 23, 22) function-interpolation-python 0.936496 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 28, 5, 25, 55) la-vector-access-cpp 152.168 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 28, 5, 26, 34) la-vector-assignment-cpp 39.6396 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 29, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.7379 "BENCH 13.7379" (2014, 12, 29, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2807 "Building point search tree to accelerate distance queries." (2014, 12, 29, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3613 "BENCH 14.3613" (2014, 12, 29, 2, 9, 46) common-progress-cpp 27.8795 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 29, 2, 10, 16) common-timing-cpp 30.5232 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 29, 2, 11, 53) fem-convergence-cpp 3.82216 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 29, 2, 11, 54) fem-jit-python 0.000424385 "JIT compilation (in memory cache)" (2014, 12, 29, 5, 30, 24) mesh-refinement-cpp 8.2567 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 29, 5, 30, 46) mesh-topology-cpp 21.6195 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 29, 5, 31, 9) mesh-unitcube-cpp 22.5672 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 29, 5, 31, 47) mesh-iteration-cpp 35.5462 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 29, 5, 31, 47) function-evaluation-cpp 0.0515208 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 29, 5, 31, 53) function-extrapolation-python 6.11285 "BENCH: 2.00217986107" (2014, 12, 29, 5, 31, 53) function-extrapolation-python 2.00218 "BENCH: 2.00217986107" (2014, 12, 29, 5, 31, 55) function-interpolation-python 2.25533 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 29, 5, 31, 55) function-interpolation-python 0.911716 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 29, 5, 34, 56) la-vector-access-cpp 180.299 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 29, 5, 35, 34) la-vector-assignment-cpp 38.0125 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 30, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1599 "BENCH 13.1599" (2014, 12, 30, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2722 "Building point search tree to accelerate distance queries." (2014, 12, 30, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2412 "BENCH 14.2412" (2014, 12, 30, 2, 9, 48) common-progress-cpp 27.8842 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 30, 2, 10, 18) common-timing-cpp 29.9201 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 30, 2, 11, 54) fem-convergence-cpp 3.8754 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 30, 2, 11, 55) fem-jit-python 0.000415802 "JIT compilation (in memory cache)" (2014, 12, 30, 5, 23, 12) mesh-refinement-cpp 8.34546 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 30, 5, 23, 34) mesh-topology-cpp 21.6367 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 30, 5, 23, 57) mesh-unitcube-cpp 22.8416 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 30, 5, 24, 39) mesh-iteration-cpp 39.1713 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 30, 5, 24, 39) function-evaluation-cpp 0.074703 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 30, 5, 24, 44) function-extrapolation-python 5.64559 "BENCH: 2.01603007317" (2014, 12, 30, 5, 24, 44) function-extrapolation-python 2.01603 "BENCH: 2.01603007317" (2014, 12, 30, 5, 24, 47) function-interpolation-python 2.23919 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 30, 5, 24, 47) function-interpolation-python 0.904289 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 30, 5, 27, 45) la-vector-access-cpp 178.718 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 30, 5, 28, 27) la-vector-assignment-cpp 41.9852 "Assigning to vector of size 10000000 (100 repetitions)" (2014, 12, 31, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0906 "BENCH 13.0906" (2014, 12, 31, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0515 "Building point search tree to accelerate distance queries." (2014, 12, 31, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.1686 "BENCH 14.1686" (2014, 12, 31, 2, 9, 48) common-progress-cpp 27.8896 "Creating progress bar with 500000000 steps (5 repetitions)" (2014, 12, 31, 2, 10, 19) common-timing-cpp 30.5862 "Timing access and registration of timings (10000000 repetitions)" (2014, 12, 31, 2, 11, 54) fem-convergence-cpp 3.83313 "Solving Poisson's equation in 2D for q = 1, n = 2." (2014, 12, 31, 2, 11, 55) fem-jit-python 0.00042758 "JIT compilation (in memory cache)" (2014, 12, 31, 5, 34, 16) mesh-refinement-cpp 8.3458 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2014, 12, 31, 5, 34, 37) mesh-topology-cpp 21.5631 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2014, 12, 31, 5, 35, 0) mesh-unitcube-cpp 22.5946 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2014, 12, 31, 5, 35, 38) mesh-iteration-cpp 35.5439 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2014, 12, 31, 5, 35, 38) function-evaluation-cpp 0.057802 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2014, 12, 31, 5, 35, 44) function-extrapolation-python 5.75814 "BENCH: 2.01219081879" (2014, 12, 31, 5, 35, 44) function-extrapolation-python 2.01219 "BENCH: 2.01219081879" (2014, 12, 31, 5, 35, 46) function-interpolation-python 2.24748 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 31, 5, 35, 46) function-interpolation-python 0.911566 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2014, 12, 31, 5, 38, 45) la-vector-access-cpp 178.298 "Accessing vector of size 10000000 (100 repetitions)" (2014, 12, 31, 5, 39, 23) la-vector-assignment-cpp 38.0089 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 1, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0587 "BENCH 13.0587" (2015, 1, 1, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9975 "Building point search tree to accelerate distance queries." (2015, 1, 1, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.3001 "BENCH 14.3001" (2015, 1, 1, 2, 9, 46) common-progress-cpp 27.8824 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 1, 2, 10, 15) common-timing-cpp 29.7459 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 1, 2, 11, 50) fem-convergence-cpp 3.87901 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 1, 2, 11, 51) fem-jit-python 0.000419617 "JIT compilation (in memory cache)" (2015, 1, 1, 5, 19, 52) mesh-refinement-cpp 8.297 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 1, 5, 20, 13) mesh-topology-cpp 21.3629 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 1, 5, 20, 36) mesh-unitcube-cpp 22.3229 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 1, 5, 21, 14) mesh-iteration-cpp 35.5587 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 1, 5, 21, 14) function-evaluation-cpp 0.055769 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 1, 5, 21, 20) function-extrapolation-python 5.90148 "BENCH: 2.0072247982" (2015, 1, 1, 5, 21, 20) function-extrapolation-python 2.00722 "BENCH: 2.0072247982" (2015, 1, 1, 5, 21, 22) function-interpolation-python 2.26069 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 1, 5, 21, 22) function-interpolation-python 0.908384 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 1, 5, 24, 22) la-vector-access-cpp 180.358 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 1, 5, 25, 0) la-vector-assignment-cpp 38.0083 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 2, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3204 "BENCH 13.3204" (2015, 1, 2, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1585 "Building point search tree to accelerate distance queries." (2015, 1, 2, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.1261 "BENCH 14.1261" (2015, 1, 2, 2, 9, 45) common-progress-cpp 27.9043 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 2, 2, 10, 14) common-timing-cpp 29.7639 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 2, 2, 11, 49) fem-convergence-cpp 3.84597 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 2, 2, 11, 51) fem-jit-python 0.000416017 "JIT compilation (in memory cache)" (2015, 1, 2, 5, 22, 36) mesh-refinement-cpp 8.2922 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 2, 5, 22, 58) mesh-topology-cpp 21.5705 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 2, 5, 23, 21) mesh-unitcube-cpp 22.5825 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 2, 5, 23, 59) mesh-iteration-cpp 35.5596 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 2, 5, 23, 59) function-evaluation-cpp 0.0744019 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 2, 5, 24, 5) function-extrapolation-python 5.96587 "BENCH: 1.99899816513" (2015, 1, 2, 5, 24, 5) function-extrapolation-python 1.999 "BENCH: 1.99899816513" (2015, 1, 2, 5, 24, 7) function-interpolation-python 2.28387 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 2, 5, 24, 7) function-interpolation-python 0.914806 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 2, 5, 27, 5) la-vector-access-cpp 177.815 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 2, 5, 27, 43) la-vector-assignment-cpp 38.024 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 3, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.5334 "BENCH 13.5334" (2015, 1, 3, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1997 "Building point search tree to accelerate distance queries." (2015, 1, 3, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2138 "BENCH 14.2138" (2015, 1, 3, 2, 9, 44) common-progress-cpp 27.8864 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 3, 2, 10, 13) common-timing-cpp 29.6123 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 3, 2, 11, 48) fem-convergence-cpp 3.81842 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 3, 2, 11, 50) fem-jit-python 0.000417399 "JIT compilation (in memory cache)" (2015, 1, 3, 5, 32, 46) mesh-refinement-cpp 8.33575 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 3, 5, 33, 7) mesh-topology-cpp 21.6951 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 3, 5, 33, 30) mesh-unitcube-cpp 22.7261 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 3, 5, 34, 16) mesh-iteration-cpp 42.928 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 3, 5, 34, 16) function-evaluation-cpp 0.0763421 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 3, 5, 34, 22) function-extrapolation-python 5.82072 "BENCH: 2.00965189934" (2015, 1, 3, 5, 34, 22) function-extrapolation-python 2.00965 "BENCH: 2.00965189934" (2015, 1, 3, 5, 34, 24) function-interpolation-python 2.24636 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 3, 5, 34, 24) function-interpolation-python 0.919411 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 3, 5, 37, 24) la-vector-access-cpp 180.672 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 3, 5, 38, 3) la-vector-assignment-cpp 38.0143 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 4, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0676 "BENCH 13.0676" (2015, 1, 4, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9599 "Building point search tree to accelerate distance queries." (2015, 1, 4, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.3822 "BENCH 14.3822" (2015, 1, 4, 2, 9, 44) common-progress-cpp 27.9026 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 4, 2, 10, 13) common-timing-cpp 29.3578 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 4, 2, 11, 49) fem-convergence-cpp 3.84838 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 4, 2, 11, 51) fem-jit-python 0.000413513 "JIT compilation (in memory cache)" (2015, 1, 4, 5, 17, 24) mesh-refinement-cpp 8.37261 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 4, 5, 17, 45) mesh-topology-cpp 21.5224 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 4, 5, 18, 8) mesh-unitcube-cpp 22.6913 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 4, 5, 18, 46) mesh-iteration-cpp 35.4926 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 4, 5, 18, 46) function-evaluation-cpp 0.0520051 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 4, 5, 18, 52) function-extrapolation-python 5.62222 "BENCH: 2.00227999687" (2015, 1, 4, 5, 18, 52) function-extrapolation-python 2.00228 "BENCH: 2.00227999687" (2015, 1, 4, 5, 18, 54) function-interpolation-python 2.25625 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 4, 5, 18, 54) function-interpolation-python 0.921135 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 4, 5, 22, 20) la-vector-access-cpp 205.464 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 4, 5, 22, 58) la-vector-assignment-cpp 38.0132 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 5, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1085 "BENCH 13.1085" (2015, 1, 5, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2546 "Building point search tree to accelerate distance queries." (2015, 1, 5, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2243 "BENCH 14.2243" (2015, 1, 5, 2, 9, 44) common-progress-cpp 27.884 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 5, 2, 10, 13) common-timing-cpp 29.1849 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 5, 2, 11, 49) fem-convergence-cpp 3.82368 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 5, 2, 11, 50) fem-jit-python 0.000422812 "JIT compilation (in memory cache)" (2015, 1, 5, 5, 23, 26) mesh-refinement-cpp 8.3452 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 5, 5, 23, 48) mesh-topology-cpp 21.6097 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 5, 5, 24, 11) mesh-unitcube-cpp 22.7151 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 5, 5, 24, 49) mesh-iteration-cpp 35.5421 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 5, 5, 24, 49) function-evaluation-cpp 0.0556581 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 5, 5, 24, 55) function-extrapolation-python 5.83613 "BENCH: 2.01349687576" (2015, 1, 5, 5, 24, 55) function-extrapolation-python 2.0135 "BENCH: 2.01349687576" (2015, 1, 5, 5, 24, 57) function-interpolation-python 2.25661 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 5, 5, 24, 57) function-interpolation-python 0.913172 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 5, 5, 27, 57) la-vector-access-cpp 180.376 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 5, 5, 28, 36) la-vector-assignment-cpp 38.0147 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 6, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3748 "BENCH 13.3748" (2015, 1, 6, 2, 9, 6) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2036 "Building point search tree to accelerate distance queries." (2015, 1, 6, 2, 9, 23) geometry-bounding_box_tree_build-cpp 14.1506 "BENCH 14.1506" (2015, 1, 6, 2, 9, 50) common-progress-cpp 27.8925 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 6, 2, 10, 20) common-timing-cpp 29.9094 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 6, 2, 11, 56) fem-convergence-cpp 3.80816 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 6, 2, 11, 57) fem-jit-python 0.000406003 "JIT compilation (in memory cache)" (2015, 1, 6, 5, 27, 33) mesh-refinement-cpp 8.34632 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 6, 5, 27, 55) mesh-topology-cpp 21.7033 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 6, 5, 28, 17) mesh-unitcube-cpp 22.756 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 6, 5, 28, 55) mesh-iteration-cpp 35.489 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 6, 5, 28, 56) function-evaluation-cpp 0.072443 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 6, 5, 29, 4) function-extrapolation-python 8.38209 "BENCH: 2.16803002357" (2015, 1, 6, 5, 29, 4) function-extrapolation-python 2.16803 "BENCH: 2.16803002357" (2015, 1, 6, 5, 29, 6) function-interpolation-python 2.46719 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 6, 5, 29, 6) function-interpolation-python 0.922065 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 6, 5, 32, 11) la-vector-access-cpp 184.665 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 6, 5, 32, 49) la-vector-assignment-cpp 38.0218 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 7, 2, 8, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1593 "BENCH 13.1593" (2015, 1, 7, 2, 9, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8902 "Building point search tree to accelerate distance queries." (2015, 1, 7, 2, 9, 24) geometry-bounding_box_tree_build-cpp 14.2057 "BENCH 14.2057" (2015, 1, 7, 2, 9, 52) common-progress-cpp 27.8808 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 7, 2, 10, 22) common-timing-cpp 29.726 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 7, 2, 11, 57) fem-convergence-cpp 3.83448 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 7, 2, 11, 59) fem-jit-python 0.000418019 "JIT compilation (in memory cache)" (2015, 1, 7, 5, 31, 59) mesh-refinement-cpp 8.35124 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 7, 5, 32, 21) mesh-topology-cpp 21.4891 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 7, 5, 32, 43) mesh-unitcube-cpp 22.7289 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 7, 5, 33, 24) mesh-iteration-cpp 38.5672 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 7, 5, 33, 24) function-evaluation-cpp 0.0537319 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 7, 5, 33, 30) function-extrapolation-python 5.59979 "BENCH: 2.02233314514" (2015, 1, 7, 5, 33, 30) function-extrapolation-python 2.02233 "BENCH: 2.02233314514" (2015, 1, 7, 5, 33, 32) function-interpolation-python 2.27106 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 7, 5, 33, 32) function-interpolation-python 0.919375 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 7, 5, 36, 30) la-vector-access-cpp 177.862 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 7, 5, 37, 8) la-vector-assignment-cpp 38.0527 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 8, 2, 8, 51) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1278 "BENCH 13.1278" (2015, 1, 8, 2, 9, 10) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1927 "Building point search tree to accelerate distance queries." (2015, 1, 8, 2, 9, 26) geometry-bounding_box_tree_build-cpp 14.1781 "BENCH 14.1781" (2015, 1, 8, 2, 9, 58) common-progress-cpp 31.6574 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 8, 2, 10, 27) common-timing-cpp 29.116 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 8, 2, 12, 3) fem-convergence-cpp 3.84759 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 8, 2, 12, 4) fem-jit-python 0.000414586 "JIT compilation (in memory cache)" (2015, 1, 8, 5, 40, 4) mesh-refinement-cpp 8.34765 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 8, 5, 40, 26) mesh-topology-cpp 21.5923 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 8, 5, 40, 49) mesh-unitcube-cpp 22.7214 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 8, 5, 41, 27) mesh-iteration-cpp 35.5546 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 8, 5, 41, 27) function-evaluation-cpp 0.0580332 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 8, 5, 41, 33) function-extrapolation-python 5.70398 "BENCH: 2.01378583908" (2015, 1, 8, 5, 41, 33) function-extrapolation-python 2.01379 "BENCH: 2.01378583908" (2015, 1, 8, 5, 41, 35) function-interpolation-python 2.26885 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 8, 5, 41, 35) function-interpolation-python 0.916959 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 8, 5, 44, 34) la-vector-access-cpp 178.486 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 8, 5, 45, 12) la-vector-assignment-cpp 38.3204 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 9, 2, 8, 50) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2731 "BENCH 13.2731" (2015, 1, 9, 2, 9, 9) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1343 "Building point search tree to accelerate distance queries." (2015, 1, 9, 2, 9, 25) geometry-bounding_box_tree_build-cpp 14.2723 "BENCH 14.2723" (2015, 1, 9, 2, 9, 53) common-progress-cpp 27.9066 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 9, 2, 10, 23) common-timing-cpp 29.8519 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 9, 2, 12, 0) fem-convergence-cpp 3.90938 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 9, 2, 12, 1) fem-jit-python 0.000414896 "JIT compilation (in memory cache)" (2015, 1, 9, 5, 21, 40) mesh-refinement-cpp 8.34622 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 9, 5, 22, 2) mesh-topology-cpp 21.5423 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 9, 5, 22, 25) mesh-unitcube-cpp 22.7429 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 9, 5, 23, 3) mesh-iteration-cpp 35.5506 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 9, 5, 23, 3) function-evaluation-cpp 0.0746551 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 9, 5, 23, 9) function-extrapolation-python 6.0087 "BENCH: 2.00626206398" (2015, 1, 9, 5, 23, 9) function-extrapolation-python 2.00626 "BENCH: 2.00626206398" (2015, 1, 9, 5, 23, 11) function-interpolation-python 2.28338 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 9, 5, 23, 11) function-interpolation-python 0.920552 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 9, 5, 26, 9) la-vector-access-cpp 177.845 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 9, 5, 26, 51) la-vector-assignment-cpp 42.02 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 10, 2, 8, 49) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8081 "BENCH 12.8081" (2015, 1, 10, 2, 9, 8) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2087 "Building point search tree to accelerate distance queries." (2015, 1, 10, 2, 9, 24) geometry-bounding_box_tree_build-cpp 14.3514 "BENCH 14.3514" (2015, 1, 10, 2, 9, 52) common-progress-cpp 27.8845 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 10, 2, 10, 23) common-timing-cpp 30.8278 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 10, 2, 11, 58) fem-convergence-cpp 3.83043 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 10, 2, 11, 59) fem-jit-python 0.000421906 "JIT compilation (in memory cache)" (2015, 1, 10, 5, 30, 16) mesh-refinement-cpp 8.33409 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 10, 5, 30, 37) mesh-topology-cpp 21.4447 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 10, 5, 31, 0) mesh-unitcube-cpp 22.8475 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 10, 5, 31, 38) mesh-iteration-cpp 35.4945 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 10, 5, 31, 38) function-evaluation-cpp 0.059942 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 10, 5, 31, 44) function-extrapolation-python 6.08539 "BENCH: 2.00567293167" (2015, 1, 10, 5, 31, 44) function-extrapolation-python 2.00567 "BENCH: 2.00567293167" (2015, 1, 10, 5, 31, 47) function-interpolation-python 2.29375 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 10, 5, 31, 47) function-interpolation-python 0.950035 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 10, 5, 34, 23) la-vector-access-cpp 156.687 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 10, 5, 35, 9) la-vector-assignment-cpp 46.0391 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 11, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8139 "BENCH 12.8139" (2015, 1, 11, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0228 "Building point search tree to accelerate distance queries." (2015, 1, 11, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.1776 "BENCH 14.1776" (2015, 1, 11, 2, 9, 43) common-progress-cpp 27.8902 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 11, 2, 10, 13) common-timing-cpp 30.2543 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 11, 2, 11, 47) fem-convergence-cpp 3.86529 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 11, 2, 11, 48) fem-jit-python 0.000416517 "JIT compilation (in memory cache)" (2015, 1, 11, 5, 28, 4) mesh-refinement-cpp 8.40151 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 11, 5, 28, 26) mesh-topology-cpp 21.3656 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 11, 5, 28, 49) mesh-unitcube-cpp 22.8252 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 11, 5, 29, 35) mesh-iteration-cpp 44.1914 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 11, 5, 29, 36) function-evaluation-cpp 0.0763211 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 11, 5, 29, 41) function-extrapolation-python 5.63749 "BENCH: 2.01725697517" (2015, 1, 11, 5, 29, 41) function-extrapolation-python 2.01726 "BENCH: 2.01725697517" (2015, 1, 11, 5, 29, 44) function-interpolation-python 2.28352 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 11, 5, 29, 44) function-interpolation-python 0.948207 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 11, 5, 32, 20) la-vector-access-cpp 156.743 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 11, 5, 33, 2) la-vector-assignment-cpp 42.0952 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 12, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7947 "BENCH 12.7947" (2015, 1, 12, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0547 "Building point search tree to accelerate distance queries." (2015, 1, 12, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.0345 "BENCH 14.0345" (2015, 1, 12, 2, 9, 45) common-progress-cpp 27.8819 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 12, 2, 10, 15) common-timing-cpp 29.6903 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 12, 2, 11, 49) fem-convergence-cpp 3.86737 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 12, 2, 11, 50) fem-jit-python 0.00042181 "JIT compilation (in memory cache)" (2015, 1, 12, 5, 25, 19) mesh-refinement-cpp 8.33512 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 12, 5, 25, 41) mesh-topology-cpp 21.3879 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 12, 5, 26, 4) mesh-unitcube-cpp 22.807 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 12, 5, 26, 42) mesh-iteration-cpp 35.545 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 12, 5, 26, 42) function-evaluation-cpp 0.053803 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 12, 5, 26, 47) function-extrapolation-python 5.6395 "BENCH: 2.0159637928" (2015, 1, 12, 5, 26, 47) function-extrapolation-python 2.01596 "BENCH: 2.0159637928" (2015, 1, 12, 5, 26, 50) function-interpolation-python 2.27788 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 12, 5, 26, 50) function-interpolation-python 0.949602 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 12, 5, 29, 26) la-vector-access-cpp 155.726 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 12, 5, 30, 12) la-vector-assignment-cpp 45.9608 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 13, 2, 8, 54) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8649 "BENCH 12.8649" (2015, 1, 13, 2, 9, 12) geometry-bounding_box_tree_compute_closest_entity-cpp 14.7849 "Building point search tree to accelerate distance queries." (2015, 1, 13, 2, 9, 29) geometry-bounding_box_tree_build-cpp 14.1641 "BENCH 14.1641" (2015, 1, 13, 2, 9, 57) common-progress-cpp 27.8841 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 13, 2, 10, 27) common-timing-cpp 30.0876 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 13, 2, 12, 0) fem-convergence-cpp 3.85457 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 13, 2, 12, 21) fem-jit-python 0.000453305 "JIT compilation (in memory cache)" (2015, 1, 13, 5, 24, 2) mesh-refinement-cpp 8.39043 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 13, 5, 24, 23) mesh-topology-cpp 21.4659 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 13, 5, 24, 46) mesh-unitcube-cpp 22.8977 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 13, 5, 25, 27) mesh-iteration-cpp 38.4988 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 13, 5, 25, 27) function-evaluation-cpp 0.074666 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 13, 5, 26, 35) function-extrapolation-python 68.289 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2015, 1, 13, 5, 26, 35) function-extrapolation-python 1.99764 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2015, 1, 13, 5, 26, 43) function-interpolation-python 7.81263 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2015, 1, 13, 5, 26, 43) function-interpolation-python 0.953647 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2015, 1, 13, 5, 29, 19) la-vector-access-cpp 155.76 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 13, 5, 30, 1) la-vector-assignment-cpp 42.0151 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 14, 2, 8, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8291 "BENCH 12.8291" (2015, 1, 14, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9222 "Building point search tree to accelerate distance queries." (2015, 1, 14, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.2174 "BENCH 14.2174" (2015, 1, 14, 2, 9, 42) common-progress-cpp 27.8864 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 14, 2, 10, 12) common-timing-cpp 29.5192 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 14, 2, 11, 47) fem-convergence-cpp 3.92293 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 14, 2, 11, 48) fem-jit-python 0.000429392 "JIT compilation (in memory cache)" (2015, 1, 14, 5, 34, 17) mesh-refinement-cpp 8.34241 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 14, 5, 34, 39) mesh-topology-cpp 21.3381 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 14, 5, 35, 2) mesh-unitcube-cpp 22.9236 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 14, 5, 35, 40) mesh-iteration-cpp 35.569 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 14, 5, 35, 40) function-evaluation-cpp 0.0829289 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 14, 5, 35, 46) function-extrapolation-python 6.62873 "BENCH: 2.096118927" (2015, 1, 14, 5, 35, 46) function-extrapolation-python 2.09612 "BENCH: 2.096118927" (2015, 1, 14, 5, 35, 49) function-interpolation-python 2.4353 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 14, 5, 35, 49) function-interpolation-python 1.02672 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 14, 5, 38, 25) la-vector-access-cpp 156.522 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 14, 5, 39, 12) la-vector-assignment-cpp 46.0434 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 15, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9918 "BENCH 12.9918" (2015, 1, 15, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1896 "Building point search tree to accelerate distance queries." (2015, 1, 15, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.1485 "BENCH 14.1485" (2015, 1, 15, 2, 9, 48) common-progress-cpp 27.8825 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 15, 2, 10, 18) common-timing-cpp 29.4368 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 15, 2, 11, 52) fem-convergence-cpp 3.87741 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 15, 2, 11, 53) fem-jit-python 0.000416303 "JIT compilation (in memory cache)" (2015, 1, 15, 5, 23, 17) mesh-refinement-cpp 8.31426 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 15, 5, 23, 39) mesh-topology-cpp 21.4694 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 15, 5, 24, 2) mesh-unitcube-cpp 22.8877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 15, 5, 24, 40) mesh-iteration-cpp 35.5491 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 15, 5, 24, 40) function-evaluation-cpp 0.0518129 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 15, 5, 24, 46) function-extrapolation-python 5.61356 "BENCH: 2.00211000443" (2015, 1, 15, 5, 24, 46) function-extrapolation-python 2.00211 "BENCH: 2.00211000443" (2015, 1, 15, 5, 24, 48) function-interpolation-python 2.28541 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 15, 5, 24, 48) function-interpolation-python 0.949981 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 15, 5, 27, 24) la-vector-access-cpp 155.737 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 15, 5, 28, 6) la-vector-assignment-cpp 42.0192 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 16, 2, 8, 55) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9335 "BENCH 12.9335" (2015, 1, 16, 2, 9, 13) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0538 "Building point search tree to accelerate distance queries." (2015, 1, 16, 2, 9, 29) geometry-bounding_box_tree_build-cpp 13.8976 "BENCH 13.8976" (2015, 1, 16, 2, 9, 57) common-progress-cpp 27.6304 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 16, 2, 10, 27) common-timing-cpp 29.9098 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 16, 2, 12, 0) fem-convergence-cpp 3.83205 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 16, 2, 12, 2) fem-jit-python 0.000410914 "JIT compilation (in memory cache)" (2015, 1, 16, 5, 28, 4) mesh-refinement-cpp 8.33054 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 16, 5, 28, 25) mesh-topology-cpp 21.4062 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 16, 5, 28, 48) mesh-unitcube-cpp 22.8267 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 16, 5, 29, 29) mesh-iteration-cpp 38.5419 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 16, 5, 29, 29) function-evaluation-cpp 0.0540919 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 16, 5, 29, 35) function-extrapolation-python 5.78303 "BENCH: 1.99957108498" (2015, 1, 16, 5, 29, 35) function-extrapolation-python 1.99957 "BENCH: 1.99957108498" (2015, 1, 16, 5, 29, 37) function-interpolation-python 2.28011 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 16, 5, 29, 37) function-interpolation-python 0.956341 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 16, 5, 32, 14) la-vector-access-cpp 156.984 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 16, 5, 33, 1) la-vector-assignment-cpp 46.3291 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 17, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.01 "BENCH 13.01" (2015, 1, 17, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0168 "Building point search tree to accelerate distance queries." (2015, 1, 17, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.3072 "BENCH 14.3072" (2015, 1, 17, 2, 9, 49) common-progress-cpp 27.8924 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 17, 2, 10, 19) common-timing-cpp 30.0094 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 17, 2, 11, 53) fem-convergence-cpp 3.89478 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 17, 2, 11, 54) fem-jit-python 0.000423813 "JIT compilation (in memory cache)" (2015, 1, 17, 5, 22, 55) mesh-refinement-cpp 8.31758 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 17, 5, 23, 17) mesh-topology-cpp 21.3774 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 17, 5, 23, 40) mesh-unitcube-cpp 22.8568 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 17, 5, 24, 18) mesh-iteration-cpp 35.5163 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 17, 5, 24, 18) function-evaluation-cpp 0.0727181 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 17, 5, 24, 24) function-extrapolation-python 5.7864 "BENCH: 1.9984459877" (2015, 1, 17, 5, 24, 24) function-extrapolation-python 1.99845 "BENCH: 1.9984459877" (2015, 1, 17, 5, 24, 26) function-interpolation-python 2.29294 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 17, 5, 24, 26) function-interpolation-python 0.953182 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 17, 5, 27, 2) la-vector-access-cpp 155.665 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 17, 5, 27, 44) la-vector-assignment-cpp 41.9984 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 18, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9547 "BENCH 12.9547" (2015, 1, 18, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8164 "Building point search tree to accelerate distance queries." (2015, 1, 18, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.1116 "BENCH 14.1116" (2015, 1, 18, 2, 9, 43) common-progress-cpp 27.8945 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 18, 2, 10, 14) common-timing-cpp 30.5726 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 18, 2, 11, 48) fem-convergence-cpp 3.83719 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 18, 2, 11, 49) fem-jit-python 0.000416708 "JIT compilation (in memory cache)" (2015, 1, 18, 5, 30, 51) mesh-refinement-cpp 8.34175 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 18, 5, 31, 13) mesh-topology-cpp 21.4229 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 18, 5, 31, 36) mesh-unitcube-cpp 22.8335 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 18, 5, 32, 13) mesh-iteration-cpp 35.5179 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 18, 5, 32, 14) function-evaluation-cpp 0.0649691 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 18, 5, 32, 19) function-extrapolation-python 5.89365 "BENCH: 1.99503993988" (2015, 1, 18, 5, 32, 19) function-extrapolation-python 1.99504 "BENCH: 1.99503993988" (2015, 1, 18, 5, 32, 22) function-interpolation-python 2.28234 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 18, 5, 32, 22) function-interpolation-python 0.950215 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 18, 5, 34, 57) la-vector-access-cpp 155.607 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 18, 5, 35, 39) la-vector-assignment-cpp 41.9789 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 19, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.957 "BENCH 12.957" (2015, 1, 19, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9742 "Building point search tree to accelerate distance queries." (2015, 1, 19, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.2274 "BENCH 14.2274" (2015, 1, 19, 2, 9, 48) common-progress-cpp 27.8882 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 19, 2, 10, 18) common-timing-cpp 30.0796 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 19, 2, 11, 52) fem-convergence-cpp 3.83207 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 19, 2, 11, 53) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2015, 1, 19, 5, 28, 51) mesh-refinement-cpp 8.31321 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 19, 5, 29, 13) mesh-topology-cpp 21.4081 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 19, 5, 29, 36) mesh-unitcube-cpp 22.7877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 19, 5, 30, 22) mesh-iteration-cpp 44.1636 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 19, 5, 30, 22) function-evaluation-cpp 0.054148 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 19, 5, 30, 28) function-extrapolation-python 5.68525 "BENCH: 1.99312996864" (2015, 1, 19, 5, 30, 28) function-extrapolation-python 1.99313 "BENCH: 1.99312996864" (2015, 1, 19, 5, 30, 30) function-interpolation-python 2.26295 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 19, 5, 30, 30) function-interpolation-python 0.948084 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 19, 5, 33, 7) la-vector-access-cpp 156.626 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 19, 5, 33, 53) la-vector-assignment-cpp 46.0023 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 20, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.938 "BENCH 12.938" (2015, 1, 20, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3592 "Building point search tree to accelerate distance queries." (2015, 1, 20, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.1309 "BENCH 14.1309" (2015, 1, 20, 2, 9, 45) common-progress-cpp 27.888 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 20, 2, 10, 15) common-timing-cpp 29.9419 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 20, 2, 11, 49) fem-convergence-cpp 3.90545 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 20, 2, 11, 51) fem-jit-python 0.000413918 "JIT compilation (in memory cache)" (2015, 1, 20, 5, 20, 37) mesh-refinement-cpp 8.33833 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 20, 5, 20, 59) mesh-topology-cpp 21.3345 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 20, 5, 21, 21) mesh-unitcube-cpp 22.8396 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 20, 5, 22, 8) mesh-iteration-cpp 44.1665 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 20, 5, 22, 8) function-evaluation-cpp 0.054038 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 20, 5, 22, 14) function-extrapolation-python 5.66934 "BENCH: 1.99401187897" (2015, 1, 20, 5, 22, 14) function-extrapolation-python 1.99401 "BENCH: 1.99401187897" (2015, 1, 20, 5, 22, 16) function-interpolation-python 2.29171 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 20, 5, 22, 16) function-interpolation-python 0.95182 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 20, 5, 24, 53) la-vector-access-cpp 156.635 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 20, 5, 25, 35) la-vector-assignment-cpp 42.0132 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 21, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9162 "BENCH 12.9162" (2015, 1, 21, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8577 "Building point search tree to accelerate distance queries." (2015, 1, 21, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.1069 "BENCH 14.1069" (2015, 1, 21, 2, 9, 45) common-progress-cpp 27.899 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 21, 2, 10, 15) common-timing-cpp 30.1389 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 21, 2, 11, 49) fem-convergence-cpp 3.85707 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 21, 2, 11, 51) fem-jit-python 0.000429916 "JIT compilation (in memory cache)" (2015, 1, 21, 5, 23, 27) mesh-refinement-cpp 8.3288 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 21, 5, 23, 48) mesh-topology-cpp 21.3835 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 21, 5, 24, 11) mesh-unitcube-cpp 22.7911 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 21, 5, 24, 49) mesh-iteration-cpp 35.5586 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 21, 5, 24, 49) function-evaluation-cpp 0.0538089 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 21, 5, 24, 55) function-extrapolation-python 5.68216 "BENCH: 1.99137687683" (2015, 1, 21, 5, 24, 55) function-extrapolation-python 1.99138 "BENCH: 1.99137687683" (2015, 1, 21, 5, 24, 57) function-interpolation-python 2.27558 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 21, 5, 24, 57) function-interpolation-python 0.947757 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 21, 5, 27, 33) la-vector-access-cpp 155.673 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 21, 5, 28, 15) la-vector-assignment-cpp 42.0759 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 22, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0302 "BENCH 13.0302" (2015, 1, 22, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0981 "Building point search tree to accelerate distance queries." (2015, 1, 22, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.2438 "BENCH 14.2438" (2015, 1, 22, 2, 9, 54) common-progress-cpp 31.6639 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 22, 2, 10, 23) common-timing-cpp 29.4664 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 22, 2, 11, 57) fem-convergence-cpp 3.84376 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 22, 2, 11, 59) fem-jit-python 0.000420499 "JIT compilation (in memory cache)" (2015, 1, 22, 5, 22, 48) mesh-refinement-cpp 8.36185 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 22, 5, 23, 10) mesh-topology-cpp 21.3294 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 22, 5, 23, 32) mesh-unitcube-cpp 22.7715 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 22, 5, 24, 10) mesh-iteration-cpp 35.5338 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 22, 5, 24, 10) function-evaluation-cpp 0.0662131 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 22, 5, 24, 16) function-extrapolation-python 5.57816 "BENCH: 2.01826906204" (2015, 1, 22, 5, 24, 16) function-extrapolation-python 2.01827 "BENCH: 2.01826906204" (2015, 1, 22, 5, 24, 18) function-interpolation-python 2.28365 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 22, 5, 24, 18) function-interpolation-python 0.951847 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 22, 5, 26, 54) la-vector-access-cpp 155.663 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 22, 5, 27, 36) la-vector-assignment-cpp 42.0044 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 23, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9662 "BENCH 12.9662" (2015, 1, 23, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9537 "Building point search tree to accelerate distance queries." (2015, 1, 23, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2481 "BENCH 14.2481" (2015, 1, 23, 2, 9, 44) common-progress-cpp 27.9001 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 23, 2, 10, 14) common-timing-cpp 29.8833 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 23, 2, 11, 49) fem-convergence-cpp 3.84386 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 23, 2, 11, 51) fem-jit-python 0.000425005 "JIT compilation (in memory cache)" (2015, 1, 23, 5, 18, 18) mesh-refinement-cpp 8.33415 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 23, 5, 18, 39) mesh-topology-cpp 21.3355 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 23, 5, 19, 2) mesh-unitcube-cpp 22.7969 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 23, 5, 19, 40) mesh-iteration-cpp 35.52 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 23, 5, 19, 40) function-evaluation-cpp 0.0749261 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 23, 5, 19, 46) function-extrapolation-python 5.81342 "BENCH: 2.0104060173" (2015, 1, 23, 5, 19, 46) function-extrapolation-python 2.01041 "BENCH: 2.0104060173" (2015, 1, 23, 5, 19, 48) function-interpolation-python 2.27555 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 23, 5, 19, 48) function-interpolation-python 0.951791 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 23, 5, 22, 24) la-vector-access-cpp 155.669 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 23, 5, 23, 6) la-vector-assignment-cpp 41.9932 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 24, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0154 "BENCH 13.0154" (2015, 1, 24, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9741 "Building point search tree to accelerate distance queries." (2015, 1, 24, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.2417 "BENCH 14.2417" (2015, 1, 24, 2, 9, 49) common-progress-cpp 27.8892 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 24, 2, 10, 18) common-timing-cpp 29.7009 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 24, 2, 11, 53) fem-convergence-cpp 3.84152 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 24, 2, 11, 54) fem-jit-python 0.000420094 "JIT compilation (in memory cache)" (2015, 1, 24, 5, 35, 33) mesh-refinement-cpp 8.33555 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 24, 5, 35, 55) mesh-topology-cpp 21.4045 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 24, 5, 36, 17) mesh-unitcube-cpp 22.8117 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 24, 5, 36, 56) mesh-iteration-cpp 35.784 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 24, 5, 36, 56) function-evaluation-cpp 0.0561161 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 24, 5, 37, 1) function-extrapolation-python 5.8041 "BENCH: 2.01261305809" (2015, 1, 24, 5, 37, 1) function-extrapolation-python 2.01261 "BENCH: 2.01261305809" (2015, 1, 24, 5, 37, 4) function-interpolation-python 2.27188 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 24, 5, 37, 4) function-interpolation-python 0.948429 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 24, 5, 39, 39) la-vector-access-cpp 155.65 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 24, 5, 40, 21) la-vector-assignment-cpp 41.9903 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 25, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9225 "BENCH 12.9225" (2015, 1, 25, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0413 "Building point search tree to accelerate distance queries." (2015, 1, 25, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2568 "BENCH 14.2568" (2015, 1, 25, 2, 9, 44) common-progress-cpp 27.8962 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 25, 2, 10, 14) common-timing-cpp 30.168 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 25, 2, 11, 48) fem-convergence-cpp 3.85531 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 25, 2, 11, 49) fem-jit-python 0.000419188 "JIT compilation (in memory cache)" (2015, 1, 25, 5, 23, 19) mesh-refinement-cpp 8.35611 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 25, 5, 23, 40) mesh-topology-cpp 21.3933 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 25, 5, 24, 3) mesh-unitcube-cpp 22.8202 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 25, 5, 24, 41) mesh-iteration-cpp 35.5174 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 25, 5, 24, 41) function-evaluation-cpp 0.0540471 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 25, 5, 24, 47) function-extrapolation-python 5.65895 "BENCH: 1.9947681427" (2015, 1, 25, 5, 24, 47) function-extrapolation-python 1.99477 "BENCH: 1.9947681427" (2015, 1, 25, 5, 24, 49) function-interpolation-python 2.29256 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 25, 5, 24, 49) function-interpolation-python 0.953536 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 25, 5, 27, 25) la-vector-access-cpp 155.651 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 25, 5, 28, 7) la-vector-assignment-cpp 41.9976 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 26, 2, 8, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7158 "BENCH 12.7158" (2015, 1, 26, 2, 8, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8494 "Building point search tree to accelerate distance queries." (2015, 1, 26, 2, 9, 15) geometry-bounding_box_tree_build-cpp 14.3352 "BENCH 14.3352" (2015, 1, 26, 2, 9, 42) common-progress-cpp 27.8912 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 26, 2, 10, 13) common-timing-cpp 30.5711 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 26, 2, 11, 47) fem-convergence-cpp 3.84786 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 26, 2, 11, 49) fem-jit-python 0.00042069 "JIT compilation (in memory cache)" (2015, 1, 26, 5, 26, 38) mesh-refinement-cpp 8.33337 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 26, 5, 27, 0) mesh-topology-cpp 21.4984 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 26, 5, 27, 23) mesh-unitcube-cpp 22.7893 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 26, 5, 28, 1) mesh-iteration-cpp 35.5359 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 26, 5, 28, 1) function-evaluation-cpp 0.0542519 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 26, 5, 28, 6) function-extrapolation-python 5.74605 "BENCH: 2.00397396088" (2015, 1, 26, 5, 28, 6) function-extrapolation-python 2.00397 "BENCH: 2.00397396088" (2015, 1, 26, 5, 28, 9) function-interpolation-python 2.2845 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 26, 5, 28, 9) function-interpolation-python 0.952035 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 26, 5, 30, 44) la-vector-access-cpp 155.659 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 26, 5, 31, 27) la-vector-assignment-cpp 42.1982 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 27, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9286 "BENCH 12.9286" (2015, 1, 27, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8295 "Building point search tree to accelerate distance queries." (2015, 1, 27, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.3962 "BENCH 14.3962" (2015, 1, 27, 2, 9, 48) common-progress-cpp 27.8978 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 27, 2, 10, 17) common-timing-cpp 29.3535 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 27, 2, 11, 54) fem-convergence-cpp 3.86384 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 27, 2, 11, 56) fem-jit-python 0.000411701 "JIT compilation (in memory cache)" (2015, 1, 27, 5, 29, 50) mesh-refinement-cpp 8.27834 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 27, 5, 30, 11) mesh-topology-cpp 21.4234 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 27, 5, 30, 34) mesh-unitcube-cpp 22.7617 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 27, 5, 31, 13) mesh-iteration-cpp 36.0146 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 27, 5, 31, 13) function-evaluation-cpp 0.077997 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 27, 5, 31, 18) function-extrapolation-python 5.69492 "BENCH: 1.99704194069" (2015, 1, 27, 5, 31, 18) function-extrapolation-python 1.99704 "BENCH: 1.99704194069" (2015, 1, 27, 5, 31, 21) function-interpolation-python 2.26771 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 27, 5, 31, 21) function-interpolation-python 0.898407 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 27, 5, 33, 56) la-vector-access-cpp 155.672 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 27, 5, 34, 42) la-vector-assignment-cpp 46.0215 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 28, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0188 "BENCH 13.0188" (2015, 1, 28, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.219 "Building point search tree to accelerate distance queries." (2015, 1, 28, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.2625 "BENCH 14.2625" (2015, 1, 28, 2, 9, 49) common-progress-cpp 27.9836 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 28, 2, 10, 18) common-timing-cpp 29.2911 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 28, 2, 11, 55) fem-convergence-cpp 3.8915 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 28, 2, 11, 56) fem-jit-python 0.000416088 "JIT compilation (in memory cache)" (2015, 1, 28, 5, 31, 40) mesh-refinement-cpp 8.25751 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 28, 5, 32, 1) mesh-topology-cpp 21.5208 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 28, 5, 32, 24) mesh-unitcube-cpp 22.5288 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 28, 5, 33, 2) mesh-iteration-cpp 35.5203 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 28, 5, 33, 2) function-evaluation-cpp 0.0531292 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 28, 5, 33, 7) function-extrapolation-python 5.5854 "BENCH: 1.99143505096" (2015, 1, 28, 5, 33, 7) function-extrapolation-python 1.99144 "BENCH: 1.99143505096" (2015, 1, 28, 5, 33, 10) function-interpolation-python 2.23877 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 28, 5, 33, 10) function-interpolation-python 0.897829 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 28, 5, 36, 26) la-vector-access-cpp 196.529 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 28, 5, 37, 8) la-vector-assignment-cpp 41.9942 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 29, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8724 "BENCH 12.8724" (2015, 1, 29, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0227 "Building point search tree to accelerate distance queries." (2015, 1, 29, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.1372 "BENCH 14.1372" (2015, 1, 29, 2, 9, 46) common-progress-cpp 27.8926 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 29, 2, 10, 17) common-timing-cpp 30.3719 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 29, 2, 11, 54) fem-convergence-cpp 3.87615 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 29, 2, 11, 55) fem-jit-python 0.000417113 "JIT compilation (in memory cache)" (2015, 1, 29, 5, 19, 13) mesh-refinement-cpp 8.30901 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 29, 5, 19, 35) mesh-topology-cpp 21.5235 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 29, 5, 19, 57) mesh-unitcube-cpp 22.569 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 29, 5, 20, 35) mesh-iteration-cpp 35.5451 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 29, 5, 20, 35) function-evaluation-cpp 0.052731 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 29, 5, 20, 41) function-extrapolation-python 5.7619 "BENCH: 1.98129105568" (2015, 1, 29, 5, 20, 41) function-extrapolation-python 1.98129 "BENCH: 1.98129105568" (2015, 1, 29, 5, 20, 43) function-interpolation-python 2.2345 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 29, 5, 20, 43) function-interpolation-python 0.896309 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 29, 5, 23, 19) la-vector-access-cpp 155.652 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 29, 5, 24, 5) la-vector-assignment-cpp 46.0091 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 30, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7906 "BENCH 12.7906" (2015, 1, 30, 2, 8, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9329 "Building point search tree to accelerate distance queries." (2015, 1, 30, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2302 "BENCH 14.2302" (2015, 1, 30, 2, 9, 43) common-progress-cpp 27.9042 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 30, 2, 10, 15) common-timing-cpp 31.4452 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 30, 2, 11, 52) fem-convergence-cpp 3.84434 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 30, 2, 11, 53) fem-jit-python 0.000427198 "JIT compilation (in memory cache)" (2015, 1, 30, 5, 31, 48) mesh-refinement-cpp 8.2837 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 30, 5, 32, 10) mesh-topology-cpp 21.5219 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 30, 5, 32, 32) mesh-unitcube-cpp 22.6069 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 30, 5, 33, 10) mesh-iteration-cpp 35.5189 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 30, 5, 33, 10) function-evaluation-cpp 0.0529749 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 30, 5, 33, 16) function-extrapolation-python 5.96111 "BENCH: 2.00668096542" (2015, 1, 30, 5, 33, 16) function-extrapolation-python 2.00668 "BENCH: 2.00668096542" (2015, 1, 30, 5, 33, 19) function-interpolation-python 2.23988 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 30, 5, 33, 19) function-interpolation-python 0.900872 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 30, 5, 35, 54) la-vector-access-cpp 155.634 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 30, 5, 36, 36) la-vector-assignment-cpp 41.9938 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 1, 31, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9474 "BENCH 12.9474" (2015, 1, 31, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 14.932 "Building point search tree to accelerate distance queries." (2015, 1, 31, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2834 "BENCH 14.2834" (2015, 1, 31, 2, 9, 46) common-progress-cpp 27.8964 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 1, 31, 2, 10, 17) common-timing-cpp 30.2897 "Timing access and registration of timings (10000000 repetitions)" (2015, 1, 31, 2, 11, 52) fem-convergence-cpp 3.87908 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 1, 31, 2, 11, 54) fem-jit-python 0.000415897 "JIT compilation (in memory cache)" (2015, 1, 31, 5, 28, 12) mesh-refinement-cpp 8.22658 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 1, 31, 5, 28, 33) mesh-topology-cpp 21.5747 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 1, 31, 5, 28, 56) mesh-unitcube-cpp 22.6085 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 1, 31, 5, 29, 34) mesh-iteration-cpp 35.7343 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 1, 31, 5, 29, 34) function-evaluation-cpp 0.0932131 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 1, 31, 5, 29, 40) function-extrapolation-python 5.73736 "BENCH: 2.10626316071" (2015, 1, 31, 5, 29, 40) function-extrapolation-python 2.10626 "BENCH: 2.10626316071" (2015, 1, 31, 5, 29, 42) function-interpolation-python 2.32087 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 31, 5, 29, 42) function-interpolation-python 0.931475 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 1, 31, 5, 32, 19) la-vector-access-cpp 156.221 "Accessing vector of size 10000000 (100 repetitions)" (2015, 1, 31, 5, 33, 1) la-vector-assignment-cpp 42.0006 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 1, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0846 "BENCH 13.0846" (2015, 2, 1, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0823 "Building point search tree to accelerate distance queries." (2015, 2, 1, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2469 "BENCH 14.2469" (2015, 2, 1, 2, 9, 44) common-progress-cpp 27.8901 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 1, 2, 10, 14) common-timing-cpp 29.9912 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 1, 2, 11, 50) fem-convergence-cpp 3.87176 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 1, 2, 11, 52) fem-jit-python 0.000423312 "JIT compilation (in memory cache)" (2015, 2, 1, 5, 19, 54) mesh-refinement-cpp 8.2386 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 1, 5, 20, 15) mesh-topology-cpp 21.5764 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 1, 5, 20, 38) mesh-unitcube-cpp 22.5593 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 1, 5, 21, 16) mesh-iteration-cpp 35.5222 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 1, 5, 21, 16) function-evaluation-cpp 0.053803 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 1, 5, 21, 22) function-extrapolation-python 5.65852 "BENCH: 1.99313807487" (2015, 2, 1, 5, 21, 22) function-extrapolation-python 1.99314 "BENCH: 1.99313807487" (2015, 2, 1, 5, 21, 24) function-interpolation-python 2.23719 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 1, 5, 21, 24) function-interpolation-python 0.898627 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 1, 5, 24, 39) la-vector-access-cpp 194.606 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 1, 5, 25, 21) la-vector-assignment-cpp 42.0002 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 2, 2, 8, 45) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7663 "BENCH 12.7663" (2015, 2, 2, 2, 9, 3) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0363 "Building point search tree to accelerate distance queries." (2015, 2, 2, 2, 9, 20) geometry-bounding_box_tree_build-cpp 14.0539 "BENCH 14.0539" (2015, 2, 2, 2, 9, 48) common-progress-cpp 27.8635 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 2, 2, 10, 18) common-timing-cpp 29.9548 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 2, 2, 11, 53) fem-convergence-cpp 3.84214 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 2, 2, 11, 54) fem-jit-python 0.000419211 "JIT compilation (in memory cache)" (2015, 2, 2, 5, 23, 29) mesh-refinement-cpp 8.28255 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 2, 5, 23, 51) mesh-topology-cpp 21.4119 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 2, 5, 24, 14) mesh-unitcube-cpp 22.5144 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 2, 5, 24, 51) mesh-iteration-cpp 35.5114 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 2, 5, 24, 52) function-evaluation-cpp 0.051955 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 2, 5, 24, 57) function-extrapolation-python 5.61891 "BENCH: 1.99913811684" (2015, 2, 2, 5, 24, 57) function-extrapolation-python 1.99914 "BENCH: 1.99913811684" (2015, 2, 2, 5, 24, 59) function-interpolation-python 2.22905 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 2, 5, 24, 59) function-interpolation-python 0.889984 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 2, 5, 27, 37) la-vector-access-cpp 157.171 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 2, 5, 28, 23) la-vector-assignment-cpp 46.0146 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 3, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.793 "BENCH 12.793" (2015, 2, 3, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0672 "Building point search tree to accelerate distance queries." (2015, 2, 3, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.1047 "BENCH 14.1047" (2015, 2, 3, 2, 9, 49) common-progress-cpp 27.887 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 3, 2, 10, 19) common-timing-cpp 30.1409 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 3, 2, 11, 56) fem-convergence-cpp 3.85087 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 3, 2, 11, 58) fem-jit-python 0.000412917 "JIT compilation (in memory cache)" (2015, 2, 3, 5, 20, 58) mesh-refinement-cpp 8.24532 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 3, 5, 21, 19) mesh-topology-cpp 21.3599 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 3, 5, 21, 42) mesh-unitcube-cpp 22.4781 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 3, 5, 22, 20) mesh-iteration-cpp 35.5103 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 3, 5, 22, 20) function-evaluation-cpp 0.0778661 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 3, 5, 22, 26) function-extrapolation-python 5.74858 "BENCH: 2.01262307167" (2015, 2, 3, 5, 22, 26) function-extrapolation-python 2.01262 "BENCH: 2.01262307167" (2015, 2, 3, 5, 22, 28) function-interpolation-python 2.24297 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 3, 5, 22, 28) function-interpolation-python 0.892446 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 3, 5, 25, 5) la-vector-access-cpp 157.21 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 3, 5, 25, 47) la-vector-assignment-cpp 41.9989 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 4, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2765 "BENCH 13.2765" (2015, 2, 4, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1752 "Building point search tree to accelerate distance queries." (2015, 2, 4, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.0402 "BENCH 14.0402" (2015, 2, 4, 2, 9, 50) common-progress-cpp 27.8841 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 4, 2, 10, 21) common-timing-cpp 30.8417 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 4, 2, 11, 57) fem-convergence-cpp 3.83733 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 4, 2, 11, 58) fem-jit-python 0.000423002 "JIT compilation (in memory cache)" (2015, 2, 4, 5, 37, 8) mesh-refinement-cpp 8.47136 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 4, 5, 37, 30) mesh-topology-cpp 22.1027 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 4, 5, 37, 53) mesh-unitcube-cpp 23.1241 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 4, 5, 38, 32) mesh-iteration-cpp 36.2096 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 4, 5, 38, 32) function-evaluation-cpp 0.0746 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 4, 5, 38, 39) function-extrapolation-python 6.33811 "BENCH: 2.01691484451" (2015, 2, 4, 5, 38, 39) function-extrapolation-python 2.01691 "BENCH: 2.01691484451" (2015, 2, 4, 5, 38, 41) function-interpolation-python 2.28027 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 4, 5, 38, 41) function-interpolation-python 0.947862 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 4, 5, 41, 19) la-vector-access-cpp 157.578 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 4, 5, 42, 1) la-vector-assignment-cpp 42.0061 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 5, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9417 "BENCH 12.9417" (2015, 2, 5, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2308 "Building point search tree to accelerate distance queries." (2015, 2, 5, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.3289 "BENCH 14.3289" (2015, 2, 5, 2, 9, 47) common-progress-cpp 27.9223 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 5, 2, 10, 17) common-timing-cpp 30.399 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 5, 2, 11, 55) fem-convergence-cpp 3.98873 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 5, 2, 11, 56) fem-jit-python 0.000418997 "JIT compilation (in memory cache)" (2015, 2, 5, 5, 35, 22) mesh-refinement-cpp 8.57701 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 5, 5, 35, 43) mesh-topology-cpp 21.7172 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 5, 5, 36, 7) mesh-unitcube-cpp 23.0297 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 5, 5, 36, 45) mesh-iteration-cpp 36.392 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 5, 5, 36, 45) function-evaluation-cpp 0.098614 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 5, 5, 36, 51) function-extrapolation-python 5.47868 "BENCH: 2.08205604553" (2015, 2, 5, 5, 36, 51) function-extrapolation-python 2.08206 "BENCH: 2.08205604553" (2015, 2, 5, 5, 36, 53) function-interpolation-python 2.38113 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 5, 5, 36, 53) function-interpolation-python 0.989093 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 5, 5, 39, 47) la-vector-access-cpp 173.161 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 5, 5, 40, 29) la-vector-assignment-cpp 42.0201 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 6, 2, 10, 13) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9155 "BENCH 12.9155" (2015, 2, 6, 2, 10, 32) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0706 "Building point search tree to accelerate distance queries." (2015, 2, 6, 2, 10, 48) geometry-bounding_box_tree_build-cpp 14.1847 "BENCH 14.1847" (2015, 2, 6, 2, 11, 16) common-progress-cpp 27.8861 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 6, 2, 11, 47) common-timing-cpp 30.4256 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 6, 2, 13, 24) fem-convergence-cpp 3.87622 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 6, 2, 13, 25) fem-jit-python 0.000423908 "JIT compilation (in memory cache)" (2015, 2, 6, 5, 24, 41) mesh-refinement-cpp 8.43665 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 6, 5, 25, 3) mesh-topology-cpp 21.5684 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 6, 5, 25, 26) mesh-unitcube-cpp 23.106 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 6, 5, 26, 5) mesh-iteration-cpp 36.0361 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 6, 5, 26, 5) function-evaluation-cpp 0.0771489 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 6, 5, 26, 10) function-extrapolation-python 5.59798 "BENCH: 2.02288913727" (2015, 2, 6, 5, 26, 10) function-extrapolation-python 2.02289 "BENCH: 2.02288913727" (2015, 2, 6, 5, 26, 13) function-interpolation-python 2.28042 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 6, 5, 26, 13) function-interpolation-python 0.941998 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 6, 5, 28, 49) la-vector-access-cpp 156.672 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 6, 5, 29, 35) la-vector-assignment-cpp 46.0157 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 7, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8681 "BENCH 12.8681" (2015, 2, 7, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9657 "Building point search tree to accelerate distance queries." (2015, 2, 7, 2, 9, 18) geometry-bounding_box_tree_build-cpp 14.354 "BENCH 14.354" (2015, 2, 7, 2, 9, 46) common-progress-cpp 27.904 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 7, 2, 10, 16) common-timing-cpp 30.5559 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 7, 2, 11, 54) fem-convergence-cpp 3.86834 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 7, 2, 11, 55) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2015, 2, 7, 5, 22, 35) mesh-refinement-cpp 8.41782 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 7, 5, 22, 57) mesh-topology-cpp 21.4043 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 7, 5, 23, 19) mesh-unitcube-cpp 22.7344 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 7, 5, 23, 58) mesh-iteration-cpp 36.0492 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 7, 5, 23, 58) function-evaluation-cpp 0.0645189 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 7, 5, 24, 4) function-extrapolation-python 5.72379 "BENCH: 2.0016849041" (2015, 2, 7, 5, 24, 4) function-extrapolation-python 2.00168 "BENCH: 2.0016849041" (2015, 2, 7, 5, 24, 6) function-interpolation-python 2.2845 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 7, 5, 24, 6) function-interpolation-python 0.944619 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 7, 5, 26, 44) la-vector-access-cpp 157.671 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 7, 5, 27, 26) la-vector-assignment-cpp 41.9998 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 8, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9149 "BENCH 12.9149" (2015, 2, 8, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8533 "Building point search tree to accelerate distance queries." (2015, 2, 8, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2944 "BENCH 14.2944" (2015, 2, 8, 2, 9, 47) common-progress-cpp 27.878 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 8, 2, 10, 17) common-timing-cpp 30.3629 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 8, 2, 11, 55) fem-convergence-cpp 3.86025 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 8, 2, 11, 56) fem-jit-python 0.000429106 "JIT compilation (in memory cache)" (2015, 2, 8, 5, 23, 51) mesh-refinement-cpp 8.42952 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 8, 5, 24, 12) mesh-topology-cpp 21.5769 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 8, 5, 24, 35) mesh-unitcube-cpp 22.8324 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 8, 5, 25, 14) mesh-iteration-cpp 36.0491 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 8, 5, 25, 14) function-evaluation-cpp 0.072722 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 8, 5, 25, 19) function-extrapolation-python 5.56836 "BENCH: 1.99747180939" (2015, 2, 8, 5, 25, 19) function-extrapolation-python 1.99747 "BENCH: 1.99747180939" (2015, 2, 8, 5, 25, 22) function-interpolation-python 2.29429 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 8, 5, 25, 22) function-interpolation-python 0.946924 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 8, 5, 27, 57) la-vector-access-cpp 155.732 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 8, 5, 28, 39) la-vector-assignment-cpp 41.9954 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 9, 2, 8, 42) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0256 "BENCH 13.0256" (2015, 2, 9, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2805 "Building point search tree to accelerate distance queries." (2015, 2, 9, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.3428 "BENCH 14.3428" (2015, 2, 9, 2, 9, 45) common-progress-cpp 27.8874 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 9, 2, 10, 15) common-timing-cpp 29.6803 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 9, 2, 11, 49) fem-convergence-cpp 3.84817 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 9, 2, 11, 51) fem-jit-python 0.000415683 "JIT compilation (in memory cache)" (2015, 2, 9, 5, 25, 22) mesh-refinement-cpp 8.41362 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 9, 5, 25, 44) mesh-topology-cpp 21.4063 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 9, 5, 26, 7) mesh-unitcube-cpp 22.769 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 9, 5, 26, 48) mesh-iteration-cpp 38.5509 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 9, 5, 26, 48) function-evaluation-cpp 0.079474 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 9, 5, 26, 54) function-extrapolation-python 5.89367 "BENCH: 2.00670695305" (2015, 2, 9, 5, 26, 54) function-extrapolation-python 2.00671 "BENCH: 2.00670695305" (2015, 2, 9, 5, 26, 56) function-interpolation-python 2.26866 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 9, 5, 26, 56) function-interpolation-python 0.945634 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 9, 5, 29, 34) la-vector-access-cpp 157.658 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 9, 5, 30, 16) la-vector-assignment-cpp 42.0093 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 10, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9004 "BENCH 12.9004" (2015, 2, 10, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8766 "Building point search tree to accelerate distance queries." (2015, 2, 10, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2157 "BENCH 14.2157" (2015, 2, 10, 2, 9, 47) common-progress-cpp 27.9047 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 10, 2, 10, 17) common-timing-cpp 30.4034 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 10, 2, 11, 52) fem-convergence-cpp 3.84225 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 10, 2, 11, 53) fem-jit-python 0.000425196 "JIT compilation (in memory cache)" (2015, 2, 10, 5, 24, 15) mesh-refinement-cpp 8.43726 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 10, 5, 24, 36) mesh-topology-cpp 21.4342 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 10, 5, 24, 59) mesh-unitcube-cpp 22.7271 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 10, 5, 25, 40) mesh-iteration-cpp 38.4914 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 10, 5, 25, 40) function-evaluation-cpp 0.099462 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 10, 5, 25, 46) function-extrapolation-python 5.61698 "BENCH: 2.02750897408" (2015, 2, 10, 5, 25, 46) function-extrapolation-python 2.02751 "BENCH: 2.02750897408" (2015, 2, 10, 5, 25, 48) function-interpolation-python 2.28898 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 10, 5, 25, 48) function-interpolation-python 0.959003 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 10, 5, 28, 24) la-vector-access-cpp 155.638 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 10, 5, 29, 6) la-vector-assignment-cpp 42.1738 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 11, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9498 "BENCH 12.9498" (2015, 2, 11, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8947 "Building point search tree to accelerate distance queries." (2015, 2, 11, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.0294 "BENCH 14.0294" (2015, 2, 11, 2, 9, 47) common-progress-cpp 28.234 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 11, 2, 10, 17) common-timing-cpp 30.0576 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 11, 2, 11, 54) fem-convergence-cpp 3.84135 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 11, 2, 11, 55) fem-jit-python 0.000418901 "JIT compilation (in memory cache)" (2015, 2, 11, 5, 20, 39) mesh-refinement-cpp 8.41591 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 11, 5, 21, 0) mesh-topology-cpp 21.5134 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 11, 5, 21, 23) mesh-unitcube-cpp 22.8824 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 11, 5, 22, 4) mesh-iteration-cpp 38.5528 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 11, 5, 22, 4) function-evaluation-cpp 0.0545449 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 11, 5, 22, 10) function-extrapolation-python 5.6231 "BENCH: 1.99815392494" (2015, 2, 11, 5, 22, 10) function-extrapolation-python 1.99815 "BENCH: 1.99815392494" (2015, 2, 11, 5, 22, 12) function-interpolation-python 2.29979 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 11, 5, 22, 12) function-interpolation-python 0.953307 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 11, 5, 25, 16) la-vector-access-cpp 183.397 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 11, 5, 25, 58) la-vector-assignment-cpp 42.0038 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 12, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9211 "BENCH 12.9211" (2015, 2, 12, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8819 "Building point search tree to accelerate distance queries." (2015, 2, 12, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.117 "BENCH 14.117" (2015, 2, 12, 2, 9, 49) common-progress-cpp 27.8984 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 12, 2, 10, 20) common-timing-cpp 31.0567 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 12, 2, 11, 57) fem-convergence-cpp 3.84313 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 12, 2, 11, 59) fem-jit-python 0.00041461 "JIT compilation (in memory cache)" (2015, 2, 12, 5, 31, 40) mesh-refinement-cpp 8.40614 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 12, 5, 32, 2) mesh-topology-cpp 21.5804 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 12, 5, 32, 25) mesh-unitcube-cpp 22.7311 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 12, 5, 33, 3) mesh-iteration-cpp 36.0717 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 12, 5, 33, 3) function-evaluation-cpp 0.072602 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 12, 5, 33, 9) function-extrapolation-python 5.54261 "BENCH: 2.005879879" (2015, 2, 12, 5, 33, 9) function-extrapolation-python 2.00588 "BENCH: 2.005879879" (2015, 2, 12, 5, 33, 11) function-interpolation-python 2.28128 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 12, 5, 33, 11) function-interpolation-python 0.943221 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 12, 5, 35, 47) la-vector-access-cpp 155.691 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 12, 5, 36, 29) la-vector-assignment-cpp 41.9873 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 13, 2, 8, 47) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8979 "BENCH 12.8979" (2015, 2, 13, 2, 9, 5) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9874 "Building point search tree to accelerate distance queries." (2015, 2, 13, 2, 9, 22) geometry-bounding_box_tree_build-cpp 14.0418 "BENCH 14.0418" (2015, 2, 13, 2, 9, 50) common-progress-cpp 27.8811 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 13, 2, 10, 20) common-timing-cpp 29.8306 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 13, 2, 11, 57) fem-convergence-cpp 3.88574 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 13, 2, 11, 58) fem-jit-python 0.000418305 "JIT compilation (in memory cache)" (2015, 2, 13, 5, 31, 47) mesh-refinement-cpp 8.56194 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 13, 5, 32, 9) mesh-topology-cpp 21.572 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 13, 5, 32, 32) mesh-unitcube-cpp 22.9348 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 13, 5, 33, 11) mesh-iteration-cpp 36.4053 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 13, 5, 33, 11) function-evaluation-cpp 0.0773149 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 13, 5, 33, 17) function-extrapolation-python 5.74959 "BENCH: 2.05807304382" (2015, 2, 13, 5, 33, 17) function-extrapolation-python 2.05807 "BENCH: 2.05807304382" (2015, 2, 13, 5, 33, 19) function-interpolation-python 2.34395 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 13, 5, 33, 19) function-interpolation-python 0.966344 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 13, 5, 35, 57) la-vector-access-cpp 157.43 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 13, 5, 36, 43) la-vector-assignment-cpp 46.0285 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 14, 2, 8, 44) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0511 "BENCH 13.0511" (2015, 2, 14, 2, 9, 2) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2607 "Building point search tree to accelerate distance queries." (2015, 2, 14, 2, 9, 19) geometry-bounding_box_tree_build-cpp 14.2074 "BENCH 14.2074" (2015, 2, 14, 2, 9, 47) common-progress-cpp 27.8872 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 14, 2, 10, 17) common-timing-cpp 30.4027 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 14, 2, 11, 53) fem-convergence-cpp 3.84649 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 14, 2, 11, 54) fem-jit-python 0.000420499 "JIT compilation (in memory cache)" (2015, 2, 14, 5, 30, 25) mesh-refinement-cpp 8.61695 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 14, 5, 30, 47) mesh-topology-cpp 21.8707 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 14, 5, 31, 10) mesh-unitcube-cpp 23.0261 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 14, 5, 31, 56) mesh-iteration-cpp 43.8163 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 14, 5, 31, 56) function-evaluation-cpp 0.112423 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 14, 5, 32, 2) function-extrapolation-python 5.47676 "BENCH: 2.07007479668" (2015, 2, 14, 5, 32, 2) function-extrapolation-python 2.07007 "BENCH: 2.07007479668" (2015, 2, 14, 5, 32, 4) function-interpolation-python 2.31784 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 14, 5, 32, 4) function-interpolation-python 0.952871 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 14, 5, 34, 41) la-vector-access-cpp 157.058 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 14, 5, 35, 23) la-vector-assignment-cpp 42.0052 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 15, 2, 8, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9295 "BENCH 12.9295" (2015, 2, 15, 2, 9, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8282 "Building point search tree to accelerate distance queries." (2015, 2, 15, 2, 9, 16) geometry-bounding_box_tree_build-cpp 14.2533 "BENCH 14.2533" (2015, 2, 15, 2, 9, 44) common-progress-cpp 27.8847 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 15, 2, 10, 14) common-timing-cpp 29.7358 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 15, 2, 11, 50) fem-convergence-cpp 3.86424 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 15, 2, 11, 51) fem-jit-python 0.00041852 "JIT compilation (in memory cache)" (2015, 2, 15, 5, 28, 1) mesh-refinement-cpp 8.42518 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 15, 5, 28, 22) mesh-topology-cpp 21.4052 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 15, 5, 28, 45) mesh-unitcube-cpp 22.7658 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 15, 5, 29, 23) mesh-iteration-cpp 36.0638 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 15, 5, 29, 23) function-evaluation-cpp 0.0539842 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 15, 5, 29, 29) function-extrapolation-python 5.72886 "BENCH: 2.00570416451" (2015, 2, 15, 5, 29, 29) function-extrapolation-python 2.0057 "BENCH: 2.00570416451" (2015, 2, 15, 5, 29, 32) function-interpolation-python 2.26687 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 15, 5, 29, 32) function-interpolation-python 0.92876 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 15, 5, 32, 7) la-vector-access-cpp 155.653 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 15, 5, 32, 49) la-vector-assignment-cpp 42.017 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 16, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9412 "BENCH 12.9412" (2015, 2, 16, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8664 "Building point search tree to accelerate distance queries." (2015, 2, 16, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.1623 "BENCH 14.1623" (2015, 2, 16, 2, 9, 49) common-progress-cpp 28.0251 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 16, 2, 10, 19) common-timing-cpp 30.8004 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 16, 2, 11, 56) fem-convergence-cpp 3.89275 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 16, 2, 11, 59) fem-jit-python 0.000421786 "JIT compilation (in memory cache)" (2015, 2, 16, 5, 27, 51) mesh-refinement-cpp 8.45581 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 16, 5, 28, 13) mesh-topology-cpp 21.418 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 16, 5, 28, 36) mesh-unitcube-cpp 22.7987 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 16, 5, 29, 14) mesh-iteration-cpp 36.0286 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 16, 5, 29, 14) function-evaluation-cpp 0.0912499 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 16, 5, 29, 20) function-extrapolation-python 5.59939 "BENCH: 1.99086213112" (2015, 2, 16, 5, 29, 20) function-extrapolation-python 1.99086 "BENCH: 1.99086213112" (2015, 2, 16, 5, 29, 22) function-interpolation-python 2.274 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 16, 5, 29, 22) function-interpolation-python 0.927842 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 16, 5, 31, 59) la-vector-access-cpp 156.662 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 16, 5, 32, 41) la-vector-assignment-cpp 41.9894 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 17, 2, 8, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9363 "BENCH 12.9363" (2015, 2, 17, 2, 9, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.7393 "Building point search tree to accelerate distance queries." (2015, 2, 17, 2, 9, 17) geometry-bounding_box_tree_build-cpp 14.0866 "BENCH 14.0866" (2015, 2, 17, 2, 9, 45) common-progress-cpp 27.8845 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 17, 2, 10, 15) common-timing-cpp 30.2329 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 17, 2, 11, 53) fem-convergence-cpp 3.8627 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 17, 2, 11, 54) fem-jit-python 0.000426412 "JIT compilation (in memory cache)" (2015, 2, 17, 5, 26, 45) mesh-refinement-cpp 8.39926 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 17, 5, 27, 7) mesh-topology-cpp 21.5359 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 17, 5, 27, 30) mesh-unitcube-cpp 22.7673 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 17, 5, 28, 8) mesh-iteration-cpp 36.0274 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 17, 5, 28, 8) function-evaluation-cpp 0.054383 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 17, 5, 28, 14) function-extrapolation-python 5.84207 "BENCH: 2.02217888832" (2015, 2, 17, 5, 28, 14) function-extrapolation-python 2.02218 "BENCH: 2.02217888832" (2015, 2, 17, 5, 28, 16) function-interpolation-python 2.27814 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 17, 5, 28, 16) function-interpolation-python 0.932276 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 17, 5, 31, 20) la-vector-access-cpp 183.302 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 17, 5, 32, 2) la-vector-assignment-cpp 42.0414 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 18, 2, 8, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8985 "BENCH 12.8985" (2015, 2, 18, 2, 9, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9901 "Building point search tree to accelerate distance queries." (2015, 2, 18, 2, 9, 21) geometry-bounding_box_tree_build-cpp 14.2467 "BENCH 14.2467" (2015, 2, 18, 2, 9, 53) common-progress-cpp 31.6521 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 18, 2, 10, 23) common-timing-cpp 29.9154 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 18, 2, 11, 57) fem-convergence-cpp 3.86983 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 18, 2, 11, 59) fem-jit-python 0.0004287 "JIT compilation (in memory cache)" (2015, 2, 18, 5, 27, 6) mesh-refinement-cpp 8.54528 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 18, 5, 27, 29) mesh-topology-cpp 22.3321 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 18, 5, 27, 52) mesh-unitcube-cpp 23.0074 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 18, 5, 28, 31) mesh-iteration-cpp 36.2444 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 18, 5, 28, 31) function-evaluation-cpp 0.0931251 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 18, 5, 28, 37) function-extrapolation-python 5.89335 "BENCH: 2.08315205574" (2015, 2, 18, 5, 28, 37) function-extrapolation-python 2.08315 "BENCH: 2.08315205574" (2015, 2, 18, 5, 28, 39) function-interpolation-python 2.35012 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 18, 5, 28, 39) function-interpolation-python 0.950281 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 18, 5, 31, 15) la-vector-access-cpp 156.085 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 18, 5, 31, 57) la-vector-assignment-cpp 42.0192 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 2, 19, 2, 9, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2872 "BENCH 13.2872" (2015, 2, 19, 2, 9, 22) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3014 "Building point search tree to accelerate distance queries." (2015, 2, 19, 2, 9, 38) geometry-bounding_box_tree_build-cpp 14.1043 "BENCH 14.1043" (2015, 2, 19, 2, 10, 6) common-progress-cpp 27.9106 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 2, 19, 2, 10, 36) common-timing-cpp 29.3973 "Timing access and registration of timings (10000000 repetitions)" (2015, 2, 19, 2, 12, 9) fem-convergence-cpp 3.90614 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 2, 19, 2, 12, 10) fem-jit-python 0.000422001 "JIT compilation (in memory cache)" (2015, 2, 19, 5, 28, 51) mesh-refinement-cpp 8.24996 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 2, 19, 5, 29, 13) mesh-topology-cpp 21.786 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 2, 19, 5, 29, 36) mesh-unitcube-cpp 22.4425 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 2, 19, 5, 30, 14) mesh-iteration-cpp 35.5109 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 2, 19, 5, 30, 14) function-evaluation-cpp 0.062834 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 2, 19, 5, 30, 19) function-extrapolation-python 5.70348 "BENCH: 2.00259017944" (2015, 2, 19, 5, 30, 19) function-extrapolation-python 2.00259 "BENCH: 2.00259017944" (2015, 2, 19, 5, 30, 22) function-interpolation-python 2.30721 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 19, 5, 30, 22) function-interpolation-python 0.968658 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2015, 2, 19, 5, 32, 53) la-vector-access-cpp 151.027 "Accessing vector of size 10000000 (100 repetitions)" (2015, 2, 19, 5, 33, 35) la-vector-assignment-cpp 42.0061 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 20, 8, 9, 3) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9364 "BENCH 12.9364" (2015, 3, 20, 8, 9, 21) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9867 "Building point search tree to accelerate distance queries." (2015, 3, 20, 8, 9, 37) geometry-bounding_box_tree_build-cpp 14.1886 "BENCH 14.1886" (2015, 3, 20, 8, 10, 5) common-progress-cpp 27.7346 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 20, 8, 11, 18) common-timing-cpp 72.5637 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 20, 8, 12, 48) fem-convergence-cpp 3.64517 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 21, 2, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.982 "BENCH 12.982" (2015, 3, 21, 2, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0123 "Building point search tree to accelerate distance queries." (2015, 3, 21, 2, 10, 12) geometry-bounding_box_tree_build-cpp 13.9065 "BENCH 13.9065" (2015, 3, 21, 2, 10, 40) common-progress-cpp 27.6032 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 21, 2, 11, 52) common-timing-cpp 72.5305 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 21, 2, 13, 21) fem-convergence-cpp 3.5965 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 21, 5, 1, 54) fem-speedup-cpp 10111.1 "Assembly/solve speedup running on 4 processors" (2015, 3, 21, 5, 1, 54) fem-speedup-cpp-assembly 6.45968 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 21, 5, 1, 54) fem-speedup-cpp-solve 0.682783 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 21, 5, 2, 4) mesh-refinement-cpp 9.6983 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 21, 5, 2, 26) mesh-topology-cpp 21.4044 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 21, 5, 2, 48) mesh-unitcube-cpp 22.1685 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 21, 5, 3, 26) mesh-iteration-cpp 35.5517 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 21, 5, 3, 26) function-evaluation-cpp 0.03566 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 21, 5, 5, 22) la-vector-access-cpp 112.442 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 21, 5, 5, 59) la-vector-assignment-cpp 37.4748 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 22, 2, 9, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9707 "BENCH 12.9707" (2015, 3, 22, 2, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9672 "Building point search tree to accelerate distance queries." (2015, 3, 22, 2, 10, 7) geometry-bounding_box_tree_build-cpp 14.1644 "BENCH 14.1644" (2015, 3, 22, 2, 10, 35) common-progress-cpp 27.7926 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 22, 2, 11, 47) common-timing-cpp 72.2379 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 22, 2, 13, 16) fem-convergence-cpp 3.64729 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 22, 4, 55, 18) fem-speedup-cpp 9720.27 "Assembly/solve speedup running on 4 processors" (2015, 3, 22, 4, 55, 18) fem-speedup-cpp-assembly 6.46243 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 22, 4, 55, 18) fem-speedup-cpp-solve 0.69393 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 22, 4, 55, 28) mesh-refinement-cpp 9.6657 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 22, 4, 55, 50) mesh-topology-cpp 21.33 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 22, 4, 56, 12) mesh-unitcube-cpp 22.0677 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 22, 4, 56, 50) mesh-iteration-cpp 35.5197 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 22, 4, 56, 50) function-evaluation-cpp 0.03547 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 22, 4, 58, 45) la-vector-access-cpp 111.883 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 22, 4, 59, 23) la-vector-assignment-cpp 37.4854 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 23, 2, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9633 "BENCH 12.9633" (2015, 3, 23, 2, 9, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0446 "Building point search tree to accelerate distance queries." (2015, 3, 23, 2, 10, 7) geometry-bounding_box_tree_build-cpp 14.1177 "BENCH 14.1177" (2015, 3, 23, 2, 10, 35) common-progress-cpp 27.7901 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 23, 2, 11, 50) common-timing-cpp 74.5936 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 23, 2, 13, 19) fem-convergence-cpp 3.65482 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 23, 5, 13, 12) fem-speedup-cpp 10791.9 "Assembly/solve speedup running on 4 processors" (2015, 3, 23, 5, 13, 12) fem-speedup-cpp-assembly 6.44391 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 23, 5, 13, 12) fem-speedup-cpp-solve 0.596431 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 23, 5, 13, 23) mesh-refinement-cpp 9.67308 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 23, 5, 13, 44) mesh-topology-cpp 21.3146 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 23, 5, 14, 6) mesh-unitcube-cpp 22.0786 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 23, 5, 14, 44) mesh-iteration-cpp 35.4986 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 23, 5, 14, 44) function-evaluation-cpp 0.0391459 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 23, 5, 16, 39) la-vector-access-cpp 110.934 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 23, 5, 17, 20) la-vector-assignment-cpp 40.9414 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 24, 2, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0505 "BENCH 13.0505" (2015, 3, 24, 2, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0085 "Building point search tree to accelerate distance queries." (2015, 3, 24, 2, 10, 13) geometry-bounding_box_tree_build-cpp 14.1158 "BENCH 14.1158" (2015, 3, 24, 2, 10, 41) common-progress-cpp 27.8055 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 24, 2, 11, 53) common-timing-cpp 72.2283 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 24, 2, 13, 23) fem-convergence-cpp 3.64277 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 24, 5, 2, 16) fem-speedup-cpp 10132 "Assembly/solve speedup running on 4 processors" (2015, 3, 24, 5, 2, 16) fem-speedup-cpp-assembly 6.2482 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 24, 5, 2, 16) fem-speedup-cpp-solve 0.653102 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 24, 5, 2, 26) mesh-refinement-cpp 9.68068 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 24, 5, 2, 48) mesh-topology-cpp 21.3483 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 24, 5, 3, 10) mesh-unitcube-cpp 22.186 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 24, 5, 3, 48) mesh-iteration-cpp 35.5008 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 24, 5, 3, 48) function-evaluation-cpp 0.0390491 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 24, 5, 5, 44) la-vector-access-cpp 112.12 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 24, 5, 6, 21) la-vector-assignment-cpp 37.5554 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 25, 2, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0383 "BENCH 13.0383" (2015, 3, 25, 2, 9, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1951 "Building point search tree to accelerate distance queries." (2015, 3, 25, 2, 10, 13) geometry-bounding_box_tree_build-cpp 14.1323 "BENCH 14.1323" (2015, 3, 25, 2, 10, 41) common-progress-cpp 27.8443 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 25, 2, 11, 54) common-timing-cpp 72.3458 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 25, 2, 13, 24) fem-convergence-cpp 3.62637 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 25, 5, 2, 29) fem-speedup-cpp 10143.7 "Assembly/solve speedup running on 4 processors" (2015, 3, 25, 5, 2, 29) fem-speedup-cpp-assembly 6.49894 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 25, 5, 2, 29) fem-speedup-cpp-solve 0.656719 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 25, 5, 2, 39) mesh-refinement-cpp 9.65583 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 25, 5, 3, 1) mesh-topology-cpp 21.3106 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 25, 5, 3, 23) mesh-unitcube-cpp 22.151 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 25, 5, 4, 1) mesh-iteration-cpp 35.5123 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 25, 5, 4, 1) function-evaluation-cpp 0.038727 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 25, 5, 5, 57) la-vector-access-cpp 112.99 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 25, 5, 6, 39) la-vector-assignment-cpp 41.4771 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 26, 2, 9, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0301 "BENCH 13.0301" (2015, 3, 26, 2, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0209 "Building point search tree to accelerate distance queries." (2015, 3, 26, 2, 10, 9) geometry-bounding_box_tree_build-cpp 14.1601 "BENCH 14.1601" (2015, 3, 26, 2, 10, 37) common-progress-cpp 27.7787 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 26, 2, 11, 50) common-timing-cpp 72.9241 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 26, 2, 13, 20) fem-convergence-cpp 3.63802 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 26, 4, 59, 31) fem-speedup-cpp 9970.21 "Assembly/solve speedup running on 4 processors" (2015, 3, 26, 4, 59, 31) fem-speedup-cpp-assembly 6.36023 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 26, 4, 59, 31) fem-speedup-cpp-solve 0.664266 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 26, 4, 59, 41) mesh-refinement-cpp 9.69414 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 26, 5, 0, 3) mesh-topology-cpp 21.3054 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 26, 5, 0, 25) mesh-unitcube-cpp 22.0974 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 26, 5, 1, 3) mesh-iteration-cpp 35.5122 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 26, 5, 1, 3) function-evaluation-cpp 0.035718 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 26, 5, 2, 56) la-vector-access-cpp 109.424 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 26, 5, 3, 33) la-vector-assignment-cpp 37.4888 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 27, 2, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0322 "BENCH 13.0322" (2015, 3, 27, 2, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1999 "Building point search tree to accelerate distance queries." (2015, 3, 27, 2, 10, 10) geometry-bounding_box_tree_build-cpp 14.2077 "BENCH 14.2077" (2015, 3, 27, 2, 10, 38) common-progress-cpp 27.7875 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 27, 2, 11, 51) common-timing-cpp 73.573 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 27, 2, 13, 20) fem-convergence-cpp 3.62865 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 27, 4, 54, 3) fem-speedup-cpp 9641.67 "Assembly/solve speedup running on 4 processors" (2015, 3, 27, 4, 54, 3) fem-speedup-cpp-assembly 6.37373 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 27, 4, 54, 3) fem-speedup-cpp-solve 0.699076 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 27, 4, 54, 14) mesh-refinement-cpp 9.68937 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 27, 4, 54, 35) mesh-topology-cpp 21.3365 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 27, 4, 54, 57) mesh-unitcube-cpp 22.0976 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 27, 4, 55, 36) mesh-iteration-cpp 36.8735 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 27, 4, 55, 36) function-evaluation-cpp 0.0354409 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 27, 4, 57, 32) la-vector-access-cpp 112.453 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 27, 4, 58, 10) la-vector-assignment-cpp 37.4824 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 28, 2, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1162 "BENCH 13.1162" (2015, 3, 28, 2, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0197 "Building point search tree to accelerate distance queries." (2015, 3, 28, 2, 10, 11) geometry-bounding_box_tree_build-cpp 14.1425 "BENCH 14.1425" (2015, 3, 28, 2, 10, 39) common-progress-cpp 27.7741 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 28, 2, 11, 52) common-timing-cpp 73.0875 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 28, 2, 13, 21) fem-convergence-cpp 3.64967 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 28, 5, 20, 40) fem-speedup-cpp 11237.1 "Assembly/solve speedup running on 4 processors" (2015, 3, 28, 5, 20, 40) fem-speedup-cpp-assembly 6.36185 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 28, 5, 20, 40) fem-speedup-cpp-solve 0.544172 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 28, 5, 20, 50) mesh-refinement-cpp 9.67083 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 28, 5, 21, 12) mesh-topology-cpp 21.3457 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 28, 5, 21, 34) mesh-unitcube-cpp 22.3124 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 28, 5, 22, 12) mesh-iteration-cpp 35.4978 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 28, 5, 22, 12) function-evaluation-cpp 0.0353961 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 28, 5, 24, 7) la-vector-access-cpp 111.928 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 28, 5, 24, 45) la-vector-assignment-cpp 37.5116 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 29, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0502 "BENCH 13.0502" (2015, 3, 29, 1, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1291 "Building point search tree to accelerate distance queries." (2015, 3, 29, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.0597 "BENCH 14.0597" (2015, 3, 29, 1, 10, 36) common-progress-cpp 27.7997 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 29, 1, 11, 49) common-timing-cpp 73.0022 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 29, 1, 13, 19) fem-convergence-cpp 3.65721 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 29, 4, 8, 39) fem-speedup-cpp 10518.5 "Assembly/solve speedup running on 4 processors" (2015, 3, 29, 4, 8, 39) fem-speedup-cpp-assembly 6.31959 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 29, 4, 8, 39) fem-speedup-cpp-solve 0.603944 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 29, 4, 8, 49) mesh-refinement-cpp 9.70359 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 29, 4, 9, 11) mesh-topology-cpp 21.3499 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 29, 4, 9, 33) mesh-unitcube-cpp 22.1585 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 29, 4, 10, 10) mesh-iteration-cpp 35.5036 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 29, 4, 10, 11) function-evaluation-cpp 0.0357509 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 29, 4, 12, 5) la-vector-access-cpp 110.89 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 29, 4, 12, 47) la-vector-assignment-cpp 41.4822 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 30, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9603 "BENCH 12.9603" (2015, 3, 30, 1, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1731 "Building point search tree to accelerate distance queries." (2015, 3, 30, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.1585 "BENCH 14.1585" (2015, 3, 30, 1, 10, 41) common-progress-cpp 32.8053 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 30, 1, 11, 54) common-timing-cpp 73.2411 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 30, 1, 13, 24) fem-convergence-cpp 3.63205 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 30, 4, 15, 54) fem-speedup-cpp 10948.6 "Assembly/solve speedup running on 4 processors" (2015, 3, 30, 4, 15, 54) fem-speedup-cpp-assembly 6.36559 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 30, 4, 15, 54) fem-speedup-cpp-solve 0.589143 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 30, 4, 16, 4) mesh-refinement-cpp 9.67372 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 30, 4, 16, 26) mesh-topology-cpp 21.3859 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 30, 4, 16, 48) mesh-unitcube-cpp 22.2561 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 30, 4, 17, 26) mesh-iteration-cpp 35.5267 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 30, 4, 17, 26) function-evaluation-cpp 0.035145 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 30, 4, 19, 25) la-vector-access-cpp 115.791 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 30, 4, 20, 7) la-vector-assignment-cpp 41.4756 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 3, 31, 1, 9, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1344 "BENCH 13.1344" (2015, 3, 31, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0434 "Building point search tree to accelerate distance queries." (2015, 3, 31, 1, 10, 7) geometry-bounding_box_tree_build-cpp 14.0284 "BENCH 14.0284" (2015, 3, 31, 1, 10, 38) common-progress-cpp 31.5462 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 3, 31, 1, 11, 52) common-timing-cpp 73.3037 "Timing access and registration of timings (10000000 repetitions)" (2015, 3, 31, 1, 13, 21) fem-convergence-cpp 3.62996 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 3, 31, 4, 8, 44) fem-speedup-cpp 10522.2 "Assembly/solve speedup running on 4 processors" (2015, 3, 31, 4, 8, 44) fem-speedup-cpp-assembly 6.29657 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 3, 31, 4, 8, 44) fem-speedup-cpp-solve 0.591001 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 3, 31, 4, 8, 55) mesh-refinement-cpp 9.64323 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 3, 31, 4, 9, 16) mesh-topology-cpp 21.4307 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 3, 31, 4, 9, 38) mesh-unitcube-cpp 21.6919 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 3, 31, 4, 10, 19) mesh-iteration-cpp 39.1356 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 3, 31, 4, 10, 19) function-evaluation-cpp 0.0353961 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 3, 31, 4, 12, 14) la-vector-access-cpp 111.431 "Accessing vector of size 10000000 (100 repetitions)" (2015, 3, 31, 4, 12, 55) la-vector-assignment-cpp 40.9787 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 1, 1, 9, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0933 "BENCH 13.0933" (2015, 4, 1, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9485 "Building point search tree to accelerate distance queries." (2015, 4, 1, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.091 "BENCH 14.091" (2015, 4, 1, 1, 10, 34) common-progress-cpp 27.7913 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 1, 1, 11, 47) common-timing-cpp 72.4916 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 1, 1, 13, 16) fem-convergence-cpp 3.63863 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 1, 3, 55, 27) fem-speedup-cpp 9729.53 "Assembly/solve speedup running on 4 processors" (2015, 4, 1, 3, 55, 27) fem-speedup-cpp-assembly 6.36345 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 1, 3, 55, 27) fem-speedup-cpp-solve 0.689531 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 1, 3, 55, 37) mesh-refinement-cpp 9.63922 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 1, 3, 55, 59) mesh-topology-cpp 21.3666 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 1, 3, 56, 20) mesh-unitcube-cpp 21.6769 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 1, 3, 56, 58) mesh-iteration-cpp 35.5269 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 1, 3, 56, 58) function-evaluation-cpp 0.0354221 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 1, 3, 58, 58) la-vector-access-cpp 115.76 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 1, 3, 59, 35) la-vector-assignment-cpp 37.4821 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 2, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3026 "BENCH 13.3026" (2015, 4, 2, 1, 9, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1131 "Building point search tree to accelerate distance queries." (2015, 4, 2, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.1829 "BENCH 14.1829" (2015, 4, 2, 1, 10, 35) common-progress-cpp 27.797 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 2, 1, 11, 47) common-timing-cpp 72.0636 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 2, 1, 13, 18) fem-convergence-cpp 3.64341 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 2, 3, 59, 52) fem-speedup-cpp 9993.54 "Assembly/solve speedup running on 4 processors" (2015, 4, 2, 3, 59, 52) fem-speedup-cpp-assembly 6.25165 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 2, 3, 59, 52) fem-speedup-cpp-solve 0.669682 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 2, 4, 0, 3) mesh-refinement-cpp 9.66889 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 2, 4, 0, 24) mesh-topology-cpp 21.3509 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 2, 4, 0, 46) mesh-unitcube-cpp 21.6824 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 2, 4, 1, 24) mesh-iteration-cpp 35.4969 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 2, 4, 1, 24) function-evaluation-cpp 0.035593 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 2, 4, 3, 20) la-vector-access-cpp 112.476 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 2, 4, 3, 57) la-vector-assignment-cpp 37.5137 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 3, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3462 "BENCH 13.3462" (2015, 4, 3, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9524 "Building point search tree to accelerate distance queries." (2015, 4, 3, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.0217 "BENCH 14.0217" (2015, 4, 3, 1, 10, 38) common-progress-cpp 27.7768 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 3, 1, 11, 51) common-timing-cpp 72.7836 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 3, 1, 13, 21) fem-convergence-cpp 3.66019 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 3, 3, 56, 53) fem-speedup-cpp 9810.88 "Assembly/solve speedup running on 4 processors" (2015, 4, 3, 3, 56, 53) fem-speedup-cpp-assembly 6.71282 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 3, 3, 56, 53) fem-speedup-cpp-solve 0.662128 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 3, 3, 57, 4) mesh-refinement-cpp 9.65438 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 3, 3, 57, 25) mesh-topology-cpp 21.3812 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 3, 3, 57, 47) mesh-unitcube-cpp 21.6871 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 3, 3, 58, 25) mesh-iteration-cpp 35.4898 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 3, 3, 58, 25) function-evaluation-cpp 0.035744 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 3, 4, 0, 22) la-vector-access-cpp 113.908 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 3, 4, 0, 59) la-vector-assignment-cpp 36.4831 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 4, 1, 9, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3173 "BENCH 13.3173" (2015, 4, 4, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9574 "Building point search tree to accelerate distance queries." (2015, 4, 4, 1, 10, 7) geometry-bounding_box_tree_build-cpp 14.1174 "BENCH 14.1174" (2015, 4, 4, 1, 10, 35) common-progress-cpp 27.7887 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 4, 1, 11, 48) common-timing-cpp 73.3024 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 4, 1, 13, 18) fem-convergence-cpp 3.64401 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 4, 4, 17, 38) fem-speedup-cpp 11059.5 "Assembly/solve speedup running on 4 processors" (2015, 4, 4, 4, 17, 38) fem-speedup-cpp-assembly 6.4694 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 4, 4, 17, 38) fem-speedup-cpp-solve 0.568368 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 4, 4, 17, 49) mesh-refinement-cpp 9.61396 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 4, 4, 18, 10) mesh-topology-cpp 21.5116 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 4, 4, 18, 32) mesh-unitcube-cpp 21.7626 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 4, 4, 19, 13) mesh-iteration-cpp 39.1351 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 4, 4, 19, 13) function-evaluation-cpp 0.039237 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 4, 4, 21, 11) la-vector-access-cpp 113.507 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 4, 4, 21, 47) la-vector-assignment-cpp 36.4969 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 5, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3351 "BENCH 13.3351" (2015, 4, 5, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1845 "Building point search tree to accelerate distance queries." (2015, 4, 5, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1159 "BENCH 14.1159" (2015, 4, 5, 1, 10, 38) common-progress-cpp 27.7801 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 5, 1, 11, 51) common-timing-cpp 73.2506 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 5, 1, 13, 21) fem-convergence-cpp 3.62065 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 5, 4, 17, 9) fem-speedup-cpp 11026.8 "Assembly/solve speedup running on 4 processors" (2015, 4, 5, 4, 17, 9) fem-speedup-cpp-assembly 6.48604 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 5, 4, 17, 9) fem-speedup-cpp-solve 0.6979 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 5, 4, 17, 20) mesh-refinement-cpp 9.65171 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 5, 4, 17, 41) mesh-topology-cpp 21.4417 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 5, 4, 18, 3) mesh-unitcube-cpp 21.6716 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 5, 4, 18, 41) mesh-iteration-cpp 35.8234 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 5, 4, 18, 41) function-evaluation-cpp 0.043462 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 5, 4, 20, 39) la-vector-access-cpp 114.277 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 5, 4, 21, 19) la-vector-assignment-cpp 39.4888 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 6, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.7024 "BENCH 13.7024" (2015, 4, 6, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3824 "Building point search tree to accelerate distance queries." (2015, 4, 6, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.0984 "BENCH 14.0984" (2015, 4, 6, 1, 10, 40) common-progress-cpp 27.7735 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 6, 1, 11, 53) common-timing-cpp 72.94 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 6, 1, 13, 23) fem-convergence-cpp 3.63467 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 6, 4, 13, 38) fem-speedup-cpp 10813.9 "Assembly/solve speedup running on 4 processors" (2015, 4, 6, 4, 13, 38) fem-speedup-cpp-assembly 6.73676 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 6, 4, 13, 38) fem-speedup-cpp-solve 0.561516 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 6, 4, 13, 48) mesh-refinement-cpp 9.6234 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 6, 4, 14, 10) mesh-topology-cpp 21.48 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 6, 4, 14, 32) mesh-unitcube-cpp 21.6753 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 6, 4, 15, 9) mesh-iteration-cpp 35.5129 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 6, 4, 15, 9) function-evaluation-cpp 0.0354102 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 6, 4, 17, 7) la-vector-access-cpp 114.335 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 6, 4, 17, 44) la-vector-assignment-cpp 36.4938 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 7, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.4472 "BENCH 13.4472" (2015, 4, 7, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9809 "Building point search tree to accelerate distance queries." (2015, 4, 7, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.0727 "BENCH 14.0727" (2015, 4, 7, 1, 10, 38) common-progress-cpp 27.7865 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 7, 1, 11, 51) common-timing-cpp 73.7367 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 7, 1, 13, 22) fem-convergence-cpp 3.63024 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 7, 4, 4, 0) fem-speedup-cpp 10237 "Assembly/solve speedup running on 4 processors" (2015, 4, 7, 4, 4, 0) fem-speedup-cpp-assembly 6.74871 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 7, 4, 4, 0) fem-speedup-cpp-solve 0.603304 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 7, 4, 4, 10) mesh-refinement-cpp 9.62282 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 7, 4, 4, 32) mesh-topology-cpp 21.4942 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 7, 4, 4, 54) mesh-unitcube-cpp 21.7091 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 7, 4, 5, 31) mesh-iteration-cpp 35.5348 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 7, 4, 5, 31) function-evaluation-cpp 0.0389779 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 7, 4, 7, 29) la-vector-access-cpp 113.439 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 7, 4, 8, 5) la-vector-assignment-cpp 36.521 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 8, 8, 51, 32) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.4379 "BENCH 13.4379" (2015, 4, 8, 8, 51, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0969 "Building point search tree to accelerate distance queries." (2015, 4, 8, 8, 52, 7) geometry-bounding_box_tree_build-cpp 14.1019 "BENCH 14.1019" (2015, 4, 8, 8, 52, 34) common-progress-cpp 27.8402 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 8, 8, 53, 38) common-timing-cpp 63.9655 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 8, 8, 55, 8) fem-convergence-cpp 3.62104 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 8, 10, 36, 5) mesh-refinement-cpp 9.14802 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 8, 10, 36, 26) mesh-topology-cpp 21.238 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 8, 10, 36, 48) mesh-unitcube-cpp 21.6292 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 8, 10, 37, 26) mesh-iteration-cpp 35.4998 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 8, 10, 37, 26) function-evaluation-cpp 0.0352221 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 8, 10, 39, 25) la-vector-access-cpp 116.317 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 8, 10, 40, 2) la-vector-assignment-cpp 36.5087 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 9, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2085 "BENCH 13.2085" (2015, 4, 9, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2299 "Building point search tree to accelerate distance queries." (2015, 4, 9, 1, 10, 14) geometry-bounding_box_tree_build-cpp 13.8995 "BENCH 13.8995" (2015, 4, 9, 1, 10, 42) common-progress-cpp 27.603 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 9, 1, 11, 46) common-timing-cpp 63.9817 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 9, 1, 13, 16) fem-convergence-cpp 3.59788 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 9, 4, 12, 15) fem-speedup-cpp 10738.2 "Assembly/solve speedup running on 4 processors" (2015, 4, 9, 4, 12, 15) fem-speedup-cpp-assembly 6.57987 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 9, 4, 12, 15) fem-speedup-cpp-solve 0.684451 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 9, 4, 12, 25) mesh-refinement-cpp 9.16209 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 9, 4, 12, 46) mesh-topology-cpp 21.382 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 9, 4, 13, 8) mesh-unitcube-cpp 21.8049 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 9, 4, 13, 46) mesh-iteration-cpp 35.519 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 9, 4, 13, 46) function-evaluation-cpp 0.038352 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 9, 4, 15, 44) la-vector-access-cpp 114.303 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 9, 4, 16, 20) la-vector-assignment-cpp 36.4739 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 10, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.591 "BENCH 13.591" (2015, 4, 10, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0553 "Building point search tree to accelerate distance queries." (2015, 4, 10, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1165 "BENCH 14.1165" (2015, 4, 10, 1, 10, 40) common-progress-cpp 27.8776 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 10, 1, 11, 44) common-timing-cpp 64.1436 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 10, 1, 13, 13) fem-convergence-cpp 3.62725 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 10, 4, 1, 21) fem-speedup-cpp 10086.9 "Assembly/solve speedup running on 4 processors" (2015, 4, 10, 4, 1, 21) fem-speedup-cpp-assembly 6.68044 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 10, 4, 1, 21) fem-speedup-cpp-solve 0.666504 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 10, 4, 1, 31) mesh-refinement-cpp 9.17588 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 10, 4, 1, 53) mesh-topology-cpp 21.3396 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 10, 4, 2, 14) mesh-unitcube-cpp 21.653 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 10, 4, 2, 52) mesh-iteration-cpp 35.5009 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 10, 4, 2, 52) function-evaluation-cpp 0.034878 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 10, 4, 4, 54) la-vector-access-cpp 117.761 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 10, 4, 5, 30) la-vector-assignment-cpp 36.4777 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 11, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1601 "BENCH 13.1601" (2015, 4, 11, 1, 9, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0435 "Building point search tree to accelerate distance queries." (2015, 4, 11, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.1495 "BENCH 14.1495" (2015, 4, 11, 1, 10, 35) common-progress-cpp 27.794 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 11, 1, 11, 39) common-timing-cpp 63.4772 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 11, 1, 13, 8) fem-convergence-cpp 3.62251 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 11, 3, 54, 38) fem-speedup-cpp 9689.09 "Assembly/solve speedup running on 4 processors" (2015, 4, 11, 3, 54, 38) fem-speedup-cpp-assembly 6.50448 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 11, 3, 54, 38) fem-speedup-cpp-solve 0.691481 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 11, 3, 54, 48) mesh-refinement-cpp 9.15763 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 11, 3, 55, 9) mesh-topology-cpp 21.2523 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 11, 3, 55, 31) mesh-unitcube-cpp 21.6626 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 11, 3, 56, 9) mesh-iteration-cpp 35.5048 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 11, 3, 56, 9) function-evaluation-cpp 0.040292 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 11, 3, 58, 7) la-vector-access-cpp 114.262 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 11, 3, 58, 43) la-vector-assignment-cpp 36.4692 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 12, 1, 9, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1518 "BENCH 13.1518" (2015, 4, 12, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1155 "Building point search tree to accelerate distance queries." (2015, 4, 12, 1, 10, 9) geometry-bounding_box_tree_build-cpp 14.2739 "BENCH 14.2739" (2015, 4, 12, 1, 10, 37) common-progress-cpp 27.7924 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 12, 1, 11, 41) common-timing-cpp 63.2712 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 12, 1, 13, 11) fem-convergence-cpp 3.61227 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 12, 4, 1, 19) fem-speedup-cpp 10087.4 "Assembly/solve speedup running on 4 processors" (2015, 4, 12, 4, 1, 19) fem-speedup-cpp-assembly 6.72262 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 12, 4, 1, 19) fem-speedup-cpp-solve 0.644347 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 12, 4, 1, 29) mesh-refinement-cpp 9.16893 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 12, 4, 1, 50) mesh-topology-cpp 21.2774 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 12, 4, 2, 12) mesh-unitcube-cpp 21.6701 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 12, 4, 2, 50) mesh-iteration-cpp 35.6816 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 12, 4, 2, 50) function-evaluation-cpp 0.027941 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 12, 4, 4, 49) la-vector-access-cpp 115.838 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 12, 4, 5, 26) la-vector-assignment-cpp 36.4761 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 13, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0692 "BENCH 13.0692" (2015, 4, 13, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0913 "Building point search tree to accelerate distance queries." (2015, 4, 13, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.1144 "BENCH 14.1144" (2015, 4, 13, 1, 10, 39) common-progress-cpp 27.803 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 13, 1, 11, 44) common-timing-cpp 64.9613 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 13, 1, 13, 13) fem-convergence-cpp 3.60443 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 13, 4, 4, 55) fem-speedup-cpp 10301.4 "Assembly/solve speedup running on 4 processors" (2015, 4, 13, 4, 4, 55) fem-speedup-cpp-assembly 6.76648 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 13, 4, 4, 55) fem-speedup-cpp-solve 0.604945 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 13, 4, 5, 5) mesh-refinement-cpp 9.14718 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 13, 4, 5, 27) mesh-topology-cpp 21.3448 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 13, 4, 5, 49) mesh-unitcube-cpp 21.6934 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 13, 4, 6, 26) mesh-iteration-cpp 35.4928 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 13, 4, 6, 26) function-evaluation-cpp 0.038332 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 13, 4, 8, 26) la-vector-access-cpp 115.658 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 13, 4, 9, 5) la-vector-assignment-cpp 39.4667 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 14, 1, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1476 "BENCH 13.1476" (2015, 4, 14, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0144 "Building point search tree to accelerate distance queries." (2015, 4, 14, 1, 10, 13) geometry-bounding_box_tree_build-cpp 14.0995 "BENCH 14.0995" (2015, 4, 14, 1, 10, 40) common-progress-cpp 27.7907 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 14, 1, 11, 44) common-timing-cpp 63.7126 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 14, 1, 13, 14) fem-convergence-cpp 3.6255 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 14, 4, 2, 10) fem-speedup-cpp 10135.6 "Assembly/solve speedup running on 4 processors" (2015, 4, 14, 4, 2, 10) fem-speedup-cpp-assembly 6.46744 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 14, 4, 2, 10) fem-speedup-cpp-solve 0.624507 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 14, 4, 2, 20) mesh-refinement-cpp 9.14568 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 14, 4, 2, 42) mesh-topology-cpp 21.2478 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 14, 4, 3, 3) mesh-unitcube-cpp 21.7618 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 14, 4, 3, 41) mesh-iteration-cpp 35.5299 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 14, 4, 3, 41) function-evaluation-cpp 0.0382171 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 14, 4, 5, 41) la-vector-access-cpp 116.271 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 14, 4, 6, 21) la-vector-assignment-cpp 39.4614 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 15, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2145 "BENCH 13.2145" (2015, 4, 15, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0778 "Building point search tree to accelerate distance queries." (2015, 4, 15, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.203 "BENCH 14.203" (2015, 4, 15, 1, 10, 40) common-progress-cpp 27.8022 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 15, 1, 11, 44) common-timing-cpp 64.3117 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 15, 1, 13, 13) fem-convergence-cpp 3.6242 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 15, 4, 0, 21) fem-speedup-cpp 10026.3 "Assembly/solve speedup running on 4 processors" (2015, 4, 15, 4, 0, 21) fem-speedup-cpp-assembly 6.50696 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 15, 4, 0, 21) fem-speedup-cpp-solve 0.670853 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 15, 4, 0, 31) mesh-refinement-cpp 9.14554 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 15, 4, 0, 52) mesh-topology-cpp 21.2688 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 15, 4, 1, 14) mesh-unitcube-cpp 21.909 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 15, 4, 1, 52) mesh-iteration-cpp 35.4966 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 15, 4, 1, 52) function-evaluation-cpp 0.0349629 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 15, 4, 3, 51) la-vector-access-cpp 115.73 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 15, 4, 4, 29) la-vector-assignment-cpp 37.4664 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 16, 1, 9, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1963 "BENCH 13.1963" (2015, 4, 16, 1, 10, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0939 "Building point search tree to accelerate distance queries." (2015, 4, 16, 1, 10, 16) geometry-bounding_box_tree_build-cpp 14.0298 "BENCH 14.0298" (2015, 4, 16, 1, 10, 44) common-progress-cpp 27.7917 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 16, 1, 11, 49) common-timing-cpp 64.7233 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 16, 1, 13, 18) fem-convergence-cpp 3.61638 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 16, 4, 4, 37) fem-speedup-cpp 10277.5 "Assembly/solve speedup running on 4 processors" (2015, 4, 16, 4, 4, 37) fem-speedup-cpp-assembly 6.38835 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 16, 4, 4, 37) fem-speedup-cpp-solve 0.620408 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 16, 4, 4, 47) mesh-refinement-cpp 9.15574 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 16, 4, 5, 8) mesh-topology-cpp 21.2789 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 16, 4, 5, 30) mesh-unitcube-cpp 21.6483 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 16, 4, 6, 8) mesh-iteration-cpp 35.5066 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 16, 4, 6, 8) function-evaluation-cpp 0.036684 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 16, 4, 8, 7) la-vector-access-cpp 115.594 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 16, 4, 8, 44) la-vector-assignment-cpp 36.4722 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 17, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.4965 "BENCH 13.4965" (2015, 4, 17, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9747 "Building point search tree to accelerate distance queries." (2015, 4, 17, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.0599 "BENCH 14.0599" (2015, 4, 17, 1, 10, 40) common-progress-cpp 27.8042 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 17, 1, 11, 44) common-timing-cpp 64.2935 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 17, 1, 13, 14) fem-convergence-cpp 3.61955 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 17, 4, 11, 15) fem-speedup-cpp 10680.2 "Assembly/solve speedup running on 4 processors" (2015, 4, 17, 4, 11, 15) fem-speedup-cpp-assembly 6.42855 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 17, 4, 11, 15) fem-speedup-cpp-solve 0.6013 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 17, 4, 11, 25) mesh-refinement-cpp 9.15371 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 17, 4, 11, 46) mesh-topology-cpp 21.2584 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 17, 4, 12, 8) mesh-unitcube-cpp 21.6452 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 17, 4, 12, 46) mesh-iteration-cpp 35.5034 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 17, 4, 12, 46) function-evaluation-cpp 0.0376451 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 17, 4, 14, 44) la-vector-access-cpp 114.283 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 17, 4, 15, 20) la-vector-assignment-cpp 36.4755 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 18, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2123 "BENCH 13.2123" (2015, 4, 18, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1565 "Building point search tree to accelerate distance queries." (2015, 4, 18, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.0401 "BENCH 14.0401" (2015, 4, 18, 1, 10, 39) common-progress-cpp 27.8243 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 18, 1, 11, 43) common-timing-cpp 63.9508 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 18, 1, 13, 13) fem-convergence-cpp 3.62749 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 18, 3, 58, 53) fem-speedup-cpp 9939.21 "Assembly/solve speedup running on 4 processors" (2015, 4, 18, 3, 58, 53) fem-speedup-cpp-assembly 6.47647 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 18, 3, 58, 53) fem-speedup-cpp-solve 0.644115 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 18, 3, 59, 3) mesh-refinement-cpp 9.21698 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 18, 3, 59, 24) mesh-topology-cpp 21.27 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 18, 3, 59, 46) mesh-unitcube-cpp 21.6802 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 18, 4, 0, 24) mesh-iteration-cpp 35.4939 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 18, 4, 0, 24) function-evaluation-cpp 0.0358541 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 18, 4, 2, 25) la-vector-access-cpp 117.745 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 18, 4, 3, 2) la-vector-assignment-cpp 36.4757 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 19, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.627 "BENCH 13.627" (2015, 4, 19, 1, 9, 51) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9444 "Building point search tree to accelerate distance queries." (2015, 4, 19, 1, 10, 7) geometry-bounding_box_tree_build-cpp 14.0878 "BENCH 14.0878" (2015, 4, 19, 1, 10, 35) common-progress-cpp 27.7724 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 19, 1, 11, 39) common-timing-cpp 63.8627 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 19, 1, 13, 9) fem-convergence-cpp 3.61193 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 19, 4, 3, 19) fem-speedup-cpp 10209.3 "Assembly/solve speedup running on 4 processors" (2015, 4, 19, 4, 3, 19) fem-speedup-cpp-assembly 6.80954 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 19, 4, 3, 19) fem-speedup-cpp-solve 0.682124 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 19, 4, 3, 29) mesh-refinement-cpp 9.14876 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 19, 4, 3, 50) mesh-topology-cpp 21.3514 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 19, 4, 4, 12) mesh-unitcube-cpp 21.7411 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 19, 4, 4, 50) mesh-iteration-cpp 35.4968 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 19, 4, 4, 50) function-evaluation-cpp 0.0377541 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 19, 4, 6, 48) la-vector-access-cpp 114.255 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 19, 4, 7, 24) la-vector-assignment-cpp 36.4751 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 20, 1, 9, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2428 "BENCH 13.2428" (2015, 4, 20, 1, 9, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0815 "Building point search tree to accelerate distance queries." (2015, 4, 20, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.1582 "BENCH 14.1582" (2015, 4, 20, 1, 10, 33) common-progress-cpp 27.7913 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 20, 1, 11, 37) common-timing-cpp 63.8659 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 20, 1, 13, 6) fem-convergence-cpp 3.60441 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 20, 4, 7, 33) fem-speedup-cpp 10465.1 "Assembly/solve speedup running on 4 processors" (2015, 4, 20, 4, 7, 33) fem-speedup-cpp-assembly 6.36324 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 20, 4, 7, 33) fem-speedup-cpp-solve 0.621485 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 20, 4, 7, 43) mesh-refinement-cpp 9.17669 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 20, 4, 8, 4) mesh-topology-cpp 21.2291 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 20, 4, 8, 26) mesh-unitcube-cpp 21.8095 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 20, 4, 9, 4) mesh-iteration-cpp 35.5152 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 20, 4, 9, 4) function-evaluation-cpp 0.03426 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 20, 4, 11, 2) la-vector-access-cpp 114.294 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 20, 4, 11, 41) la-vector-assignment-cpp 39.4686 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 21, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3882 "BENCH 13.3882" (2015, 4, 21, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0361 "Building point search tree to accelerate distance queries." (2015, 4, 21, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.076 "BENCH 14.076" (2015, 4, 21, 1, 10, 43) common-progress-cpp 27.7929 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 21, 1, 11, 46) common-timing-cpp 63.906 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 21, 1, 13, 16) fem-convergence-cpp 3.61848 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 21, 4, 6, 48) fem-speedup-cpp 10410.6 "Assembly/solve speedup running on 4 processors" (2015, 4, 21, 4, 6, 48) fem-speedup-cpp-assembly 6.67826 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 21, 4, 6, 48) fem-speedup-cpp-solve 0.607917 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 21, 4, 6, 58) mesh-refinement-cpp 9.27125 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 21, 4, 6, 59) mesh-topology-cpp 1.33654 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 21, 4, 7, 22) mesh-unitcube-cpp 22.1842 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 21, 4, 8, 0) mesh-iteration-cpp 35.7457 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 21, 4, 8, 0) function-evaluation-cpp 0.037791 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 21, 4, 9, 59) la-vector-access-cpp 115.772 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 21, 4, 10, 35) la-vector-assignment-cpp 35.9818 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 22, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1908 "BENCH 13.1908" (2015, 4, 22, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1477 "Building point search tree to accelerate distance queries." (2015, 4, 22, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1099 "BENCH 14.1099" (2015, 4, 22, 1, 10, 40) common-progress-cpp 27.7906 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 22, 1, 11, 43) common-timing-cpp 63.213 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 22, 1, 13, 13) fem-convergence-cpp 3.62069 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 22, 4, 4, 9) fem-speedup-cpp 10254.9 "Assembly/solve speedup running on 4 processors" (2015, 4, 22, 4, 4, 9) fem-speedup-cpp-assembly 6.41021 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 22, 4, 4, 9) fem-speedup-cpp-solve 0.640712 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 22, 4, 4, 19) mesh-refinement-cpp 9.20264 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 22, 4, 4, 20) mesh-topology-cpp 1.33284 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 22, 4, 4, 42) mesh-unitcube-cpp 22.1166 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 22, 4, 5, 20) mesh-iteration-cpp 35.478 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 22, 4, 5, 20) function-evaluation-cpp 0.037667 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 22, 4, 7, 20) la-vector-access-cpp 116.28 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 22, 4, 7, 56) la-vector-assignment-cpp 35.9827 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 23, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2766 "BENCH 13.2766" (2015, 4, 23, 1, 9, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8697 "Building point search tree to accelerate distance queries." (2015, 4, 23, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.0791 "BENCH 14.0791" (2015, 4, 23, 1, 10, 43) common-progress-cpp 27.7834 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 23, 1, 11, 47) common-timing-cpp 63.9912 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 23, 1, 13, 17) fem-convergence-cpp 3.63087 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 23, 4, 3, 36) fem-speedup-cpp 10218.8 "Assembly/solve speedup running on 4 processors" (2015, 4, 23, 4, 3, 36) fem-speedup-cpp-assembly 6.49663 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 23, 4, 3, 36) fem-speedup-cpp-solve 0.617887 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 23, 4, 3, 47) mesh-refinement-cpp 9.21024 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 23, 4, 3, 48) mesh-topology-cpp 1.33339 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 23, 4, 4, 10) mesh-unitcube-cpp 22.1295 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 23, 4, 4, 56) mesh-iteration-cpp 44.1427 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 23, 4, 4, 57) function-evaluation-cpp 0.034364 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 23, 4, 6, 54) la-vector-access-cpp 114.239 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 23, 4, 7, 30) la-vector-assignment-cpp 35.9838 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 24, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.127 "BENCH 13.127" (2015, 4, 24, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0772 "Building point search tree to accelerate distance queries." (2015, 4, 24, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.2133 "BENCH 14.2133" (2015, 4, 24, 1, 10, 43) common-progress-cpp 27.7949 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 24, 1, 11, 46) common-timing-cpp 63.2649 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 24, 1, 13, 15) fem-convergence-cpp 3.62138 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 24, 4, 8, 10) fem-speedup-cpp 10494.4 "Assembly/solve speedup running on 4 processors" (2015, 4, 24, 4, 8, 10) fem-speedup-cpp-assembly 6.82869 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 24, 4, 8, 10) fem-speedup-cpp-solve 0.609111 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 24, 4, 8, 20) mesh-refinement-cpp 9.2111 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 24, 4, 8, 22) mesh-topology-cpp 1.33133 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 24, 4, 8, 44) mesh-unitcube-cpp 22.1796 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 24, 4, 9, 22) mesh-iteration-cpp 35.528 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 24, 4, 9, 22) function-evaluation-cpp 0.0352299 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 24, 4, 11, 20) la-vector-access-cpp 114.317 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 24, 4, 11, 56) la-vector-assignment-cpp 35.9852 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 25, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1298 "BENCH 13.1298" (2015, 4, 25, 1, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 14.985 "Building point search tree to accelerate distance queries." (2015, 4, 25, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.0954 "BENCH 14.0954" (2015, 4, 25, 1, 10, 36) common-progress-cpp 27.7815 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 25, 1, 11, 41) common-timing-cpp 64.7918 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 25, 1, 13, 10) fem-convergence-cpp 3.62762 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 25, 4, 5, 20) fem-speedup-cpp 10329 "Assembly/solve speedup running on 4 processors" (2015, 4, 25, 4, 5, 20) fem-speedup-cpp-assembly 6.47005 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 25, 4, 5, 20) fem-speedup-cpp-solve 0.627884 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 25, 4, 5, 30) mesh-refinement-cpp 9.18892 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 25, 4, 5, 32) mesh-topology-cpp 1.33027 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 25, 4, 5, 54) mesh-unitcube-cpp 22.1017 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 25, 4, 6, 32) mesh-iteration-cpp 35.5081 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 25, 4, 6, 32) function-evaluation-cpp 0.0343881 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 25, 4, 8, 29) la-vector-access-cpp 114.288 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 25, 4, 9, 5) la-vector-assignment-cpp 35.9791 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 26, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.4863 "BENCH 13.4863" (2015, 4, 26, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3225 "Building point search tree to accelerate distance queries." (2015, 4, 26, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1405 "BENCH 14.1405" (2015, 4, 26, 1, 10, 38) common-progress-cpp 27.7882 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 26, 1, 11, 41) common-timing-cpp 63.6421 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 26, 1, 13, 11) fem-convergence-cpp 3.62832 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 26, 4, 3, 40) fem-speedup-cpp 10227.6 "Assembly/solve speedup running on 4 processors" (2015, 4, 26, 4, 3, 40) fem-speedup-cpp-assembly 6.39645 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 26, 4, 3, 40) fem-speedup-cpp-solve 0.719526 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 26, 4, 3, 49) mesh-refinement-cpp 9.22817 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 26, 4, 3, 51) mesh-topology-cpp 1.33867 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 26, 4, 4, 13) mesh-unitcube-cpp 22.4204 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 26, 4, 4, 51) mesh-iteration-cpp 35.5024 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 26, 4, 4, 51) function-evaluation-cpp 0.034106 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 26, 4, 6, 51) la-vector-access-cpp 115.84 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 26, 4, 7, 27) la-vector-assignment-cpp 36.0699 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 27, 1, 9, 30) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1501 "BENCH 13.1501" (2015, 4, 27, 1, 9, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1377 "Building point search tree to accelerate distance queries." (2015, 4, 27, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.2875 "BENCH 14.2875" (2015, 4, 27, 1, 10, 33) common-progress-cpp 27.8033 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 27, 1, 11, 39) common-timing-cpp 65.2472 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 27, 1, 13, 8) fem-convergence-cpp 3.6252 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 27, 4, 15, 43) fem-speedup-cpp 10954.2 "Assembly/solve speedup running on 4 processors" (2015, 4, 27, 4, 15, 43) fem-speedup-cpp-assembly 6.44218 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 27, 4, 15, 43) fem-speedup-cpp-solve 0.601751 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 27, 4, 15, 53) mesh-refinement-cpp 9.24067 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 27, 4, 15, 55) mesh-topology-cpp 1.33275 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 27, 4, 16, 17) mesh-unitcube-cpp 22.193 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 27, 4, 16, 55) mesh-iteration-cpp 35.5279 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 27, 4, 16, 55) function-evaluation-cpp 0.034445 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 27, 4, 18, 53) la-vector-access-cpp 114.263 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 27, 4, 19, 29) la-vector-assignment-cpp 35.9776 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 28, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1393 "BENCH 13.1393" (2015, 4, 28, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9272 "Building point search tree to accelerate distance queries." (2015, 4, 28, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.1232 "BENCH 14.1232" (2015, 4, 28, 1, 10, 42) common-progress-cpp 27.799 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 28, 1, 11, 47) common-timing-cpp 64.3191 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 28, 1, 13, 16) fem-convergence-cpp 3.61657 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 28, 4, 10, 39) fem-speedup-cpp 10642.3 "Assembly/solve speedup running on 4 processors" (2015, 4, 28, 4, 10, 39) fem-speedup-cpp-assembly 6.51455 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 28, 4, 10, 39) fem-speedup-cpp-solve 0.595347 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 28, 4, 10, 49) mesh-refinement-cpp 9.32179 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 28, 4, 10, 51) mesh-topology-cpp 1.33548 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 28, 4, 11, 13) mesh-unitcube-cpp 22.1749 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 28, 4, 11, 51) mesh-iteration-cpp 35.5042 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 28, 4, 11, 51) function-evaluation-cpp 0.0343492 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 28, 4, 13, 48) la-vector-access-cpp 114.03 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 28, 4, 14, 27) la-vector-assignment-cpp 38.9139 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 29, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3096 "BENCH 13.3096" (2015, 4, 29, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2465 "Building point search tree to accelerate distance queries." (2015, 4, 29, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.0984 "BENCH 14.0984" (2015, 4, 29, 1, 10, 39) common-progress-cpp 27.9258 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 29, 1, 11, 45) common-timing-cpp 65.6278 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 29, 1, 13, 14) fem-convergence-cpp 3.6139 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 29, 4, 16, 38) fem-speedup-cpp 11002.8 "Assembly/solve speedup running on 4 processors" (2015, 4, 29, 4, 16, 38) fem-speedup-cpp-assembly 6.41102 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 29, 4, 16, 38) fem-speedup-cpp-solve 0.601815 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 29, 4, 16, 48) mesh-refinement-cpp 9.24805 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 29, 4, 16, 49) mesh-topology-cpp 1.3351 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 29, 4, 17, 12) mesh-unitcube-cpp 22.1454 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 29, 4, 17, 49) mesh-iteration-cpp 35.5179 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 29, 4, 17, 49) function-evaluation-cpp 0.037694 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 29, 4, 19, 49) la-vector-access-cpp 115.809 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 29, 4, 20, 25) la-vector-assignment-cpp 35.9823 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 4, 30, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.252 "BENCH 13.252" (2015, 4, 30, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1466 "Building point search tree to accelerate distance queries." (2015, 4, 30, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1009 "BENCH 14.1009" (2015, 4, 30, 1, 10, 40) common-progress-cpp 27.7946 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 4, 30, 1, 11, 44) common-timing-cpp 63.8807 "Timing access and registration of timings (10000000 repetitions)" (2015, 4, 30, 1, 13, 13) fem-convergence-cpp 3.62591 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 4, 30, 4, 2, 49) fem-speedup-cpp 10174.9 "Assembly/solve speedup running on 4 processors" (2015, 4, 30, 4, 2, 49) fem-speedup-cpp-assembly 6.70051 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 4, 30, 4, 2, 49) fem-speedup-cpp-solve 0.658303 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 4, 30, 4, 2, 59) mesh-refinement-cpp 9.26497 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 4, 30, 4, 3, 1) mesh-topology-cpp 1.33582 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 4, 30, 4, 3, 23) mesh-unitcube-cpp 22.1691 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 4, 30, 4, 4, 4) mesh-iteration-cpp 39.1205 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 4, 30, 4, 4, 4) function-evaluation-cpp 0.0377491 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 4, 30, 4, 6, 4) la-vector-access-cpp 115.655 "Accessing vector of size 10000000 (100 repetitions)" (2015, 4, 30, 4, 6, 40) la-vector-assignment-cpp 35.9795 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 1, 1, 9, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3916 "BENCH 13.3916" (2015, 5, 1, 1, 10, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1031 "Building point search tree to accelerate distance queries." (2015, 5, 1, 1, 10, 18) geometry-bounding_box_tree_build-cpp 14.1213 "BENCH 14.1213" (2015, 5, 1, 1, 10, 45) common-progress-cpp 27.7879 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 1, 1, 11, 50) common-timing-cpp 64.2198 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 1, 1, 13, 19) fem-convergence-cpp 3.60775 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 1, 4, 8, 18) fem-speedup-cpp 10497.6 "Assembly/solve speedup running on 4 processors" (2015, 5, 1, 4, 8, 18) fem-speedup-cpp-assembly 6.75316 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 1, 4, 8, 18) fem-speedup-cpp-solve 0.666971 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 1, 4, 8, 28) mesh-refinement-cpp 9.23515 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 1, 4, 8, 29) mesh-topology-cpp 1.33692 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 1, 4, 8, 52) mesh-unitcube-cpp 22.2531 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 1, 4, 9, 29) mesh-iteration-cpp 35.5034 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 1, 4, 9, 29) function-evaluation-cpp 0.0350571 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 1, 4, 11, 27) la-vector-access-cpp 114.075 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 1, 4, 12, 3) la-vector-assignment-cpp 35.9778 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 2, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3049 "BENCH 13.3049" (2015, 5, 2, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9532 "Building point search tree to accelerate distance queries." (2015, 5, 2, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1583 "BENCH 14.1583" (2015, 5, 2, 1, 10, 38) common-progress-cpp 27.7897 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 2, 1, 11, 41) common-timing-cpp 63.6705 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 2, 1, 13, 11) fem-convergence-cpp 3.61901 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 2, 4, 8, 9) fem-speedup-cpp 10497.3 "Assembly/solve speedup running on 4 processors" (2015, 5, 2, 4, 8, 9) fem-speedup-cpp-assembly 6.68014 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 2, 4, 8, 9) fem-speedup-cpp-solve 0.705326 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 2, 4, 8, 19) mesh-refinement-cpp 9.19727 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 2, 4, 8, 21) mesh-topology-cpp 1.33485 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 2, 4, 8, 43) mesh-unitcube-cpp 22.1784 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 2, 4, 9, 24) mesh-iteration-cpp 39.1313 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 2, 4, 9, 24) function-evaluation-cpp 0.0362399 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 2, 4, 11, 20) la-vector-access-cpp 111.887 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 2, 4, 11, 56) la-vector-assignment-cpp 35.9775 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 3, 1, 9, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1809 "BENCH 13.1809" (2015, 5, 3, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3801 "Building point search tree to accelerate distance queries." (2015, 5, 3, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.2466 "BENCH 14.2466" (2015, 5, 3, 1, 10, 34) common-progress-cpp 27.812 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 3, 1, 11, 38) common-timing-cpp 63.3593 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 3, 1, 13, 7) fem-convergence-cpp 3.62116 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 3, 4, 7, 44) fem-speedup-cpp 10475.5 "Assembly/solve speedup running on 4 processors" (2015, 5, 3, 4, 7, 44) fem-speedup-cpp-assembly 6.44249 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 3, 4, 7, 44) fem-speedup-cpp-solve 0.638994 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 3, 4, 7, 54) mesh-refinement-cpp 9.18968 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 3, 4, 7, 55) mesh-topology-cpp 1.33324 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 3, 4, 8, 18) mesh-unitcube-cpp 22.145 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 3, 4, 8, 55) mesh-iteration-cpp 35.501 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 3, 4, 8, 55) function-evaluation-cpp 0.031553 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 3, 4, 10, 53) la-vector-access-cpp 113.882 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 3, 4, 11, 29) la-vector-assignment-cpp 35.9921 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 4, 1, 9, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1769 "BENCH 13.1769" (2015, 5, 4, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3681 "Building point search tree to accelerate distance queries." (2015, 5, 4, 1, 10, 9) geometry-bounding_box_tree_build-cpp 14.1525 "BENCH 14.1525" (2015, 5, 4, 1, 10, 37) common-progress-cpp 27.8031 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 4, 1, 11, 41) common-timing-cpp 63.7817 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 4, 1, 13, 10) fem-convergence-cpp 3.61341 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 4, 4, 3, 28) fem-speedup-cpp 10217.1 "Assembly/solve speedup running on 4 processors" (2015, 5, 4, 4, 3, 28) fem-speedup-cpp-assembly 6.49471 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 4, 4, 3, 28) fem-speedup-cpp-solve 0.667914 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 4, 4, 3, 38) mesh-refinement-cpp 9.19906 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 4, 4, 3, 40) mesh-topology-cpp 1.32894 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 4, 4, 4, 2) mesh-unitcube-cpp 22.1444 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 4, 4, 4, 40) mesh-iteration-cpp 35.5155 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 4, 4, 4, 40) function-evaluation-cpp 0.0600781 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 4, 4, 6, 39) la-vector-access-cpp 115.701 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 4, 4, 7, 15) la-vector-assignment-cpp 35.9845 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 5, 1, 9, 33) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2422 "BENCH 13.2422" (2015, 5, 5, 1, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3069 "Building point search tree to accelerate distance queries." (2015, 5, 5, 1, 10, 8) geometry-bounding_box_tree_build-cpp 14.218 "BENCH 14.218" (2015, 5, 5, 1, 10, 36) common-progress-cpp 27.8013 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 5, 1, 11, 39) common-timing-cpp 63.501 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 5, 1, 13, 9) fem-convergence-cpp 3.60328 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 5, 4, 11, 29) fem-speedup-cpp 10699.2 "Assembly/solve speedup running on 4 processors" (2015, 5, 5, 4, 11, 29) fem-speedup-cpp-assembly 6.72412 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 5, 4, 11, 29) fem-speedup-cpp-solve 0.595569 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 5, 4, 11, 39) mesh-refinement-cpp 9.21576 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 5, 4, 11, 40) mesh-topology-cpp 1.33347 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 5, 4, 12, 3) mesh-unitcube-cpp 22.1891 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 5, 4, 12, 40) mesh-iteration-cpp 35.5179 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 5, 4, 12, 40) function-evaluation-cpp 0.026839 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 5, 4, 14, 40) la-vector-access-cpp 115.823 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 5, 4, 15, 16) la-vector-assignment-cpp 35.9849 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 6, 1, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1269 "BENCH 13.1269" (2015, 5, 6, 1, 9, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1539 "Building point search tree to accelerate distance queries." (2015, 5, 6, 1, 10, 13) geometry-bounding_box_tree_build-cpp 14.1364 "BENCH 14.1364" (2015, 5, 6, 1, 10, 41) common-progress-cpp 27.7964 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 6, 1, 11, 46) common-timing-cpp 64.7608 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 6, 1, 13, 15) fem-convergence-cpp 3.6169 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 6, 4, 1, 22) fem-speedup-cpp 10086.1 "Assembly/solve speedup running on 4 processors" (2015, 5, 6, 4, 1, 22) fem-speedup-cpp-assembly 6.7631 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 6, 4, 1, 22) fem-speedup-cpp-solve 0.651919 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 6, 4, 1, 33) mesh-refinement-cpp 9.19839 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 6, 4, 1, 34) mesh-topology-cpp 1.32919 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 6, 4, 1, 56) mesh-unitcube-cpp 22.1314 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 6, 4, 2, 38) mesh-iteration-cpp 39.1986 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 6, 4, 2, 38) function-evaluation-cpp 0.031312 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 6, 4, 4, 37) la-vector-access-cpp 115.724 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 6, 4, 5, 13) la-vector-assignment-cpp 35.978 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 7, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.286 "BENCH 13.286" (2015, 5, 7, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0032 "Building point search tree to accelerate distance queries." (2015, 5, 7, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1178 "BENCH 14.1178" (2015, 5, 7, 1, 10, 39) common-progress-cpp 27.822 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 7, 1, 11, 44) common-timing-cpp 64.5017 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 7, 1, 13, 14) fem-convergence-cpp 3.62513 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 7, 4, 2, 53) fem-speedup-cpp 10178 "Assembly/solve speedup running on 4 processors" (2015, 5, 7, 4, 2, 53) fem-speedup-cpp-assembly 6.3487 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 7, 4, 2, 53) fem-speedup-cpp-solve 0.640873 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 7, 4, 3, 3) mesh-refinement-cpp 9.19681 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 7, 4, 3, 4) mesh-topology-cpp 1.33526 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 7, 4, 3, 27) mesh-unitcube-cpp 22.2315 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 7, 4, 4, 5) mesh-iteration-cpp 35.4977 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 7, 4, 4, 5) function-evaluation-cpp 0.0313361 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 7, 4, 6, 4) la-vector-access-cpp 115.598 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 7, 4, 6, 40) la-vector-assignment-cpp 35.9767 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 8, 1, 9, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.333 "BENCH 13.333" (2015, 5, 8, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9318 "Building point search tree to accelerate distance queries." (2015, 5, 8, 1, 10, 9) geometry-bounding_box_tree_build-cpp 14.1801 "BENCH 14.1801" (2015, 5, 8, 1, 10, 37) common-progress-cpp 27.7838 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 8, 1, 11, 41) common-timing-cpp 64.1077 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 8, 1, 13, 11) fem-convergence-cpp 3.61972 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 8, 4, 28, 53) fem-speedup-cpp 11740.7 "Assembly/solve speedup running on 4 processors" (2015, 5, 8, 4, 28, 53) fem-speedup-cpp-assembly 6.38319 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 8, 4, 28, 53) fem-speedup-cpp-solve 0.643348 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 8, 4, 29, 3) mesh-refinement-cpp 9.44242 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 8, 4, 29, 5) mesh-topology-cpp 1.36346 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 8, 4, 29, 27) mesh-unitcube-cpp 22.5659 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 8, 4, 30, 7) mesh-iteration-cpp 37.1618 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 8, 4, 30, 7) function-evaluation-cpp 0.0418441 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 8, 4, 32, 9) la-vector-access-cpp 118.361 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 8, 4, 32, 45) la-vector-assignment-cpp 35.9868 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 9, 1, 9, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.105 "BENCH 13.105" (2015, 5, 9, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9785 "Building point search tree to accelerate distance queries." (2015, 5, 9, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.0586 "BENCH 14.0586" (2015, 5, 9, 1, 10, 34) common-progress-cpp 27.7846 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 9, 1, 11, 41) common-timing-cpp 66.9516 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 9, 1, 13, 10) fem-convergence-cpp 3.59804 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 9, 4, 26, 47) fem-speedup-cpp 11616 "Assembly/solve speedup running on 4 processors" (2015, 5, 9, 4, 26, 47) fem-speedup-cpp-assembly 6.35108 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 9, 4, 26, 47) fem-speedup-cpp-solve 0.65702 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 9, 4, 26, 57) mesh-refinement-cpp 9.24196 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 9, 4, 26, 58) mesh-topology-cpp 1.33529 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 9, 4, 27, 21) mesh-unitcube-cpp 22.2079 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 9, 4, 27, 59) mesh-iteration-cpp 35.7816 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 9, 4, 27, 59) function-evaluation-cpp 0.0350521 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 9, 4, 30, 0) la-vector-access-cpp 117.742 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 9, 4, 30, 40) la-vector-assignment-cpp 39.4738 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 10, 1, 9, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0942 "BENCH 13.0942" (2015, 5, 10, 1, 9, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2329 "Building point search tree to accelerate distance queries." (2015, 5, 10, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.1026 "BENCH 14.1026" (2015, 5, 10, 1, 10, 34) common-progress-cpp 27.7957 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 10, 1, 11, 39) common-timing-cpp 65.1618 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 10, 1, 13, 8) fem-convergence-cpp 3.60671 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 10, 4, 22, 17) fem-speedup-cpp 11348.2 "Assembly/solve speedup running on 4 processors" (2015, 5, 10, 4, 22, 17) fem-speedup-cpp-assembly 6.35993 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 10, 4, 22, 17) fem-speedup-cpp-solve 0.569338 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 10, 4, 22, 27) mesh-refinement-cpp 9.22262 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 10, 4, 22, 29) mesh-topology-cpp 1.34306 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 10, 4, 22, 51) mesh-unitcube-cpp 22.2386 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 10, 4, 23, 29) mesh-iteration-cpp 35.5047 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 10, 4, 23, 29) function-evaluation-cpp 0.0395811 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 10, 4, 25, 27) la-vector-access-cpp 114.359 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 10, 4, 26, 3) la-vector-assignment-cpp 35.9801 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 11, 1, 9, 31) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2812 "BENCH 13.2812" (2015, 5, 11, 1, 9, 50) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8705 "Building point search tree to accelerate distance queries." (2015, 5, 11, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.1654 "BENCH 14.1654" (2015, 5, 11, 1, 10, 34) common-progress-cpp 27.804 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 11, 1, 11, 37) common-timing-cpp 63.5965 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 11, 1, 13, 7) fem-convergence-cpp 3.60635 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 11, 3, 58, 6) fem-speedup-cpp 9897.63 "Assembly/solve speedup running on 4 processors" (2015, 5, 11, 3, 58, 6) fem-speedup-cpp-assembly 6.65418 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 11, 3, 58, 6) fem-speedup-cpp-solve 0.658484 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 11, 3, 58, 16) mesh-refinement-cpp 9.25455 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 11, 3, 58, 17) mesh-topology-cpp 1.33601 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 11, 3, 58, 39) mesh-unitcube-cpp 22.1975 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 11, 3, 59, 17) mesh-iteration-cpp 35.5126 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 11, 3, 59, 17) function-evaluation-cpp 0.035089 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 11, 4, 1, 16) la-vector-access-cpp 115.574 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 11, 4, 1, 56) la-vector-assignment-cpp 39.4618 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 12, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1916 "BENCH 13.1916" (2015, 5, 12, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1956 "Building point search tree to accelerate distance queries." (2015, 5, 12, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.1227 "BENCH 14.1227" (2015, 5, 12, 1, 10, 39) common-progress-cpp 27.7881 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 12, 1, 11, 42) common-timing-cpp 63.7534 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 12, 1, 13, 12) fem-convergence-cpp 3.62458 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 12, 3, 59, 17) fem-speedup-cpp 9964.21 "Assembly/solve speedup running on 4 processors" (2015, 5, 12, 3, 59, 17) fem-speedup-cpp-assembly 6.47625 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 12, 3, 59, 17) fem-speedup-cpp-solve 0.674075 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 12, 3, 59, 27) mesh-refinement-cpp 9.19405 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 12, 3, 59, 29) mesh-topology-cpp 1.33516 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 12, 3, 59, 51) mesh-unitcube-cpp 22.3238 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 12, 4, 0, 29) mesh-iteration-cpp 35.4929 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 12, 4, 0, 29) function-evaluation-cpp 0.027689 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 12, 4, 2, 24) la-vector-access-cpp 111.853 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 12, 4, 3, 0) la-vector-assignment-cpp 35.9819 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 13, 1, 9, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.02 "BENCH 13.02" (2015, 5, 13, 1, 10, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8263 "Building point search tree to accelerate distance queries." (2015, 5, 13, 1, 10, 17) geometry-bounding_box_tree_build-cpp 14.1537 "BENCH 14.1537" (2015, 5, 13, 1, 10, 45) common-progress-cpp 27.8072 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 13, 1, 11, 49) common-timing-cpp 63.9778 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 13, 1, 13, 18) fem-convergence-cpp 3.60392 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 13, 3, 59, 56) fem-speedup-cpp 9996.21 "Assembly/solve speedup running on 4 processors" (2015, 5, 13, 3, 59, 56) fem-speedup-cpp-assembly 6.56391 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 13, 3, 59, 56) fem-speedup-cpp-solve 0.656601 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 13, 4, 0, 5) mesh-refinement-cpp 9.10503 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 13, 4, 0, 7) mesh-topology-cpp 1.32504 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 13, 4, 0, 29) mesh-unitcube-cpp 21.6359 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 13, 4, 1, 6) mesh-iteration-cpp 35.4939 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 13, 4, 1, 6) function-evaluation-cpp 0.0445838 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 13, 4, 3, 6) la-vector-access-cpp 115.737 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 13, 4, 3, 42) la-vector-assignment-cpp 36.4723 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 14, 1, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0821 "BENCH 13.0821" (2015, 5, 14, 1, 9, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2316 "Building point search tree to accelerate distance queries." (2015, 5, 14, 1, 10, 13) geometry-bounding_box_tree_build-cpp 14.1653 "BENCH 14.1653" (2015, 5, 14, 1, 10, 41) common-progress-cpp 27.7959 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 14, 1, 11, 45) common-timing-cpp 63.74 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 14, 1, 13, 15) fem-convergence-cpp 3.62163 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 14, 4, 1, 19) fem-speedup-cpp 10082.7 "Assembly/solve speedup running on 4 processors" (2015, 5, 14, 4, 1, 19) fem-speedup-cpp-assembly 6.46595 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 14, 4, 1, 19) fem-speedup-cpp-solve 0.68896 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 14, 4, 1, 29) mesh-refinement-cpp 9.19429 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 14, 4, 1, 30) mesh-topology-cpp 1.3294 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 14, 4, 1, 53) mesh-unitcube-cpp 22.502 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 14, 4, 2, 39) mesh-iteration-cpp 44.1367 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 14, 4, 2, 39) function-evaluation-cpp 0.0368998 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 14, 4, 4, 39) la-vector-access-cpp 116.073 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 14, 4, 5, 15) la-vector-assignment-cpp 35.4609 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 15, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0923 "BENCH 13.0923" (2015, 5, 15, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.492 "Building point search tree to accelerate distance queries." (2015, 5, 15, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1569 "BENCH 14.1569" (2015, 5, 15, 1, 10, 38) common-progress-cpp 27.8163 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 15, 1, 11, 41) common-timing-cpp 62.9399 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 15, 1, 13, 11) fem-convergence-cpp 3.61412 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 15, 4, 6, 19) fem-speedup-cpp 10387.3 "Assembly/solve speedup running on 4 processors" (2015, 5, 15, 4, 6, 19) fem-speedup-cpp-assembly 6.58943 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 15, 4, 6, 19) fem-speedup-cpp-solve 0.649473 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 15, 4, 6, 29) mesh-refinement-cpp 9.21166 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 15, 4, 6, 31) mesh-topology-cpp 1.33391 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 15, 4, 6, 53) mesh-unitcube-cpp 22.2499 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 15, 4, 7, 31) mesh-iteration-cpp 35.5015 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 15, 4, 7, 31) function-evaluation-cpp 0.0313599 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 15, 4, 9, 33) la-vector-access-cpp 118.372 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 15, 4, 10, 8) la-vector-assignment-cpp 35.48 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 16, 1, 9, 30) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1017 "BENCH 13.1017" (2015, 5, 16, 1, 9, 49) geometry-bounding_box_tree_compute_closest_entity-cpp 15.422 "Building point search tree to accelerate distance queries." (2015, 5, 16, 1, 10, 6) geometry-bounding_box_tree_build-cpp 14.2061 "BENCH 14.2061" (2015, 5, 16, 1, 10, 33) common-progress-cpp 27.7992 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 16, 1, 11, 37) common-timing-cpp 63.5072 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 16, 1, 13, 6) fem-convergence-cpp 3.62827 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 16, 4, 2, 32) fem-speedup-cpp 10164.6 "Assembly/solve speedup running on 4 processors" (2015, 5, 16, 4, 2, 32) fem-speedup-cpp-assembly 6.68347 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 16, 4, 2, 32) fem-speedup-cpp-solve 0.644706 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 16, 4, 2, 42) mesh-refinement-cpp 9.18675 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 16, 4, 2, 43) mesh-topology-cpp 1.33247 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 16, 4, 3, 6) mesh-unitcube-cpp 22.2515 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 16, 4, 3, 43) mesh-iteration-cpp 35.4869 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 16, 4, 3, 43) function-evaluation-cpp 0.0528982 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 16, 4, 5, 43) la-vector-access-cpp 116.065 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 16, 4, 6, 17) la-vector-assignment-cpp 33.4704 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 17, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0692 "BENCH 13.0692" (2015, 5, 17, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2863 "Building point search tree to accelerate distance queries." (2015, 5, 17, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1382 "BENCH 14.1382" (2015, 5, 17, 1, 10, 39) common-progress-cpp 27.792 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 17, 1, 11, 43) common-timing-cpp 63.3082 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 17, 1, 13, 12) fem-convergence-cpp 3.63546 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 17, 4, 7, 57) fem-speedup-cpp 10484.1 "Assembly/solve speedup running on 4 processors" (2015, 5, 17, 4, 7, 57) fem-speedup-cpp-assembly 6.72715 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 17, 4, 7, 57) fem-speedup-cpp-solve 0.604418 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 17, 4, 8, 7) mesh-refinement-cpp 9.19743 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 17, 4, 8, 9) mesh-topology-cpp 1.33812 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 17, 4, 8, 31) mesh-unitcube-cpp 22.3097 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 17, 4, 9, 9) mesh-iteration-cpp 35.5041 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 17, 4, 9, 9) function-evaluation-cpp 0.031534 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 17, 4, 11, 9) la-vector-access-cpp 116.337 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 17, 4, 11, 42) la-vector-assignment-cpp 33.471 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 18, 1, 9, 37) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2006 "BENCH 13.2006" (2015, 5, 18, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3881 "Building point search tree to accelerate distance queries." (2015, 5, 18, 1, 10, 12) geometry-bounding_box_tree_build-cpp 14.1302 "BENCH 14.1302" (2015, 5, 18, 1, 10, 40) common-progress-cpp 27.788 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 18, 1, 11, 43) common-timing-cpp 63.1407 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 18, 1, 13, 13) fem-convergence-cpp 3.62292 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 18, 3, 52, 56) fem-speedup-cpp 9581.63 "Assembly/solve speedup running on 4 processors" (2015, 5, 18, 3, 52, 56) fem-speedup-cpp-assembly 6.64952 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 18, 3, 52, 56) fem-speedup-cpp-solve 0.712101 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 18, 3, 53, 6) mesh-refinement-cpp 9.18237 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 18, 3, 53, 7) mesh-topology-cpp 1.33161 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 18, 3, 53, 29) mesh-unitcube-cpp 22.2909 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 18, 3, 54, 7) mesh-iteration-cpp 35.4651 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 18, 3, 54, 7) function-evaluation-cpp 0.044569 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 18, 3, 56, 11) la-vector-access-cpp 119.75 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 18, 3, 56, 46) la-vector-assignment-cpp 34.9184 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 19, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1062 "BENCH 13.1062" (2015, 5, 19, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2652 "Building point search tree to accelerate distance queries." (2015, 5, 19, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.0972 "BENCH 14.0972" (2015, 5, 19, 1, 10, 38) common-progress-cpp 27.7832 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 19, 1, 11, 41) common-timing-cpp 63.0396 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 19, 1, 13, 10) fem-convergence-cpp 3.62534 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 19, 4, 2, 54) fem-speedup-cpp 10182.9 "Assembly/solve speedup running on 4 processors" (2015, 5, 19, 4, 2, 54) fem-speedup-cpp-assembly 6.47302 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 19, 4, 2, 54) fem-speedup-cpp-solve 0.648827 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 19, 4, 3, 4) mesh-refinement-cpp 9.17086 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 19, 4, 3, 5) mesh-topology-cpp 1.33115 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 19, 4, 3, 28) mesh-unitcube-cpp 22.2405 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 19, 4, 4, 5) mesh-iteration-cpp 35.4968 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 19, 4, 4, 5) function-evaluation-cpp 0.031419 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 19, 4, 6, 7) la-vector-access-cpp 118.27 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 19, 4, 6, 41) la-vector-assignment-cpp 33.4779 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 20, 1, 9, 41) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2799 "BENCH 13.2799" (2015, 5, 20, 1, 10, 0) geometry-bounding_box_tree_compute_closest_entity-cpp 15.4288 "Building point search tree to accelerate distance queries." (2015, 5, 20, 1, 10, 16) geometry-bounding_box_tree_build-cpp 14.0988 "BENCH 14.0988" (2015, 5, 20, 1, 10, 44) common-progress-cpp 27.7831 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 20, 1, 11, 47) common-timing-cpp 63.5677 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 20, 1, 13, 17) fem-convergence-cpp 3.63273 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 20, 4, 16, 38) fem-speedup-cpp 10999.7 "Assembly/solve speedup running on 4 processors" (2015, 5, 20, 4, 16, 38) fem-speedup-cpp-assembly 6.71979 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 20, 4, 16, 38) fem-speedup-cpp-solve 0.564518 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 20, 4, 16, 48) mesh-refinement-cpp 9.19663 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 20, 4, 16, 49) mesh-topology-cpp 1.33903 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 20, 4, 17, 11) mesh-unitcube-cpp 22.3058 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 20, 4, 17, 49) mesh-iteration-cpp 35.4981 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 20, 4, 17, 49) function-evaluation-cpp 0.0400188 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 20, 4, 19, 53) la-vector-access-cpp 119.831 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 20, 4, 20, 26) la-vector-assignment-cpp 33.4705 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 21, 1, 9, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0793 "BENCH 13.0793" (2015, 5, 21, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3295 "Building point search tree to accelerate distance queries." (2015, 5, 21, 1, 10, 14) geometry-bounding_box_tree_build-cpp 14.0527 "BENCH 14.0527" (2015, 5, 21, 1, 10, 42) common-progress-cpp 27.8197 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 21, 1, 11, 46) common-timing-cpp 63.7731 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 21, 1, 13, 15) fem-convergence-cpp 3.6158 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 21, 3, 59, 44) fem-speedup-cpp 9987.67 "Assembly/solve speedup running on 4 processors" (2015, 5, 21, 3, 59, 44) fem-speedup-cpp-assembly 6.64901 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 21, 3, 59, 44) fem-speedup-cpp-solve 0.65516 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 21, 3, 59, 54) mesh-refinement-cpp 9.2202 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 21, 3, 59, 56) mesh-topology-cpp 1.33504 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 21, 4, 0, 18) mesh-unitcube-cpp 22.2203 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 21, 4, 0, 56) mesh-iteration-cpp 35.4997 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 21, 4, 0, 56) function-evaluation-cpp 0.0396161 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 21, 4, 2, 59) la-vector-access-cpp 119.638 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 21, 4, 3, 35) la-vector-assignment-cpp 35.4622 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 22, 1, 9, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.073 "BENCH 13.073" (2015, 5, 22, 1, 9, 58) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2407 "Building point search tree to accelerate distance queries." (2015, 5, 22, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.1881 "BENCH 14.1881" (2015, 5, 22, 1, 10, 46) common-progress-cpp 31.5631 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 22, 1, 11, 50) common-timing-cpp 63.6722 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 22, 1, 13, 19) fem-convergence-cpp 3.61861 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 22, 4, 6, 22) fem-speedup-cpp 10381.3 "Assembly/solve speedup running on 4 processors" (2015, 5, 22, 4, 6, 22) fem-speedup-cpp-assembly 6.23963 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 22, 4, 6, 22) fem-speedup-cpp-solve 0.719185 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 22, 4, 6, 32) mesh-refinement-cpp 9.18518 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 22, 4, 6, 33) mesh-topology-cpp 1.32972 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 22, 4, 6, 55) mesh-unitcube-cpp 22.2147 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 22, 4, 7, 33) mesh-iteration-cpp 35.4962 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 22, 4, 7, 33) function-evaluation-cpp 0.039968 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 22, 4, 9, 33) la-vector-access-cpp 116.303 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 22, 4, 10, 7) la-vector-assignment-cpp 33.4661 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 23, 1, 9, 38) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.054 "BENCH 13.054" (2015, 5, 23, 1, 9, 56) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0558 "Building point search tree to accelerate distance queries." (2015, 5, 23, 1, 10, 13) geometry-bounding_box_tree_build-cpp 14.1691 "BENCH 14.1691" (2015, 5, 23, 1, 10, 41) common-progress-cpp 27.813 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 23, 1, 11, 44) common-timing-cpp 63.3912 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 23, 1, 13, 15) fem-convergence-cpp 3.63453 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 23, 4, 13, 47) fem-speedup-cpp 10830.8 "Assembly/solve speedup running on 4 processors" (2015, 5, 23, 4, 13, 47) fem-speedup-cpp-assembly 6.77954 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 23, 4, 13, 47) fem-speedup-cpp-solve 0.571426 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 23, 4, 13, 57) mesh-refinement-cpp 9.18243 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 23, 4, 13, 58) mesh-topology-cpp 1.33325 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 23, 4, 14, 20) mesh-unitcube-cpp 22.1584 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 23, 4, 15, 2) mesh-iteration-cpp 39.1656 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 23, 4, 15, 2) function-evaluation-cpp 0.0401371 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 23, 4, 17, 1) la-vector-access-cpp 115.794 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 23, 4, 17, 35) la-vector-assignment-cpp 33.6034 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 24, 1, 9, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2301 "BENCH 13.2301" (2015, 5, 24, 1, 9, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.13 "Building point search tree to accelerate distance queries." (2015, 5, 24, 1, 10, 14) geometry-bounding_box_tree_build-cpp 14.115 "BENCH 14.115" (2015, 5, 24, 1, 10, 42) common-progress-cpp 27.79 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 24, 1, 11, 46) common-timing-cpp 64.323 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 24, 1, 13, 16) fem-convergence-cpp 3.63862 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 24, 4, 2, 25) fem-speedup-cpp 10148 "Assembly/solve speedup running on 4 processors" (2015, 5, 24, 4, 2, 25) fem-speedup-cpp-assembly 6.47607 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 24, 4, 2, 25) fem-speedup-cpp-solve 0.65411 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 24, 4, 2, 35) mesh-refinement-cpp 9.1844 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 24, 4, 2, 36) mesh-topology-cpp 1.33284 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 24, 4, 2, 59) mesh-unitcube-cpp 22.1717 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 24, 4, 3, 36) mesh-iteration-cpp 35.5782 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 24, 4, 3, 37) function-evaluation-cpp 0.039763 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 24, 4, 5, 31) la-vector-access-cpp 110.339 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 24, 4, 6, 4) la-vector-assignment-cpp 33.6123 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 25, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1317 "BENCH 13.1317" (2015, 5, 25, 1, 9, 55) geometry-bounding_box_tree_compute_closest_entity-cpp 15.062 "Building point search tree to accelerate distance queries." (2015, 5, 25, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.131 "BENCH 14.131" (2015, 5, 25, 1, 10, 39) common-progress-cpp 27.7945 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 25, 1, 11, 43) common-timing-cpp 64.102 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 25, 1, 13, 13) fem-convergence-cpp 3.64034 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 25, 3, 56, 42) fem-speedup-cpp 9808.74 "Assembly/solve speedup running on 4 processors" (2015, 5, 25, 3, 56, 42) fem-speedup-cpp-assembly 6.46907 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 25, 3, 56, 42) fem-speedup-cpp-solve 0.692098 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 25, 3, 56, 52) mesh-refinement-cpp 9.18119 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 25, 3, 56, 54) mesh-topology-cpp 1.33201 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 25, 3, 57, 16) mesh-unitcube-cpp 22.1656 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 25, 3, 57, 54) mesh-iteration-cpp 35.4964 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 25, 3, 57, 54) function-evaluation-cpp 0.0395319 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 25, 3, 59, 53) la-vector-access-cpp 115.678 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 25, 4, 0, 27) la-vector-assignment-cpp 33.5344 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 26, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1692 "BENCH 13.1692" (2015, 5, 26, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1991 "Building point search tree to accelerate distance queries." (2015, 5, 26, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1592 "BENCH 14.1592" (2015, 5, 26, 1, 10, 38) common-progress-cpp 27.7909 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 26, 1, 11, 43) common-timing-cpp 64.5831 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 26, 1, 13, 12) fem-convergence-cpp 3.63471 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 26, 4, 5, 44) fem-speedup-cpp 10351 "Assembly/solve speedup running on 4 processors" (2015, 5, 26, 4, 5, 44) fem-speedup-cpp-assembly 6.65164 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 26, 4, 5, 44) fem-speedup-cpp-solve 0.626458 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 26, 4, 5, 54) mesh-refinement-cpp 9.17867 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 26, 4, 5, 56) mesh-topology-cpp 1.33212 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 26, 4, 6, 18) mesh-unitcube-cpp 22.1565 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 26, 4, 6, 56) mesh-iteration-cpp 35.4959 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 26, 4, 6, 56) function-evaluation-cpp 0.0400879 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 26, 4, 8, 53) la-vector-access-cpp 113.925 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 26, 4, 9, 29) la-vector-assignment-cpp 35.4713 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 27, 1, 9, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1039 "BENCH 13.1039" (2015, 5, 27, 1, 9, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9967 "Building point search tree to accelerate distance queries." (2015, 5, 27, 1, 10, 14) geometry-bounding_box_tree_build-cpp 14.1639 "BENCH 14.1639" (2015, 5, 27, 1, 10, 41) common-progress-cpp 27.8088 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 27, 1, 11, 45) common-timing-cpp 63.7079 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 27, 1, 13, 15) fem-convergence-cpp 3.64222 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 27, 4, 11, 44) fem-speedup-cpp 10708.3 "Assembly/solve speedup running on 4 processors" (2015, 5, 27, 4, 11, 44) fem-speedup-cpp-assembly 6.75209 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 27, 4, 11, 44) fem-speedup-cpp-solve 0.59584 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 27, 4, 11, 54) mesh-refinement-cpp 9.18061 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 27, 4, 11, 56) mesh-topology-cpp 1.33289 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 27, 4, 12, 18) mesh-unitcube-cpp 22.1645 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 27, 4, 12, 56) mesh-iteration-cpp 36.0776 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 27, 4, 12, 56) function-evaluation-cpp 0.034977 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 27, 4, 14, 50) la-vector-access-cpp 110.33 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 27, 4, 15, 24) la-vector-assignment-cpp 33.4631 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 28, 1, 9, 34) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1549 "BENCH 13.1549" (2015, 5, 28, 1, 9, 52) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2985 "Building point search tree to accelerate distance queries." (2015, 5, 28, 1, 10, 9) geometry-bounding_box_tree_build-cpp 14.0955 "BENCH 14.0955" (2015, 5, 28, 1, 10, 37) common-progress-cpp 27.7823 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 28, 1, 11, 40) common-timing-cpp 63.1981 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 28, 1, 13, 9) fem-convergence-cpp 3.62635 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 28, 4, 6, 53) fem-speedup-cpp 10422.7 "Assembly/solve speedup running on 4 processors" (2015, 5, 28, 4, 6, 53) fem-speedup-cpp-assembly 6.37557 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 28, 4, 6, 53) fem-speedup-cpp-solve 0.61855 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 28, 4, 7, 3) mesh-refinement-cpp 9.17186 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 28, 4, 7, 4) mesh-topology-cpp 1.33146 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 28, 4, 7, 26) mesh-unitcube-cpp 22.1993 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 28, 4, 8, 6) mesh-iteration-cpp 37.6185 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 28, 4, 8, 6) function-evaluation-cpp 0.059747 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 28, 4, 10, 2) la-vector-access-cpp 111.832 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 28, 4, 10, 38) la-vector-assignment-cpp 35.5461 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 29, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1965 "BENCH 13.1965" (2015, 5, 29, 1, 9, 53) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0843 "Building point search tree to accelerate distance queries." (2015, 5, 29, 1, 10, 10) geometry-bounding_box_tree_build-cpp 14.1967 "BENCH 14.1967" (2015, 5, 29, 1, 10, 38) common-progress-cpp 27.791 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 29, 1, 11, 42) common-timing-cpp 63.8591 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 29, 1, 13, 12) fem-convergence-cpp 3.62871 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 29, 4, 2, 30) fem-speedup-cpp 10157 "Assembly/solve speedup running on 4 processors" (2015, 5, 29, 4, 2, 30) fem-speedup-cpp-assembly 6.54513 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 29, 4, 2, 30) fem-speedup-cpp-solve 0.644168 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 29, 4, 2, 40) mesh-refinement-cpp 9.20834 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 29, 4, 2, 41) mesh-topology-cpp 1.33024 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 29, 4, 3, 3) mesh-unitcube-cpp 22.2337 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 29, 4, 3, 41) mesh-iteration-cpp 35.4975 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 29, 4, 3, 41) function-evaluation-cpp 0.035125 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 29, 4, 5, 37) la-vector-access-cpp 111.849 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 29, 4, 6, 9) la-vector-assignment-cpp 32.4764 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 30, 1, 9, 40) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0537 "BENCH 13.0537" (2015, 5, 30, 1, 9, 59) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1262 "Building point search tree to accelerate distance queries." (2015, 5, 30, 1, 10, 15) geometry-bounding_box_tree_build-cpp 14.0357 "BENCH 14.0357" (2015, 5, 30, 1, 10, 43) common-progress-cpp 27.7927 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 30, 1, 11, 47) common-timing-cpp 63.96 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 30, 1, 13, 16) fem-convergence-cpp 3.62078 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 30, 4, 12, 55) fem-speedup-cpp 10777.1 "Assembly/solve speedup running on 4 processors" (2015, 5, 30, 4, 12, 55) fem-speedup-cpp-assembly 6.46509 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 30, 4, 12, 55) fem-speedup-cpp-solve 0.601104 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 30, 4, 13, 52) mesh-refinement-cpp 56.5105 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 30, 4, 13, 53) mesh-topology-cpp 1.33562 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 30, 4, 14, 16) mesh-unitcube-cpp 22.2629 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 30, 4, 14, 53) mesh-iteration-cpp 35.4927 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 30, 4, 14, 53) function-evaluation-cpp 0.0350139 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 30, 4, 16, 51) la-vector-access-cpp 114.147 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 30, 4, 17, 24) la-vector-assignment-cpp 32.5975 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 5, 31, 1, 9, 35) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9543 "BENCH 12.9543" (2015, 5, 31, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3911 "Building point search tree to accelerate distance queries." (2015, 5, 31, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.2107 "BENCH 14.2107" (2015, 5, 31, 1, 10, 38) common-progress-cpp 27.7872 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 5, 31, 1, 11, 42) common-timing-cpp 63.805 "Timing access and registration of timings (10000000 repetitions)" (2015, 5, 31, 1, 13, 11) fem-convergence-cpp 3.63784 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 5, 31, 3, 59, 30) fem-speedup-cpp 9977.87 "Assembly/solve speedup running on 4 processors" (2015, 5, 31, 3, 59, 30) fem-speedup-cpp-assembly 6.60786 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 5, 31, 3, 59, 30) fem-speedup-cpp-solve 0.633574 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 5, 31, 4, 0, 28) mesh-refinement-cpp 56.5378 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 5, 31, 4, 0, 29) mesh-topology-cpp 1.33151 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 5, 31, 4, 0, 52) mesh-unitcube-cpp 22.2179 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 5, 31, 4, 1, 29) mesh-iteration-cpp 35.5112 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 5, 31, 4, 1, 29) function-evaluation-cpp 0.034982 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 5, 31, 4, 3, 29) la-vector-access-cpp 115.709 "Accessing vector of size 10000000 (100 repetitions)" (2015, 5, 31, 4, 4, 4) la-vector-assignment-cpp 35.4738 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 6, 1, 1, 9, 36) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9724 "BENCH 12.9724" (2015, 6, 1, 1, 9, 54) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0399 "Building point search tree to accelerate distance queries." (2015, 6, 1, 1, 10, 11) geometry-bounding_box_tree_build-cpp 14.1122 "BENCH 14.1122" (2015, 6, 1, 1, 10, 39) common-progress-cpp 27.7921 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 6, 1, 1, 11, 43) common-timing-cpp 64.17 "Timing access and registration of timings (10000000 repetitions)" (2015, 6, 1, 1, 13, 13) fem-convergence-cpp 3.62823 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 6, 1, 4, 18, 25) fem-speedup-cpp 11110.8 "Assembly/solve speedup running on 4 processors" (2015, 6, 1, 4, 18, 25) fem-speedup-cpp-assembly 6.45291 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 6, 1, 4, 18, 25) fem-speedup-cpp-solve 0.653592 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 6, 1, 4, 19, 22) mesh-refinement-cpp 56.6729 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 6, 1, 4, 19, 23) mesh-topology-cpp 1.33115 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 6, 1, 4, 19, 46) mesh-unitcube-cpp 22.1575 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 6, 1, 4, 20, 23) mesh-iteration-cpp 35.5269 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 6, 1, 4, 20, 23) function-evaluation-cpp 0.0316911 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 6, 1, 4, 22, 23) la-vector-access-cpp 115.753 "Accessing vector of size 10000000 (100 repetitions)" (2015, 6, 1, 4, 22, 56) la-vector-assignment-cpp 32.4727 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 6, 2, 1, 9, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1557 "BENCH 13.1557" (2015, 6, 2, 1, 10, 18) geometry-bounding_box_tree_compute_closest_entity-cpp 16.1171 "Building point search tree to accelerate distance queries." (2015, 6, 2, 1, 10, 34) geometry-bounding_box_tree_build-cpp 14.2383 "BENCH 14.2383" (2015, 6, 2, 1, 11, 2) common-progress-cpp 27.7828 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 6, 2, 1, 12, 6) common-timing-cpp 63.9632 "Timing access and registration of timings (10000000 repetitions)" (2015, 6, 2, 1, 13, 36) fem-convergence-cpp 3.62058 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 6, 2, 4, 13, 18) fem-speedup-cpp 10781.5 "Assembly/solve speedup running on 4 processors" (2015, 6, 2, 4, 13, 18) fem-speedup-cpp-assembly 6.43249 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 6, 2, 4, 13, 18) fem-speedup-cpp-solve 0.636069 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 6, 2, 4, 14, 16) mesh-refinement-cpp 56.3707 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 6, 2, 4, 14, 17) mesh-topology-cpp 1.33689 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 6, 2, 4, 14, 39) mesh-unitcube-cpp 22.1904 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 6, 2, 4, 15, 17) mesh-iteration-cpp 35.5202 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 6, 2, 4, 15, 17) function-evaluation-cpp 0.0351071 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 6, 2, 4, 17, 15) la-vector-access-cpp 114.035 "Accessing vector of size 10000000 (100 repetitions)" (2015, 6, 2, 4, 17, 51) la-vector-assignment-cpp 35.9738 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 1, 8, 23, 11) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.868 "BENCH 13.868" (2015, 10, 1, 8, 23, 29) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8265 "Building point search tree to accelerate distance queries." (2015, 10, 1, 8, 23, 46) geometry-bounding_box_tree_build-cpp 14.1841 "BENCH 14.1841" (2015, 10, 1, 8, 24, 13) common-progress-cpp 27.6473 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 1, 8, 25, 21) common-timing-cpp 67.3676 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 1, 10, 37, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8858 "BENCH 12.8858" (2015, 10, 1, 10, 37, 48) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9127 "Building point search tree to accelerate distance queries." (2015, 10, 1, 10, 38, 4) geometry-bounding_box_tree_build-cpp 14.1632 "BENCH 14.1632" (2015, 10, 1, 10, 38, 32) common-progress-cpp 27.8573 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 1, 10, 39, 38) common-timing-cpp 66.1329 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 1, 10, 41, 10) fem-convergence-cpp 3.65488 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 1, 14, 31, 51) fem-speedup-cpp 13838.4 "Assembly/solve speedup running on 4 processors" (2015, 10, 1, 14, 31, 51) fem-speedup-cpp-assembly 6.47118 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 1, 14, 31, 51) fem-speedup-cpp-solve 1.32891 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 1, 14, 32, 43) mesh-refinement-cpp 51.0654 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 1, 14, 32, 45) mesh-topology-cpp 1.36636 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 1, 14, 33, 6) mesh-unitcube-cpp 21.6493 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 1, 14, 33, 52) mesh-iteration-cpp 43.5068 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 1, 14, 33, 52) function-evaluation-cpp 0.083353 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 1, 14, 36, 9) la-vector-access-cpp 132.079 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 1, 14, 36, 45) la-vector-assignment-cpp 35.959 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 2, 1, 10, 48) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9539 "BENCH 12.9539" (2015, 10, 2, 1, 11, 7) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1559 "Building point search tree to accelerate distance queries." (2015, 10, 2, 1, 11, 23) geometry-bounding_box_tree_build-cpp 13.9152 "BENCH 13.9152" (2015, 10, 2, 1, 11, 51) common-progress-cpp 27.6401 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 2, 1, 12, 57) common-timing-cpp 66.1957 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 2, 1, 14, 30) fem-convergence-cpp 3.62948 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 2, 4, 26, 53) fem-speedup-cpp 11542.3 "Assembly/solve speedup running on 4 processors" (2015, 10, 2, 4, 26, 53) fem-speedup-cpp-assembly 6.73345 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 2, 4, 26, 53) fem-speedup-cpp-solve 1.04887 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 2, 4, 27, 45) mesh-refinement-cpp 50.458 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 2, 4, 27, 46) mesh-topology-cpp 1.37204 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 2, 4, 28, 8) mesh-unitcube-cpp 21.7509 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 2, 4, 28, 46) mesh-iteration-cpp 35.5101 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 2, 4, 28, 46) function-evaluation-cpp 0.0834799 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 2, 4, 31, 3) la-vector-access-cpp 132.962 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 2, 4, 31, 43) la-vector-assignment-cpp 40.0095 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 3, 1, 10, 43) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0063 "BENCH 13.0063" (2015, 10, 3, 1, 11, 1) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9672 "Building point search tree to accelerate distance queries." (2015, 10, 3, 1, 11, 18) geometry-bounding_box_tree_build-cpp 14.2761 "BENCH 14.2761" (2015, 10, 3, 1, 11, 46) common-progress-cpp 28.0115 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 3, 1, 12, 52) common-timing-cpp 66.4155 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 3, 1, 14, 25) fem-convergence-cpp 3.64651 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 3, 4, 22, 1) fem-speedup-cpp 11255.5 "Assembly/solve speedup running on 4 processors" (2015, 10, 3, 4, 22, 1) fem-speedup-cpp-assembly 6.39372 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 3, 4, 22, 1) fem-speedup-cpp-solve 1.1077 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 3, 4, 22, 46) mesh-refinement-cpp 43.5946 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 3, 4, 22, 47) mesh-topology-cpp 1.37345 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 3, 4, 23, 9) mesh-unitcube-cpp 22.0839 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 3, 4, 23, 47) mesh-iteration-cpp 35.4531 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 3, 4, 23, 47) function-evaluation-cpp 0.0834908 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 3, 4, 26, 4) la-vector-access-cpp 133.166 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 3, 4, 26, 41) la-vector-assignment-cpp 36.5269 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 4, 1, 10, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9048 "BENCH 12.9048" (2015, 10, 4, 1, 10, 43) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0772 "Building point search tree to accelerate distance queries." (2015, 10, 4, 1, 10, 59) geometry-bounding_box_tree_build-cpp 14.1211 "BENCH 14.1211" (2015, 10, 4, 1, 11, 27) common-progress-cpp 27.9925 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 4, 1, 12, 34) common-timing-cpp 66.6978 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 4, 1, 14, 9) fem-convergence-cpp 3.68284 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 4, 4, 58, 46) fem-speedup-cpp 13476.3 "Assembly/solve speedup running on 4 processors" (2015, 10, 4, 4, 58, 46) fem-speedup-cpp-assembly 6.43066 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 4, 4, 58, 46) fem-speedup-cpp-solve 0.997223 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 4, 4, 59, 34) mesh-refinement-cpp 45.6495 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 4, 4, 59, 35) mesh-topology-cpp 1.51458 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 4, 4, 59, 59) mesh-unitcube-cpp 23.458 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 4, 5, 0, 38) mesh-iteration-cpp 36.9863 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 4, 5, 0, 39) function-evaluation-cpp 0.127343 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 4, 5, 2, 53) la-vector-access-cpp 130.734 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 4, 5, 3, 27) la-vector-assignment-cpp 33.5224 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 5, 1, 10, 25) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9663 "BENCH 12.9663" (2015, 10, 5, 1, 10, 44) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0519 "Building point search tree to accelerate distance queries." (2015, 10, 5, 1, 11, 1) geometry-bounding_box_tree_build-cpp 14.354 "BENCH 14.354" (2015, 10, 5, 1, 11, 28) common-progress-cpp 27.9373 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 5, 1, 12, 35) common-timing-cpp 66.2193 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 5, 1, 14, 6) fem-convergence-cpp 3.64699 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 5, 4, 36, 36) fem-speedup-cpp 12149.2 "Assembly/solve speedup running on 4 processors" (2015, 10, 5, 4, 36, 36) fem-speedup-cpp-assembly 6.46818 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 5, 4, 36, 36) fem-speedup-cpp-solve 1.08054 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 5, 4, 37, 21) mesh-refinement-cpp 43.9704 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 5, 4, 37, 23) mesh-topology-cpp 1.37521 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 5, 4, 37, 45) mesh-unitcube-cpp 22.0812 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 5, 4, 38, 31) mesh-iteration-cpp 43.5028 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 5, 4, 38, 31) function-evaluation-cpp 0.083483 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 5, 4, 40, 44) la-vector-access-cpp 129.096 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 5, 4, 41, 20) la-vector-assignment-cpp 36.0117 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 6, 1, 10, 39) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8688 "BENCH 12.8688" (2015, 10, 6, 1, 10, 57) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0222 "Building point search tree to accelerate distance queries." (2015, 10, 6, 1, 11, 14) geometry-bounding_box_tree_build-cpp 14.2543 "BENCH 14.2543" (2015, 10, 6, 1, 11, 42) common-progress-cpp 27.9561 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 6, 1, 12, 47) common-timing-cpp 65.4735 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 6, 1, 12, 57) fem-convergence-cpp 3.66275 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 6, 4, 25, 53) fem-speedup-cpp 11575.4 "Assembly/solve speedup running on 4 processors" (2015, 10, 6, 4, 25, 53) fem-speedup-cpp-assembly 6.50386 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 6, 4, 25, 53) fem-speedup-cpp-solve 1.04638 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 6, 4, 26, 38) mesh-refinement-cpp 44.2493 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 6, 4, 26, 40) mesh-topology-cpp 1.38087 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 6, 4, 27, 2) mesh-unitcube-cpp 22.1959 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 6, 4, 27, 48) mesh-iteration-cpp 43.5135 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 6, 4, 27, 48) function-evaluation-cpp 0.0779641 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 6, 4, 30, 5) la-vector-access-cpp 133.52 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 6, 4, 30, 38) la-vector-assignment-cpp 32.5162 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 7, 1, 10, 46) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.3652 "BENCH 13.3652" (2015, 10, 7, 1, 11, 4) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8993 "Building point search tree to accelerate distance queries." (2015, 10, 7, 1, 11, 21) geometry-bounding_box_tree_build-cpp 14.2974 "BENCH 14.2974" (2015, 10, 7, 1, 11, 48) common-progress-cpp 27.9534 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 7, 1, 12, 57) common-timing-cpp 68.9611 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 7, 1, 13, 7) fem-convergence-cpp 3.67022 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 7, 4, 30, 46) fem-speedup-cpp 11857.9 "Assembly/solve speedup running on 4 processors" (2015, 10, 7, 4, 30, 46) fem-speedup-cpp-assembly 6.39553 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 7, 4, 30, 46) fem-speedup-cpp-solve 1.03566 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 7, 4, 31, 30) mesh-refinement-cpp 43.3144 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 7, 4, 31, 32) mesh-topology-cpp 1.36764 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 7, 4, 31, 53) mesh-unitcube-cpp 21.5323 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 7, 4, 32, 31) mesh-iteration-cpp 35.5022 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 7, 4, 32, 31) function-evaluation-cpp 0.0777099 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 7, 4, 35, 2) la-vector-access-cpp 146.528 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 7, 4, 35, 36) la-vector-assignment-cpp 33.7382 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 8, 1, 10, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0246 "BENCH 13.0246" (2015, 10, 8, 1, 10, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1043 "Building point search tree to accelerate distance queries." (2015, 10, 8, 1, 10, 58) geometry-bounding_box_tree_build-cpp 14.1725 "BENCH 14.1725" (2015, 10, 8, 1, 11, 26) common-progress-cpp 27.957 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 8, 1, 12, 33) common-timing-cpp 67.3633 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 8, 1, 12, 43) fem-convergence-cpp 3.67977 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 8, 3, 55, 4) fem-speedup-cpp 9739.89 "Assembly/solve speedup running on 4 processors" (2015, 10, 8, 3, 55, 4) fem-speedup-cpp-assembly 6.41048 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 8, 3, 55, 4) fem-speedup-cpp-solve 1.06121 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 8, 3, 55, 48) mesh-refinement-cpp 43.3083 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 8, 3, 55, 50) mesh-topology-cpp 1.36514 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 8, 3, 56, 11) mesh-unitcube-cpp 21.3923 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 8, 3, 56, 57) mesh-iteration-cpp 43.505 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 8, 3, 56, 57) function-evaluation-cpp 0.077934 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 8, 3, 59, 26) la-vector-access-cpp 144.975 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 8, 4, 0, 0) la-vector-assignment-cpp 33.4515 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 9, 1, 10, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.2625 "BENCH 13.2625" (2015, 10, 9, 1, 10, 41) geometry-bounding_box_tree_compute_closest_entity-cpp 15.2746 "Building point search tree to accelerate distance queries." (2015, 10, 9, 1, 10, 58) geometry-bounding_box_tree_build-cpp 14.1672 "BENCH 14.1672" (2015, 10, 9, 1, 11, 26) common-progress-cpp 28.0114 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 9, 1, 12, 35) common-timing-cpp 68.7436 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 9, 1, 12, 44) fem-convergence-cpp 3.66727 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 9, 4, 6, 7) fem-speedup-cpp 10401.6 "Assembly/solve speedup running on 4 processors" (2015, 10, 9, 4, 6, 7) fem-speedup-cpp-assembly 6.4454 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 9, 4, 6, 7) fem-speedup-cpp-solve 1.05344 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 9, 4, 6, 52) mesh-refinement-cpp 43.4011 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 9, 4, 6, 53) mesh-topology-cpp 1.36247 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 9, 4, 7, 15) mesh-unitcube-cpp 21.497 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 9, 4, 7, 52) mesh-iteration-cpp 35.5042 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 9, 4, 7, 52) function-evaluation-cpp 0.078007 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 9, 4, 10, 20) la-vector-access-cpp 143.893 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 9, 4, 10, 54) la-vector-assignment-cpp 33.4507 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 10, 1, 10, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0096 "BENCH 13.0096" (2015, 10, 10, 1, 11, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 14.972 "Building point search tree to accelerate distance queries." (2015, 10, 10, 1, 11, 32) geometry-bounding_box_tree_build-cpp 14.181 "BENCH 14.181" (2015, 10, 10, 1, 12, 0) common-progress-cpp 27.9524 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 10, 1, 13, 6) common-timing-cpp 65.9889 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 10, 1, 13, 16) fem-convergence-cpp 3.64206 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 10, 4, 29, 14) fem-speedup-cpp 11757.2 "Assembly/solve speedup running on 4 processors" (2015, 10, 10, 4, 29, 14) fem-speedup-cpp-assembly 6.36321 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 10, 4, 29, 14) fem-speedup-cpp-solve 0.956146 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 10, 4, 29, 58) mesh-refinement-cpp 43.3836 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 10, 4, 30, 0) mesh-topology-cpp 1.36694 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 10, 4, 30, 21) mesh-unitcube-cpp 21.4641 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 10, 4, 31, 3) mesh-iteration-cpp 39.1195 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 10, 4, 31, 3) function-evaluation-cpp 0.0777721 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 10, 4, 33, 31) la-vector-access-cpp 144.298 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 10, 4, 34, 9) la-vector-assignment-cpp 37.4541 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 11, 1, 10, 22) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9928 "BENCH 12.9928" (2015, 10, 11, 1, 10, 41) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8762 "Building point search tree to accelerate distance queries." (2015, 10, 11, 1, 10, 57) geometry-bounding_box_tree_build-cpp 14.1424 "BENCH 14.1424" (2015, 10, 11, 1, 11, 25) common-progress-cpp 27.9932 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 11, 1, 12, 33) common-timing-cpp 68.2888 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 11, 1, 12, 43) fem-convergence-cpp 3.67741 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 11, 4, 26, 34) fem-speedup-cpp 11629.3 "Assembly/solve speedup running on 4 processors" (2015, 10, 11, 4, 26, 34) fem-speedup-cpp-assembly 6.27018 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 11, 4, 26, 34) fem-speedup-cpp-solve 1.05243 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 11, 4, 27, 18) mesh-refinement-cpp 43.6719 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 11, 4, 27, 20) mesh-topology-cpp 1.37007 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 11, 4, 27, 41) mesh-unitcube-cpp 21.6116 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 11, 4, 28, 19) mesh-iteration-cpp 35.5123 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 11, 4, 28, 19) function-evaluation-cpp 0.0778549 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 11, 4, 30, 48) la-vector-access-cpp 144.523 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 11, 4, 31, 21) la-vector-assignment-cpp 33.4478 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 12, 1, 10, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.217 "BENCH 13.217" (2015, 10, 12, 1, 10, 41) geometry-bounding_box_tree_compute_closest_entity-cpp 15.0076 "Building point search tree to accelerate distance queries." (2015, 10, 12, 1, 10, 58) geometry-bounding_box_tree_build-cpp 14.2142 "BENCH 14.2142" (2015, 10, 12, 1, 11, 31) common-progress-cpp 32.9442 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 12, 1, 12, 38) common-timing-cpp 66.8853 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 12, 1, 12, 47) fem-convergence-cpp 3.68608 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 12, 4, 10, 57) fem-speedup-cpp 10688.6 "Assembly/solve speedup running on 4 processors" (2015, 10, 12, 4, 10, 57) fem-speedup-cpp-assembly 6.31784 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 12, 4, 10, 57) fem-speedup-cpp-solve 1.08165 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 12, 4, 11, 42) mesh-refinement-cpp 43.3394 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 12, 4, 11, 43) mesh-topology-cpp 1.36363 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 12, 4, 12, 5) mesh-unitcube-cpp 21.4352 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 12, 4, 12, 42) mesh-iteration-cpp 35.5036 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 12, 4, 12, 42) function-evaluation-cpp 0.0779529 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 12, 4, 15, 9) la-vector-access-cpp 142.506 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 12, 4, 15, 43) la-vector-assignment-cpp 33.5055 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 13, 1, 10, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.0836 "BENCH 13.0836" (2015, 10, 13, 1, 10, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 14.7692 "Building point search tree to accelerate distance queries." (2015, 10, 13, 1, 10, 58) geometry-bounding_box_tree_build-cpp 14.1163 "BENCH 14.1163" (2015, 10, 13, 1, 11, 26) common-progress-cpp 27.9336 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 13, 1, 12, 33) common-timing-cpp 67.1536 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 13, 1, 12, 43) fem-convergence-cpp 3.66291 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 13, 4, 9, 2) fem-speedup-cpp 10578.7 "Assembly/solve speedup running on 4 processors" (2015, 10, 13, 4, 9, 2) fem-speedup-cpp-assembly 6.36985 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 13, 4, 9, 2) fem-speedup-cpp-solve 1.05971 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 13, 4, 9, 47) mesh-refinement-cpp 43.3787 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 13, 4, 9, 48) mesh-topology-cpp 1.36231 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 13, 4, 10, 10) mesh-unitcube-cpp 21.329 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 13, 4, 10, 55) mesh-iteration-cpp 43.5009 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 13, 4, 10, 55) function-evaluation-cpp 0.0778451 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 13, 4, 13, 19) la-vector-access-cpp 139.006 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 13, 4, 13, 52) la-vector-assignment-cpp 33.4994 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 14, 1, 10, 57) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9036 "BENCH 12.9036" (2015, 10, 14, 1, 11, 16) geometry-bounding_box_tree_compute_closest_entity-cpp 15.139 "Building point search tree to accelerate distance queries." (2015, 10, 14, 1, 11, 32) geometry-bounding_box_tree_build-cpp 14.1545 "BENCH 14.1545" (2015, 10, 14, 1, 12, 0) common-progress-cpp 27.9677 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 14, 1, 13, 7) common-timing-cpp 67.2447 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 14, 1, 13, 17) fem-convergence-cpp 3.65761 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 14, 4, 15, 7) fem-speedup-cpp 10908.6 "Assembly/solve speedup running on 4 processors" (2015, 10, 14, 4, 15, 7) fem-speedup-cpp-assembly 6.37425 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 14, 4, 15, 7) fem-speedup-cpp-solve 1.10867 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 14, 4, 15, 51) mesh-refinement-cpp 43.3868 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 14, 4, 15, 52) mesh-topology-cpp 1.36329 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 14, 4, 16, 14) mesh-unitcube-cpp 21.4763 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 14, 4, 17, 0) mesh-iteration-cpp 43.5014 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 14, 4, 17, 0) function-evaluation-cpp 0.0777609 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 14, 4, 19, 26) la-vector-access-cpp 141.663 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 14, 4, 19, 59) la-vector-assignment-cpp 33.449 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 15, 1, 10, 21) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1661 "BENCH 13.1661" (2015, 10, 15, 1, 10, 40) geometry-bounding_box_tree_compute_closest_entity-cpp 14.8812 "Building point search tree to accelerate distance queries." (2015, 10, 15, 1, 10, 56) geometry-bounding_box_tree_build-cpp 14.2048 "BENCH 14.2048" (2015, 10, 15, 1, 11, 24) common-progress-cpp 27.9823 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 15, 1, 12, 31) common-timing-cpp 67.0245 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 15, 1, 12, 41) fem-convergence-cpp 3.66993 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 15, 4, 36, 10) fem-speedup-cpp 12208.5 "Assembly/solve speedup running on 4 processors" (2015, 10, 15, 4, 36, 10) fem-speedup-cpp-assembly 6.36905 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 15, 4, 36, 10) fem-speedup-cpp-solve 1.10716 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 15, 4, 36, 55) mesh-refinement-cpp 43.3009 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 15, 4, 36, 56) mesh-topology-cpp 1.36589 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 15, 4, 37, 18) mesh-unitcube-cpp 21.4298 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 15, 4, 37, 59) mesh-iteration-cpp 39.2077 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 15, 4, 37, 59) function-evaluation-cpp 0.078197 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 15, 4, 40, 24) la-vector-access-cpp 140.765 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 15, 4, 40, 58) la-vector-assignment-cpp 33.4298 "Assigning to vector of size 10000000 (100 repetitions)" (2015, 10, 16, 1, 10, 58) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.1583 "BENCH 13.1583" (2015, 10, 16, 1, 11, 17) geometry-bounding_box_tree_compute_closest_entity-cpp 14.9526 "Building point search tree to accelerate distance queries." (2015, 10, 16, 1, 11, 33) geometry-bounding_box_tree_build-cpp 14.1348 "BENCH 14.1348" (2015, 10, 16, 1, 12, 1) common-progress-cpp 27.9648 "Creating progress bar with 500000000 steps (5 repetitions)" (2015, 10, 16, 1, 13, 9) common-timing-cpp 67.2636 "Timing access and registration of timings (10000000 repetitions)" (2015, 10, 16, 1, 13, 18) fem-convergence-cpp 3.67179 "Solving Poisson's equation in 2D for q = 1, n = 2." (2015, 10, 16, 4, 14, 18) fem-speedup-cpp 10858.9 "Assembly/solve speedup running on 4 processors" (2015, 10, 16, 4, 14, 18) fem-speedup-cpp-assembly 6.35766 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2015, 10, 16, 4, 14, 18) fem-speedup-cpp-solve 0.960496 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2015, 10, 16, 4, 15, 3) mesh-refinement-cpp 43.5144 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2015, 10, 16, 4, 15, 4) mesh-topology-cpp 1.3632 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2015, 10, 16, 4, 15, 26) mesh-unitcube-cpp 21.4539 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2015, 10, 16, 4, 16, 7) mesh-iteration-cpp 39.1171 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2015, 10, 16, 4, 16, 7) function-evaluation-cpp 0.0781951 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2015, 10, 16, 4, 18, 34) la-vector-access-cpp 142.526 "Accessing vector of size 10000000 (100 repetitions)" (2015, 10, 16, 4, 19, 7) la-vector-assignment-cpp 33.5249 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 13, 16, 3, 4) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.506 "BENCH 13.506" (2016, 1, 13, 16, 3, 22) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1554 "Building point search tree to accelerate distance queries." (2016, 1, 13, 16, 3, 36) geometry-bounding_box_tree_build-cpp 11.594 "BENCH 11.594" (2016, 1, 13, 16, 4, 7) common-progress-cpp 31.4197 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 13, 16, 5, 8) common-timing-cpp 60.6782 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 13, 16, 5, 17) fem-convergence-cpp 3.47625 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 13, 16, 5, 51) fem-jit-python 0.0005023 "JIT compilation (in memory cache)" (2016, 1, 13, 16, 10, 43) fem-speedup-cpp 292.091 "Assembly/solve speedup running on 4 processors" (2016, 1, 13, 16, 10, 43) fem-speedup-cpp-assembly 4.50146 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 13, 16, 10, 43) fem-speedup-cpp-solve 2.00072 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 13, 16, 11, 24) mesh-refinement-cpp 40.2751 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 13, 16, 11, 25) mesh-topology-cpp 1.35198 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 13, 16, 11, 46) mesh-unitcube-cpp 20.7443 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 13, 16, 12, 27) mesh-iteration-cpp 38.511 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 13, 16, 12, 27) function-evaluation-cpp 0.080951 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 13, 16, 13, 29) function-extrapolation-python 61.7874 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2016, 1, 13, 16, 13, 29) function-extrapolation-python 1.67974 "Calling FFC just-in-time (JIT) compiler, this may take some time." (2016, 1, 13, 16, 13, 40) function-interpolation-python 11.5981 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2016, 1, 13, 16, 13, 40) function-interpolation-python 0.940371 "Calling DOLFIN just-in-time (JIT) compiler, this may take some time." (2016, 1, 13, 16, 15, 44) la-vector-access-cpp 124.272 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 13, 16, 16, 16) la-vector-assignment-cpp 32.0029 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 14, 2, 15, 8) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.7979 "BENCH 12.7979" (2016, 1, 14, 2, 15, 27) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1097 "Building point search tree to accelerate distance queries." (2016, 1, 14, 2, 15, 41) geometry-bounding_box_tree_build-cpp 11.9556 "BENCH 11.9556" (2016, 1, 14, 2, 16, 12) common-progress-cpp 31.394 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 14, 2, 17, 17) common-timing-cpp 64.6461 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 14, 2, 17, 26) fem-convergence-cpp 3.4811 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 14, 2, 17, 27) fem-jit-python 0.000479102 "JIT compilation (in memory cache)" (2016, 1, 14, 2, 22, 17) fem-speedup-cpp 290.087 "Assembly/solve speedup running on 4 processors" (2016, 1, 14, 2, 22, 17) fem-speedup-cpp-assembly 4.54294 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 14, 2, 22, 17) fem-speedup-cpp-solve 2.04486 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 14, 2, 22, 58) mesh-refinement-cpp 40.6016 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 14, 2, 23, 0) mesh-topology-cpp 1.31767 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 14, 2, 23, 20) mesh-unitcube-cpp 19.9415 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 14, 2, 24, 0) mesh-iteration-cpp 38.5566 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 14, 2, 24, 0) function-evaluation-cpp 0.0667651 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 14, 2, 24, 6) function-extrapolation-python 5.68779 "BENCH: 1.68426918983" (2016, 1, 14, 2, 24, 6) function-extrapolation-python 1.68427 "BENCH: 1.68426918983" (2016, 1, 14, 2, 24, 9) function-interpolation-python 2.49873 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 14, 2, 24, 9) function-interpolation-python 0.927591 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 14, 2, 26, 17) la-vector-access-cpp 128.29 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 14, 2, 26, 51) la-vector-assignment-cpp 34.0574 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 15, 2, 15, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8773 "BENCH 12.8773" (2016, 1, 15, 2, 15, 48) geometry-bounding_box_tree_compute_closest_entity-cpp 15.3814 "Building point search tree to accelerate distance queries." (2016, 1, 15, 2, 16, 3) geometry-bounding_box_tree_build-cpp 12.7854 "BENCH 12.7854" (2016, 1, 15, 2, 16, 34) common-progress-cpp 31.4387 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 15, 2, 17, 38) common-timing-cpp 63.4933 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 15, 2, 17, 47) fem-convergence-cpp 3.53207 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 15, 2, 17, 50) fem-jit-python 0.000484204 "JIT compilation (in memory cache)" (2016, 1, 15, 2, 22, 40) fem-speedup-cpp 290.87 "Assembly/solve speedup running on 4 processors" (2016, 1, 15, 2, 22, 40) fem-speedup-cpp-assembly 4.439 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 15, 2, 22, 40) fem-speedup-cpp-solve 2.06219 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 15, 2, 23, 22) mesh-refinement-cpp 40.9061 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 15, 2, 23, 23) mesh-topology-cpp 1.32659 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 15, 2, 23, 44) mesh-unitcube-cpp 20.5496 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 15, 2, 24, 34) mesh-iteration-cpp 47.8602 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 15, 2, 24, 34) function-evaluation-cpp 0.0660989 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 15, 2, 24, 40) function-extrapolation-python 5.93016 "BENCH: 1.66257119179" (2016, 1, 15, 2, 24, 40) function-extrapolation-python 1.66257 "BENCH: 1.66257119179" (2016, 1, 15, 2, 24, 42) function-interpolation-python 2.46605 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 15, 2, 24, 42) function-interpolation-python 0.918086 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 15, 2, 26, 48) la-vector-access-cpp 125.244 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 15, 2, 27, 20) la-vector-assignment-cpp 32.0039 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 16, 2, 15, 23) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.9146 "BENCH 12.9146" (2016, 1, 16, 2, 15, 42) geometry-bounding_box_tree_compute_closest_entity-cpp 15.8391 "Building point search tree to accelerate distance queries." (2016, 1, 16, 2, 15, 56) geometry-bounding_box_tree_build-cpp 12.1027 "BENCH 12.1027" (2016, 1, 16, 2, 16, 28) common-progress-cpp 31.669 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 16, 2, 17, 31) common-timing-cpp 63.0912 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 16, 2, 17, 40) fem-convergence-cpp 3.50697 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 16, 2, 17, 42) fem-jit-python 0.000497794 "JIT compilation (in memory cache)" (2016, 1, 16, 2, 22, 32) fem-speedup-cpp 290.234 "Assembly/solve speedup running on 4 processors" (2016, 1, 16, 2, 22, 32) fem-speedup-cpp-assembly 4.52228 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 16, 2, 22, 32) fem-speedup-cpp-solve 2.06122 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 16, 2, 23, 13) mesh-refinement-cpp 40.7782 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 16, 2, 23, 15) mesh-topology-cpp 1.32719 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 16, 2, 23, 35) mesh-unitcube-cpp 20.5641 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 16, 2, 24, 19) mesh-iteration-cpp 40.9487 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 16, 2, 24, 19) function-evaluation-cpp 0.0583792 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 16, 2, 24, 25) function-extrapolation-python 6.04254 "BENCH: 1.66025710106" (2016, 1, 16, 2, 24, 25) function-extrapolation-python 1.66026 "BENCH: 1.66025710106" (2016, 1, 16, 2, 24, 27) function-interpolation-python 2.49797 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 16, 2, 24, 27) function-interpolation-python 0.922166 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 16, 2, 26, 32) la-vector-access-cpp 124.897 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 16, 2, 27, 4) la-vector-assignment-cpp 32.0119 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 17, 2, 15, 30) geometry-bounding_box_tree_compute_entity_collisions-cpp 12.8844 "BENCH 12.8844" (2016, 1, 17, 2, 15, 48) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1341 "Building point search tree to accelerate distance queries." (2016, 1, 17, 2, 16, 2) geometry-bounding_box_tree_build-cpp 11.9931 "BENCH 11.9931" (2016, 1, 17, 2, 16, 34) common-progress-cpp 31.4539 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 17, 2, 17, 37) common-timing-cpp 63.1319 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 17, 2, 17, 46) fem-convergence-cpp 3.48352 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 17, 2, 17, 47) fem-jit-python 0.000487208 "JIT compilation (in memory cache)" (2016, 1, 17, 2, 22, 44) fem-speedup-cpp 297.13 "Assembly/solve speedup running on 4 processors" (2016, 1, 17, 2, 22, 44) fem-speedup-cpp-assembly 4.5637 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 17, 2, 22, 44) fem-speedup-cpp-solve 1.95258 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 17, 2, 23, 26) mesh-refinement-cpp 40.9425 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 17, 2, 23, 27) mesh-topology-cpp 1.31377 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 17, 2, 23, 48) mesh-unitcube-cpp 20.6877 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 17, 2, 24, 31) mesh-iteration-cpp 40.9479 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 17, 2, 24, 31) function-evaluation-cpp 0.065727 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 17, 2, 24, 37) function-extrapolation-python 5.7739 "BENCH: 1.66412186623" (2016, 1, 17, 2, 24, 37) function-extrapolation-python 1.66412 "BENCH: 1.66412186623" (2016, 1, 17, 2, 24, 39) function-interpolation-python 2.49006 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 17, 2, 24, 39) function-interpolation-python 0.93913 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 17, 2, 26, 45) la-vector-access-cpp 125.926 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 17, 2, 27, 17) la-vector-assignment-cpp 32.0128 "Assigning to vector of size 10000000 (100 repetitions)" (2016, 1, 18, 2, 15, 29) geometry-bounding_box_tree_compute_entity_collisions-cpp 13.9525 "BENCH 13.9525" (2016, 1, 18, 2, 15, 47) geometry-bounding_box_tree_compute_closest_entity-cpp 15.1188 "Building point search tree to accelerate distance queries." (2016, 1, 18, 2, 16, 2) geometry-bounding_box_tree_build-cpp 12.1198 "BENCH 12.1198" (2016, 1, 18, 2, 16, 33) common-progress-cpp 31.4964 "Creating progress bar with 500000000 steps (5 repetitions)" (2016, 1, 18, 2, 17, 32) common-timing-cpp 58.8124 "Timing access and registration of timings (10000000 repetitions)" (2016, 1, 18, 2, 17, 41) fem-convergence-cpp 3.49213 "Solving Poisson's equation in 2D for q = 1, n = 2." (2016, 1, 18, 2, 17, 42) fem-jit-python 0.000485015 "JIT compilation (in memory cache)" (2016, 1, 18, 2, 22, 34) fem-speedup-cpp 291.706 "Assembly/solve speedup running on 4 processors" (2016, 1, 18, 2, 22, 34) fem-speedup-cpp-assembly 4.56212 "Assembly/solve speedup running on 4 processors ((assembly_1st+2nd))" (2016, 1, 18, 2, 22, 34) fem-speedup-cpp-solve 2.03206 "Assembly/solve speedup running on 4 processors ((solve_1st))" (2016, 1, 18, 2, 23, 15) mesh-refinement-cpp 40.5546 "Uniform refinement of unit cube of size 4 x 4 x 4 (5 refinements)" (2016, 1, 18, 2, 23, 17) mesh-topology-cpp 1.35012 "Creating cell-cell connectivity for unit cube of size 64 x 64 x 64 (5 repetitions)" (2016, 1, 18, 2, 23, 38) mesh-unitcube-cpp 21.0976 "Creating unit cube of size 128 x 128 x 128 (10 repetitions)" (2016, 1, 18, 2, 24, 21) mesh-iteration-cpp 40.9485 "Iteration over entities of unit cube of size 128 x 128 x 128 (100 repetitions)" (2016, 1, 18, 2, 24, 21) function-evaluation-cpp 0.0591931 "DOLFIN must be compiled with CGAL to run function eval benchmark." (2016, 1, 18, 2, 24, 27) function-extrapolation-python 5.84827 "BENCH: 1.6565310955" (2016, 1, 18, 2, 24, 27) function-extrapolation-python 1.65653 "BENCH: 1.6565310955" (2016, 1, 18, 2, 24, 29) function-interpolation-python 2.45584 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 18, 2, 24, 29) function-interpolation-python 0.916362 "*** Warning: Plotting not available. DOLFIN has been compiled without VTK support." (2016, 1, 18, 2, 26, 40) la-vector-access-cpp 130.74 "Accessing vector of size 10000000 (100 repetitions)" (2016, 1, 18, 2, 27, 12) la-vector-assignment-cpp 32.0081 "Assigning to vector of size 10000000 (100 repetitions)" bench/logs/milestones.log000066400000000000000000000011051412460263600157670ustar00rootroot000000000000002008-02-18 DOLFIN 0.7.2 2008-04-30 DOLFIN 0.7.3 2008-06-23 DOLFIN 0.8.0 2008-10-20 DOLFIN 0.8.1 2009-01-05 DOLFIN 0.9.0 2009-02-17 DOLFIN 0.9.1 2009-04-07 DOLFIN 0.9.2 2009-09-26 DOLFIN 0.9.3 2009-10-12 DOLFIN 0.9.4 2009-12-04 DOLFIN 0.9.5 2010-02-03 DOLFIN 0.9.6 2010-02-17 DOLFIN 0.9.7 2010-07-01 DOLFIN 0.9.8 2010-09-02 DOLFIN 0.9.9 2011-02-23 DOLFIN 0.9.10 2011-05-16 DOLFIN 0.9.11 2011-08-11 DOLFIN 1.0-beta 2011-12-06 DOLFIN 1.0.0 2013-01-08 DOLFIN 1.1.0 2013-03-24 DOLFIN 1.2.0 2014-01-07 DOLFIN 1.3.0 2014-06-02 DOLFIN 1.4.0 2015-01-12 DOLFIN 1.5.0 2015-07-28 DOLFIN 1.6.0 bench/mesh/000077500000000000000000000000001412460263600130755ustar00rootroot00000000000000bench/mesh/iteration/000077500000000000000000000000001412460263600150735ustar00rootroot00000000000000bench/mesh/iteration/cpp/000077500000000000000000000000001412460263600156555ustar00rootroot00000000000000bench/mesh/iteration/cpp/main.cpp000066400000000000000000000026251412460263600173120ustar00rootroot00000000000000// Copyright (C) 2006-2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2006-11-01 // Last changed: 2012-12-12 #include using namespace dolfin; #define NUM_REPS 100 #define SIZE 128 int main(int argc, char* argv[]) { info("Iteration over entities of unit cube of size %d x %d x %d (%d repetitions)", SIZE, SIZE, SIZE, NUM_REPS); parameters.parse(argc, argv); UnitCubeMesh mesh(SIZE, SIZE, SIZE); std::size_t sum = 0; tic(); for (int i = 0; i < NUM_REPS; i++) { for (CellIterator c(mesh); !c.end(); ++c) for (VertexIterator v(*c); !v.end(); ++v) sum += v->index(); } info("BENCH %g", toc()); // To prevent optimizing the loop away info("Sum is %llu", (unsigned long long)sum); return 0; } bench/mesh/refinement/000077500000000000000000000000001412460263600152315ustar00rootroot00000000000000bench/mesh/refinement/cpp/000077500000000000000000000000001412460263600160135ustar00rootroot00000000000000bench/mesh/refinement/cpp/main.cpp000066400000000000000000000024361412460263600174500ustar00rootroot00000000000000// Copyright (C) 2006-2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2006-11-01 // Last changed: 2012-12-12 #include using namespace dolfin; #define NUM_REPS 5 #define SIZE 4 int main(int argc, char* argv[]) { info("Uniform refinement of unit cube of size %d x %d x %d (%d refinements)", SIZE, SIZE, SIZE, NUM_REPS); parameters.parse(argc, argv); UnitCubeMesh unitcube_mesh(SIZE, SIZE, SIZE); Mesh mesh(unitcube_mesh); tic(); for (int i = 0; i < NUM_REPS; i++) { mesh = refine(mesh); dolfin::cout << "Refined mesh: " << mesh << dolfin::endl; } info("BENCH %g", toc()); return 0; } bench/mesh/topology/000077500000000000000000000000001412460263600147515ustar00rootroot00000000000000bench/mesh/topology/cpp/000077500000000000000000000000001412460263600155335ustar00rootroot00000000000000bench/mesh/topology/cpp/main.cpp000066400000000000000000000034411412460263600171650ustar00rootroot00000000000000// Copyright (C) 2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-11-25 // Last changed: 2012-12-12 #include #include using namespace dolfin; #define NUM_REPS 5 #define SIZE 64 // Use for quick testing //#define NUM_REPS 2 //#define SIZE 32 int main(int argc, char* argv[]) { info("Creating cell-cell connectivity for unit cube of size %d x %d x %d (%d repetitions)", SIZE, SIZE, SIZE, NUM_REPS); set_log_level(DBG); parameters.parse(argc, argv); UnitCubeMesh mesh(SIZE, SIZE, SIZE); const int D = mesh.topology().dim(); // Clear timing (if there is some) { Timer t("Compute connectivity 3-3"); } timing("Compute connectivity 3-3", TimingClear::clear); for (int i = 0; i < NUM_REPS; i++) { mesh.clean(); mesh.init(D, D); dolfin::cout << "Created unit cube: " << mesh << dolfin::endl; } // Report timings list_timings(TimingClear::keep, { TimingType::wall, TimingType::user, TimingType::system }); // Report timing const auto t = timing("Compute connectivity 3-3", TimingClear::clear); info("BENCH %g", std::get<1>(t)); return 0; } bench/mesh/unitcube/000077500000000000000000000000001412460263600147135ustar00rootroot00000000000000bench/mesh/unitcube/cpp/000077500000000000000000000000001412460263600154755ustar00rootroot00000000000000bench/mesh/unitcube/cpp/main.cpp000066400000000000000000000022701412460263600171260ustar00rootroot00000000000000// Copyright (C) 2006-2010 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2006-11-01 // Last changed: 2010-05-03 #include using namespace dolfin; #define NUM_REPS 10 #define SIZE 128 int main(int argc, char* argv[]) { info("Creating unit cube of size %d x %d x %d (%d repetitions)", SIZE, SIZE, SIZE, NUM_REPS); parameters.parse(argc, argv); for (int i = 0; i < NUM_REPS; i++) { UnitCubeMesh mesh(SIZE, SIZE, SIZE); dolfin::cout << "Created unit cube: " << mesh << dolfin::endl; } return 0; } bench/plot.py000066400000000000000000000223221412460263600134720ustar00rootroot00000000000000#!/usr/bin/env python """ This script parses logs/bench.log and create plots for each case with the timings function of time (date plot). It also creates a web page index.html for easy viewing of the generated plots. """ # Copyright (C) 2010 Johannes Ring # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2010-04-06 # Last changed: 2010-04-13 from __future__ import print_function import os import re import time import datetime import textwrap import numpy import matplotlib.pyplot as plt import matplotlib.dates as mdates # Change some of the default Matplotlib parameters plt.rcParams.update({'figure.figsize': [6, 4], 'font.size' : 10, 'axes.labelsize' : 10, 'axes.grid': True, 'text.fontsize' : 10, 'legend.fontsize' : 8, 'xtick.labelsize' : 8, 'ytick.labelsize' : 8, }) # Write to web page index.html outfile = open("index.html", "w") outfile.write("

DOLFIN Benchmarks

\n") outfile.write("Last updated: %s.\n\n" % time.asctime()) # Open and read in logs/bench.log benchlog = "logs/bench.log" lines = open(benchlog, 'r').readlines() benchmarks = {} pattern = "\((.*)\)\s+(.*)\s+(.*)\s+\"(.*)\"" # Extract data from logfile print("Parsing %s..." % benchlog) for line in lines: match = re.search(pattern, line) if match: year, month, day, hour, minute, second = \ [int(i) for i in match.group(1).split(',')] #date = datetime.datetime(year, month, day, hour, minute, second) date = datetime.date(year, month, day) name = match.group(2) elapsed_time = float(match.group(3)) description = match.group(4) if not name in benchmarks: benchmarks[name] = [[[date], [elapsed_time], description]] else: benchmarks[name][0][0].append(date) benchmarks[name][0][1].append(elapsed_time) benchmarks[name][0][2] = description # take later description # Open and read in logs/milestones.log milestones = [] milestoneslog = "logs/milestones.log" if os.path.isfile(milestoneslog): lines = open(milestoneslog, 'r').readlines() for line in lines: date = datetime.datetime.strptime(line.split()[0], "%Y-%m-%d") progname = ' '.join(line.split()[1:]) milestones.append([date, progname]) # Get Matplotlib line markers for use later markers = [] for m in plt.Line2D.markers: try: if len(m) == 1 and m != ' ': markers.append(m) except TypeError: pass year = datetime.timedelta(days=365) month = datetime.timedelta(days=30) week = datetime.timedelta(days=7) today = datetime.date.today() lasts = ['week', 'month', 'year', 'five years'] locators = [mdates.DayLocator(), mdates.DayLocator(interval=2), mdates.MonthLocator(), mdates.YearLocator()] date_fmts = ['%Y-%m-%d', '%d %b', '%b %Y', '%Y'] xmins = [today - week, today - month, today - year, today - 5*year] outfile.write("

All benchmarks

\n") outfile.write("

\n") outfile.write("\n") def get_maxtime(dates, min_date, max_date, run_timings): """Return the maximum time between min_date and max_date""" max_time = 0 for i, date in enumerate(dates): if date < min_date: continue elif date > max_date: break else: if max_time < run_timings[i]: max_time = run_timings[i] return max_time # Create normalized plots with all benchmarks in same plot for # last week, last month, last year, and last five years linetypes = {} print("Generating plots for all benchmarks...") for last, locator, date_fmt, xmin in zip(lasts, locators, date_fmts, xmins): fig = plt.figure() ax = fig.gca() num = 0 ymax = 0 for benchmark, values in benchmarks.items(): num += 1 dates = values[0][0] run_timings = values[0][1]/numpy.linalg.norm(values[0][1]) p = ax.plot(dates, run_timings, marker=markers[num % len(markers)], markersize=3, label=benchmark) ax.hold(True) linetypes[benchmark] = p[0] maxtime = get_maxtime(dates, xmin, today, run_timings) if maxtime > ymax: ymax = maxtime ax.xaxis.set_major_locator(locator) ax.xaxis.set_major_formatter(mdates.DateFormatter(date_fmt)) ax.set_xlim(xmin, today) ax.set_ylim(0, ymax) # Add milestones to plot for milestone in milestones: milestone_num = mdates.date2num(milestone[0]) ax.annotate(milestone[1], xy=(milestone_num, 0.1E-10), xycoords='data', xytext=(0, 30), textcoords='offset points', horizontalalignment='center', verticalalignment='bottom', style='italic', fontsize=6, alpha=0.7, rotation='vertical', arrowprops=dict(arrowstyle="->", alpha=0.3) ) #lgd = plt.legend(loc='best') fig.autofmt_xdate() plt.title("All benchmarks (last %s)" % last) filename = "all_last_%s.png" % last.replace(' ', '_') plt.savefig(filename, facecolor='#eeeeee') # Add plots to web page if last in ['week', 'year']: outfile.write(" \n" % filename) else: outfile.write(" \n" % filename) # Separate legend linetypes = sorted(linetypes.items()) handles = [p for (t, p) in linetypes] labels = [t for (t, p) in linetypes] plt.figure(figsize=(12, 4)) # twice wide the default plt.figlegend(handles, labels, 'center', ncol=3) plt.savefig('all_legend.png') outfile.write(" \n" % 'all_legend.png') outfile.write("
\n") outfile.write("
\n") # Put together subtasks benchmarks which should be plotted together # (annotated by ((...)) in description) for benchmark, values in benchmarks.items(): postfix = values[0][2].split("((") if len(postfix) == 1: continue assert len(postfix) == 2 postfix = postfix[1].strip().replace("))", "") benchmarks.pop(benchmark) name = "-".join(benchmark.split("-")[:3]) + "-subtasks" if not name in benchmarks: benchmarks[name] = [] benchmarks[name].append((values[0][0], values[0][1], postfix)) # Now create separate plots for every benchmark for benchmark, values in sorted(benchmarks.items()): print("Generating plots for %s..." % benchmark) outfile.write("

%s

\n" % benchmark) outfile.write("

\n") outfile.write("\n") # Create plots for last week, last month, last year, and last five years for last, locator, date_fmt, xmin in zip(lasts, locators, date_fmts, xmins): fig = plt.figure() ax = fig.gca() if any(s in benchmark for s in ["fem-speedup-cpp-"]): ax.set_ylabel("speedup") else: ax.set_ylabel("time (seconds)") maxtime = 0.0 for v in values: dates = v[0] run_timings = v[1] description = textwrap.fill(v[2], width=30) maxtime = max(maxtime, get_maxtime(dates, xmin, today, run_timings)) ax.set_ylim(0, maxtime + maxtime/2) ax.plot(dates, run_timings, marker='o', markersize=3, label=description) ax.legend(loc='best') ax.xaxis.set_major_locator(locator) ax.xaxis.set_major_formatter(mdates.DateFormatter(date_fmt)) ax.set_xlim(xmin, today) # Add milestones to plot for milestone in milestones: milestone_num = mdates.date2num(milestone[0]) ax.annotate(milestone[1], xy=(milestone_num, 0.1E-10), xycoords='data', xytext=(0, 30), textcoords='offset points', horizontalalignment='center', verticalalignment='bottom', style='italic', fontsize=6, alpha=0.7, rotation='vertical', arrowprops=dict(arrowstyle="->", alpha=0.3) ) fig.autofmt_xdate() plt.title("%s (last %s)" % (benchmark, last)) filename = "%s_last_%s.png" % (benchmark, last.replace(' ', '_')) plt.savefig(filename, facecolor='#eeeeee') # Add plots to web page if last in ['week', 'year']: outfile.write(" \n" % filename) else: outfile.write(" \n" % filename) outfile.write("
\n") outfile.write("
\n") cmake/000077500000000000000000000000001412460263600121425ustar00rootroot00000000000000cmake/modules/000077500000000000000000000000001412460263600136125ustar00rootroot00000000000000cmake/modules/CorrectWindowsPaths.cmake000066400000000000000000000006611412460263600205730ustar00rootroot00000000000000# CorrectWindowsPaths - this module defines one macro # # CONVERT_CYGWIN_PATH( PATH ) # This uses the command cygpath (provided by cygwin) to convert # unix-style paths into paths useable by cmake on windows macro (CONVERT_CYGWIN_PATH _path) if (WIN32) EXECUTE_PROCESS(COMMAND cygpath.exe -m ${${_path}} OUTPUT_VARIABLE ${_path}) string (STRIP ${${_path}} ${_path}) endif (WIN32) endmacro (CONVERT_CYGWIN_PATH) cmake/modules/FindAMD.cmake000066400000000000000000000045331412460263600160230ustar00rootroot00000000000000# - Try to find AMD # Once done this will define # # AMD_FOUND - system has AMD # AMD_INCLUDE_DIRS - include directories for AMD # AMD_LIBRARIES - libraries for AMD #============================================================================= # Copyright (C) 2010 Anders Logg # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'AMD'") # Check for header file find_path(AMD_INCLUDE_DIRS amd.h HINTS ${AMD_DIR}/include $ENV{AMD_DIR}/include ${PETSC_INCLUDE_DIRS} $ENV{PETSC_DIR}/include PATH_SUFFIXES suitesparse ufsparse DOC "Directory where the AMD header is located" ) mark_as_advanced(AMD_INCLUDE_DIRS) # Check for AMD library find_library(AMD_LIBRARIES amd HINTS ${AMD_DIR}/lib $ENV{AMD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The AMD library") mark_as_advanced(AMD_LIBRARIES) # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(AMD "AMD could not be found. Be sure to set AMD_DIR." AMD_LIBRARIES AMD_INCLUDE_DIRS) cmake/modules/FindBLAS.cmake000066400000000000000000000473241412460263600161500ustar00rootroot00000000000000# - Find BLAS library # This module finds an installed fortran library that implements the BLAS # linear-algebra interface (see http://www.netlib.org/blas/). # The list of libraries searched for is taken # from the autoconf macro file, acx_blas.m4 (distributed at # http://ac-archive.sourceforge.net/ac-archive/acx_blas.html). # # This module sets the following variables: # BLAS_FOUND - set to true if a library implementing the BLAS interface # is found # BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l # and -L). # BLAS_LIBRARIES - uncached list of libraries (using full path name) to # link against to use BLAS # BLAS95_LIBRARIES - uncached list of libraries (using full path name) # to link against to use BLAS95 interface # BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface # is found # BLA_STATIC if set on this determines what kind of linkage we do (static) # BLA_VENDOR if set checks only the specified vendor, if not set checks # all the possibilities # BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK ########## ### List of vendors (BLA_VENDOR) valid in this module ## Goto,ATLAS PhiPACK,CXML,DXML,SunPerf,SCSL,SGIMATH,IBMESSL,Intel10_32 (intel mkl v10 32 bit),Intel10_64lp (intel mkl v10 64 bit,lp thread model, lp64 model), ## Intel10_64lp_seq (intel mkl v10 64 bit,sequential code, lp64 model), ## Intel( older versions of mkl 32 and 64 bit), ACML,ACML_MP,ACML_GPU,Apple, NAS, Generic # C/CXX should be enabled to use Intel mkl #============================================================================= # Copyright 2007-2009 Kitware, Inc. # # 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 copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # 3. The name of the author may not be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. #============================================================================= include(CheckFunctionExists) include(CheckFortranFunctionExists) set(_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) # Check the language being used get_property( _LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES ) if( _LANGUAGES_ MATCHES Fortran AND CMAKE_Fortran_COMPILER_WORKS ) set( _CHECK_FORTRAN TRUE ) elseif( (_LANGUAGES_ MATCHES C) OR (_LANGUAGES_ MATCHES CXX) ) set( _CHECK_FORTRAN FALSE ) else() if(BLAS_FIND_REQUIRED) message(FATAL_ERROR "FindBLAS requires Fortran, C, or C++ to be enabled.") else(BLAS_FIND_REQUIRED) message(STATUS "Looking for BLAS... - NOT found (Unsupported languages)") return() endif(BLAS_FIND_REQUIRED) endif( ) macro(Check_Fortran_Libraries LIBRARIES _prefix _name _flags _list _thread) # This macro checks for the existence of the combination of fortran libraries # given by _list. If the combination is found, this macro checks (using the # Check_Fortran_Function_Exists macro) whether can link against that library # combination using the name of a routine given by _name using the linker # flags given by _flags. If the combination of libraries is found and passes # the link test, LIBRARIES is set to the list of complete library paths that # have been found. Otherwise, LIBRARIES is set to FALSE. # N.B. _prefix is the prefix applied to the names of all cached variables that # are generated internally and marked advanced by this macro. set(_libdir ${ARGN}) set(_libraries_work TRUE) set(${LIBRARIES}) set(_combined_name) if (NOT _libdir) if (WIN32) set(_libdir ENV LIB) elseif (APPLE) set(_libdir /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV DYLD_LIBRARY_PATH) else () set(_libdir /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV LD_LIBRARY_PATH) endif () endif () foreach(_library ${_list}) set(_combined_name ${_combined_name}_${_library}) if(_libraries_work) if (BLA_STATIC) if (WIN32) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif ( WIN32 ) if (APPLE) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) else (APPLE) set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif (APPLE) else (BLA_STATIC) if (CMAKE_SYSTEM_NAME STREQUAL "Linux") # for ubuntu's libblas3gf and liblapack3gf packages #set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) endif () endif (BLA_STATIC) find_library(${_prefix}_${_library}_LIBRARY NAMES ${_library} PATHS ${_libdir} ) mark_as_advanced(${_prefix}_${_library}_LIBRARY) set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY}) set(_libraries_work ${${_prefix}_${_library}_LIBRARY}) endif(_libraries_work) endforeach(_library ${_list}) if(_libraries_work) # Test this combination of libraries. set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_thread}) # message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}") # GNW: Add special flags for static BLAS libraries for function check if(BLA_STATIC AND UNIX) set(CMAKE_REQUIRED_LIBRARIES ${_flags} "-Wl,--start-group ${${LIBRARIES}};-Wl,--end-group" ${_thread}) endif() if (_CHECK_FORTRAN) check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS) else() check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) endif() set(CMAKE_REQUIRED_LIBRARIES) mark_as_advanced(${_prefix}${_combined_name}_WORKS) set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) endif(_libraries_work) if(NOT _libraries_work) set(${LIBRARIES} FALSE) endif(NOT _libraries_work) #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}") endmacro(Check_Fortran_Libraries) set(BLAS_LINKER_FLAGS) set(BLAS_LIBRARIES) set(BLAS95_LIBRARIES) if ($ENV{BLA_VENDOR} MATCHES ".+") set(BLA_VENDOR $ENV{BLA_VENDOR}) else ($ENV{BLA_VENDOR} MATCHES ".+") if(NOT BLA_VENDOR) set(BLA_VENDOR "All") endif(NOT BLA_VENDOR) endif ($ENV{BLA_VENDOR} MATCHES ".+") if (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) # gotoblas (http://www.tacc.utexas.edu/tacc-projects/gotoblas2) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "goto2" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") if (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) # openblas (http://www.openblas.net) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "openblas" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") if (BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) # BLAS in ATLAS library? (http://math-atlas.sourceforge.net/) check_fortran_libraries( BLAS_LIBRARIES BLAS dgemm "" "cblas;f77blas;atlas" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All") # BLAS in PhiPACK libraries? (requires generic BLAS lib, too) if (BLA_VENDOR STREQUAL "PhiPACK" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "sgemm;dgemm;blas" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "PhiPACK" OR BLA_VENDOR STREQUAL "All") # BLAS in Alpha CXML library? if (BLA_VENDOR STREQUAL "CXML" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "cxml" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "CXML" OR BLA_VENDOR STREQUAL "All") # BLAS in Alpha DXML library? (now called CXML, see above) if (BLA_VENDOR STREQUAL "DXML" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "dxml" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "DXML" OR BLA_VENDOR STREQUAL "All") # BLAS in Sun Performance library? if (BLA_VENDOR STREQUAL "SunPerf" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "-xlic_lib=sunperf" "sunperf;sunmath" "" ) if(BLAS_LIBRARIES) set(BLAS_LINKER_FLAGS "-xlic_lib=sunperf") endif(BLAS_LIBRARIES) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "SunPerf" OR BLA_VENDOR STREQUAL "All") # BLAS in SCSL library? (SGI/Cray Scientific Library) if (BLA_VENDOR STREQUAL "SCSL" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "scsl" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "SCSL" OR BLA_VENDOR STREQUAL "All") # BLAS in SGIMATH library? if (BLA_VENDOR STREQUAL "SGIMATH" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "complib.sgimath" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "SGIMATH" OR BLA_VENDOR STREQUAL "All") # BLAS in IBM ESSL library? (requires generic BLAS lib, too) if (BLA_VENDOR STREQUAL "IBMESSL" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "essl;blas" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "IBMESSL" OR BLA_VENDOR STREQUAL "All") #BLAS in acml library? if (BLA_VENDOR MATCHES "ACML.*" OR BLA_VENDOR STREQUAL "All") if( ((BLA_VENDOR STREQUAL "ACML") AND (NOT BLAS_ACML_LIB_DIRS)) OR ((BLA_VENDOR STREQUAL "ACML_MP") AND (NOT BLAS_ACML_MP_LIB_DIRS)) OR ((BLA_VENDOR STREQUAL "ACML_GPU") AND (NOT BLAS_ACML_GPU_LIB_DIRS)) ) # try to find acml in "standard" paths if( WIN32 ) file( GLOB _ACML_ROOT "C:/AMD/acml*/ACML-EULA.txt" ) else() file( GLOB _ACML_ROOT "/opt/acml*/ACML-EULA.txt" ) endif() if( WIN32 ) file( GLOB _ACML_GPU_ROOT "C:/AMD/acml*/GPGPUexamples" ) else() file( GLOB _ACML_GPU_ROOT "/opt/acml*/GPGPUexamples" ) endif() list(GET _ACML_ROOT 0 _ACML_ROOT) list(GET _ACML_GPU_ROOT 0 _ACML_GPU_ROOT) if( _ACML_ROOT ) get_filename_component( _ACML_ROOT ${_ACML_ROOT} PATH ) if( SIZEOF_INTEGER EQUAL 8 ) set( _ACML_PATH_SUFFIX "_int64" ) else() set( _ACML_PATH_SUFFIX "" ) endif() if( CMAKE_Fortran_COMPILER_ID STREQUAL "Intel" ) set( _ACML_COMPILER32 "ifort32" ) set( _ACML_COMPILER64 "ifort64" ) elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "SunPro" ) set( _ACML_COMPILER32 "sun32" ) set( _ACML_COMPILER64 "sun64" ) elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "PGI" ) set( _ACML_COMPILER32 "pgi32" ) if( WIN32 ) set( _ACML_COMPILER64 "win64" ) else() set( _ACML_COMPILER64 "pgi64" ) endif() elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "Open64" ) # 32 bit builds not supported on Open64 but for code simplicity # We'll just use the same directory twice set( _ACML_COMPILER32 "open64_64" ) set( _ACML_COMPILER64 "open64_64" ) elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "NAG" ) set( _ACML_COMPILER32 "nag32" ) set( _ACML_COMPILER64 "nag64" ) else() #if( CMAKE_Fortran_COMPILER_ID STREQUAL "GNU" ) set( _ACML_COMPILER32 "gfortran32" ) set( _ACML_COMPILER64 "gfortran64" ) endif() if( BLA_VENDOR STREQUAL "ACML_MP" ) set(_ACML_MP_LIB_DIRS "${_ACML_ROOT}/${_ACML_COMPILER32}_mp${_ACML_PATH_SUFFIX}/lib" "${_ACML_ROOT}/${_ACML_COMPILER64}_mp${_ACML_PATH_SUFFIX}/lib" ) else() #if( _BLAS_VENDOR STREQUAL "ACML" ) set(_ACML_LIB_DIRS "${_ACML_ROOT}/${_ACML_COMPILER32}${_ACML_PATH_SUFFIX}/lib" "${_ACML_ROOT}/${_ACML_COMPILER64}${_ACML_PATH_SUFFIX}/lib" ) endif() endif() elseif(BLAS_${BLA_VENDOR}_LIB_DIRS) set(_${BLA_VENDOR}_LIB_DIRS ${BLAS_${BLA_VENDOR}_LIB_DIRS}) endif() if( BLA_VENDOR STREQUAL "ACML_MP" ) foreach( BLAS_ACML_MP_LIB_DIRS ${_ACML_MP_LIB_DIRS}) check_fortran_libraries ( BLAS_LIBRARIES BLAS sgemm "" "acml_mp;acml_mv" "" ${BLAS_ACML_MP_LIB_DIRS} ) if( BLAS_LIBRARIES ) break() endif() endforeach() elseif( BLA_VENDOR STREQUAL "ACML_GPU" ) foreach( BLAS_ACML_GPU_LIB_DIRS ${_ACML_GPU_LIB_DIRS}) check_fortran_libraries ( BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv;CALBLAS" "" ${BLAS_ACML_GPU_LIB_DIRS} ) if( BLAS_LIBRARIES ) break() endif() endforeach() else() #if( _BLAS_VENDOR STREQUAL "ACML" ) foreach( BLAS_ACML_LIB_DIRS ${_ACML_LIB_DIRS} ) check_fortran_libraries ( BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv" "" ${BLAS_ACML_LIB_DIRS} ) if( BLAS_LIBRARIES ) break() endif() endforeach() endif() # Either acml or acml_mp should be in LD_LIBRARY_PATH but not both if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv" "" ) endif(NOT BLAS_LIBRARIES) if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "acml_mp;acml_mv" "" ) endif(NOT BLAS_LIBRARIES) if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "acml;acml_mv;CALBLAS" "" ) endif(NOT BLAS_LIBRARIES) endif () # ACML # Apple BLAS library? if (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS dgemm "" "Accelerate" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") if (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") if ( NOT BLAS_LIBRARIES ) check_fortran_libraries( BLAS_LIBRARIES BLAS dgemm "" "vecLib" "" ) endif ( NOT BLAS_LIBRARIES ) endif (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") # Generic BLAS library? if (BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "All") if(NOT BLAS_LIBRARIES) check_fortran_libraries( BLAS_LIBRARIES BLAS sgemm "" "blas" "" ) endif(NOT BLAS_LIBRARIES) endif (BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "All") #BLAS in intel mkl 10 library? (em64t 64bit) if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All") if (NOT WIN32) set(LM "-lm") endif () if (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX) if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) find_package(Threads) else(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) find_package(Threads REQUIRED) endif(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) set(BLAS_SEARCH_LIBS "") if(BLA_F95) set(BLAS_mkl_SEARCH_SYMBOL SGEMM) set(_LIBRARIES BLAS95_LIBRARIES) if (WIN32) list(APPEND BLAS_SEARCH_LIBS "mkl_blas95 mkl_intel_c mkl_intel_thread mkl_core libguide40") else (WIN32) if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") list(APPEND BLAS_SEARCH_LIBS "mkl_blas95 mkl_intel mkl_intel_thread mkl_core guide") endif () if (BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All") # old version list(APPEND BLAS_SEARCH_LIBS "mkl_blas95 mkl_intel_lp64 mkl_intel_thread mkl_core guide") # mkl >= 10.3 if (CMAKE_C_COMPILER MATCHES ".+gcc.*") list(APPEND BLAS_SEARCH_LIBS "mkl_blas95_lp64 mkl_intel_lp64 mkl_gnu_thread mkl_core") set(LM "${LM};-lgomp") else () list(APPEND BLAS_SEARCH_LIBS "mkl_blas95_lp64 mkl_intel_lp64 mkl_intel_thread mkl_core iomp5") endif () endif () endif (WIN32) if (BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All") list(APPEND BLAS_SEARCH_LIBS "mkl_blas95_lp64 mkl_intel_lp64 mkl_sequential mkl_core") endif () else (BLA_F95) set(BLAS_mkl_SEARCH_SYMBOL sgemm) set(_LIBRARIES BLAS_LIBRARIES) if (WIN32) list(APPEND BLAS_SEARCH_LIBS "mkl_c_dll mkl_intel_thread_dll mkl_core_dll libguide40") else (WIN32) if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") list(APPEND BLAS_SEARCH_LIBS "mkl_intel mkl_intel_thread mkl_core guide") endif () if (BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All") # old version list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_intel_thread mkl_core guide") # mkl >= 10.3 if (CMAKE_C_COMPILER MATCHES ".+gcc.*") list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_gnu_thread mkl_core") set(LM "${LM};-lgomp") else () list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_intel_thread mkl_core iomp5") endif () endif () #older vesions of intel mkl libs if (BLA_VENDOR STREQUAL "Intel" OR BLA_VENDOR STREQUAL "All") list(APPEND BLAS_SEARCH_LIBS "mkl") list(APPEND BLAS_SEARCH_LIBS "mkl_ia32") list(APPEND BLAS_SEARCH_LIBS "mkl_em64t") endif () endif (WIN32) if (BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All") list(APPEND BLAS_SEARCH_LIBS "mkl_intel_lp64 mkl_sequential mkl_core") endif () endif (BLA_F95) foreach (IT ${BLAS_SEARCH_LIBS}) string(REPLACE " " ";" SEARCH_LIBS ${IT}) if (${_LIBRARIES}) else () check_fortran_libraries( ${_LIBRARIES} BLAS ${BLAS_mkl_SEARCH_SYMBOL} "" "${SEARCH_LIBS}" "${CMAKE_THREAD_LIBS_INIT};${LM}" ) endif () endforeach () endif (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX) endif (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All") if(BLA_F95) if(BLAS95_LIBRARIES) set(BLAS95_FOUND TRUE) else(BLAS95_LIBRARIES) set(BLAS95_FOUND FALSE) endif(BLAS95_LIBRARIES) if(NOT BLAS_FIND_QUIETLY) if(BLAS95_FOUND) message(STATUS "A library with BLAS95 API found.") else(BLAS95_FOUND) if(BLAS_FIND_REQUIRED) message(FATAL_ERROR "A required library with BLAS95 API not found. Please specify library location.") else(BLAS_FIND_REQUIRED) message(STATUS "A library with BLAS95 API not found. Please specify library location.") endif(BLAS_FIND_REQUIRED) endif(BLAS95_FOUND) endif(NOT BLAS_FIND_QUIETLY) set(BLAS_FOUND TRUE) set(BLAS_LIBRARIES "${BLAS95_LIBRARIES}") else(BLA_F95) if(BLAS_LIBRARIES) set(BLAS_FOUND TRUE) else(BLAS_LIBRARIES) set(BLAS_FOUND FALSE) endif(BLAS_LIBRARIES) if(NOT BLAS_FIND_QUIETLY) if(BLAS_FOUND) message(STATUS "Found BLAS: ${BLAS_LIBRARIES}") else(BLAS_FOUND) if(BLAS_FIND_REQUIRED) message(FATAL_ERROR "A required library with BLAS API not found. Please specify library location." ) else(BLAS_FIND_REQUIRED) message(STATUS "A library with BLAS API not found. Please specify library location." ) endif(BLAS_FIND_REQUIRED) endif(BLAS_FOUND) endif(NOT BLAS_FIND_QUIETLY) endif(BLA_F95) set(CMAKE_FIND_LIBRARY_SUFFIXES ${_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) cmake/modules/FindBLASHeader.cmake000066400000000000000000000041531412460263600172520ustar00rootroot00000000000000# - Try to find BLAS header cblas.h # Once done this will define # # BLASHEADER_FOUND - system has BLAS # BLAS_INCLUDE_DIRS - include directories for BLAS # #============================================================================= # Copyright (C) 2010 Garth N. Wells # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'BLAS'") # Check for header file find_path(BLASHEADER_INCLUDE_DIRS cblas.h HINTS ${BLASHEADER_DIR}/include $ENV{BLASHEADER_DIR}/include DOC "Directory where the BLAS header is located" ) mark_as_advanced(BLASBLASHEADER_INCLUDE_DIRS) # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(BLASHEADER "BLAS C header could not be found. Be sure to set BLASHEADER_DIR." BLASHEADER_INCLUDE_DIRS) cmake/modules/FindCHOLMOD.cmake000066400000000000000000000205051412460263600165040ustar00rootroot00000000000000# - Try to find CHOLMOD # Once done this will define # # CHOLMOD_FOUND - system has CHOLMOD # CHOLMOD_INCLUDE_DIRS - include directories for CHOLMOD # CHOLMOD_LIBRARIES - libraries for CHOLMOD #============================================================================= # Copyright (C) 2010-2011 Garth N. Wells, Anders Logg and Johannes Ring # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'CHOLMOD'") # Find packages that CHOLMOD depends on set(CMAKE_LIBRARY_PATH ${BLAS_DIR}/lib $ENV{BLAS_DIR}/lib ${CMAKE_LIBRARY_PATH}) set(CMAKE_LIBRARY_PATH ${LAPACK_DIR}/lib $ENV{LAPACK_DIR}/lib ${CMAKE_LIBRARY_PATH}) find_package(AMD QUIET) find_package(BLAS QUIET) find_package(LAPACK QUIET) if (DOLFIN_ENABLE_PARMETIS) find_package(ParMETIS 4.0.2 QUIET) endif() # FIXME: Should we have separate FindXX modules for CAMD, COLAMD, and CCOLAMD? # FIXME: find_package(CAMD) # FIXME: find_package(COLAMD) # FIXME: find_package(CCOLAMD) # FIXME: It may be necessary to link to LAPACK and BLAS (or the vecLib # FIXME: framework on Darwin). # Check for header file find_path(CHOLMOD_INCLUDE_DIRS cholmod.h HINTS ${CHOLMOD_DIR}/include $ENV{CHOLMOD_DIR}/include ${PETSC_INCLUDE_DIRS} $ENV{PETSC_DIR}/include PATH_SUFFIXES suitesparse ufsparse DOC "Directory where the CHOLMOD header is located") # Check for CHOLMOD library find_library(CHOLMOD_LIBRARY cholmod HINTS ${CHOLMOD_DIR}/lib $ENV{CHOLMOD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The CHOLMOD library") # Check for CAMD library find_library(CAMD_LIBRARY camd HINTS ${CHOLMOD_DIR}/lib ${CAMD_DIR}/lib $ENV{CHOLMOD_DIR}/lib $ENV{CAMD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The CAMD library") # Check for COLAMD library find_library(COLAMD_LIBRARY colamd HINTS ${CHOLMOD_DIR}/lib ${COLAMD_DIR}/lib $ENV{CHOLMOD_DIR}/lib $ENV{COLAMD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The COLAMD library" ) # Check for CCOLAMD library find_library(CCOLAMD_LIBRARY ccolamd HINTS ${CHOLMOD_DIR}/lib ${CCOLAMD_DIR}/lib $ENV{CHOLMOD_DIR}/lib $ENV{CCOLAMD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The CCOLAMD library") # Check for SUITESPARSECONFIG library find_library(SUITESPARSECONFIG_LIBRARY suitesparseconfig HINTS ${CHOLMOD_DIR}/lib ${CCOLAMD_DIR}/lib $ENV{CHOLMOD_DIR}/lib $ENV{CCOLAMD_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The SUITESPARSECONFIG library") if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND NOT APPLE) # Check for rt library find_library(RT_LIBRARY rt DOC "The RT library") endif() # Collect libraries (order is important) set(CHOLMOD_LIBRARIES) if (CHOLMOD_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${CHOLMOD_LIBRARY}) endif() if (AMD_FOUND) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${AMD_LIBRARIES}) endif() if (CAMD_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${CAMD_LIBRARY}) endif() if (COLAMD_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${COLAMD_LIBRARY}) endif() if (CCOLAMD_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${CCOLAMD_LIBRARY}) endif() if (SUITESPARSECONFIG_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${SUITESPARSECONFIG_LIBRARY}) endif() if (RT_LIBRARY) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${RT_LIBRARY}) endif() if (PARMETIS_FOUND) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${PARMETIS_LIBRARIES}) endif() if (LAPACK_FOUND) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${LAPACK_LIBRARIES}) endif() if (BLAS_FOUND) set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${BLAS_LIBRARIES}) endif() find_program(GFORTRAN_EXECUTABLE gfortran) if (GFORTRAN_EXECUTABLE) execute_process(COMMAND ${GFORTRAN_EXECUTABLE} -print-file-name=libgfortran.so OUTPUT_VARIABLE GFORTRAN_LIBRARY OUTPUT_STRIP_TRAILING_WHITESPACE) if (EXISTS "${GFORTRAN_LIBRARY}") set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${GFORTRAN_LIBRARY}) endif() endif() mark_as_advanced(CHOLMOD_INCLUDE_DIRS CHOLMOD_LIBRARY CHOLMOD_LIBRARIES CAMD_LIBRARY COLAMD_LIBRARY CCOLAMD_LIBRARY) # Try to run a test program that uses CHOLMOD if (DOLFIN_SKIP_BUILD_TESTS) set(CHOLMOD_TEST_RUNS TRUE) elseif (CHOLMOD_INCLUDE_DIRS AND CHOLMOD_LIBRARIES AND AMD_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CHOLMOD_INCLUDE_DIRS} ${AMD_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${CHOLMOD_LIBRARIES}) set(CHOLMOD_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/cholmod_test_lib.cpp") file(WRITE ${CHOLMOD_TEST_LIB_CPP} " #include #include int main() { cholmod_dense *D; cholmod_sparse *S; cholmod_dense *x, *b, *r; cholmod_factor *L; double one[2] = {1,0}, m1[2] = {-1,0}; double *dx; cholmod_common c; int n = 5; double K[5][5] = {{1.0, 0.0, 0.0, 0.0, 0.0}, {0.0, 2.0,-1.0, 0.0, 0.0}, {0.0,-1.0, 2.0,-1.0, 0.0}, {0.0, 0.0,-1.0, 2.0, 0.0}, {0.0, 0.0, 0.0, 0.0, 1.0}}; cholmod_start (&c); D = cholmod_allocate_dense(n, n, n, CHOLMOD_REAL, &c); dx = (double*)D->x; for (int i=0; i < n; i++) for (int j=0; j < n; j++) dx[i+j*n] = K[i][j]; S = cholmod_dense_to_sparse(D, 1, &c); S->stype = 1; cholmod_reallocate_sparse(cholmod_nnz(S, &c), S, &c); b = cholmod_ones(S->nrow, 1, S->xtype, &c); L = cholmod_analyze(S, &c); /* cholmod_factorize(S, L, &c); x = cholmod_solve(CHOLMOD_A, L, b, &c); r = cholmod_copy_dense(b, &c); cholmod_sdmult(S, 0, m1, one, x, r, &c); cholmod_free_factor(&L, &c); cholmod_free_dense(&D, &c); cholmod_free_sparse(&S, &c); cholmod_free_dense(&r, &c); cholmod_free_dense(&x, &c); cholmod_free_dense(&b, &c); cholmod_finish(&c); return 0; */ } ") try_run(CHOLMOD_TEST_LIB_EXITCODE CHOLMOD_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${CHOLMOD_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE CHOLMOD_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE CHOLMOD_TEST_LIB_OUTPUT ) if (CHOLMOD_TEST_LIB_COMPILED AND CHOLMOD_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Performing test CHOLMOD_TEST_RUNS - Success") set(CHOLMOD_TEST_RUNS TRUE) else() message(STATUS "Performing test CHOLMOD_TEST_RUNS - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run CHOLMOD test:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "CHOLMOD_TEST_LIB_EXITCODE: ${CHOLMOD_TEST_LIB_EXITCODE}\n" "CHOLMOD_TEST_LIB_COMPILED: ${CHOLMOD_TEST_LIB_COMPILED}\n" "CHOLMOD_TEST_LIB_COMPILE_OUTPUT: ${CHOLMOD_TEST_LIB_COMPILE_OUTPUT}\n" "CHOLMOD_TEST_LIB_OUTPUT: ${CHOLMOD_TEST_LIB_OUTPUT}\n\n") endif() endif() # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(CHOLMOD "CHOLMOD could not be found. Be sure to set CHOLMOD_DIR." CHOLMOD_LIBRARIES CHOLMOD_INCLUDE_DIRS CHOLMOD_TEST_RUNS) cmake/modules/FindEigen3.cmake000066400000000000000000000070451412460263600165350ustar00rootroot00000000000000# - Try to find Eigen3 lib # # This module supports requiring a minimum version, e.g. you can do # find_package(Eigen3 3.1.2) # to require version 3.1.2 or newer of Eigen3. # # Once done this will define # # EIGEN3_FOUND - system has eigen lib with correct version # EIGEN3_INCLUDE_DIR - the eigen include directory # EIGEN3_VERSION - eigen version # # This module reads hints about search locations from # the following enviroment variables: # # EIGEN3_ROOT # EIGEN3_ROOT_DIR # Copyright (c) 2006, 2007 Montel Laurent, # Copyright (c) 2008, 2009 Gael Guennebaud, # Copyright (c) 2009 Benoit Jacob # Redistribution and use is allowed according to the terms of the 2-clause BSD license. # Modified by Garth N. Wells to add EIGEN_DIR to # search path if(NOT Eigen3_FIND_VERSION) if(NOT Eigen3_FIND_VERSION_MAJOR) set(Eigen3_FIND_VERSION_MAJOR 2) endif(NOT Eigen3_FIND_VERSION_MAJOR) if(NOT Eigen3_FIND_VERSION_MINOR) set(Eigen3_FIND_VERSION_MINOR 91) endif(NOT Eigen3_FIND_VERSION_MINOR) if(NOT Eigen3_FIND_VERSION_PATCH) set(Eigen3_FIND_VERSION_PATCH 0) endif(NOT Eigen3_FIND_VERSION_PATCH) set(Eigen3_FIND_VERSION "${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}") endif(NOT Eigen3_FIND_VERSION) macro(_eigen3_check_version) file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header) string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}") set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}") string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}") set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}") set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}) if(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) set(EIGEN3_VERSION_OK FALSE) else(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) set(EIGEN3_VERSION_OK TRUE) endif(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) if(NOT EIGEN3_VERSION_OK) message(STATUS "Eigen3 version ${EIGEN3_VERSION} found in ${EIGEN3_INCLUDE_DIR}, " "but at least version ${Eigen3_FIND_VERSION} is required") endif(NOT EIGEN3_VERSION_OK) endmacro(_eigen3_check_version) if (EIGEN3_INCLUDE_DIR) # in cache already _eigen3_check_version() set(EIGEN3_FOUND ${EIGEN3_VERSION_OK}) else (EIGEN3_INCLUDE_DIR) # search first if an Eigen3Config.cmake is available in the system, # if successful this would set EIGEN3_INCLUDE_DIR and the rest of # the script will work as usual find_package(Eigen3 ${Eigen3_FIND_VERSION} NO_MODULE QUIET) if(NOT EIGEN3_INCLUDE_DIR) find_path(EIGEN3_INCLUDE_DIR NAMES signature_of_eigen3_matrix_library HINTS ${EIGEN_DIR} ENV EIGEN_DIR ENV EIGEN3_ROOT ENV EIGEN3_ROOT_DIR PATHS ${CMAKE_INSTALL_PREFIX}/include ${KDE4_INCLUDE_DIR} PATH_SUFFIXES eigen3 eigen ) endif(NOT EIGEN3_INCLUDE_DIR) if(EIGEN3_INCLUDE_DIR) _eigen3_check_version() endif(EIGEN3_INCLUDE_DIR) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Eigen3 DEFAULT_MSG EIGEN3_INCLUDE_DIR EIGEN3_VERSION_OK) mark_as_advanced(EIGEN3_INCLUDE_DIR) endif(EIGEN3_INCLUDE_DIR) cmake/modules/FindGMP.cmake000066400000000000000000000012501412460263600160360ustar00rootroot00000000000000# Try to find the GMP librairies # GMP_FOUND - system has GMP lib # GMP_INCLUDE_DIR - the GMP include directory # GMP_LIBRARIES - Libraries needed to use GMP if (GMP_INCLUDE_DIR AND GMP_LIBRARIES) # Already in cache, be silent set(GMP_FIND_QUIETLY TRUE) endif (GMP_INCLUDE_DIR AND GMP_LIBRARIES) find_path(GMP_INCLUDE_DIR NAMES gmp.h ) find_library(GMP_LIBRARIES NAMES gmp libgmp ) find_library(GMPXX_LIBRARIES NAMES gmpxx libgmpxx ) MESSAGE(STATUS "GMP libs: " ${GMP_LIBRARIES} " " ${GMPXX_LIBRARIES} ) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(GMP DEFAULT_MSG GMP_INCLUDE_DIR GMP_LIBRARIES) mark_as_advanced(GMP_INCLUDE_DIR GMP_LIBRARIES) cmake/modules/FindLAPACK.cmake000066400000000000000000000300261412460263600163510ustar00rootroot00000000000000# - Find LAPACK library # This module finds an installed fortran library that implements the LAPACK # linear-algebra interface (see http://www.netlib.org/lapack/). # # The approach follows that taken for the autoconf macro file, acx_lapack.m4 # (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html). # # This module sets the following variables: # LAPACK_FOUND - set to true if a library implementing the LAPACK interface # is found # LAPACK_LINKER_FLAGS - uncached list of required linker flags (excluding -l # and -L). # LAPACK_LIBRARIES - uncached list of libraries (using full path name) to # link against to use LAPACK # LAPACK95_LIBRARIES - uncached list of libraries (using full path name) to # link against to use LAPACK95 # LAPACK95_FOUND - set to true if a library implementing the LAPACK f95 # interface is found # BLA_STATIC if set on this determines what kind of linkage we do (static) # BLA_VENDOR if set checks only the specified vendor, if not set checks # all the possibilities # BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK ### List of vendors (BLA_VENDOR) valid in this module ## Intel(mkl), ACML,Apple, NAS, Generic #============================================================================= # Copyright 2007-2009 Kitware, Inc. # # 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 copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # 3. The name of the author may not be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. #============================================================================= set(_lapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) get_property(_LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES) if (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) include(CheckFunctionExists) else (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) include(CheckFortranFunctionExists) endif (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) set(LAPACK_FOUND FALSE) set(LAPACK95_FOUND FALSE) # TODO: move this stuff to separate module macro(Check_Lapack_Libraries LIBRARIES _prefix _name _flags _list _blas _threads) # This macro checks for the existence of the combination of fortran libraries # given by _list. If the combination is found, this macro checks (using the # Check_Fortran_Function_Exists macro) whether can link against that library # combination using the name of a routine given by _name using the linker # flags given by _flags. If the combination of libraries is found and passes # the link test, LIBRARIES is set to the list of complete library paths that # have been found. Otherwise, LIBRARIES is set to FALSE. # N.B. _prefix is the prefix applied to the names of all cached variables that # are generated internally and marked advanced by this macro. set(_libraries_work TRUE) set(${LIBRARIES}) set(_combined_name) if (NOT _libdir) if (WIN32) set(_libdir ENV LIB) elseif (APPLE) set(_libdir /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV DYLD_LIBRARY_PATH) else () set(_libdir /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV LD_LIBRARY_PATH) endif () endif () foreach(_library ${_list}) set(_combined_name ${_combined_name}_${_library}) if(_libraries_work) if (BLA_STATIC) if (WIN32) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif ( WIN32 ) if (APPLE) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) else (APPLE) set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) endif (APPLE) else (BLA_STATIC) if (CMAKE_SYSTEM_NAME STREQUAL "Linux") # for ubuntu's libblas3gf and liblapack3gf packages #set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) endif () endif (BLA_STATIC) find_library(${_prefix}_${_library}_LIBRARY NAMES ${_library} PATHS ${_libdir} ) mark_as_advanced(${_prefix}_${_library}_LIBRARY) set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY}) set(_libraries_work ${${_prefix}_${_library}_LIBRARY}) endif(_libraries_work) endforeach(_library ${_list}) if(_libraries_work) # Test this combination of libraries. if(UNIX AND BLA_STATIC) set(CMAKE_REQUIRED_LIBRARIES ${_flags} "-Wl,--start-group" ${${LIBRARIES}} ${_blas} "-Wl,--end-group" ${_threads}) else(UNIX AND BLA_STATIC) set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blas} ${_threads}) endif(UNIX AND BLA_STATIC) # message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}") if (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) else (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS) endif (NOT _LANGUAGES_ MATCHES Fortran OR NOT CMAKE_Fortran_COMPILER_WORKS) set(CMAKE_REQUIRED_LIBRARIES) mark_as_advanced(${_prefix}${_combined_name}_WORKS) set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}") endif(_libraries_work) if(_libraries_work) set(${LIBRARIES} ${${LIBRARIES}} ${_blas} ${_threads}) else(_libraries_work) set(${LIBRARIES} FALSE) endif(_libraries_work) endmacro(Check_Lapack_Libraries) set(LAPACK_LINKER_FLAGS) set(LAPACK_LIBRARIES) set(LAPACK95_LIBRARIES) if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) find_package(BLAS) else(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) find_package(BLAS REQUIRED) endif(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) if(BLAS_FOUND) set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS}) if ($ENV{BLA_VENDOR} MATCHES ".+") set(BLA_VENDOR $ENV{BLA_VENDOR}) else ($ENV{BLA_VENDOR} MATCHES ".+") if(NOT BLA_VENDOR) set(BLA_VENDOR "All") endif(NOT BLA_VENDOR) endif ($ENV{BLA_VENDOR} MATCHES ".+") if (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") if(NOT LAPACK_LIBRARIES) check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "goto2" "${BLAS_LIBRARIES}" "" ) endif(NOT LAPACK_LIBRARIES) endif (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") if (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") if(NOT LAPACK_LIBRARIES) check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "openblas" "${BLAS_LIBRARIES}" "" ) endif(NOT LAPACK_LIBRARIES) endif (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") #acml lapack if (BLA_VENDOR MATCHES "ACML.*" OR BLA_VENDOR STREQUAL "All") if (BLAS_LIBRARIES MATCHES ".+acml.+") set (LAPACK_LIBRARIES ${BLAS_LIBRARIES}) endif () endif () # Apple LAPACK library? if (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") if(NOT LAPACK_LIBRARIES) check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "Accelerate" "${BLAS_LIBRARIES}" "" ) endif(NOT LAPACK_LIBRARIES) endif (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") if (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") if ( NOT LAPACK_LIBRARIES ) check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "vecLib" "${BLAS_LIBRARIES}" "" ) endif ( NOT LAPACK_LIBRARIES ) endif (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") # Generic LAPACK library? if (BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All") if ( NOT LAPACK_LIBRARIES ) check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "lapack" "${BLAS_LIBRARIES}" "" ) endif ( NOT LAPACK_LIBRARIES ) endif () #intel lapack if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All") if (NOT WIN32) set(LM "-lm") endif () if (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX) if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) find_PACKAGE(Threads) else(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) find_package(Threads REQUIRED) endif(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) if (BLA_F95) if(NOT LAPACK95_LIBRARIES) # old check_lapack_libraries( LAPACK95_LIBRARIES LAPACK cheev "" "mkl_lapack95" "${BLAS95_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT};${LM}" ) endif(NOT LAPACK95_LIBRARIES) if(NOT LAPACK95_LIBRARIES) # new >= 10.3 check_lapack_libraries( LAPACK95_LIBRARIES LAPACK CHEEV "" "mkl_intel_lp64" "${BLAS95_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT};${LM}" ) endif(NOT LAPACK95_LIBRARIES) else(BLA_F95) if(NOT LAPACK_LIBRARIES) # old check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "mkl_lapack" "${BLAS_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT};${LM}" ) endif(NOT LAPACK_LIBRARIES) if(NOT LAPACK_LIBRARIES) # new >= 10.3 check_lapack_libraries( LAPACK_LIBRARIES LAPACK cheev "" "mkl_gf_lp64" "${BLAS_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT};${LM}" ) endif(NOT LAPACK_LIBRARIES) endif(BLA_F95) endif (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX) endif(BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All") else(BLAS_FOUND) message(STATUS "LAPACK requires BLAS") endif(BLAS_FOUND) if(BLA_F95) if(LAPACK95_LIBRARIES) set(LAPACK95_FOUND TRUE) else(LAPACK95_LIBRARIES) set(LAPACK95_FOUND FALSE) endif(LAPACK95_LIBRARIES) if(NOT LAPACK_FIND_QUIETLY) if(LAPACK95_FOUND) message(STATUS "A library with LAPACK95 API found.") else(LAPACK95_FOUND) if(LAPACK_FIND_REQUIRED) message(FATAL_ERROR "A required library with LAPACK95 API not found. Please specify library location." ) else(LAPACK_FIND_REQUIRED) message(STATUS "A library with LAPACK95 API not found. Please specify library location." ) endif(LAPACK_FIND_REQUIRED) endif(LAPACK95_FOUND) endif(NOT LAPACK_FIND_QUIETLY) set(LAPACK_FOUND "${LAPACK95_FOUND}") set(LAPACK_LIBRARIES "${LAPACK95_LIBRARIES}") else(BLA_F95) if(LAPACK_LIBRARIES) set(LAPACK_FOUND TRUE) else(LAPACK_LIBRARIES) set(LAPACK_FOUND FALSE) endif(LAPACK_LIBRARIES) if(NOT LAPACK_FIND_QUIETLY) if(LAPACK_FOUND) message(STATUS "Found LAPACK: ${LAPACK_LIBRARIES}") else(LAPACK_FOUND) if(LAPACK_FIND_REQUIRED) message(FATAL_ERROR "A required library with LAPACK API not found. Please specify library location." ) else(LAPACK_FIND_REQUIRED) message(STATUS "A library with LAPACK API not found. Please specify library location." ) endif(LAPACK_FIND_REQUIRED) endif(LAPACK_FOUND) endif(NOT LAPACK_FIND_QUIETLY) endif(BLA_F95) set(CMAKE_FIND_LIBRARY_SUFFIXES ${_lapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) cmake/modules/FindMPFR.cmake000066400000000000000000000054231412460263600161650ustar00rootroot00000000000000# Try to find the MPFR library # See http://www.mpfr.org/ # # This module supports requiring a minimum version, e.g. you can do # find_package(MPFR 2.3.0) # to require version 2.3.0 to newer of MPFR. # # Once done this will define # # MPFR_FOUND - system has MPFR lib with correct version # MPFR_INCLUDES - the MPFR include directory # MPFR_LIBRARIES - the MPFR library # MPFR_VERSION - MPFR version # Copyright (c) 2006, 2007 Montel Laurent, # Copyright (c) 2008, 2009 Gael Guennebaud, # Copyright (c) 2010 Jitse Niesen, # Redistribution and use is allowed according to the terms of the BSD license. # Set MPFR_INCLUDES find_path(MPFR_INCLUDES NAMES mpfr.h PATHS $ENV{GMPDIR} ${INCLUDE_INSTALL_DIR} ) # Set MPFR_FIND_VERSION to 1.0.0 if no minimum version is specified if(NOT MPFR_FIND_VERSION) if(NOT MPFR_FIND_VERSION_MAJOR) set(MPFR_FIND_VERSION_MAJOR 1) endif(NOT MPFR_FIND_VERSION_MAJOR) if(NOT MPFR_FIND_VERSION_MINOR) set(MPFR_FIND_VERSION_MINOR 0) endif(NOT MPFR_FIND_VERSION_MINOR) if(NOT MPFR_FIND_VERSION_PATCH) set(MPFR_FIND_VERSION_PATCH 0) endif(NOT MPFR_FIND_VERSION_PATCH) set(MPFR_FIND_VERSION "${MPFR_FIND_VERSION_MAJOR}.${MPFR_FIND_VERSION_MINOR}.${MPFR_FIND_VERSION_PATCH}") endif(NOT MPFR_FIND_VERSION) if(MPFR_INCLUDES) # Set MPFR_VERSION file(READ "${MPFR_INCLUDES}/mpfr.h" _mpfr_version_header) string(REGEX MATCH "define[ \t]+MPFR_VERSION_MAJOR[ \t]+([0-9]+)" _mpfr_major_version_match "${_mpfr_version_header}") set(MPFR_MAJOR_VERSION "${CMAKE_MATCH_1}") string(REGEX MATCH "define[ \t]+MPFR_VERSION_MINOR[ \t]+([0-9]+)" _mpfr_minor_version_match "${_mpfr_version_header}") set(MPFR_MINOR_VERSION "${CMAKE_MATCH_1}") string(REGEX MATCH "define[ \t]+MPFR_VERSION_PATCHLEVEL[ \t]+([0-9]+)" _mpfr_patchlevel_version_match "${_mpfr_version_header}") set(MPFR_PATCHLEVEL_VERSION "${CMAKE_MATCH_1}") set(MPFR_VERSION ${MPFR_MAJOR_VERSION}.${MPFR_MINOR_VERSION}.${MPFR_PATCHLEVEL_VERSION}) # Check whether found version exceeds minimum version if(${MPFR_VERSION} VERSION_LESS ${MPFR_FIND_VERSION}) set(MPFR_VERSION_OK FALSE) message(STATUS "MPFR version ${MPFR_VERSION} found in ${MPFR_INCLUDES}, " "but at least version ${MPFR_FIND_VERSION} is required") else(${MPFR_VERSION} VERSION_LESS ${MPFR_FIND_VERSION}) set(MPFR_VERSION_OK TRUE) endif(${MPFR_VERSION} VERSION_LESS ${MPFR_FIND_VERSION}) endif(MPFR_INCLUDES) # Set MPFR_LIBRARIES find_library(MPFR_LIBRARIES mpfr PATHS $ENV{GMPDIR} ${LIB_INSTALL_DIR}) # Epilogue include(FindPackageHandleStandardArgs) find_package_handle_standard_args(MPFR DEFAULT_MSG MPFR_INCLUDES MPFR_LIBRARIES MPFR_VERSION_OK) mark_as_advanced(MPFR_INCLUDES MPFR_LIBRARIES) cmake/modules/FindMPI.cmake000066400000000000000000000744251412460263600160560ustar00rootroot00000000000000# - Find a Message Passing Interface (MPI) implementation # The Message Passing Interface (MPI) is a library used to write # high-performance distributed-memory parallel applications, and # is typically deployed on a cluster. MPI is a standard interface # (defined by the MPI forum) for which many implementations are # available. All of them have somewhat different include paths, # libraries to link against, etc., and this module tries to smooth # out those differences. # # === Variables === # # This module will set the following variables per language in your project, # where is one of C, CXX, or Fortran: # MPI__FOUND TRUE if FindMPI found MPI flags for # MPI__COMPILER MPI Compiler wrapper for # MPI__COMPILE_FLAGS Compilation flags for MPI programs # MPI__INCLUDE_PATH Include path(s) for MPI header # MPI__LINK_FLAGS Linking flags for MPI programs # MPI__LIBRARIES All libraries to link MPI programs against # Additionally, FindMPI sets the following variables for running MPI # programs from the command line: # MPIEXEC Executable for running MPI programs # MPIEXEC_NUMPROC_FLAG Flag to pass to MPIEXEC before giving # it the number of processors to run on # MPIEXEC_PREFLAGS Flags to pass to MPIEXEC directly # before the executable to run. # MPIEXEC_POSTFLAGS Flags to pass to MPIEXEC after other flags # === Usage === # # To use this module, simply call FindMPI from a CMakeLists.txt file, or # run find_package(MPI), then run CMake. If you are happy with the auto- # detected configuration for your language, then you're done. If not, you # have two options: # 1. Set MPI__COMPILER to the MPI wrapper (mpicc, etc.) of your # choice and reconfigure. FindMPI will attempt to determine all the # necessary variables using THAT compiler's compile and link flags. # 2. If this fails, or if your MPI implementation does not come with # a compiler wrapper, then set both MPI__LIBRARIES and # MPI__INCLUDE_PATH. You may also set any other variables # listed above, but these two are required. This will circumvent # autodetection entirely. # When configuration is successful, MPI__COMPILER will be set to the # compiler wrapper for , if it was found. MPI__FOUND and other # variables above will be set if any MPI implementation was found for , # regardless of whether a compiler was found. # # When using MPIEXEC to execute MPI applications, you should typically use # all of the MPIEXEC flags as follows: # ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} PROCS # ${MPIEXEC_PREFLAGS} EXECUTABLE ${MPIEXEC_POSTFLAGS} ARGS # where PROCS is the number of processors on which to execute the program, # EXECUTABLE is the MPI program, and ARGS are the arguments to pass to the # MPI program. # # === Backward Compatibility === # # For backward compatibility with older versions of FindMPI, these # variables are set, but deprecated: # MPI_FOUND MPI_COMPILER MPI_LIBRARY # MPI_COMPILE_FLAGS MPI_INCLUDE_PATH MPI_EXTRA_LIBRARY # MPI_LINK_FLAGS MPI_LIBRARIES # In new projects, please use the MPI__XXX equivalents. #============================================================================= # Copyright 2001-2011 Kitware, Inc. # Copyright 2010-2011 Todd Gamblin tgamblin@llnl.gov # Copyright 2001-2009 Dave Partyka # # 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 copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # 3. The name of the author may not be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. #============================================================================= # include this to handle the QUIETLY and REQUIRED arguments include(FindPackageHandleStandardArgs) include(GetPrerequisites) # # This part detects MPI compilers, attempting to wade through the mess of compiler names in # a sensible way. # # The compilers are detected in this order: # # 1. Try to find the most generic availble MPI compiler, as this is usually set up by # cluster admins. e.g., if plain old mpicc is available, we'll use it and assume it's # the right compiler. # # 2. If a generic mpicc is NOT found, then we attempt to find one that matches # CMAKE__COMPILER_ID. e.g. if you are using XL compilers, we'll try to find mpixlc # and company, but not mpiicc. This hopefully prevents toolchain mismatches. # # If you want to force a particular MPI compiler other than what we autodetect (e.g. if you # want to compile regular stuff with GNU and parallel stuff with Intel), you can always set # your favorite MPI__COMPILER explicitly and this stuff will be ignored. # # Start out with the generic MPI compiler names, as these are most commonly used. set(_MPI_C_COMPILER_NAMES mpicc mpcc mpicc_r mpcc_r) set(_MPI_CXX_COMPILER_NAMES mpicxx mpiCC mpcxx mpCC mpic++ mpc++ mpicxx_r mpiCC_r mpcxx_r mpCC_r mpic++_r mpc++_r) set(_MPI_Fortran_COMPILER_NAMES mpif95 mpif95_r mpf95 mpf95_r mpif90 mpif90_r mpf90 mpf90_r mpif77 mpif77_r mpf77 mpf77_r) # GNU compiler names set(_MPI_GNU_C_COMPILER_NAMES mpigcc mpgcc mpigcc_r mpgcc_r) set(_MPI_GNU_CXX_COMPILER_NAMES mpig++ mpg++ mpig++_r mpg++_r) set(_MPI_GNU_Fortran_COMPILER_NAMES mpigfortran mpgfortran mpigfortran_r mpgfortran_r mpig77 mpig77_r mpg77 mpg77_r) # Intel MPI compiler names set(_MPI_Intel_C_COMPILER_NAMES mpiicc) set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc mpiicxx mpiic++ mpiiCC) set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort mpiif95 mpiif90 mpiif77) # PGI compiler names set(_MPI_PGI_C_COMPILER_NAMES mpipgcc mppgcc) set(_MPI_PGI_CXX_COMPILER_NAMES mpipgCC mppgCC) set(_MPI_PGI_Fortran_COMPILER_NAMES mpipgf95 mpipgf90 mppgf95 mppgf90 mpipgf77 mppgf77) # XLC MPI Compiler names set(_MPI_XL_C_COMPILER_NAMES mpxlc mpxlc_r mpixlc mpixlc_r) set(_MPI_XL_CXX_COMPILER_NAMES mpixlcxx mpixlC mpixlc++ mpxlcxx mpxlc++ mpixlc++ mpxlCC mpixlcxx_r mpixlC_r mpixlc++_r mpxlcxx_r mpxlc++_r mpixlc++_r mpxlCC_r) set(_MPI_XL_Fortran_COMPILER_NAMES mpixlf95 mpixlf95_r mpxlf95 mpxlf95_r mpixlf90 mpixlf90_r mpxlf90 mpxlf90_r mpixlf77 mpixlf77_r mpxlf77 mpxlf77_r mpixlf mpixlf_r mpxlf mpxlf_r) # append vendor-specific compilers to the list if we either don't know the compiler id, # or if we know it matches the regular compiler. foreach (lang C CXX Fortran) foreach (id GNU Intel PGI XL) if (NOT CMAKE_${lang}_COMPILER_ID OR "${CMAKE_${lang}_COMPILER_ID}" STREQUAL "${id}") list(APPEND _MPI_${lang}_COMPILER_NAMES ${_MPI_${id}_${lang}_COMPILER_NAMES}) endif() unset(_MPI_${id}_${lang}_COMPILER_NAMES) # clean up the namespace here endforeach() endforeach() # Names to try for MPI exec set(_MPI_EXEC_NAMES mpiexec mpirun lamexec srun) # Grab the path to MPI from the registry if we're on windows. set(_MPI_PREFIX_PATH) if(WIN32) list(APPEND _MPI_PREFIX_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MPICH\\SMPD;binary]/..") list(APPEND _MPI_PREFIX_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MPICH2;Path]") list(APPEND _MPI_PREFIX_PATH "$ENV{ProgramW6432}/MPICH2/") endif() # Build a list of prefixes to search for MPI. foreach(SystemPrefixDir ${CMAKE_SYSTEM_PREFIX_PATH}) foreach(MpiPackageDir ${_MPI_PREFIX_PATH}) if(EXISTS ${SystemPrefixDir}/${MpiPackageDir}) list(APPEND _MPI_PREFIX_PATH "${SystemPrefixDir}/${MpiPackageDir}") endif() endforeach() endforeach() # # interrogate_mpi_compiler(lang try_libs) # # Attempts to extract compiler and linker args from an MPI compiler. The arguments set # by this function are: # # MPI__INCLUDE_PATH MPI__LINK_FLAGS MPI__FOUND # MPI__COMPILE_FLAGS MPI__LIBRARIES # # MPI__COMPILER must be set beforehand to the absolute path to an MPI compiler for # . Additionally, MPI__INCLUDE_PATH and MPI__LIBRARIES may be set # to skip autodetection. # # If try_libs is TRUE, this will also attempt to find plain MPI libraries in the usual # way. In general, this is not as effective as interrogating the compilers, as it # ignores language-specific flags and libraries. However, some MPI implementations # (Windows implementations) do not have compiler wrappers, so this approach must be used. # function (interrogate_mpi_compiler lang try_libs) # MPI_${lang}_NO_INTERROGATE will be set to a compiler name when the *regular* compiler was # discovered to be the MPI compiler. This happens on machines like the Cray XE6 that use # modules to set cc, CC, and ftn to the MPI compilers. If the user force-sets another MPI # compiler, MPI_${lang}_COMPILER won't be equal to MPI_${lang}_NO_INTERROGATE, and we'll # inspect that compiler anew. This allows users to set new compilers w/o rm'ing cache. string(COMPARE NOTEQUAL "${MPI_${lang}_NO_INTERROGATE}" "${MPI_${lang}_COMPILER}" interrogate) # If MPI is set already in the cache, don't bother with interrogating the compiler. if (interrogate AND ((NOT MPI_${lang}_INCLUDE_PATH) OR (NOT MPI_${lang}_LIBRARIES))) if (MPI_${lang}_COMPILER) # Check whether the -showme:compile option works. This indicates that we have either OpenMPI # or a newer version of LAM-MPI, and implies that -showme:link will also work. execute_process( COMMAND ${MPI_${lang}_COMPILER} -showme:compile OUTPUT_VARIABLE MPI_COMPILE_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_COMPILE_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) if (MPI_COMPILER_RETURN EQUAL 0) # If we appear to have -showme:compile, then we should # also have -showme:link. Try it. execute_process( COMMAND ${MPI_${lang}_COMPILER} -showme:link OUTPUT_VARIABLE MPI_LINK_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_LINK_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) if (MPI_COMPILER_RETURN EQUAL 0) # We probably have -showme:incdirs and -showme:libdirs as well, # so grab that while we're at it. execute_process( COMMAND ${MPI_${lang}_COMPILER} -showme:incdirs OUTPUT_VARIABLE MPI_INCDIRS OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_INCDIRS ERROR_STRIP_TRAILING_WHITESPACE) execute_process( COMMAND ${MPI_${lang}_COMPILER} -showme:libdirs OUTPUT_VARIABLE MPI_LIBDIRS OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_LIBDIRS ERROR_STRIP_TRAILING_WHITESPACE) else() # reset things here if something went wrong. set(MPI_COMPILE_CMDLINE) set(MPI_LINK_CMDLINE) endif() endif () # Older versions of LAM-MPI have "-showme". Try to find that. if (NOT MPI_COMPILER_RETURN EQUAL 0) execute_process( COMMAND ${MPI_${lang}_COMPILER} -showme OUTPUT_VARIABLE MPI_COMPILE_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_COMPILE_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) endif() # MVAPICH uses -compile-info and -link-info. Try them. if (NOT MPI_COMPILER_RETURN EQUAL 0) execute_process( COMMAND ${MPI_${lang}_COMPILER} -compile-info OUTPUT_VARIABLE MPI_COMPILE_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_COMPILE_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) # If we have compile-info, also have link-info. if (MPI_COMPILER_RETURN EQUAL 0) execute_process( COMMAND ${MPI_${lang}_COMPILER} -link-info OUTPUT_VARIABLE MPI_LINK_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_LINK_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) endif() # make sure we got compile and link. Reset vars if something's wrong. if (NOT MPI_COMPILER_RETURN EQUAL 0) set(MPI_COMPILE_CMDLINE) set(MPI_LINK_CMDLINE) endif() endif() # MPICH just uses "-show". Try it. if (NOT MPI_COMPILER_RETURN EQUAL 0) execute_process( COMMAND ${MPI_${lang}_COMPILER} -show OUTPUT_VARIABLE MPI_COMPILE_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE MPI_COMPILE_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE MPI_COMPILER_RETURN) endif() if (MPI_COMPILER_RETURN EQUAL 0) # We have our command lines, but we might need to copy MPI_COMPILE_CMDLINE # into MPI_LINK_CMDLINE, if we didn't find the link line. if (NOT MPI_LINK_CMDLINE) set(MPI_LINK_CMDLINE ${MPI_COMPILE_CMDLINE}) endif() else() message(STATUS "Unable to determine MPI from MPI driver ${MPI_${lang}_COMPILER}") set(MPI_COMPILE_CMDLINE) set(MPI_LINK_CMDLINE) endif() # Here, we're done with the interrogation part, and we'll try to extract args we care # about from what we learned from the compiler wrapper scripts. # If interrogation came back with something, extract our variable from the MPI command line if (MPI_COMPILE_CMDLINE OR MPI_LINK_CMDLINE) # Extract compile flags from the compile command line. string(REGEX MATCHALL "(^| )-[Df]([^\" ]+|\"[^\"]+\")" MPI_ALL_COMPILE_FLAGS "${MPI_COMPILE_CMDLINE}") set(MPI_COMPILE_FLAGS_WORK) foreach(FLAG ${MPI_ALL_COMPILE_FLAGS}) if (MPI_COMPILE_FLAGS_WORK) set(MPI_COMPILE_FLAGS_WORK "${MPI_COMPILE_FLAGS_WORK} ${FLAG}") else() set(MPI_COMPILE_FLAGS_WORK ${FLAG}) endif() endforeach() # Extract include paths from compile command line string(REGEX MATCHALL "(^| )-I([^\" ]+|\"[^\"]+\")" MPI_ALL_INCLUDE_PATHS "${MPI_COMPILE_CMDLINE}") foreach(IPATH ${MPI_ALL_INCLUDE_PATHS}) string(REGEX REPLACE "^ ?-I" "" IPATH ${IPATH}) string(REGEX REPLACE "//" "/" IPATH ${IPATH}) list(APPEND MPI_INCLUDE_PATH_WORK ${IPATH}) endforeach() # try using showme:incdirs if extracting didn't work. if (NOT MPI_INCLUDE_PATH_WORK) set(MPI_INCLUDE_PATH_WORK ${MPI_INCDIRS}) separate_arguments(MPI_INCLUDE_PATH_WORK) endif() # If all else fails, just search for mpi.h in the normal include paths. if (NOT MPI_INCLUDE_PATH_WORK) set(MPI_HEADER_PATH "MPI_HEADER_PATH-NOTFOUND" CACHE FILEPATH "Cleared" FORCE) find_path(MPI_HEADER_PATH mpi.h HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH} PATH_SUFFIXES include) set(MPI_INCLUDE_PATH_WORK ${MPI_HEADER_PATH}) endif() # Extract linker paths from the link command line string(REGEX MATCHALL "(^| |-Wl,)-L([^\" ]+|\"[^\"]+\")" MPI_ALL_LINK_PATHS "${MPI_LINK_CMDLINE}") set(MPI_LINK_PATH) foreach(LPATH ${MPI_ALL_LINK_PATHS}) string(REGEX REPLACE "^(| |-Wl,)-L" "" LPATH ${LPATH}) string(REGEX REPLACE "//" "/" LPATH ${LPATH}) list(APPEND MPI_LINK_PATH ${LPATH}) endforeach() # try using showme:libdirs if extracting didn't work. if (NOT MPI_LINK_PATH) set(MPI_LINK_PATH ${MPI_LIBDIRS}) separate_arguments(MPI_LINK_PATH) endif() # Extract linker flags from the link command line string(REGEX MATCHALL "(^| )-Wl,([^\" ]+|\"[^\"]+\")" MPI_ALL_LINK_FLAGS "${MPI_LINK_CMDLINE}") set(MPI_LINK_FLAGS_WORK) foreach(FLAG ${MPI_ALL_LINK_FLAGS}) if (MPI_LINK_FLAGS_WORK) set(MPI_LINK_FLAGS_WORK "${MPI_LINK_FLAGS_WORK} ${FLAG}") else() set(MPI_LINK_FLAGS_WORK ${FLAG}) endif() endforeach() # Extract the set of libraries to link against from the link command # line string(REGEX MATCHALL "(^| )-l([^\" ]+|\"[^\"]+\")" MPI_LIBNAMES "${MPI_LINK_CMDLINE}") # add the compiler implicit directories because some compilers # such as the intel compiler have libraries that show up # in the showme list that can only be found in the implicit # link directories of the compiler. Do this for C++ and C # compilers if the implicit link directories are defined. if (DEFINED CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES) set(MPI_LINK_PATH "${MPI_LINK_PATH};${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}") endif () if (DEFINED CMAKE_C_IMPLICIT_LINK_DIRECTORIES) set(MPI_LINK_PATH "${MPI_LINK_PATH};${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}") endif () # Determine full path names for all of the libraries that one needs # to link against in an MPI program foreach(LIB ${MPI_LIBNAMES}) string(REGEX REPLACE "^ ?-l" "" LIB ${LIB}) # MPI_LIB is cached by find_library, but we don't want that. # Clear it first. set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE) find_library(MPI_LIB NAMES ${LIB} HINTS ${MPI_LINK_PATH} NO_DEFAULT_PATH ) find_library(MPI_LIB NAMES ${LIB}) if (MPI_LIB) list(APPEND MPI_LIBRARIES_WORK ${MPI_LIB}) elseif (NOT MPI_FIND_QUIETLY) message(WARNING "Unable to find MPI library ${LIB}") endif() endforeach() # Sanity check MPI_LIBRARIES to make sure there are enough libraries list(LENGTH MPI_LIBRARIES_WORK MPI_NUMLIBS) list(LENGTH MPI_LIBNAMES MPI_NUMLIBS_EXPECTED) if (NOT MPI_NUMLIBS EQUAL MPI_NUMLIBS_EXPECTED) set(MPI_LIBRARIES_WORK "MPI_${lang}_LIBRARIES-NOTFOUND") endif() endif() elseif(try_libs) # If we didn't have an MPI compiler script to interrogate, attempt to find everything # with plain old find functions. This is nasty because MPI implementations have LOTS of # different library names, so this section isn't going to be very generic. We need to # make sure it works for MS MPI, though, since there are no compiler wrappers for that. find_path(MPI_HEADER_PATH mpi.h HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH} PATH_SUFFIXES include Inc) set(MPI_INCLUDE_PATH_WORK ${MPI_HEADER_PATH}) # Decide between 32-bit and 64-bit libraries for Microsoft's MPI if("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) set(MS_MPI_ARCH_DIR amd64) else() set(MS_MPI_ARCH_DIR i386) endif() set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE) find_library(MPI_LIB NAMES mpi mpich mpich2 msmpi HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH} PATH_SUFFIXES lib lib/${MS_MPI_ARCH_DIR} Lib Lib/${MS_MPI_ARCH_DIR} NO_DEFAULT_PATH ) find_library(MPI_LIB NAMES mpi mpich mpich2 msmpi ) set(MPI_LIBRARIES_WORK ${MPI_LIB}) # Right now, we only know about the extra libs for C++. # We could add Fortran here (as there is usually libfmpich, etc.), but # this really only has to work with MS MPI on Windows. # Assume that other MPI's are covered by the compiler wrappers. if (${lang} STREQUAL CXX) set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE) find_library(MPI_LIB NAMES mpi++ mpicxx cxx mpi_cxx HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH} PATH_SUFFIXES lib NO_DEFAULT_PATH ) find_library(MPI_LIB NAMES mpi++ mpicxx cxx mpi_cxx ) if (MPI_LIBRARIES_WORK AND MPI_LIB) list(APPEND MPI_LIBRARIES_WORK ${MPI_LIB}) endif() endif() if (NOT MPI_LIBRARIES_WORK) set(MPI_LIBRARIES_WORK "MPI_${lang}_LIBRARIES-NOTFOUND") endif() endif() # If we found MPI, set up all of the appropriate cache entries set(MPI_${lang}_COMPILE_FLAGS ${MPI_COMPILE_FLAGS_WORK} CACHE STRING "MPI ${lang} compilation flags" FORCE) set(MPI_${lang}_INCLUDE_PATH ${MPI_INCLUDE_PATH_WORK} CACHE STRING "MPI ${lang} include path" FORCE) set(MPI_${lang}_LINK_FLAGS ${MPI_LINK_FLAGS_WORK} CACHE STRING "MPI ${lang} linking flags" FORCE) set(MPI_${lang}_LIBRARIES ${MPI_LIBRARIES_WORK} CACHE STRING "MPI ${lang} libraries to link against" FORCE) mark_as_advanced(MPI_${lang}_COMPILE_FLAGS MPI_${lang}_INCLUDE_PATH MPI_${lang}_LINK_FLAGS MPI_${lang}_LIBRARIES) # clear out our temporary lib/header detectionv variable here. set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE INTERNAL "Scratch variable for MPI lib detection" FORCE) set(MPI_HEADER_PATH "MPI_HEADER_PATH-NOTFOUND" CACHE INTERNAL "Scratch variable for MPI header detection" FORCE) endif() # finally set a found variable for each MPI language if (MPI_${lang}_INCLUDE_PATH AND MPI_${lang}_LIBRARIES) set(MPI_${lang}_FOUND TRUE PARENT_SCOPE) else() set(MPI_${lang}_FOUND FALSE PARENT_SCOPE) endif() endfunction() # This function attempts to compile with the regular compiler, to see if MPI programs # work with it. This is a last ditch attempt after we've tried interrogating mpicc and # friends, and after we've tried to find generic libraries. Works on machines like # Cray XE6, where the modules environment changes what MPI version cc, CC, and ftn use. function(try_regular_compiler lang success) set(scratch_directory ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}) if (${lang} STREQUAL Fortran) set(test_file ${scratch_directory}/cmake_mpi_test.f90) file(WRITE ${test_file} "program hello\n" "include 'mpif.h'\n" "integer ierror\n" "call MPI_INIT(ierror)\n" "call MPI_FINALIZE(ierror)\n" "end\n") else() if (${lang} STREQUAL CXX) set(test_file ${scratch_directory}/cmake_mpi_test.cpp) else() set(test_file ${scratch_directory}/cmake_mpi_test.c) endif() file(WRITE ${test_file} "#include \n" "int main(int argc, char **argv) {\n" " MPI_Init(&argc, &argv);\n" " MPI_Finalize();\n" "}\n") endif() try_compile(compiler_has_mpi ${scratch_directory} ${test_file}) if (compiler_has_mpi) set(MPI_${lang}_NO_INTERROGATE ${CMAKE_${lang}_COMPILER} CACHE STRING "Whether to interrogate MPI ${lang} compiler" FORCE) set(MPI_${lang}_COMPILER ${CMAKE_${lang}_COMPILER} CACHE STRING "MPI ${lang} compiler" FORCE) set(MPI_${lang}_COMPILE_FLAGS "" CACHE STRING "MPI ${lang} compilation flags" FORCE) set(MPI_${lang}_INCLUDE_PATH "" CACHE STRING "MPI ${lang} include path" FORCE) set(MPI_${lang}_LINK_FLAGS "" CACHE STRING "MPI ${lang} linking flags" FORCE) set(MPI_${lang}_LIBRARIES "" CACHE STRING "MPI ${lang} libraries to link against" FORCE) endif() set(${success} ${compiler_has_mpi} PARENT_SCOPE) unset(compiler_has_mpi CACHE) endfunction() # End definitions, commence real work here. # Most mpi distros have some form of mpiexec which gives us something we can reliably look for. find_program(MPIEXEC NAMES ${_MPI_EXEC_NAMES} PATHS ${_MPI_PREFIX_PATH} PATH_SUFFIXES bin DOC "Executable for running MPI programs.") # call get_filename_component twice to remove mpiexec and the directory it exists in (typically bin). # This gives us a fairly reliable base directory to search for /bin /lib and /include from. get_filename_component(_MPI_BASE_DIR "${MPIEXEC}" PATH) get_filename_component(_MPI_BASE_DIR "${_MPI_BASE_DIR}" PATH) set(MPIEXEC_NUMPROC_FLAG "-np" CACHE STRING "Flag used by MPI to specify the number of processes for MPIEXEC; the next option will be the number of processes.") set(MPIEXEC_PREFLAGS "" CACHE STRING "These flags will be directly before the executable that is being run by MPIEXEC.") set(MPIEXEC_POSTFLAGS "" CACHE STRING "These flags will come after all flags given to MPIEXEC.") set(MPIEXEC_MAX_NUMPROCS "2" CACHE STRING "Maximum number of processors available to run MPI applications.") mark_as_advanced(MPIEXEC MPIEXEC_NUMPROC_FLAG MPIEXEC_PREFLAGS MPIEXEC_POSTFLAGS MPIEXEC_MAX_NUMPROCS) #============================================================================= # Backward compatibility input hacks. Propagate the FindMPI hints to C and # CXX if the respective new versions are not defined. Translate the old # MPI_LIBRARY and MPI_EXTRA_LIBRARY to respective MPI_${lang}_LIBRARIES. # # Once we find the new variables, we translate them back into their old # equivalents below. foreach (lang C CXX) # Old input variables. set(_MPI_OLD_INPUT_VARS COMPILER COMPILE_FLAGS INCLUDE_PATH LINK_FLAGS) # Set new vars based on their old equivalents, if the new versions are not already set. foreach (var ${_MPI_OLD_INPUT_VARS}) if (NOT MPI_${lang}_${var} AND MPI_${var}) set(MPI_${lang}_${var} "${MPI_${var}}") endif() endforeach() # Special handling for MPI_LIBRARY and MPI_EXTRA_LIBRARY, which we nixed in the # new FindMPI. These need to be merged into MPI__LIBRARIES if (NOT MPI_${lang}_LIBRARIES AND (MPI_LIBRARY OR MPI_EXTRA_LIBRARY)) set(MPI_${lang}_LIBRARIES ${MPI_LIBRARY} ${MPI_EXTRA_LIBRARY}) endif() endforeach() #============================================================================= # This loop finds the compilers and sends them off for interrogation. foreach (lang C CXX Fortran) if (CMAKE_${lang}_COMPILER_WORKS) # If the user supplies a compiler *name* instead of an absolute path, assume that we need to find THAT compiler. if (MPI_${lang}_COMPILER) is_file_executable(MPI_${lang}_COMPILER MPI_COMPILER_IS_EXECUTABLE) if (NOT MPI_COMPILER_IS_EXECUTABLE) # Get rid of our default list of names and just search for the name the user wants. set(_MPI_${lang}_COMPILER_NAMES ${MPI_${lang}_COMPILER}) set(MPI_${lang}_COMPILER "MPI_${lang}_COMPILER-NOTFOUND" CACHE FILEPATH "Cleared" FORCE) # If the user specifies a compiler, we don't want to try to search libraries either. set(try_libs FALSE) endif() else() set(try_libs TRUE) endif() find_program(MPI_${lang}_COMPILER NAMES ${_MPI_${lang}_COMPILER_NAMES} PATHS "${MPI_HOME}/bin" "$ENV{MPI_HOME}/bin" ${_MPI_PREFIX_PATH}) interrogate_mpi_compiler(${lang} ${try_libs}) mark_as_advanced(MPI_${lang}_COMPILER) # last ditch try -- if nothing works so far, just try running the regular compiler and # see if we can create an MPI executable. set(regular_compiler_worked 0) if (NOT MPI_${lang}_LIBRARIES OR NOT MPI_${lang}_INCLUDE_PATH) try_regular_compiler(${lang} regular_compiler_worked) endif() if (regular_compiler_worked) find_package_handle_standard_args(MPI_${lang} DEFAULT_MSG MPI_${lang}_COMPILER) else() find_package_handle_standard_args(MPI_${lang} DEFAULT_MSG MPI_${lang}_LIBRARIES MPI_${lang}_INCLUDE_PATH) endif() endif() endforeach() #============================================================================= # More backward compatibility stuff # # Bare MPI sans ${lang} vars are set to CXX then C, depending on what was found. # This mimics the behavior of the old language-oblivious FindMPI. set(_MPI_OLD_VARS FOUND COMPILER INCLUDE_PATH COMPILE_FLAGS LINK_FLAGS LIBRARIES) if (MPI_CXX_FOUND) foreach (var ${_MPI_OLD_VARS}) set(MPI_${var} ${MPI_CXX_${var}}) endforeach() elseif (MPI_C_FOUND) foreach (var ${_MPI_OLD_VARS}) set(MPI_${var} ${MPI_C_${var}}) endforeach() else() # Note that we might still have found Fortran, but you'll need to use MPI_Fortran_FOUND set(MPI_FOUND FALSE) endif() # Chop MPI_LIBRARIES into the old-style MPI_LIBRARY and MPI_EXTRA_LIBRARY, and set them in cache. if (MPI_LIBRARIES) list(GET MPI_LIBRARIES 0 MPI_LIBRARY_WORK) set(MPI_LIBRARY ${MPI_LIBRARY_WORK} CACHE FILEPATH "MPI library to link against" FORCE) else() set(MPI_LIBRARY "MPI_LIBRARY-NOTFOUND" CACHE FILEPATH "MPI library to link against" FORCE) endif() list(LENGTH MPI_LIBRARIES MPI_NUMLIBS) if (MPI_NUMLIBS GREATER 1) set(MPI_EXTRA_LIBRARY_WORK ${MPI_LIBRARIES}) list(REMOVE_AT MPI_EXTRA_LIBRARY_WORK 0) set(MPI_EXTRA_LIBRARY ${MPI_EXTRA_LIBRARY_WORK} CACHE STRING "Extra MPI libraries to link against" FORCE) else() set(MPI_EXTRA_LIBRARY "MPI_EXTRA_LIBRARY-NOTFOUND" CACHE STRING "Extra MPI libraries to link against" FORCE) endif() #============================================================================= # unset these vars to cleanup namespace unset(_MPI_OLD_VARS) unset(_MPI_PREFIX_PATH) unset(_MPI_BASE_DIR) foreach (lang C CXX Fortran) unset(_MPI_${lang}_COMPILER_NAMES) endforeach() cmake/modules/FindNumPy.cmake000066400000000000000000000063301412460263600164670ustar00rootroot00000000000000# - Find NumPy # Find the native NumPy includes # This module defines # NUMPY_INCLUDE_DIR, where to find numpy/arrayobject.h, etc. # NUMPY_VERSION, The string version of the numpy version # NUMPY_VERSION_MAJOR, The first number of the numpy version # NUMPY_VERSION_MINOR, The second number of the numpy version # NUMPY_VERSION_MICRO, The third number of the numpy version # NUMPY_FOUND, If false, do not try to use NumPy headers. #============================================================================= # Copyright (C) 2010 Johannes Ring # 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. # # 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. #============================================================================= if(NUMPY_INCLUDE_DIR) # in cache already set(NUMPY_FIND_QUIETLY TRUE) endif(NUMPY_INCLUDE_DIR) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print(numpy.get_include())" OUTPUT_VARIABLE NUMPY_INCLUDE_DIR RESULT_VARIABLE NUMPY_NOT_FOUND OUTPUT_STRIP_TRAILING_WHITESPACE ) if(NUMPY_INCLUDE_DIR) set(NUMPY_FOUND TRUE) set(NUMPY_INCLUDE_DIR ${NUMPY_INCLUDE_DIR} CACHE STRING "NumPy include path") else(NUMPY_INCLUDE_DIR) set(NUMPY_FOUND FALSE) endif(NUMPY_INCLUDE_DIR) if(NUMPY_FOUND) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print(numpy.version.version)" OUTPUT_VARIABLE NUMPY_VERSION RESULT_VARIABLE NUMPY_NOT_FOUND OUTPUT_STRIP_TRAILING_WHITESPACE ) string(REPLACE "." ";" NUMPY_VERSION_LIST ${NUMPY_VERSION}) list(GET NUMPY_VERSION_LIST 0 NUMPY_VERSION_MAJOR) list(GET NUMPY_VERSION_LIST 1 NUMPY_VERSION_MINOR) list(GET NUMPY_VERSION_LIST 2 NUMPY_VERSION_MICRO) if(NOT NUMPY_FIND_QUIETLY) message(STATUS "NumPy header version ${NUMPY_VERSION} found") endif(NOT NUMPY_FIND_QUIETLY) else(NUMPY_FOUND) if(NUMPY_FIND_REQUIRED) message(FATAL_ERROR "NumPy headers missing") endif(NUMPY_FIND_REQUIRED) endif(NUMPY_FOUND) mark_as_advanced(NUMPY_INCLUDE_DIR, NUMPY_VERSION, NUMPY_VERSION_MAJOR, NUMPY_VERSION_MINOR, NUMPY_VERSION_MICRO) cmake/modules/FindPETSc.cmake000066400000000000000000000214761412460263600163450ustar00rootroot00000000000000# - Try to find PETSc # Once done this will define # # PETSC_FOUND - system has PETSc # PETSC_INCLUDE_DIRS - include directories for PETSc # PETSC_LIBRARY_DIRS - library directories for PETSc # PETSC_LIBRARIES - libraries for PETSc # PETSC_STATIC_LIBRARIES - libraries for PETSc (static linking, undefined if not required) # PETSC_VERSION - version for PETSc # PETSC_VERSION_MAJOR - First number in PETSC_VERSION # PETSC_VERSION_MINOR - Second number in PETSC_VERSION # PETSC_VERSION_SUBMINOR - Third number in PETSC_VERSION # PETSC_INT_SIZE - sizeof(PetscInt) # #============================================================================= # Copyright (C) 2010-2016 Garth N. Wells, Anders Logg and Johannes Ring # 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. # # 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. #============================================================================= # Outline: # 1. Get flags from PETSc-generated pkg-config file # 2. Test compile and run program using shared library linking # 3. If shared library linking fails, test with static library linking # Load pkg-config module (provided by CMake) find_package(PkgConfig REQUIRED) # Find PETSc pkg-config file. Note: craypetsc_real is on Cray systems set(ENV{PKG_CONFIG_PATH} "$ENV{CRAY_PETSC_PREFIX_DIR}/lib/pkgconfig:$ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib/pkgconfig:$ENV{PETSC_DIR}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") pkg_search_module(PETSC craypetsc_real PETSc) # Extract major, minor, etc from version string if (PETSC_VERSION) string(REPLACE "." ";" VERSION_LIST ${PETSC_VERSION}) list(GET VERSION_LIST 0 PETSC_VERSION_MAJOR) list(GET VERSION_LIST 1 PETSC_VERSION_MINOR) list(GET VERSION_LIST 2 PETSC_VERSION_SUBMINOR) endif() # Configure PETSc IMPORT (this involves creating an 'imported' target # and attaching 'properties') if (PETSC_FOUND AND NOT TARGET PETSC::petsc) add_library(PETSC::petsc INTERFACE IMPORTED) # Add include paths set_property(TARGET PETSC::petsc PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PETSC_INCLUDE_DIRS}) # Add libraries unset(_libs) foreach (lib ${PETSC_LIBRARIES}) find_library(LIB_${lib} NAMES ${lib} PATHS ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH) list(APPEND _libs ${LIB_${lib}}) endforeach() set_property(TARGET PETSC::petsc PROPERTY INTERFACE_LINK_LIBRARIES "${_libs}") endif() # Configure PETSc 'static' IMPORT (this involves creating an # 'imported' target and attaching 'properties') if (PETSC_FOUND AND NOT TARGET PETSC::petsc_static) add_library(PETSC::petsc_static INTERFACE IMPORTED) # Add libraries (static) unset(_libs) foreach (lib ${PETSC_STATIC_LIBRARIES}) find_library(LIB_${lib} ${lib} HINTS ${PETSC_STATIC_LIBRARY_DIRS}) list(APPEND _libs ${LIB_${lib}}) endforeach() set_property(TARGET PETSC::petsc_static PROPERTY INTERFACE_LINK_LIBRARIES "${_libs}") endif() # Attempt to build and run PETSc test program if (DOLFIN_SKIP_BUILD_TESTS) # Assume PETSc works set(PETSC_TEST_RUNS TRUE) elseif (PETSC_FOUND) # Create PETSc test program set(PETSC_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/petsc_test_lib.cpp") file(WRITE ${PETSC_TEST_LIB_CPP} " #include \"petscts.h\" #include \"petsc.h\" int main() { PetscErrorCode ierr; TS ts; int argc = 0; char** argv = NULL; ierr = PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);CHKERRQ(ierr); ierr = TSCreate(PETSC_COMM_WORLD,&ts);CHKERRQ(ierr); ierr = TSSetFromOptions(ts);CHKERRQ(ierr); ierr = TSDestroy(&ts);CHKERRQ(ierr); ierr = PetscFinalize();CHKERRQ(ierr); return 0; } ") # Add MPI variables if MPI has been found if (MPI_C_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_C_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_C_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_C_COMPILE_FLAGS}") endif() # Try to run test program (shared linking) try_run( PETSC_TEST_LIB_EXITCODE PETSC_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${PETSC_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} PETSC::petsc COMPILE_OUTPUT_VARIABLE PETSC_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE PETSC_TEST_LIB_OUTPUT) # Check program output if (PETSC_TEST_LIB_COMPILED AND PETSC_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Test PETSC_TEST_RUNS with shared library linking - Success") set(PETSC_TEST_RUNS TRUE) # Static libraries not required, so unset set_property(TARGET PETSC::petsc_static PROPERTY INTERFACE_LINK_LIBRARIES) else() message(STATUS "Test PETSC_TEST_RUNS with shared library linking - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run PETSc test with shared library linking:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "PETSC_TEST_LIB_EXITCODE: ${PETSC_TEST_LIB_EXITCODE}\n" "PETSC_TEST_LIB_COMPILED: ${PETSC_TEST_LIB_COMPILED}\n" "PETSC_TEST_LIB_COMPILE_OUTPUT: ${PETSC_TEST_LIB_COMPILE_OUTPUT}\n" "PETSC_TEST_LIB_OUTPUT: ${PETSC_TEST_LIB_OUTPUT}\n\n") # Add MPI variables if MPI has been found if (MPI_C_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_C_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_C_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_C_COMPILE_FLAGS}") endif() # Try to run test program (static linking) try_run( PETSC_TEST_LIB_EXITCODE PETSC_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${PETSC_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} PETSC::petsc PETSC::petsc_static COMPILE_OUTPUT_VARIABLE PETSC_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE PETSC_TEST_LIB_OUTPUT) if (PETSC_TEST_LIB_COMPILED AND PETSC_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Test PETSC_TEST_RUNS static linking - Success") set(PETSC_TEST_RUNS TRUE) else() message(STATUS "Test PETSC_TEST_RUNS static linking - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run PETSc test with static library linking:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "PETSC_TEST_LIB_EXITCODE: ${PETSC_TEST_LIB_EXITCODE}\n" "PETSC_TEST_LIB_COMPILED: ${PETSC_TEST_LIB_COMPILED}\n" "PETSC_TEST_LIB_COMPILE_OUTPUT: ${PETSC_TEST_LIB_COMPILE_OUTPUT}\n" "PETSC_TEST_LIB_OUTPUT: ${PETSC_TEST_LIB_OUTPUT}\n\n") set(PETSC_TEST_RUNS FALSE) endif() endif() endif() # Check sizeof(PetscInt) if (PETSC_INCLUDE_DIRS) include(CheckTypeSize) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${PETSC_INCLUDE_DIRS}) set(CMAKE_EXTRA_INCLUDE_FILES petscsys.h) check_type_size("PetscInt" PETSC_INT_SIZE) unset(CMAKE_EXTRA_INCLUDE_FILES) unset(CMAKE_REQUIRED_INCLUDES) endif() # Standard package handling include(FindPackageHandleStandardArgs) if (PETSC_FOUND) find_package_handle_standard_args(PETSc REQUIRED_VARS PETSC_FOUND PETSC_TEST_RUNS VERSION_VAR PETSC_VERSION FAIL_MESSAGE "PETSc could not be configured.") else() find_package_handle_standard_args(PETSc REQUIRED_VARS PETSC_FOUND FAIL_MESSAGE "PETSc could not be found. Be sure to set PETSC_DIR.") endif() cmake/modules/FindPETSc4py.cmake000066400000000000000000000104601412460263600167710ustar00rootroot00000000000000# - Try to find petsc4py # Once done this will define # # PETSC4PY_FOUND - system has petsc4py # PETSC4PY_INCLUDE_DIRS - include directories for petsc4py # PETSC4PY_VERSION - version of petsc4py # PETSC4PY_VERSION_MAJOR - first number in PETSC4PY_VERSION # PETSC4PY_VERSION_MINOR - second number in PETSC4PY_VERSION # Based on FindNumPy.cmake #============================================================================= # Copyright (C) 2013 Lawrence Mitchell # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'PETSc4Py'") if(PETSC4PY_INCLUDE_DIRS) # In cache already set(PETSC4PY_FIND_QUIETLY TRUE) endif(PETSC4PY_INCLUDE_DIRS) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import petsc4py; print(petsc4py.get_include())" OUTPUT_VARIABLE PETSC4PY_INCLUDE_DIRS RESULT_VARIABLE PETSC4PY_NOT_FOUND ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if(PETSC4PY_INCLUDE_DIRS) set(PETSC4PY_FOUND TRUE) set(PETSC4PY_INCLUDE_DIRS ${PETSC4PY_INCLUDE_DIRS} CACHE STRING "petsc4py include path") else(PETSC4PY_INCLUDE_DIRS) set(PETSC4PY_FOUND FALSE) endif(PETSC4PY_INCLUDE_DIRS) if(PETSC4PY_FOUND) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import petsc4py; print(petsc4py.__version__)" OUTPUT_VARIABLE PETSC4PY_VERSION RESULT_VARIABLE PETSC4PY_NOT_FOUND OUTPUT_STRIP_TRAILING_WHITESPACE ) string(REPLACE "." ";" PETSC4PY_VERSION_LIST ${PETSC4PY_VERSION}) list(GET PETSC4PY_VERSION_LIST 0 PETSC4PY_VERSION_MAJOR) list(GET PETSC4PY_VERSION_LIST 1 PETSC4PY_VERSION_MINOR) if(NOT PETSC4PY_FIND_QUIETLY) message(STATUS "petsc4py version ${PETSC4PY_VERSION} found") endif(NOT PETSC4PY_FIND_QUIETLY) else(PETSC4PY_FOUND) if(PETSC4PY_FIND_REQUIRED) message(FATAL_ERROR "petsc4py missing") endif(PETSC4PY_FIND_REQUIRED) endif(PETSC4PY_FOUND) mark_as_advanced(PETSC4PY_INCLUDE_DIRS, PETSC4PY_VERSION, PETSC4PY_VERSION_MAJOR, PETSC4PY_VERSION_MINOR) if (PETSc4py_FIND_VERSION) # Check if version found is >= required version if (NOT "${PETSC4PY_VERSION}" VERSION_LESS "${PETSc4py_FIND_VERSION}") set(PETSC4PY_VERSION_OK TRUE) endif() else() # No specific version requested set(PETSC4PY_VERSION_OK TRUE) endif() mark_as_advanced(PETSC4PY_VERSION_OK) # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(PETSc4py "PETSc4py could not be found. Be sure to set PYTHONPATH appropriately." PETSC4PY_INCLUDE_DIRS PETSC4PY_VERSION PETSC4PY_VERSION_OK) # Check petsc4py.i for PETSC_INT if(PETSC4PY_INCLUDE_DIRS) file(STRINGS "${PETSC4PY_INCLUDE_DIRS}/petsc4py/petsc4py.i" PETSC4PY_INT) string(REGEX MATCH "SWIG_TYPECHECK_INT[0-9]+" PETSC4PY_INT "${PETSC4PY_INT}") string(REPLACE "SWIG_TYPECHECK_INT" "" PETSC4PY_INT "${PETSC4PY_INT}") math(EXPR PETSC_INT "${PETSC_INT_SIZE}*8") if(NOT PETSC_INT STREQUAL PETSC4PY_INT) message(STATUS "PETSC_INT = ${PETSC4PY_INT} ${PETSC_INT}") message(STATUS " - does not match") set(PETSC4PY_FOUND FALSE) endif() endif()cmake/modules/FindParMETIS.cmake000066400000000000000000000125441412460263600167470ustar00rootroot00000000000000# - Try to find ParMETIS # Once done this will define # # PARMETIS_FOUND - system has ParMETIS # PARMETIS_INCLUDE_DIRS - include directories for ParMETIS # PARMETIS_LIBRARIES - libraries for ParMETIS # PARMETIS_VERSION - version for ParMETIS #============================================================================= # Copyright (C) 2010 Garth N. Wells, Anders Logg and Johannes Ring # 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. # # 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. #============================================================================= if (MPI_CXX_FOUND) find_path(PARMETIS_INCLUDE_DIRS parmetis.h HINTS ${PARMETIS_DIR}/include $ENV{PARMETIS_DIR}/include ${PETSC_INCLUDE_DIRS} DOC "Directory where the ParMETIS header files are located" ) find_library(PARMETIS_LIBRARY parmetis HINTS ${PARMETIS_DIR}/lib $ENV{PARMETIS_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "Directory where the ParMETIS library is located" ) find_library(PARMETIS_LIBRARY parmetis DOC "Directory where the ParMETIS library is located" ) find_library(METIS_LIBRARY metis HINTS ${PARMETIS_DIR}/lib $ENV{PARMETIS_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "Directory where the METIS library is located" ) find_library(METIS_LIBRARY metis DOC "Directory where the METIS library is located" ) set(PARMETIS_LIBRARIES ${PARMETIS_LIBRARY}) if (METIS_LIBRARY) set(PARMETIS_LIBRARIES ${PARMETIS_LIBRARIES} ${METIS_LIBRARY}) endif() # Try compiling and running test program if (DOLFIN_SKIP_BUILD_TESTS) set(PARMETIS_TEST_RUNS TRUE) set(PARMETIS_VERSION "UNKNOWN") set(PARMETIS_VERSION_OK TRUE) elseif (PARMETIS_INCLUDE_DIRS AND PARMETIS_LIBRARY) # Set flags for building test program set(CMAKE_REQUIRED_INCLUDES ${PARMETIS_INCLUDE_DIRS} ${MPI_CXX_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${PARMETIS_LIBRARIES} ${MPI_CXX_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} ${MPI_CXX_COMPILE_FLAGS}) # Check ParMETIS version set(PARMETIS_CONFIG_TEST_VERSION_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/parmetis_config_test_version.cpp") file(WRITE ${PARMETIS_CONFIG_TEST_VERSION_CPP} " #define MPICH_IGNORE_CXX_SEEK 1 #include #include \"parmetis.h\" int main() { #ifdef PARMETIS_SUBMINOR_VERSION std::cout << PARMETIS_MAJOR_VERSION << \".\" << PARMETIS_MINOR_VERSION << \".\" << PARMETIS_SUBMINOR_VERSION; #else std::cout << PARMETIS_MAJOR_VERSION << \".\" << PARMETIS_MINOR_VERSION; #endif return 0; } ") try_run( PARMETIS_CONFIG_TEST_VERSION_EXITCODE PARMETIS_CONFIG_TEST_VERSION_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${PARMETIS_CONFIG_TEST_VERSION_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE PARMETIS_CONFIG_TEST_VERSION_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE PARMETIS_CONFIG_TEST_VERSION_OUTPUT ) if (PARMETIS_CONFIG_TEST_VERSION_EXITCODE EQUAL 0) set(PARMETIS_VERSION ${PARMETIS_CONFIG_TEST_VERSION_OUTPUT} CACHE TYPE STRING) mark_as_advanced(PARMETIS_VERSION) endif() if (ParMETIS_FIND_VERSION) # Check if version found is >= required version if (NOT "${PARMETIS_VERSION}" VERSION_LESS "${ParMETIS_FIND_VERSION}") set(PARMETIS_VERSION_OK TRUE) endif() else() # No specific version requested set(PARMETIS_VERSION_OK TRUE) endif() mark_as_advanced(PARMETIS_VERSION_OK) # Build and run test program include(CheckCXXSourceRuns) check_cxx_source_runs(" #define MPICH_IGNORE_CXX_SEEK 1 #include #include int main() { // FIXME: Find a simple but sensible test for ParMETIS return 0; } " PARMETIS_TEST_RUNS) endif() endif() # Standard package handling find_package_handle_standard_args(ParMETIS "ParMETIS could not be found/configured." PARMETIS_LIBRARIES PARMETIS_TEST_RUNS PARMETIS_INCLUDE_DIRS PARMETIS_VERSION PARMETIS_VERSION_OK) cmake/modules/FindPythonModule.cmake000066400000000000000000000023441412460263600200470ustar00rootroot00000000000000# Find if a Python module is installed # Found at http://www.cmake.org/pipermail/cmake/2011-January/041666.html # To use do: find_python_module(PyQt4 REQUIRED) # Modified to give PY_FOO_FOUND global scope function(find_python_module module) string(TOUPPER ${module} module_upper) if(NOT PY_${module_upper}_path) if(ARGC GREATER 1 AND ARGV1 STREQUAL "REQUIRED") set(${module}_FIND_REQUIRED TRUE) endif() # A module's location is usually a directory, but for binary modules # it's a .so file. execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" "import re, ${module}; print(re.compile('/__init__.py.*').sub('',${module}.__file__))" RESULT_VARIABLE _${module}_status OUTPUT_VARIABLE _${module}_location ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT _${module}_status) set(PY_${module_upper}_path ${_${module}_location} CACHE STRING "Location of Python module ${module}") endif(NOT _${module}_status) endif(NOT PY_${module_upper}_path) find_package_handle_standard_args(PY_${module} DEFAULT_MSG PY_${module_upper}_path) # Raise scope (make PY_FOO_FOUND global) SET(PY_${module_upper}_FOUND ${PY_${module_upper}_FOUND} PARENT_SCOPE) endfunction(find_python_module)cmake/modules/FindSCOTCH.cmake000066400000000000000000000326671412460263600164160ustar00rootroot00000000000000# - Try to find SCOTCH # Once done this will define # # SCOTCH_FOUND - system has found SCOTCH # SCOTCH_INCLUDE_DIRS - include directories for SCOTCH # SCOTCH_LIBARIES - libraries for SCOTCH # SCOTCH_VERSION - version for SCOTCH # # Variables used by this module, they can change the default behaviour and # need to be set before calling find_package: # # SCOTCH_DEBUG - Set this to TRUE to enable debugging output # of FindScotchPT.cmake if you are having problems. # Please enable this before filing any bug reports. #============================================================================= # Copyright (C) 2010-2011 Garth N. Wells, Johannes Ring and Anders Logg # 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. # # 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. #============================================================================= set(SCOTCH_FOUND FALSE) message(STATUS "Checking for package 'SCOTCH-PT'") # Check for header file find_path(SCOTCH_INCLUDE_DIRS ptscotch.h HINTS ${SCOTCH_DIR}/include $ENV{SCOTCH_DIR}/include ${PETSC_INCLUDE_DIRS} PATH_SUFFIXES scotch DOC "Directory where the SCOTCH-PT header is located" ) # Check for scotch find_library(SCOTCH_LIBRARY NAMES scotch HINTS ${SCOTCH_DIR}/lib $ENV{SCOTCH_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "The SCOTCH library" ) find_library(SCOTCH_LIBRARY NAMES scotch DOC "The SCOTCH library" ) # Check for scotcherr find_library(SCOTCHERR_LIBRARY NAMES scotcherr HINTS ${SCOTCH_DIR}/lib $ENV{SCOTCH_DIR}/lib NO_DEFAULT_PATH DOC "The SCOTCH-ERROR library" ) find_library(SCOTCHERR_LIBRARY NAMES scotcherr DOC "The SCOTCH-ERROR library" ) # Check for ptscotch find_library(PTSCOTCH_LIBRARY NAMES ptscotch HINTS ${SCOTCH_DIR}/lib $ENV{SCOTCH_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "The PTSCOTCH library" ) find_library(PTSCOTCH_LIBRARY NAMES ptscotch DOC "The PTSCOTCH library" ) # Check for ptesmumps find_library(PTESMUMPS_LIBRARY NAMES ptesmumps esmumps HINTS ${SCOTCH_DIR}/lib $ENV{SCOTCH_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "The PTSCOTCH-ESMUMPS library" ) find_library(PTESMUMPS_LIBRARY NAMES ptesmumps esmumps DOC "The PTSCOTCH-ESMUMPS library" ) # Check for ptscotcherr find_library(PTSCOTCHERR_LIBRARY NAMES ptscotcherr HINTS ${SCOTCH_DIR}/lib $ENV{SCOTCH_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "The PTSCOTCH-ERROR library" ) find_library(PTSCOTCHERR_LIBRARY NAMES ptscotcherr DOC "The PTSCOTCH-ERROR library" ) set(SCOTCH_LIBRARIES ${PTSCOTCH_LIBRARY}) if (PTESMUMPS_LIBRARY) set(SCOTCH_LIBRARIES ${SCOTCH_LIBRARIES} ${PTESMUMPS_LIBRARY}) endif() set(SCOTCH_LIBRARIES ${SCOTCH_LIBRARIES} ${PTSCOTCHERR_LIBRARY}) # Basic check of SCOTCH_VERSION which does not require compilation if (SCOTCH_INCLUDE_DIRS) file(STRINGS "${SCOTCH_INCLUDE_DIRS}/ptscotch.h" PTSCOTCH_H) string(REGEX MATCH "SCOTCH_VERSION [0-9]+" SCOTCH_VERSION "${PTSCOTCH_H}") string(REGEX MATCH "[0-9]+" SCOTCH_VERSION "${SCOTCH_VERSION}") endif() # If SCOTCH_VERSION was not found in ptscotch.h, look in scotch.h if (SCOTCH_INCLUDE_DIRS AND NOT SCOTCH_VERSION) file(STRINGS "${SCOTCH_INCLUDE_DIRS}/scotch.h" SCOTCH_H) string(REGEX MATCH "SCOTCH_VERSION [0-9]+" SCOTCH_VERSION "${SCOTCH_H}") string(REGEX MATCH "[0-9]+" SCOTCH_VERSION "${SCOTCH_VERSION}") endif() # For SCOTCH version > 6, need to add libraries scotch and ptscotch if (NOT "${SCOTCH_VERSION}" VERSION_LESS "6") set(SCOTCH_LIBRARIES ${PTSCOTCH_LIBRARY} ${SCOTCH_LIBRARY} ${PTSCOTCHERR_LIBRARY}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${SCOTCH_LIBRARY}) endif() # Try compiling and running test program if (DOLFIN_SKIP_BUILD_TESTS) message(STATUS "Found SCOTCH (version ${SCOTCH_VERSION})") set(SCOTCH_TEST_RUNS TRUE) elseif (SCOTCH_INCLUDE_DIRS AND SCOTCH_LIBRARIES) if (SCOTCH_DEBUG) message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "location of ptscotch.h: ${SCOTCH_INCLUDE_DIRS}/ptscotch.h") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "location of libscotch: ${SCOTCH_LIBRARY}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "location of libptscotch: ${PTSCOTCH_LIBRARY}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "location of libptscotcherr: ${PTSCOTCHERR_LIBRARY}") endif() # Set flags for building test program set(CMAKE_REQUIRED_INCLUDES ${SCOTCH_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${SCOTCH_LIBRARIES}) #set(CMAKE_REQUIRED_LIBRARIES ${SCOTCH_LIBRARY} ${SCOTCHERR_LIBRARY}) # Add MPI variables if MPI has been found if (MPI_CXX_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_CXX_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_CXX_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_CXX_COMPILE_FLAGS}") endif() set(SCOTCH_CONFIG_TEST_VERSION_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/scotch_config_test_version.cpp") file(WRITE ${SCOTCH_CONFIG_TEST_VERSION_CPP} " #define MPICH_IGNORE_CXX_SEEK 1 #include #include #include #include #include int main() { std::cout << SCOTCH_VERSION << \".\" << SCOTCH_RELEASE << \".\" << SCOTCH_PATCHLEVEL; return 0; } ") try_run( SCOTCH_CONFIG_TEST_VERSION_EXITCODE SCOTCH_CONFIG_TEST_VERSION_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SCOTCH_CONFIG_TEST_VERSION_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT RUN_OUTPUT_VARIABLE OUTPUT ) # Set version number if (SCOTCH_CONFIG_TEST_VERSION_EXITCODE EQUAL 0) set(SCOTCH_VERSION ${OUTPUT} CACHE TYPE STRING) message(STATUS "Found SCOTCH (version ${SCOTCH_VERSION})") endif() # PT-SCOTCH was first introduced in SCOTCH version 5.0 # FIXME: parallel graph partitioning features in PT-SCOTCH was first # introduced in 5.1. Do we require version 5.1? if (NOT ${SCOTCH_VERSION} VERSION_LESS "5.0") set(SCOTCH_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/scotch_test_lib.cpp") file(WRITE ${SCOTCH_TEST_LIB_CPP} " #define MPICH_IGNORE_CXX_SEEK 1 #include #include #include #include #include #include int main() { int provided; SCOTCH_Dgraph dgrafdat; MPI_Init_thread(0, 0, MPI_THREAD_MULTIPLE, &provided); if (SCOTCH_dgraphInit(&dgrafdat, MPI_COMM_WORLD) != 0) { if (MPI_THREAD_MULTIPLE > provided) { std::cout << \"MPI implementation is not thread-safe:\" << std::endl; std::cout << \"SCOTCH should be compiled without SCOTCH_PTHREAD\" << std::endl; exit(1); } else { std::cout << \"libptscotch linked to libscotch or other unknown error\" << std::endl; exit(2); } } else { SCOTCH_dgraphExit(&dgrafdat); } MPI_Finalize(); return 0; } ") message(STATUS "Performing test SCOTCH_TEST_RUNS") try_run( SCOTCH_TEST_LIB_EXITCODE SCOTCH_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SCOTCH_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE SCOTCH_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SCOTCH_TEST_LIB_OUTPUT ) if (SCOTCH_TEST_LIB_COMPILED AND SCOTCH_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Performing test SCOTCH_TEST_RUNS - Success") set(SCOTCH_TEST_RUNS TRUE) else() message(STATUS "Performing test SCOTCH_TEST_RUNS - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run SCOTCH test:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "SCOTCH_TEST_LIB_EXITCODE: ${SCOTCH_TEST_LIB_EXITCODE}\n" "SCOTCH_TEST_LIB_COMPILED: ${SCOTCH_TEST_LIB_COMPILED}\n" "SCOTCH_TEST_LIB_COMPILE_OUTPUT: ${SCOTCH_TEST_LIB_COMPILE_OUTPUT}\n" "SCOTCH_TEST_LIB_OUTPUT: ${SCOTCH_TEST_LIB_OUTPUT}\n\n") if (SCOTCH_DEBUG) # Output some variables message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_COMPILED = ${SCOTCH_TEST_LIB_COMPILED}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_COMPILE_OUTPUT = ${SCOTCH_TEST_LIB_COMPILE_OUTPUT}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_EXITCODE = ${SCOTCH_TEST_LIB_EXITCODE}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_OUTPUT = ${SCOTCH_TEST_LIB_OUTPUT}") endif() endif() # If program does not run, try adding zlib library and test again if(NOT SCOTCH_TEST_RUNS) if (NOT ZLIB_FOUND) find_package(ZLIB) endif() if (ZLIB_INCLUDE_DIRS AND ZLIB_LIBRARIES) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${ZLIB_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${ZLIB_LIBRARIES}) message(STATUS "Performing test SCOTCH_ZLIB_TEST_RUNS") try_run( SCOTCH_ZLIB_TEST_LIB_EXITCODE SCOTCH_ZLIB_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SCOTCH_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE SCOTCH_ZLIB_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SCOTCH_ZLIB_TEST_LIB_OUTPUT ) # Add zlib flags if required and set test run to 'true' if (SCOTCH_ZLIB_TEST_LIB_COMPILED AND SCOTCH_ZLIB_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Performing test SCOTCH_ZLIB_TEST_RUNS - Success") set(SCOTCH_INCLUDE_DIRS ${SCOTCH_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS}) set(SCOTCH_LIBRARIES ${SCOTCH_LIBRARIES} ${ZLIB_LIBRARIES}) set(SCOTCH_TEST_RUNS TRUE) else() message(STATUS "Performing test SCOTCH_ZLIB_TEST_RUNS - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run SCOTCH test with zlib:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "SCOTCH_ZLIB_TEST_LIB_EXITCODE: ${SCOTCH_ZLIB_TEST_LIB_EXITCODE}\n" "SCOTCH_ZLIB_TEST_LIB_COMPILED: ${SCOTCH_ZLIB_TEST_LIB_COMPILED}\n" "SCOTCH_ZLIB_TEST_LIB_COMPILE_OUTPUT: ${SCOTCH_ZLIB_TEST_LIB_COMPILE_OUTPUT}\n" "SCOTCH_ZLIB_TEST_LIB_OUTPUT: ${SCOTCH_ZLIB_TEST_LIB_OUTPUT}\n\n") if (SCOTCH_DEBUG) message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_ZLIB_TEST_LIB_COMPILED = ${SCOTCH_ZLIB_TEST_LIB_COMPILED}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_ZLIB_TEST_LIB_COMPILE_OUTPUT = ${SCOTCH_ZLIB_TEST_LIB_COMPILE_OUTPUT}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_EXITCODE = ${SCOTCH_TEST_LIB_EXITCODE}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SCOTCH_TEST_LIB_OUTPUT = ${SCOTCH_TEST_LIB_OUTPUT}") endif() endif() endif() endif() endif() endif() # Standard package handling find_package_handle_standard_args(SCOTCH "SCOTCH could not be found. Be sure to set SCOTCH_DIR." SCOTCH_LIBRARIES SCOTCH_INCLUDE_DIRS SCOTCH_TEST_RUNS) cmake/modules/FindSLEPc.cmake000066400000000000000000000205701412460263600163270ustar00rootroot00000000000000# - Try to find SLEPC # Once done this will define # # SLEPC_FOUND - system has SLEPc # SLEPC_INCLUDE_DIRS - include directories for SLEPc # SLEPC_LIBRARY_DIRS - library directories for SLEPc # SLEPC_LIBARIES - libraries for SLEPc # SLEPC_STATIC_LIBARIES - ibraries for SLEPc (static linking, undefined if not required) # SLEPC_VERSION - version of SLEPc # SLEPC_VERSION_MAJOR - First number in SLEPC_VERSION # SLEPC_VERSION_MINOR - Second number in SLEPC_VERSION # SLEPC_VERSION_SUBMINOR - Third number in SLEPC_VERSION #============================================================================= # Copyright (C) 2010-2016 Garth N. Wells, Anders Logg and Johannes Ring # 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. # # 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. #============================================================================= # Load CMake pkg-config module find_package(PkgConfig REQUIRED) # Find SLEPc pkg-config file set(ENV{PKG_CONFIG_PATH} "$ENV{SLEPC_DIR}/$ENV{PETSC_ARCH}/lib/pkgconfig:$ENV{SLEPC_DIR}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") set(ENV{PKG_CONFIG_PATH} "$ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib/pkgconfig:$ENV{PETSC_DIR}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}") set(ENV{PKG_CONFIG_PATH} "$ENV{PETSC_DIR}/$ENV{PETSC_ARCH}:$ENV{PETSC_DIR}:$ENV{PKG_CONFIG_PATH}") pkg_search_module(SLEPC crayslepc_real SLEPc) # Extract major, minor, etc from version string if (SLEPC_VERSION) string(REPLACE "." ";" VERSION_LIST ${SLEPC_VERSION}) list(GET VERSION_LIST 0 SLEPC_VERSION_MAJOR) list(GET VERSION_LIST 1 SLEPC_VERSION_MINOR) list(GET VERSION_LIST 2 SLEPC_VERSION_SUBMINOR) endif() # Configure SLEPc IMPORT (this involves creating an 'imported' target # and attaching 'properties') if (SLEPC_FOUND AND NOT TARGET SLEPC::slepc) add_library(SLEPC::slepc INTERFACE IMPORTED) # Add include paths set_property(TARGET SLEPC::slepc PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${SLEPC_INCLUDE_DIRS}) # Add libraries unset(_libs) foreach (lib ${SLEPC_LIBRARIES}) find_library(LIB_${lib} NAMES ${lib} PATHS ${SLEPC_LIBRARY_DIRS} NO_DEFAULT_PATH) list(APPEND _libs ${LIB_${lib}}) endforeach() set_property(TARGET SLEPC::slepc PROPERTY INTERFACE_LINK_LIBRARIES "${_libs}") endif() if (SLEPC_FOUND AND NOT TARGET SLEPC::slepc_static) add_library(SLEPC::slepc_static INTERFACE IMPORTED) # Add libraries (static) unset(_libs) foreach (lib ${SLEPC_STATIC_LIBRARIES}) find_library(LIB_${lib} ${lib} HINTS ${SLEPC_STATIC_LIBRARY_DIRS}) list(APPEND _libs ${LIB_${lib}}) endforeach() set_property(TARGET SLEPC::slepc_static PROPERTY INTERFACE_LINK_LIBRARIES "${_libs}") endif() # Compile and run test if (DOLFIN_SKIP_BUILD_TESTS) # Assume SLEPc works set(SLEPC_TEST_RUNS TRUE) elseif (SLEPC_FOUND) # Create SLEPc test program set(SLEPC_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/slepc_test_lib.cpp") file(WRITE ${SLEPC_TEST_LIB_CPP} " #include \"petsc.h\" #include \"slepceps.h\" int main() { PetscErrorCode ierr; int argc = 0; char** argv = NULL; ierr = SlepcInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL); EPS eps; ierr = EPSCreate(PETSC_COMM_SELF, &eps); CHKERRQ(ierr); //ierr = EPSSetFromOptions(eps); CHKERRQ(ierr); ierr = EPSDestroy(&eps); CHKERRQ(ierr); ierr = SlepcFinalize(); CHKERRQ(ierr); return 0; } ") # Add MPI variables if MPI has been found if (MPI_C_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_C_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_C_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_C_COMPILE_FLAGS}") endif() # Try to run test program (shared linking) try_run( SLEPC_TEST_LIB_EXITCODE SLEPC_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SLEPC_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} PETSC::petsc SLEPC::slepc COMPILE_OUTPUT_VARIABLE SLEPC_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SLEPC_TEST_LIB_OUTPUT ) if (SLEPC_TEST_LIB_COMPILED AND SLEPC_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Test SLEPC_TEST_RUNS with shared library linking - Success") set(SLEPC_TEST_RUNS TRUE) # Static libraries not required, so unset set_property(TARGET SLEPC::slepc_static PROPERTY INTERFACE_LINK_LIBRARIES) else() message(STATUS "Test SLEPC_TEST_RUNS with shared library linking - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run SLEPc test with shared library linking:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "SLEPC_TEST_LIB_EXITCODE: ${SLEPC_TEST_LIB_EXITCODE}\n" "SLEPC_TEST_LIB_COMPILED: ${SLEPC_TEST_LIB_COMPILED}\n" "SLEPC_TEST_LIB_COMPILE_OUTPUT: ${SLEPC_TEST_LIB_COMPILE_OUTPUT}\n" "SLEPC_TEST_LIB_OUTPUT: ${SLEPC_TEST_LIB_OUTPUT}\n\n") # Add MPI variables if MPI has been found if (MPI_C_FOUND) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_C_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_C_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_C_COMPILE_FLAGS}") endif() # Try to run test program (static linking) try_run( SLEPC_TEST_STATIC_LIBS_EXITCODE SLEPC_TEST_STATIC_LIBS_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SLEPC_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} SLEPC::slepc SLEPC::slepc_static COMPILE_OUTPUT_VARIABLE SLEPC_TEST_STATIC_LIBS_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SLEPC_TEST_STATIC_LIBS_OUTPUT ) if (SLEPC_TEST_STATIC_LIBS_COMPILED AND SLEPC_TEST_STATIC_LIBS_EXITCODE EQUAL 0) message(STATUS "Test SLEPC_TEST__RUNS with static linking - Success") set(SLEPC_TEST_RUNS TRUE) else() message(STATUS "Test SLEPC_TETS_RUNS with static linking - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run SLEPc test with static library linking:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "SLEPC_TEST_STATIC_LIB_EXITCODE: ${SLEPC_TEST_STATIC_LIB_EXITCODE}\n" "SLEPC_TEST_STATIC_LIB_COMPILED: ${PETSC_TEST_STATIC_LIB_COMPILED}\n" "SLEPC_TEST_STATIC_LIBS_COMPILE_OUTPUT: ${SLEPC_TEST_STATIC_LIBS_COMPILE_OUTPUT}\n" "SLEPC_TEST_STATIC_LIBS_OUTPUT: ${SLEPC_TEST_STATIC_LIBS_OUTPUT}\n\n") set(SLEPC_TEST_RUNS FALSE) endif() endif() endif() # Standard package handling include(FindPackageHandleStandardArgs) if (SLEPC_FOUND) find_package_handle_standard_args(SLEPc REQUIRED_VARS SLEPC_FOUND SLEPC_TEST_RUNS VERSION_VAR SLEPC_VERSION FAIL_MESSAGE "SLEPc could not be configured.") else() find_package_handle_standard_args(SLEPc REQUIRED_VARS SLEPC_FOUND FAIL_MESSAGE "SLEPc could not be found. Be sure to set SLEPC_DIR.") endif() cmake/modules/FindSLEPc4py.cmake000066400000000000000000000074451412460263600167720ustar00rootroot00000000000000# - Try to find slepc4py # Once done this will define # # SLEPC4PY_FOUND - system has slepc4py # SLEPC4PY_INCLUDE_DIRS - include directories for slepc4py # SLEPC4PY_VERSION - version of slepc4py # SLEPC4PY_VERSION_MAJOR - first number in SLEPC4PY_VERSION # SLEPC4PY_VERSION_MINOR - second number in SLEPC4PY_VERSION # Based on FindPETSc4py.cmake #============================================================================= # Copyright (C) 2013 Lawrence Mitchell # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'SLEPc4Py'") if(SLEPC4PY_INCLUDE_DIRS) # In cache already set(SLEPC4PY_FIND_QUIETLY TRUE) endif(SLEPC4PY_INCLUDE_DIRS) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import slepc4py; print(slepc4py.get_include())" OUTPUT_VARIABLE SLEPC4PY_INCLUDE_DIRS RESULT_VARIABLE SLEPC4PY_NOT_FOUND ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ) if(SLEPC4PY_INCLUDE_DIRS) set(SLEPC4PY_FOUND TRUE) set(SLEPC4PY_INCLUDE_DIRS ${SLEPC4PY_INCLUDE_DIRS} CACHE STRING "slepc4py include path") else(SLEPC4PY_INCLUDE_DIRS) set(SLEPC4PY_FOUND FALSE) endif(SLEPC4PY_INCLUDE_DIRS) if(SLEPC4PY_FOUND) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import slepc4py; print(slepc4py.__version__)" OUTPUT_VARIABLE SLEPC4PY_VERSION RESULT_VARIABLE SLEPC4PY_NOT_FOUND OUTPUT_STRIP_TRAILING_WHITESPACE ) string(REPLACE "." ";" SLEPC4PY_VERSION_LIST ${SLEPC4PY_VERSION}) list(GET SLEPC4PY_VERSION_LIST 0 SLEPC4PY_VERSION_MAJOR) list(GET SLEPC4PY_VERSION_LIST 1 SLEPC4PY_VERSION_MINOR) if(NOT SLEPC4PY_FIND_QUIETLY) message(STATUS "slepc4py version ${SLEPC4PY_VERSION} found") endif(NOT SLEPC4PY_FIND_QUIETLY) else(SLEPC4PY_FOUND) if(SLEPC4PY_FIND_REQUIRED) message(FATAL_ERROR "slepc4py missing") endif(SLEPC4PY_FIND_REQUIRED) endif(SLEPC4PY_FOUND) mark_as_advanced(SLEPC4PY_INCLUDE_DIRS, SLEPC4PY_VERSION, SLEPC4PY_VERSION_MAJOR, SLEPC4PY_VERSION_MINOR) if (SLEPc4py_FIND_VERSION) # Check if version found is >= required version if (NOT "${SLEPC4PY_VERSION}" VERSION_LESS "${SLEPc4py_FIND_VERSION}") set(SLEPC4PY_VERSION_OK TRUE) endif() else() # No specific version requested set(SLEPC4PY_VERSION_OK TRUE) endif() mark_as_advanced(SLEPC4PY_VERSION_OK) # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(SLEPc4py "SLEPc4py could not be found. Be sure to set PYTHONPATH appropriately." SLEPC4PY_INCLUDE_DIRS SLEPC4PY_VERSION SLEPC4PY_VERSION_OK) cmake/modules/FindSUNDIALS.cmake000066400000000000000000000164171412460263600166500ustar00rootroot00000000000000# - Try to find SUNDIALS # Once done this will define # # SUNDIALS_FOUND - system has SUNDIALS # SUNDIALS_INCLUDE_DIRS - include directories for SUNDIALS # SUNDIALS_LIBRARIES - libraries for SUNDIALS # SUNDIALS_VERSION - version for SUNDIALS #============================================================================= # Copyright (C) 2010 Garth N. Wells, Anders Logg and Johannes Ring # 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. # # 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. #============================================================================= if (MPI_CXX_FOUND) find_path(SUNDIALS_INCLUDE_DIRS NAMES cvode/cvode.h HINTS ${SUNDIALS_DIR}/include $ENV{SUNDIALS_DIR}/include ${PETSC_INCLUDE_DIRS} DOC "Directory where the SUNDIALS CVODE header files are located" ) find_library(SUNDIALS_LIBRARY NAMES sundials_cvode HINTS ${SUNDIALS_DIR}/lib $ENV{SUNDIALS_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "Directory where the SUNDIALS CVODE library is located" ) find_library(SUNDIALS_NVECTOR_SERIAL_LIBRARY NAMES sundials_nvecserial HINTS ${SUNDIALS_DIR}/lib $ENV{SUNDIALS_DIR}/lib ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH DOC "Directory where the SUNDIALS CVODE library is located" ) set(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY}) set(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARIES} ${SUNDIALS_NVECTOR_PARALLEL_LIBRARY}) set(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARIES} ${SUNDIALS_NVECTOR_SERIAL_LIBRARY}) # Try compiling and running test program if (DOLFIN_SKIP_BUILD_TESTS) set(SUNDIALS_TEST_RUNS TRUE) set(SUNDIALS_VERSION "UNKNOWN") set(SUNDIALS_VERSION_OK TRUE) elseif (SUNDIALS_INCLUDE_DIRS AND SUNDIALS_LIBRARIES) # Set flags for building test program set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_CXX_INCLUDE_PATH}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${MPI_CXX_LIBRARIES}) set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} ${MPI_CXX_COMPILE_FLAGS}) set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${SUNDIALS_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${SUNDIALS_LIBRARIES}) # Check SUNDIALS version set(SUNDIALS_CONFIG_TEST_VERSION_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/sundials_config_test_version.cpp") file(WRITE ${SUNDIALS_CONFIG_TEST_VERSION_CPP} " #define MPICH_IGNORE_CXX_SEEK 1 #include #include \"cvode/cvode.h\" int main() { #ifdef SUNDIALS_VERSION std::cout << SUNDIALS_VERSION; #elif defined(SUNDIALS_PACKAGE_VERSION) std::cout << SUNDIALS_PACKAGE_VERSION; #else std::cout << SUNDIALS_VERSION_MAJOR << \".\" << SUNDIALS_VERSION_MINOR; #endif return 0; } ") try_run( SUNDIALS_CONFIG_TEST_VERSION_EXITCODE SUNDIALS_CONFIG_TEST_VERSION_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SUNDIALS_CONFIG_TEST_VERSION_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE SUNDIALS_CONFIG_TEST_VERSION_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SUNDIALS_CONFIG_TEST_VERSION_OUTPUT ) if (SUNDIALS_CONFIG_TEST_VERSION_EXITCODE EQUAL 0) set(SUNDIALS_VERSION ${SUNDIALS_CONFIG_TEST_VERSION_OUTPUT} CACHE TYPE STRING) mark_as_advanced(SUNDIALS_VERSION) endif() if (SUNDIALS_FIND_VERSION) string(REPLACE "." ";" VERSION_LIST ${SUNDIALS_VERSION}) list(GET VERSION_LIST 0 SUNDIALS_VERSION_MAJOR) list(GET VERSION_LIST 1 SUNDIALS_VERSION_MINOR) # Check if version found is >= required version if (NOT "${SUNDIALS_VERSION_MAJOR}" VERSION_LESS "3") set(SUNDIALS_VERSION_OK TRUE) endif() else() # No specific version requested set(SUNDIALS_VERSION_OK TRUE) endif() mark_as_advanced(SUNDIALS_VERSION_OK) # Build and run test program set(SUNDIALS_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/sundials_test_lib.cpp") file(WRITE ${SUNDIALS_TEST_LIB_CPP} " #define MPICH_IGNORE_CXX_SEEK 1 #define NEQ 10 #include #include #include int main(int argc, char** argv) { int my_pe, npes; long int local_N, nperpe, nrem; N_Vector u; u = N_VNew_Serial(NEQ); N_VDestroy_Serial(u); return 0; }") message(STATUS "Performing test SUNDIALS_TEST_RUNS") try_run( SUNDIALS_TEST_LIB_EXITCODE SUNDIALS_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${SUNDIALS_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE SUNDIALS_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE SUNDIALS_TEST_LIB_OUTPUT ) if (SUNDIALS_TEST_LIB_COMPILED AND SUNDIALS_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Performing test SUNDIALS_TEST_RUNS - Success") set(SUNDIALS_TEST_RUNS TRUE) else() message(STATUS "Performing test SUNDIALS_TEST_RUNS - Failed") if (SUNDIALS_DEBUG) # Output some variables message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SUNDIALS_TEST_LIB_COMPILED = ${SUNDIALS_TEST_LIB_COMPILED}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SUNDIALS_TEST_LIB_COMPILE_OUTPUT = ${SUNDIALS_TEST_LIB_COMPILE_OUTPUT}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SUNDIALS_TEST_LIB_EXITCODE = ${SUNDIALS_TEST_LIB_EXITCODE}") message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " "SUNDIALS_TEST_LIB_OUTPUT = ${SUNDIALS_TEST_LIB_OUTPUT}") endif() endif() endif() endif() # Standard package handling find_package_handle_standard_args(SUNDIALS "SUNDIALS could not be found/configured." SUNDIALS_LIBRARIES SUNDIALS_TEST_RUNS SUNDIALS_INCLUDE_DIRS SUNDIALS_VERSION SUNDIALS_VERSION_OK) cmake/modules/FindSphinx.cmake000066400000000000000000000054751412460263600167010ustar00rootroot00000000000000# - Try to find Sphinx (sphinx-build) # Once done this will define # # SPHINX_FOUND - system has Sphinx # SPHINX_EXECUTABLE - full path to the Sphinx documentation generator tool # SPHINX_VERSION - the version of Sphinx which was found, e.g. "1.0.7" #============================================================================= # Copyright (C) 2011 Marie Rognes and Johannes Ring # 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. # # 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. #============================================================================= message(STATUS "Checking for package 'Sphinx'") # Make sure Python is available if (NOT PYTHON_EXECUTABLE) find_package(PythonInterp) endif() # Try to find sphinx-build find_program(SPHINX_EXECUTABLE sphinx-build HINTS ${SPHINX_DIR} $ENV{SPHINX_DIR} PATH_SUFFIXES bin DOC "Sphinx documentation generator tool" ) if (SPHINX_EXECUTABLE) # Try to check Sphinx version by importing Sphinx execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import sphinx; print(sphinx.__version__)" OUTPUT_VARIABLE SPHINX_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) if (Sphinx_FIND_VERSION) # Check if version found is >= required version if (NOT "${SPHINX_VERSION}" VERSION_LESS "${Sphinx_FIND_VERSION}") set(SPHINX_VERSION_OK TRUE) endif() else() # No specific version of Sphinx is requested set(SPHINX_VERSION_OK TRUE) endif() endif() mark_as_advanced( SPHINX_EXECUTABLE SPHINX_VERSION SPHINX_VERSION_OK ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Sphinx DEFAULT_MSG SPHINX_EXECUTABLE SPHINX_VERSION_OK) cmake/modules/FindUFC.cmake000066400000000000000000000057621412460263600160440ustar00rootroot00000000000000# - Try to find UFC # # Once done this will define # # This module defines # # UFC_FOUND - system has UFC with correct version # UFC_INCLUDE_DIRS - where to find ufc.h # UFC_VERSION - UFC version # UFC_SIGNATURE - UFC signature #============================================================================= # Copyright (C) 2010 Johannes Ring # 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. # # 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. #============================================================================= execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import ffc, sys; sys.stdout.write(ffc.backends.ufc.get_include_path())" OUTPUT_VARIABLE UFC_INCLUDE_DIR ) if (UFC_INCLUDE_DIR) set(UFC_INCLUDE_DIRS ${UFC_INCLUDE_DIR} CACHE STRING "Where to find ufc.h") mark_as_advanced(UFC_INCLUDE_DIRS) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import ffc, sys; sys.stdout.write(ffc.__version__)" OUTPUT_VARIABLE UFC_VERSION ) mark_as_advanced(UFC_VERSION) if (UFC_FIND_VERSION) # Check if version found is >= required version if (NOT "${UFC_VERSION}" VERSION_LESS "${UFC_FIND_VERSION}") set(UFC_VERSION_OK TRUE) endif() else() # No specific version requested set(UFC_VERSION_OK TRUE) endif() mark_as_advanced(UFC_VERSION_OK) execute_process( COMMAND ${PYTHON_EXECUTABLE} -c "import ffc, sys; sys.stdout.write(ffc.ufc_signature())" OUTPUT_VARIABLE UFC_SIGNATURE ) mark_as_advanced(UFC_SIGNATURE) endif() # Standard package handling find_package_handle_standard_args(UFC "UFC could not be found." UFC_INCLUDE_DIRS UFC_VERSION UFC_VERSION_OK UFC_SIGNATURE) cmake/modules/FindUMFPACK.cmake000066400000000000000000000127771412460263600165210ustar00rootroot00000000000000# - Try to find UMFPACK # Once done this will define # # UMFPACK_FOUND - system has UMFPACK # UMFPACK_INCLUDE_DIRS - include directories for UMFPACK # UMFPACK_LIBRARIES - libraries for UMFPACK message(STATUS "Checking for package 'UMFPACK'") # Find packages that UMFPACK depends on #set(CMAKE_LIBRARY_PATH ${BLAS_DIR}/lib $ENV{BLAS_DIR}/lib ${CMAKE_LIBRARY_PATH}) find_package(AMD QUIET) find_package(BLAS QUIET) find_package(CHOLMOD QUIET) # Check for header file find_path(UMFPACK_INCLUDE_DIRS umfpack.h HINTS ${UMFPACK_DIR}/include $ENV{UMFPACK_DIR}/include ${PETSC_INCLUDE_DIRS} $ENV{PETSC_DIR}/include PATH_SUFFIXES suitesparse ufsparse DOC "Directory where the UMFPACK header is located") mark_as_advanced(UMFPACK_INCLUDE_DIRS) # Check for UMFPACK library find_library(UMFPACK_LIBRARY umfpack HINTS ${UMFPACK_DIR}/lib $ENV{UMFPACK_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The UMFPACK library") mark_as_advanced(UMFPACK_LIBRARY) # Check for SUITESPARSE library on Apple if (APPLE) find_library(SUITESPARSE_LIBRARY SuiteSparse HINTS ${UMFPACK_DIR}/lib $ENV{UMFPACK_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The SUITESPARSE library") mark_as_advanced(SUITESPARSE_LIBRARY) endif() # Check for SUITESPARSECONFIG library find_library(SUITESPARSECONFIG_LIBRARY suitesparseconfig HINTS ${UMFPACK_DIR}/lib $ENV{UMFPACK_DIR}/lib ${PETSC_LIBRARY_DIRS} $ENV{PETSC_DIR}/lib DOC "The SUITESPARSE library") mark_as_advanced(SUITESPARSECONFIG_LIBRARY) # Collect libraries if (AMD_FOUND) set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARY} ${AMD_LIBRARIES}) endif() if (BLAS_FOUND) set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES}) endif() if (CHOLMOD_FOUND) set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${CHOLMOD_LIBRARIES}) endif() if (SUITESPARSE_LIBRARY) set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${SUITESPARSE_LIBRARY}) endif() if (SUITESPARSECONFIG_LIBRARY) set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${SUITESPARSECONFIG_LIBRARY}) endif() find_program(GFORTRAN_EXECUTABLE gfortran) if (GFORTRAN_EXECUTABLE) execute_process(COMMAND ${GFORTRAN_EXECUTABLE} -print-file-name=libgfortran.so OUTPUT_VARIABLE GFORTRAN_LIBRARY OUTPUT_STRIP_TRAILING_WHITESPACE) if (EXISTS "${GFORTRAN_LIBRARY}") set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${GFORTRAN_LIBRARY}) endif() endif() # Try compiling and running test program if (DOLFIN_SKIP_BUILD_TESTS) set(UMFPACK_TEST_RUNS TRUE) elseif (UMFPACK_INCLUDE_DIRS AND UMFPACK_LIBRARIES AND AMD_LIBRARIES) # Set flags for building test program set(CMAKE_REQUIRED_INCLUDES ${UMFPACK_INCLUDE_DIRS}) set(CMAKE_REQUIRED_LIBRARIES ${UMFPACK_LIBRARIES}) set(UMFPACK_TEST_LIB_CPP "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/umfpack_test_lib.cpp") file(WRITE ${UMFPACK_TEST_LIB_CPP} " /* Test program umfpack-ex1.c */ #include int main() { int n = 5; double x[5]; void *Symbolic, *Numeric; int i; int Ap[] = { 0, 2, 5, 9, 10, 12 }; int Ai[] = { 0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4 }; double Ax[] = { 2, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 1 }; double b[] = { 8, 45, -3, 3, 19 }; umfpack_di_symbolic(n, n, Ap, Ai, Ax, &Symbolic, NULL, NULL); umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL); umfpack_di_free_symbolic(&Symbolic); umfpack_di_solve(UMFPACK_A, Ap, Ai, Ax, x, b, Numeric, NULL, NULL); umfpack_di_free_numeric(&Numeric); return 0; } ") try_run(UMFPACK_TEST_LIB_EXITCODE UMFPACK_TEST_LIB_COMPILED ${CMAKE_CURRENT_BINARY_DIR} ${UMFPACK_TEST_LIB_CPP} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" COMPILE_OUTPUT_VARIABLE UMFPACK_TEST_LIB_COMPILE_OUTPUT RUN_OUTPUT_VARIABLE UMFPACK_TEST_LIB_OUTPUT ) if (UMFPACK_TEST_LIB_COMPILED AND UMFPACK_TEST_LIB_EXITCODE EQUAL 0) message(STATUS "Performing test UMFPACK_TEST_RUNS - Success") set(UMFPACK_TEST_RUNS TRUE) else() message(STATUS "Performing test UMFPACK_TEST_RUNS - Failed") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Failed to run UMFPACK test:\n" "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}\n" "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}\n" "CMAKE_REQUIRED_FLAGS: ${CMAKE_REQUIRED_FLAGS}\n" "UMFPACK_TEST_LIB_EXITCODE: ${UMFPACK_TEST_LIB_EXITCODE}\n" "UMFPACK_TEST_LIB_COMPILED: ${UMFPACK_TEST_LIB_COMPILED}\n" "UMFPACK_TEST_LIB_COMPILE_OUTPUT: ${UMFPACK_TEST_LIB_COMPILE_OUTPUT}\n" "UMFPACK_TEST_LIB_OUTPUT: ${UMFPACK_TEST_LIB_OUTPUT}\n\n") endif() # Build and run test program include(CheckCXXSourceRuns) check_cxx_source_runs(" /* Test program umfpack-ex1.c */ #include int main() { int n = 5; double x[5]; void *Symbolic, *Numeric; int i; int Ap[] = { 0, 2, 5, 9, 10, 12 }; int Ai[] = { 0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4 }; double Ax[] = { 2, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 1 }; double b[] = { 8, 45, -3, 3, 19 }; umfpack_di_symbolic(n, n, Ap, Ai, Ax, &Symbolic, NULL, NULL); umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL); umfpack_di_free_symbolic(&Symbolic); umfpack_di_solve(UMFPACK_A, Ap, Ai, Ax, x, b, Numeric, NULL, NULL); umfpack_di_free_numeric(&Numeric); return 0; } " UMFPACK_TEST_RUNS) endif() # Standard package handling include(FindPackageHandleStandardArgs) find_package_handle_standard_args(UMFPACK "UMFPACK could not be found. Be sure to set UMFPACK_DIR." UMFPACK_LIBRARIES UMFPACK_INCLUDE_DIRS AMD_LIBRARIES BLAS_LIBRARIES UMFPACK_TEST_RUNS) cmake/post-install/000077500000000000000000000000001412460263600145735ustar00rootroot00000000000000cmake/post-install/CMakeLists.txt000066400000000000000000000014551412460263600173400ustar00rootroot00000000000000install(CODE "MESSAGE( \"---------------------------------------------------------------------------- DOLFIN has now been installed in ${CMAKE_INSTALL_PREFIX} and the demo programs have been installed in ${CMAKE_INSTALL_PREFIX}/${DOLFIN_SHARE_DIR}/demo Before rushing off to try the demos, don't forget to update your environment variables. This can be done easily using the helper file 'dolfin.conf' which sets the appropriate variables (for users of the Bash shell). To update your environment variables, run the following command: source ${CMAKE_INSTALL_PREFIX}/${DOLFIN_SHARE_DIR}/dolfin.conf For future reference, we recommend that you add this command to your configuration (.bashrc, .profile or similar). ----------------------------------------------------------------------------\")") cmake/scripts/000077500000000000000000000000001412460263600136315ustar00rootroot00000000000000cmake/scripts/copy-test-demo-data.py000066400000000000000000000050471412460263600177710ustar00rootroot00000000000000# Copyright (C) 2013 Johan Hake # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Copy all data, tests and demo to a given directory relative to the top dolfin # source directory import os import sys import re import shutil # Subdirectories sub_directories = ['demo', 'test', 'bench'] # Copy all files with the following suffixes suffix_patterns = ["py", "h", "cpp", "cpp.rst", "ufl", "ufl.rst", "xdmf", "xml", "xml.gz", "off", "inp", "msh", "supp", "rst", "py.rst", "ele", "node", "grid", "edge", "sh"] suffix_pattern = re.compile("(%s)," % ("|".join("[\w-]+\.%s" % pattern for pattern in suffix_patterns))) script_rel_path = os.sep.join(__file__.split(os.sep)[:-1]) script_rel_path = script_rel_path or "." dolfin_dir = os.path.abspath(os.path.join(script_rel_path, os.pardir, os.pardir)) def copy_data(top_destdir): abs_destdir = top_destdir if os.path.isabs(top_destdir) else os.path.join(dolfin_dir, top_destdir) if abs_destdir == dolfin_dir: raise RuntimeError("destination directory cannot be the same as " "the dolfin source directory") if not os.path.isdir(abs_destdir): raise RuntimeError("%s is not a directory." % abs_destdir) for subdir in sub_directories: top_dir = os.path.join(dolfin_dir, subdir) for dirpath, dirnames, filenames in os.walk(top_dir): destdir = dirpath.replace(dolfin_dir, abs_destdir) if not os.path.isdir(destdir): os.makedirs(destdir) for f in re.findall(suffix_pattern, " ".join("%s," % f for f in filenames)): srcfile = os.path.join(dirpath, f) shutil.copy(srcfile, destdir) if __name__ == "__main__": # Expecting a destination argument if len(sys.argv) != 2: raise RuntimeError("Expecting 1 argument with the destination directory") copy_data(sys.argv[-1]) cmake/scripts/generate-cmakefiles.py000066400000000000000000000142541412460263600201040ustar00rootroot00000000000000# Copyright (C) 2010-16 Garth N. Wells # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Generate CMakeLists.txt files in demo and test directories # This script should be run from the top level directory. # # Modified by Anders Logg 2013, 2014 import os import subprocess cmakelists_str = \ """# This file is automatically generated by running # # cmake/scripts/generate-cmakefiles # # Require CMake 3.5 cmake_minimum_required(VERSION 3.5) set(PROJECT_NAME %(project_name)s) project(${PROJECT_NAME}) # Set CMake behavior cmake_policy(SET CMP0004 NEW) # Get DOLFIN configuration data (DOLFINConfig.cmake must be in # DOLFIN_CMAKE_CONFIG_PATH) find_package(DOLFIN REQUIRED) include(${DOLFIN_USE_FILE}) # Default build type (can be overridden by user) if (NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build, options are: Debug MinSizeRel Release RelWithDebInfo." FORCE) endif() # Do not throw error for 'multi-line comments' (these are typical in # rst which includes LaTeX) include(CheckCXXCompilerFlag) CHECK_CXX_COMPILER_FLAG("-Wno-comment" HAVE_NO_MULTLINE) if (HAVE_NO_MULTLINE) set(CMAKE_CXX_FLAGS "-Wno-comment ${CMAKE_CXX_FLAGS}") endif() # Executable %(executables)s # Target libraries %(target_libraries)s # Test targets set(test_parameters -np 3 ${MPIEXEC_PARAMS} "./${PROJECT_NAME}") add_test(NAME ${PROJECT_NAME}_mpi COMMAND "mpirun" ${test_parameters}) add_test(NAME ${PROJECT_NAME}_serial COMMAND ${PROJECT_NAME}) """ executable_str = "add_executable(%s %s)" target_link_libraries_str = "target_link_libraries(%s dolfin)" # Subdirectories sub_directories = ['demo', 'bench'] # Prefix map for subdirectories executable_prefixes = dict(demo="demo_", bench="bench_") # Main file name map for subdirectories main_file_names = dict(demo=set(["main.cpp", "main.cpp.rst"]), bench=set(["main.cpp"])) # Projects that use custom CMakeLists.txt (shouldn't overwrite) #exclude_projects = [os.path.join('demo', 'undocumented', 'plot-qt')] exclude_projects = [] def generate_cmake_files(subdirectory, generated_files): """Search for C++ code and write CMakeLists.txt files""" cwd = os.getcwd() executable_prefix = executable_prefixes[subdirectory] main_file_name = main_file_names[subdirectory] for root, dirs, files in os.walk(cwd + "/" + subdirectory): executable_names = set() # For 'cpp' directories, get list of .cpp files if "cpp" in dirs: cpp_files = set() program_dir = root + "/cpp" program_name = os.path.split(root)[-1] skip = False for exclude in exclude_projects : if exclude in root : skip = True if skip : print("Skipping custom CMakeLists.txt file:", root) continue if executable_prefix == "bench_": program_name = program_dir[program_dir.find("bench")+6:].replace(os.path.sep, "_") name_forms = dict( project_name=executable_prefix + program_name, executables="NOT_SET", target_libraries="NOT_SET") for f in os.listdir(program_dir): filename, extension = os.path.splitext(f) if extension == ".cpp": cpp_files.add(f) if ".cpp.rst" in f: cpp_files.add(filename) # If no .cpp continue if not cpp_files: continue # Ensure deterministic output across py2/py3 cpp_files = sorted(cpp_files) # Name of demo and cpp source files if not main_file_name.isdisjoint(cpp_files): # If directory contains a main file we assume that # only one executable should be generated for this # directory and all other .cpp files should be linked # to this name_forms["executables"] = executable_str % \ ("${PROJECT_NAME}", ' '.join(cpp_files)) name_forms["target_libraries"] = target_link_libraries_str % \ "${PROJECT_NAME}" else: # If no main file in source files, we assume each # source should be compiled as an executable name_forms["executables"] = "\n".join(\ executable_str % (executable_prefix + f.replace(".cpp", ""), f) \ for f in cpp_files) name_forms["target_libraries"] = "\n".join(\ target_link_libraries_str % (\ executable_prefix + f.replace(".cpp", "")) \ for f in cpp_files) # Check for duplicate executable names if program_name not in executable_names: executable_names.add(program_name) else: print("Warning: duplicate executable names found when generating CMakeLists.txt files.") # Write file filename = os.path.join(program_dir, "CMakeLists.txt") generated_files.append(filename) with open(filename, "w") as f: f.write(cmakelists_str % name_forms) # Generate CMakeLists.txt files for all subdirectories generated_files = [] for subdirectory in sub_directories: generate_cmake_files(subdirectory, generated_files) # Print list of generated files print("The following files were generated:") print("\n".join(generated_files)) cmake/scripts/generate-demo-files.py000066400000000000000000000035331412460263600200230ustar00rootroot00000000000000# Copyright (C) 2016 Garth N. Wells # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Recompile all ffc forms (use when FFC has been updated) # This script should be run from the top level directory. import os, sys # Directories to scan subdirs = ["demo"] # Check that we can find pylint.py parser = "./utils/pylit/pylit.py" if os.path.isfile(parser): pass else: raise RuntimeError("Cannot find pylit.py. Are you running from the top level directory") # Get absolute path to parser parser = os.path.abspath(parser) # Generate .py files from all .py.rst files topdir = os.getcwd() for subdir in subdirs: for root, dirs, files in os.walk(subdir): # Check for .py.rst files rstfiles = [f for f in files if len(f) > 7 and f[-7:] == ".py.rst"] if len(rstfiles) == 0: continue # Compile files os.chdir(root) print("Converting rst files in in {} ...".format(root)) for f in rstfiles: command = sys.executable + " " + parser + " " + os.path.abspath(f) #print(" " + command) ret = os.system(command) if not ret == 0: raise RuntimeError("Unable to convert rst file to a .py ({})".format(f)) os.chdir(topdir) cmake/scripts/generate-form-files.py000066400000000000000000000054671412460263600200520ustar00rootroot00000000000000# Copyright (C) 2005-2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Recompile all ffc forms (use when FFC has been updated) # This script should be run from the top level directory. import os import ffc # Forms that need special options use_error = ["AdaptivePoisson.ufl", "AdaptiveNavierStokes.ufl", ] use_representation = {"HyperElasticity.ufl": "uflacs", "CahnHilliard2D.ufl": "uflacs", "CahnHilliard3D.ufl": "uflacs", } use_split = ["Poisson2D_1.ufl", "Poisson2D_2.ufl", "Poisson2D_3.ufl", "Poisson2D_4.ufl", "Poisson2D_5.ufl", "Poisson3D_1.ufl", "Poisson3D_2.ufl", "Poisson3D_3.ufl", "Poisson3D_4.ufl", "Poisson3D_5.ufl", "CahnHilliard2D.ufl", "CahnHilliard3D.ufl", ] # Forms for which we don't want to generate functions for evaluating # the basis skip_basis = ["Poisson2D_5.ufl", "Poisson3D_4.ufl"] # Directories to scan subdirs = ["demo", "bench", "test"] # Compile all form files topdir = os.getcwd() for subdir in subdirs: for root, dirs, files in os.walk(subdir): # Check for .ufl files formfiles = [f for f in files if f[-4:] == ".ufl"] if not formfiles: continue # Compile files os.chdir(root) print("Compiling %d forms in %s..." % (len(formfiles), root)) for f in formfiles: args = ["-l", "dolfin"] args.append("-s") args.append("-O") args.append("-r") args.append(use_representation.get(f, "auto")) if f in use_split: args.append("-fsplit") if f in use_error: args.append("-e") if f in skip_basis: args.append("-fno-evaluate_basis") args.append("-fno-evaluate_basis_derivatives") args.append(f) command = "ffc " + " ".join(args) # + " >> compile.log" print(command) ret = ffc.main(args) if ret != 0: raise RuntimeError("Unable to compile form: %s/%s" % (root, f)) os.chdir(topdir) cmake/templates/000077500000000000000000000000001412460263600141405ustar00rootroot00000000000000cmake/templates/DOLFINConfig.cmake.in000066400000000000000000000031711412460263600176520ustar00rootroot00000000000000# - Build details for DOLFIN: Dynamic Object-oriented Library for # - FINite element computation # # This file has been automatically generated. # FIXME: Check that naming conforms to CMake standards if (POLICY CMP0011) cmake_policy(SET CMP0011 NEW) endif() if (POLICY CMP0012) cmake_policy(SET CMP0012 NEW) endif() # Compute path get_filename_component(DOLFIN_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) # Library dependencies (contains definitions for IMPORTED targets) # NOTE: DOLFIN demo CMakeLists.txt are written to be stand-alone, as # well as the build system building the demo. Therefore, we need the # below guard to avoid exporting the targets twice. if (NOT TARGET dolfin) include("${DOLFIN_CMAKE_DIR}/DOLFINTargets.cmake") endif() # Compilers set(DOLFIN_CXX_COMPILER "@CMAKE_CXX_COMPILER@") # Compiler defintions set(DOLFIN_CXX_DEFINITIONS "-DDOLFIN_VERSION=\"@DOLFIN_VERSION@\";@DOLFIN_CXX_DEFINITIONS@") # Compiler flags set(DOLFIN_CXX_FLAGS "@CMAKE_CXX_FLAGS@") # Linker flags set(DOLFIN_LINK_FLAGS "@CMAKE_EXE_LINKER_FLAGS@") # Include directories set(DOLFIN_INCLUDE_DIRS "@CMAKE_INSTALL_PREFIX@/@DOLFIN_INCLUDE_DIR@") # Third party include directories set(DOLFIN_3RD_PARTY_INCLUDE_DIRS "@DOLFIN_DEP_INCLUDE_DIRECTORIES@;@DOLFIN_DEP_SYSTEM_INCLUDE_DIRECTORIES@") # DOLFIN library set(DOLFIN_LIBRARIES dolfin) # Version set(DOLFIN_VERSION_MAJOR "@DOLFIN_VERSION_MAJOR@") set(DOLFIN_VERSION_MINOR "@DOLFIN_VERSION_MINOR@") set(DOLFIN_VERSION_MICRO "@DOLFIN_VERSION_MICRO@") set(DOLFIN_VERSION_STR "@DOLFIN_VERSION@") # The location of the UseDOLFIN.cmake file set(DOLFIN_USE_FILE "${DOLFIN_CMAKE_DIR}/UseDOLFIN.cmake") cmake/templates/DOLFINConfigVersion.cmake.in000066400000000000000000000014301412460263600212140ustar00rootroot00000000000000set(PACKAGE_VERSION "@DOLFIN_VERSION@") set(PACKAGE_VERSION_MAJOR "@DOLFIN_VERSION_MAJOR@") set(PACKAGE_VERSION_MINOR "@DOLFIN_VERSION_MINOR@") set(PACKAGE_VERSION_PATCH "@DOLFIN_VERSION_MICRO@") # FIXME: When should versions be defined as compatible? # This version is compatible only with matching major.minor versions. if ("${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}" VERSION_EQUAL "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}") # This version is compatible with equal or lesser patch versions. if (NOT "${PACKAGE_VERSION_PATCH}" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}") set(PACKAGE_VERSION_COMPATIBLE 1) if ("${PACKAGE_VERSION_PATCH}" VERSION_EQUAL "${PACKAGE_FIND_VERSION_PATCH}") set(PACKAGE_VERSION_EXACT 1) endif() endif() endif() cmake/templates/UseDOLFIN.cmake.in000066400000000000000000000033671412460263600172100ustar00rootroot00000000000000# # This file sets up include directories, link directories, and # compiler settings for a project to use DOLFIN. It should not be # included directly, but rather through the DOLFIN_USE_FILE setting # obtained from DOLFINConfig.cmake. # if (NOT DOLFIN_USE_FILE_INCLUDED) set(DOLFIN_USE_FILE_INCLUDED 1) if(POLICY CMP0012) cmake_policy(SET CMP0012 NEW) endif() # Require and use C++11 set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # Add DOLFIN-installed FindFoo.cmake files to path list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}") # Check for Boost set(BOOST_ROOT $ENV{BOOST_DIR} $ENV{BOOST_HOME}) if (BOOST_ROOT) set(Boost_NO_SYSTEM_PATHS on) endif() # Prevent FindBoost.cmake from looking for system Boost{foo}.cmake # files set(Boost_NO_BOOST_CMAKE true) set(Boost_USE_MULTITHREADED $ENV{BOOST_USE_MULTITHREADED}) find_package(Boost 1.48 QUIET REQUIRED COMPONENTS @DOLFIN_BOOST_COMPONENTS_PUBLIC@) if (@PETSC_FOUND@) if (NOT PETSC::petsc) set(DOLFIN_SKIP_BUILD_TESTS TRUE) find_package(PETSc REQUIRED QUIET) endif() endif() if (@SLEPC_FOUND@) if (NOT SLEPC::slepc) set(DOLFIN_SKIP_BUILD_TESTS TRUE) find_package(SLEPc REQUIRED QUIET) endif() endif() # Add include directories needed to use DOLFIN include_directories(${DOLFIN_INCLUDE_DIRS}) # Add compiler flags needed to use DOLFIN #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DOLFIN_CXX_FLAGS}") #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DOLFIN_LINK_FLAGS}") #set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${DOLFIN_LINK_FLAGS}") #set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${DOLFIN_LINK_FLAGS}") endif() cmake/templates/cmake_uninstall.cmake.in000066400000000000000000000014311412460263600207170ustar00rootroot00000000000000if (NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") endif() file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach (file ${files}) message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") if (EXISTS "$ENV{DESTDIR}${file}") exec_program( "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) if (NOT "${rm_retval}" STREQUAL 0) message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") endif() else() message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") endif() endforeach() cmake/templates/dolfin-get-demos.in000066400000000000000000000020761412460263600176320ustar00rootroot00000000000000#!/bin/bash # # Utility script for installing demos in user's home directory DEMO_DIR=@CMAKE_INSTALL_PREFIX@/@DOLFIN_SHARE_DIR@/demo INSTALL_DIR=$HOME/dolfin-demos URL="http://fenicsproject.org/documentation/doc_"`echo @DOLFIN_VERSION@ | cut -d'+' -f1`".html" echo "This script will install the DOLFIN demos in your home directory:" echo echo " $INSTALL_DIR" echo echo -n "Do you want to install the DOLFIN demos in your home directory? [y] " read answer if [[ $answer == "y" || $answer == "" ]]; then echo "Installing demos..." cp -r $DEMO_DIR $INSTALL_DIR echo echo "The demos have now been installed in $INSTALL_DIR." echo echo "-------------------------------------------------------------------------------" echo "To get started, enter the following command:" echo echo " cd $INSTALL_DIR/pde" echo echo "The documentation can be found at the following address:" echo echo " $URL" echo "-------------------------------------------------------------------------------" echo else echo "ok, demos not installed" fi cmake/templates/dolfin-version.in000066400000000000000000000001221412460263600174210ustar00rootroot00000000000000#!/bin/bash # Helper script to print the version of DOLFIN echo @DOLFIN_VERSION@ cmake/templates/dolfin.conf.in000066400000000000000000000007611412460263600166730ustar00rootroot00000000000000# Helper file for setting non-default DOLFIN environment variables # Common Unix variables export @OS_LIBRARY_PATH_NAME@=@CMAKE_INSTALL_PREFIX@/@DOLFIN_LIB_DIR@:$@OS_LIBRARY_PATH_NAME@ export PATH=@CMAKE_INSTALL_PREFIX@/@DOLFIN_BIN_DIR@:$PATH export PKG_CONFIG_PATH=@CMAKE_INSTALL_PREFIX@/@DOLFIN_PKGCONFIG_DIR@:$PKG_CONFIG_PATH export MANPATH=@CMAKE_INSTALL_PREFIX@/@DOLFIN_MAN_DIR@:$MANPATH # Special Mac variables export DYLD_FRAMEWORK_PATH=/opt/local/Library/Frameworks:$DYLD_FRAMEWORK_PATH cmake/templates/dolfin.pc.in000066400000000000000000000011411412460263600163410ustar00rootroot00000000000000# pkg-config configuration for DOLFIN prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=@CMAKE_INSTALL_PREFIX@ libdir=${exec_prefix}/@DOLFIN_LIB_DIR@ includedir=${prefix}/@DOLFIN_INCLUDE_DIR@ compiler=@CMAKE_CXX_COMPILER@ definitions=@PKG_DEFINITIONS@ extlibs=@DOLFIN_EXT_LIBS@ boost_includedir=@BOOST_INCLUDE_DIR@ Name: DOLFIN Description: Dynamic Object-oriented Library for FINite element computation Version: @DOLFIN_VERSION@ Requires: @PKG_REQUIRES@ Conflicts: Libs: @PKG_LINKFLAGS@ -L${libdir} -ldolfin Cflags: @PKG_CXXFLAGS@ -DDOLFIN_VERSION=\"@DOLFIN_VERSION@\" ${definitions} -I${includedir} @PKG_INCLUDES@ cmake/templates/fenics-version.in000066400000000000000000000001221412460263600174150ustar00rootroot00000000000000#!/bin/bash # Helper script to print the version of FEniCS echo @DOLFIN_VERSION@ data/000077500000000000000000000000001412460263600117735ustar00rootroot00000000000000data/README000066400000000000000000000006071412460263600126560ustar00rootroot00000000000000The data in this directory, including example meshes, have been moved to the FEniCS web server to decrease the size of this repository. For a selection of meshes, please visit http://fenicsproject.org/download/data.html http://fenicsproject.org/pub/data/meshes/ Update 2016: The meshes are now stored again as part of the DOLFIN repository using Git LFS (https://git-lfs.github.com/). demo/000077500000000000000000000000001412460263600120065ustar00rootroot00000000000000demo/CMakeLists.txt000066400000000000000000000054371412460263600145570ustar00rootroot00000000000000project(dolfin-demos) # Require CMake 2.8 cmake_minimum_required(VERSION 3.5) # Find DOLFIN config file (not used here, but check that the demo will # be able to find it #find_package(DOLFIN PATHS ${CMAKE_BINARY_DIR} REQUIRED) include_directories(${DOLFIN_SOURCE_DIR} ${DOLFIN_SOURCE_DIR}/dolfin ${DOLFIN_BINARY_DIR}) # Documented demos add_subdirectory(documented/auto-adaptive-poisson/cpp) add_subdirectory(documented/bcs/cpp) add_subdirectory(documented/biharmonic/cpp) add_subdirectory(documented/built-in-meshes/cpp) add_subdirectory(documented/cahn-hilliard/cpp) add_subdirectory(documented/eigenvalue/cpp) add_subdirectory(documented/hyperelasticity/cpp) add_subdirectory(documented/mixed-poisson/cpp) add_subdirectory(documented/navier-stokes/cpp) add_subdirectory(documented/neumann-poisson/cpp) add_subdirectory(documented/nonlinear-poisson/cpp) add_subdirectory(documented/nonmatching-interpolation/cpp) add_subdirectory(documented/periodic/cpp) add_subdirectory(documented/poisson/cpp) add_subdirectory(documented/singular-poisson/cpp) add_subdirectory(documented/stokes-iterative/cpp) add_subdirectory(documented/stokes-taylor-hood/cpp) add_subdirectory(documented/subdomains/cpp) # Undocumented demos add_subdirectory(undocumented/advection-diffusion/cpp) add_subdirectory(undocumented/ale/cpp) add_subdirectory(undocumented/auto-adaptive-navier-stokes/cpp) add_subdirectory(undocumented/block-matrix/cpp) add_subdirectory(undocumented/conditional/cpp) add_subdirectory(undocumented/contact-vi-snes/cpp) add_subdirectory(undocumented/contact-vi-tao/cpp) add_subdirectory(undocumented/curl-curl/cpp) add_subdirectory(undocumented/dg-advection-diffusion/cpp) add_subdirectory(undocumented/dg-poisson/cpp) add_subdirectory(undocumented/elasticity/cpp) add_subdirectory(undocumented/elastodynamics/cpp) add_subdirectory(undocumented/eval/cpp) add_subdirectory(undocumented/extrapolation/cpp) add_subdirectory(undocumented/functional/cpp) add_subdirectory(undocumented/gmg-poisson/cpp) add_subdirectory(undocumented/lift-drag/cpp) add_subdirectory(undocumented/mesh-quality/cpp) add_subdirectory(undocumented/meshfunction-refinement/cpp) add_subdirectory(undocumented/multimesh-poisson/cpp) add_subdirectory(undocumented/multimesh-stokes/cpp) add_subdirectory(undocumented/nonmatching-projection/cpp) add_subdirectory(undocumented/parallel-refinement/cpp) add_subdirectory(undocumented/parameters/cpp) add_subdirectory(undocumented/poisson1D/cpp) add_subdirectory(undocumented/poisson1D-in-2D/cpp) add_subdirectory(undocumented/poisson-disc/cpp) add_subdirectory(undocumented/refinement/cpp) add_subdirectory(undocumented/spatial-coordinates/cpp) add_subdirectory(undocumented/submesh/cpp) add_subdirectory(undocumented/sym-dirichlet-bc/cpp) add_subdirectory(undocumented/time-series/cpp) add_subdirectory(undocumented/waveguide/cpp) demo/README000066400000000000000000000042211412460263600126650ustar00rootroot00000000000000Documenting DOLFIN demos ======================== The documentation for the DOLFIN demos is written by hand and located together with the demos in the DOLFIN source tree. To document a (new) DOLFIN demo located in the directory foo (for instance pde/poisson), follow the two steps below. In general, the simplest way is probably to look at one of the documented demos for instance (demo/pde/poisson/) and follow the same setup. 1) Add these 3 files * foo/common.txt -- containing common information such as the main features the demo illustrates and, if applicable, a mathematical description of the differential equation that is solved. This file should then be included in the C++ and Python versions. * foo/cpp/documentation.rst -- containing the reST source file with the documentation that is specific to the C++ version of the demo. * foo/python/documentation.rst -- containing the reST source file with the documentation that is specific to the Python version of the demo. If either the C++ or the Python version of the demo does not exist, feel free to add the version and continue. 2) Move the directory foo from the directory undocumented/ to the suitable directory (for instance pde/ or la/). Note The demo documentation is automatically included in the complete DOLFIN documentation when running make doc after building DOLFIN. While documenting a demo, it may be handy to only run make doc_demo and then make doc_html_[python|cpp]. Note Tests for the validity of the code snippets used in the demo documentation are included in the standard DOLFIN tests. C++ and Python specific contents ================================ The C++ and Python documentation reST source files should * Explain each step of the solution procedure. Do this by including and explaining code snippets from the demo source code. * Include links to the API documentation using the :cpp:class: and :py:class: directives. Note that for the Python classes, the full module path is required (for instance py:class:dolfin.cpp.NewtonSolver) * Include the complete set of files needed to run the demo using the include directive. demo/cmake.local000077500000000000000000000007161412460263600141110ustar00rootroot00000000000000#!/bin/sh # Configure for a local install. Build files will be generated in the # directory $toplevel/local and installation will go in the directory # $toplevel/build. # # This is useful to be able to run demos from within the source tree # without needing to specify an installation directory. # TODO: Add -DCMAKE_BUILD_TYPE=xxxx flag INSTALLDIR=`pwd`"/local" mkdir -p ../build_demo cd ../build_demo cmake ../demo -DCMAKE_INSTALL_PREFIX=$INSTALLDIR make demo/documented/000077500000000000000000000000001412460263600141355ustar00rootroot00000000000000demo/documented/auto-adaptive-poisson/000077500000000000000000000000001412460263600203705ustar00rootroot00000000000000demo/documented/auto-adaptive-poisson/common.txt000066400000000000000000000113721412460263600224250ustar00rootroot00000000000000In this demo we will use goal oriented adaptivity and error control which applies a duality technique to derive error estimates taken directly from the computed solution which then are used to weight local residuals. To this end, we derive an :math:`\textit{a posteriori}` error estimate and error indicators. We define a goal functional :math:`\mathcal{M} : V \rightarrow \mathbb{R}`, which expresses the localized physical properties of the solution of a simulation. The objective of goal oriented adaptive error control is to minimize computational work to obtain a given level of accuracy in :math:`\mathcal{M}`. We will thus illustrate how to: * Solve a linear partial differential equation with automatic adaptive mesh refinement * Define a goal functional * Use :py:class:`AdaptiveLinearVariationalSolver ` The two solutions for u in this demo will look as follows, where the first is the unrefined while the second is the refined solution: .. image:: ../u_unrefined.png :scale: 75 % .. image:: ../u_refined.png :scale: 75 % Equation and problem definition ------------------------------- The Poisson equation is the canonical elliptic partial differential equation. For a domain :math:`\Omega \subset \mathbb{R}^n` with boundary :math:`\partial \Omega = \Gamma_{D} \cup \Gamma_{N}`, the Poisson equation with particular boundary conditions reads: .. math:: - \nabla^{2} u &= f \quad {\rm in} \ \Omega, \\ u &= 0 \quad {\rm on} \ \Gamma_{D}, \\ \nabla u \cdot n &= g \quad {\rm on} \ \Gamma_{N}. \\ Here, :math:`f` and :math:`g` are input data and n denotes the outward directed boundary normal. The variational form of Poisson equation reads: find :math:`u \in V` such that .. math:: a(u, v) = L(v) \quad \forall \ v \in \hat{V}, which we will call the continous primal problem, where :math:`V`, :math:`\hat{V}` are the trial- and test spaces and .. math:: a(u, v) &= \int_{\Omega} \nabla u \cdot \nabla v \, {\rm d} x, \\ L(v) &= \int_{\Omega} f v \, {\rm d} x + \int_{\Gamma_{N}} g v \, {\rm d} s. The expression :math:`a(u, v)` is the bilinear form and :math:`L(v)` is the linear form. It is assumed that all functions in :math:`V` satisfy the Dirichlet boundary conditions (:math:`u = 0 \ {\rm on} \ \Gamma_{D}`). The above definitions is that of the continuous problem. In the actual computer implementation we use a descrete formulation which reads: find :math:`u \in V_h` such that .. math:: a(u_h, v) = L(v) \quad \forall \ v \in \hat{V}_h. We will refer to the above equation as the discrete primal problem. Here, :math:`V_h` and :math:`\hat{V_h}` are finite dimensional subspaces. The weak residual is defined as .. math:: r(v) = L(v) - a(u_h, v). By the Galerkin orthogonality, we have .. math:: r(v) = L(v) - a(u_h, v) = a(u_h, v) - a(u_h, v) = 0\,\, \forall v \in \hat{V}_{h}, which means that the residual vanishes for all functions in :math:`\hat{V}_{h}`. This property is used further in the derivation of the error estimates. wish to compute a solution :math:`u_h` to the discrete primal problem defined above such that for a given tolerance :math:`\mathrm{TOL}` we have .. math:: \eta = \left| \mathcal{M}(u_h) - \mathcal{u_h} \right| \leq \mathrm{TOL}. Next we derive an :math:`\textit{a posteriori}` error estimate by defining the discrete dual variational problem: find :math:`z_h \in V_h^*` such that .. :math:: a^*(z_h,v) = \mathcal{v}, \quad \forall v \in \hat{V}_h^*. Here :math:`V^*, \hat{V}_h^*` are the dual trial- and test spaces and :math:`a^* : V^* \times \hat{V}^* \rightarrow \mathbb{R}` is the adjoint of :math:`a` such that :math:`a^*(v,w) = a(w,v)`. We find that .. math:: \mathcal{M}(u - \mathcal{u_h}) = a^*(z, u - u_h) = a(u - u_h, z) = a(u,z) - a(u_h,z) = L(z) - a(u_h,z) = r(z) and by Galerkin orthogonality we have :math:`r(z) = r(z - v_h)\,\, \forall v_h \in \hat{V}_h`. Note that the residual vanishes if :math:`z \in \hat{V}_h^*` and has to either be approximated in a higher order element space or one may use an extrapolation. The choice of goal functional depends on what quantity you are interested in. Here, we take the goal functional to be defined as .. math:: \mathcal{M}(u) = \int_{\Omega} u dx. We use :math:`D\ddot{o}rfler` marking as the mesh marking procedure. In this demo, we shall consider the following definitions of the input functions, the domain, and the boundaries: * :math:`\Omega = [0,1] \times [0,1]\,` (a unit square) * :math:`\Gamma_{D} = \{(0, y) \cup (1, y) \subset \partial \Omega\}\,` (Dirichlet boundary) * :math:`\Gamma_{N} = \{(x, 0) \cup (x, 1) \subset \partial \Omega\}\,` (Neumann boundary) * :math:`g = \sin(5x)\,` (normal derivative) * :math:`f = 10\exp(-((x - 0.5)^2 + (y - 0.5)^2) / 0.02)\,` (source term) demo/documented/auto-adaptive-poisson/cpp/000077500000000000000000000000001412460263600211525ustar00rootroot00000000000000demo/documented/auto-adaptive-poisson/cpp/AdaptivePoisson.ufl.rst000066400000000000000000000011331412460263600255770ustar00rootroot00000000000000UFL input for the auto adaptive Poisson problem =============================================== UFL code:: element = FiniteElement("CG", triangle, 1) u = TrialFunction(element) v = TestFunction(element) f = Coefficient(element) g = Coefficient(element) a = dot(grad(u), grad(v))*dx() L = f*v*dx() + g*v*ds() M = u*dx() Before the form file can be used in the C++ program, it must be compiled using FFC by running (on the command-line): .. code-block:: sh ffc -l dolfin -e AdaptivePoisson.ufl Parameter ``-e`` ensures that a code for forms used for error control is generated. demo/documented/auto-adaptive-poisson/cpp/main.cpp.rst000066400000000000000000000056471412460263600234250ustar00rootroot00000000000000Auto adaptive Poisson equation (C++) ==================================== Implementation -------------- Running this demo requires the files: :download:`main.cpp`, :download:`AdaptivePoisson.ufl` and :download:`CMakeLists.txt`. Under construction. .. code-block:: cpp #include #include "AdaptivePoisson.h" using namespace dolfin; // Source term (right-hand side) class Source : public Expression { void eval(Array& values, const Array& x) const { double dx = x[0] - 0.5; double dy = x[1] - 0.5; values[0] = 10*exp(-(dx*dx + dy*dy) / 0.02); } }; // Normal derivative (Neumann boundary condition) class dUdN : public Expression { void eval(Array& values, const Array& x) const { values[0] = sin(5*x[0]); } }; // Sub domain for Dirichlet boundary condition class DirichletBoundary : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[0] < DOLFIN_EPS or x[0] > 1.0 - DOLFIN_EPS; } }; int main() { if (dolfin::MPI::size(MPI_COMM_WORLD) > 1) { std::cout << "This demo does not work in parallel" << std::endl; return 0; } // Create mesh and define function space auto mesh = std::make_shared(8, 8); auto V = std::make_shared(mesh); // Define boundary condition auto u0 = std::make_shared(0.0); auto boundary = std::make_shared(); auto bc = std::make_shared(V, u0, boundary); // Define variational forms auto a = std::make_shared(V, V); auto L = std::make_shared(V); auto f = std::make_shared(); auto g = std::make_shared(); L->f = f; L->g = g; // Define Function for solution auto u = std::make_shared(V); // Define goal functional (quantity of interest) auto M = std::make_shared(mesh); // Define error tolerance double tol = 1.e-5; // Solve equation a = L with respect to u and the given boundary // conditions, such that the estimated error (measured in M) is less // than tol std::vector> bcs({bc}); auto problem = std::make_shared(a, L, u, bcs); AdaptiveLinearVariationalSolver solver(problem, M); solver.parameters("error_control")("dual_variational_solver")["linear_solver"] = "cg"; solver.parameters("error_control")("dual_variational_solver")["symmetric"] = true; solver.solve(tol); solver.summary(); // Output solution to XDMF for Paraview XDMFFile("initial_solution.xdmf").write(u->root_node()); XDMFFile("final_solution.xdmf").write(u->leaf_node()); return 0; } demo/documented/auto-adaptive-poisson/u_refined.png000066400000000000000000001155701412460263600230470ustar00rootroot00000000000000PNG  IHDRXW IDATxo-gu<} H$!$0v !.BƐ̄r@ĮjHr$Sv f8cCxL\e`ۡ@L+RO$zZow{@?խsݻw}PEQ]((I aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQM aQEqДEQ\s=zիnᆫxwe6koٟ}ǿ(!,?W\q-u]_W//y??w{7}CB>_ ]^L(y?u]!NHyO>}ԩ3G>g o|xܯ9WѢ(˕ݟgoW>pw˯ԧ򔧜((r<+rꫯ/|[kw>/tyQBXEqyC..G|_O|ӟ_5yͿ}ˎ¢(˕kvO~ەhf^{}wq|l_貣(rn{[޲x)%mo[iC}^-oYo}[_}/tYsٿ(CMoz-C5__{{޳t{{ '?o~~ӟ;/'>w_ }芯s_L)(2/xoo׿??z΍}{?g>G./hQEq🿠eEQM(_9((8hJ(bEQEIYEQASBXEQ4%EQAS1¢(/`sRaQEqДEQM aQEqДEQM%EQ ꋢ(RBXEQ4%EQAS1¢(1WA}QEQ\\J((8h*FXEQ\4.EXEQ8%EQASBXEQ4%EQAS2EQEcԗ# $ y'w_C-|@m֋ Ð_=hq1_4мPG}Q&!xµ#"@ e""F`\D2_Vх|<%e߱ШBAꩈ g)[tvf̰:\q(,~ k :"S83GPrX"%EUtDM̈!x_pX j#FQ_ S[SF1kg FamJ{΄vN!þ9\7EJ aQ|w혚 &A,N a$6#.h͔#TzUPCaTw@i}_e&3IPw7ϵ((!,GŏFk0J30cM)AO[ZA eytn˜5 o" :VߩF)"H!!҅сNN_ R#=(4(Q2aPm ~GM}؂0h%,iBvkG5Q.ИAGHfNg}?ݢƠ(~&C1 }h`Rd,YK(0JPNTz[D[5l$0dT1wiUkafMN8>=6Θ"w/Щ/ H aQ]fjjD#eDj&`al؅2\E1ZeY!G6֖GTSJŒ ϊwhH 2SFk؅ lSdXsy7~} Eq(!,3iШf КZL!2p !ͩyMQD0!E9\c rFsǹK;|&!LER҅ 53oDRBX'x/^՚1M`Wa 6c #a-Y3۫YpPXȚA+2i$,6RT _BεnRzO7i;);wFM8q03Jo~+.sJKWW;>12 E\B B di2)}k j9bY5D赶c,c+P%qFJ a<%t ]$5~1~}|:Eq(!, o ڄM+.do).TyFV0L@wdu4K4М45qG H9QA1_])1D1:ԠEr֡v| Ċ18tnk5 &50S8EG]Zd9}ͲqQ>Q6YRc k8::EFoQHږgK6UfAaD >gX.ڴѕ)D3.Yí:%3zG>xa>x pGP[kFj!^F#MF&z̚_<=t2-?2'ˋrhyF7%M4-E r C8a¬&d"}1t&*x{`څ@+f`K؏o}.X_wgJ?qt$#8e."!:5Maֱ$Q$kJ NPjFu1B3+1j ׆ DxM5=5htzB clTgS@w ɥ$ '0v|~r?Т)!,.4,|}%M: jdwGPj_&!f.F$@<_TfQ:%dbG(|0StQZZuр[|E1Bwx3մh;;bv2Bb?d?V^a>?I?jQ\ƔѕMG0Beƨ^p eEl*e5| ɑCP蠺rT}ϧs&1hd@_Hq sity$N7/䄾?^bF%ƐO]Yn؞ynk{>w>ܢ|)!,.c<KѦ,hT,gAHH3q pQ3F!̶2A3G5bTe.P兹FnĦLEOX(9iRylIEYN#hH *H1wWrw.#}A71晽e1ĐSbwΝ{va~yr9w8сl2;;p}x,#c~.8eoidF$@$I1$ eI.3@C.#BNHsY$f"(%%>MF9Ip .`aZ=ߣβj-ﳬ0,FpFd1dj=P ˸ϲ9$Fheq/o74ʯ-y_W~?3?sttw;;~n n}C_g< _§?oes G瑧ϵCv&3&`f F7T dDD`&$)QJe3ܡ# #_=eFhp#cDDeŦBltw KtF9}E=ƤCFwgpǾ}La5{:؏p4oy~^wu|;-|7~s=WWԩSKtƖ$?=]u]7|}MM?{s&,8_I#`#OCT0HjA(FAډ̹올wN6ktE1~otnd.l>#R{PlF-92A@߇T8?, }N%R #aS=Ż}w~Ņa~wuWwyӧO:u~o7~^׽Ѽ=sW_wcfGJµ6;E9 xhQ kaԱl"FI %Ɉh1c0C>ӠyAc:NBCm1$1'|Ja#FD>)P<ђ;~P#̧|P$d `Kz1C.o}Ճ:Q{J7i'<.sg?ەx33xvU:=^S@, a.G*T )Fk\L:1^}ka\Gp-؀ |)+~przdd(YXI1dJsI]4'|o_{/Aq?+ܮ| g6d3??c{??y3q _OɷGPBX<\u_VS{ayw=T6"wƲ2G&M9*I,sAR]Υ@B$h\Dq#@x +0ŽaəK}z>?]MTy?a "3"iIwq9A.Ddp!:DH ̏E{4?gW'*WC[f{o]w__bOxvJvd0ɻHSwƀ51e{Y# Cdgd4CBb"ر6&㨔'iE X Zkɼߒ㈊yF H!ukZbXxlNV8ܜ&DhP7#be,STJab6ݹég?U?=ߊ+^oۯ=y򔧼owy||ϋ8"9gNw#{َ^6s8`фc]#5`aaBHED==}Q>9l7H{XbV\ԑPX*Q9~ujP:sQ>Rn/{zMm/vl4(6R]r3NP<YoSd4i?$wZW?smvw嫼/=c/8>>>::zG{J).wwHHB5 ;Se1lCz>d ςF>ZL.:e"')1ޘHX!M$}郩Jazf.K d$v./h7e; GV" %M Q1ޛM,\*1iO v Ǡ;&R0oiફ'>ҳ瞗/yK~~ #տ==ەOӏok;K7cIf<#S{ؑIr7%^lS%H =K;rA8̟^@d(4̲~:cZAfmm4RPlJn6h.vDߧ[<#! P6V-Cdy*{Fr1qwoε^;M'?ɛoyYfvמ)𲗽컾wMӣz;}l+{wWp _[6iqr^5n}3u)Qh1A!r>S> }G(01ё}xnF}ca<}c>ּ_ ;^y)YC`>|Z^>c>F?wYir?V{9W0v{^W?|Ftc,=g , )9 WH2+3D4k`͹Mv 8NОt_n-oy[o {衇-K_~wݣW՟'/ky~W\EX|}˳WwrQΉraV.4Ì5-FHf "M?m)@^ CQ>c> 9P= !D}ڗdx ּMM{䧬}gZeyI(ZxrRF=IwiJIL4ȳx+ IDAT0j~֠1Rfu7PuDyӛt-JbzT+l6?GQ1hWڎ(Fu--`2WScc02LZsv4BjԎخyj\yJ/E^o׿Nz _z[}w}hzm oxs? pz{m\Th1=VMl6sNNl6c?s3$hM"tRD hT)YfqL_3p170Uӗ~VL#tQ O٤`kPid˕7j.y\tIj\yW٘Tb&ǖsRթSd:}/ӽՏx,yI=~/g,*n Pb⟧0 ޳vdH5A-5\ЋR{fK!szK}V[rJfxBƲoY3(-I73A||Tsdi;1"dG!CC-x&Alc4Xq R1b? W^ޣv 3cBG{ p̚4uFPn5z].Sf- =a.)6>VFL _ڂC_ M XM6ޤ>LۭwdWUJvDɬAz>0itM]ٿpIq7}_ObKqPBX<:ȈޭI_K W'KuLK b0C?|$}*`/l{%:>-@QH{{ +sRj#R1)BZ'4`S*ӝ4-ѳ,{IjNE0 #9QɴiMN{oO ݿpjx7sGFK쥋˚+Ӟv#zfМ%0hP^K#=۠E]f Y\^+R;!ljbk j)_qrF. 3zGp-<a6`&Sίװ) }\ bo<[j2CI3b0q<4|DNMVI~.q<Ռh#k6)b\2h<#FudEk =JSyt= hOn7{Ӌ etɀ:zH )B耂34L $s`jX[ R+|6eG0+ŽEOK%7g!l@NbXG %8zjnzC:"dp+Dזq6t1R7#k֣ߌaٔrD9 %!(ۮF Vq[ZՄIA6fSRQ c2)'zkOz ^if!>7_ #DۢJabFgmKi,?MrUBf 6%yFɞNS:#r\E *E<5Qz?l{u3f;X,aj_Ck7f:sY1h ȁK!AaY8 h랅~JW"-4 s fzׄ;zͶ%2ͥ QtHAeCgx>3F8|wG5.&C iB,; sGk1>>C8M`%dxa i4"HosXGgD,XAe{Oa `.p 9tA1ScxNe lÎ @3UbťN{K[,vd02CF L޹XU\J%m#Θf5ynLz*_,+rmY4閿bXW48@NyP,xѵCMmcFNd t pֺ`Bzbi0C!DwZ.|)N3Lݡa *ϮdvDH[459#80wLw\YQ6MpxRڕҸN8YJǘ2)-ނAb6Gѵ:>dͨ𾚥 .AAjj({e87*sh$YQߏiO>0Ftp%\Q.#dѱ0\jC9φY:MS0êq]FDNꈱB~Q9qQ>D;H=L!MV څaN ܝWa;|7+a6ц ;8 0'5:=c3aqNzDSk#!!кqL/}J=-~r܇bDT҈].w+0 eq ?S]Vߞy|=֩0}Cxu%#FMLT1vp`͑5Bzzb]y ޣeܣ,7+! mϊjFꎢ?p:m1$8K]ݚ$\ll.t|dkZ&gI-%#Ñ *a`[6Hm`DFsȌ$45:hcĔ hZH. #|>Zڐ"Zrcx>}`-[Ñqߺ=(ZldČ兾Y8_5e[UOm)ϫtx*LDi1 9pꊑ&C1 _h40-/-viqo knc@Ylc!~pf4ʆENZ~]|YS8C5DѲp^K)Se!'4od̎i8#NXs#H> ܡ]gNq("x˽-}wXFd(Q L9qdl|螞U#E1|ټ;eK6ŅՆ\|Aۯ>nEl: aK.kr!;kJI%8 5& Nؚ8Š#c]boE6rQ>,V#oyvl<{ &ش>wjN-4 k0z=+[kUk2nBC`Ȉa_ v~Ν64=ifNDh?(BɈQ%?j-$s! =Zܬyly4³\8-r.fb_#%FFX&ڌWw^-B.?-[mǢ8_qgV',/.dO#p\Fi$}x~Zo2L2%R./FV-PʥΏ^y!,*AԳ(%*2eGL00A4C؄h;q]v^ZZ 0; e;-.B`6E'=.>{X TDTʰ#={Hbgġ<0|dQEiA*FqoRvγ-1GhK077++ORtAH礄8'M?ˆMpX_~<$GFGU-]I@ jyFg[ja6ckp%@ӎ90|l)b(3To-YGZkDƦ\y.g2kԐX@WY"<>Cr0J Mw`L*gXK8הPv 9RhTQE:bơL ,.gpOe$@>ygFO&ERBXI0əbO)a텒h$z|B4‘SuujTA Ki--i A%52~Lm340FRFLpP:X<!J`sFq'cϜhC Sk"QN/&pg(pY6_FL5d^ltYGp)RwU.:k\Ly'nF@_=!§^Faq,86 )ظsaqfbc xJn"GpYXQ8yk"8UF1rV8YZ~!ciXR+@kiMΪk2 4Q'RcPU;EAj䔃hifS8a\t.sP ؎^!g]<y>rƸ 278O`F_xҹ)g{xݐh s|я%[cK~ae⻄8!WΔ@,fY^,YWsU<.;\pO$XFjo6y.Pm"_ZZ$mh-#k@8\3zaz@pـ; l6{NkGE~g'BuNc0u`MF7 g1)?421ӄc',y4Õfj5%phKa tK+^l.⒢W Dɳ̵q Շ8DCVqg'V] @m0\, FZ.XØO6LGH`L5oF¦,x)[w ΌO8`- `m:k`k#r'm&rKS7 mè|Sm2tw mgc8'l;][kim\-v^-rҘ ulyi ^ae_-QLkG)4ibCYIk |#fTh"ˡO>O ñտUY>%/J-݋;'#\Ä9dJ,a2Ө@% ,QF-r@eɄBml,;@tȰup0d*gEȶv@knkt #0H&1O)mlR߅>g-&z)Rcʦ0B;P|N\QB-u6Q{(J3 Z[`l.nygwC duop ҉E8~c|Q (.QjȖ pinI phj3J0NV7AT;sU_b<|c\J}ǥ3:fܰɖG{K睨 hFgh6>6dImCIru03EQ{7&ȨXȧ(-;)Ĝ&-n#"l niA:4' Clݧddcǚh9t!]c:iSQz&Hm>pBkg-omY|áq4>q?4~,SW;o -e)-_ h{Q +*dFzΣvg1,ԀM4N0GRG6  zɲ0s6xϺ\%ְ?q9?iydO~vfШy3yq\N_fnXƀZ i2Xޘ}y:Ʃ QQX~X>B.BZQTLd%C,lǯ(b\G{ә6gHU7kFne1 \ZpDRFe5gyxvr2&z[/M{Z 3 2DHIGh!`GgQ4;\ء#Uȍ>;f>N93UtXcX4pV"nD lٕ&ڎ6 p"&G3ߤ'2ށhpd2oIdFrx$uEXlEn-O2,Q,6vj_Vpy\.s,+B-]}z#^-- h-SK6y4f62:kKp9eJ,# 8>\q.KmM%po9x35tO/Mt@-eÍsdDe_pFqi6,8Oe1yl5n(KqqjQI4%ASBX6UV7ևuf~7KgFqƯj>HC(d8QF+p يgpԿD!~g rcp5Qjrz"NY-6Iؚq3[rVWk*!P[Xg B "du?3&<+l [pL{QS`7BXJ %Toy?wn JUrGU$h/8 36EDbix:6Q= (lNE&ER3eR.\⒎E5zpݯ$J!tzEK6O}T/ט`]ubEϨ#]$"qMo2hH yy\I 84F,J(GP7ŲA?+PJTEU,qދh YfNH||WFQȘzWQdhBSd4Eh@Eb#lm*hjҮ1Ѐ}3l7m Smjvt.v}id QPje.H`5mN)A,vE76f!@KdB`jB8jcF IS QJc%hkƈ=غ|}lR RIzvC\ U#J@}|r6 70f)e6a֖}ljRGY )ɰdT5y^Cx 16.A;_f$@C>ۤ |ZNH]+dSbN (궦R,ӥ8zfզ l\([tٍ*NpvW3P!p*. ӅjEFqv ѹ! _4HMjb1 AqO!CeLED946L{& v/ȢK#gyɺɺh41 풵])4emʊF1%/xTHv,`bdIh1֌[Y' ! -$TiD p(w J>7 a<1',g\͜&. PJK0Q1~S]>!.͌֘,!gQP *6n FcW"mq7.qnDwͭ$g4Hgo?H!Obz Vn@ D*ZD YahuDBghd1sst,v8AAZҭn=l:O3`u64u t!a?sw<") _JliG^*f7SǑ,C׭&Nt{+Ɋ-/k%;NRxb3.!,@D ~ҽ|k>?Lğ>hB "(ф%[iXղyx0X2N4N)+E1! 8 h&qڞ $+e"o  D3t|;&_<J+U Dmvvb%MfAA1;%@&~M(Xovl("-q;ܞvj47ZH ^`=jA-8"}( b?U=`*K_Oilm9ZPZP Ԓ %Kğhu"X X3Bp5u3b糖 UȧىeiiTXp{וQډ3ګrMhKSc3݇ziG(#;h歄1j?K6|+v=iJ#n9muyW/qihl3>)Q;L soP5 +2o 'nD(`n߼D:~~$7Z-R8CimFk.K6 g[k &t(afPUϐ"axB`/)BHFuP th+h^Ԭu:(UPvڔ@4, S%d2ٛ )H~;[O) ゎޤ4}ʒa0ZD4b.F۬0Pp@XP~1'qNQ6'il C !̋v!\> _*S yFnz.M .%<΄eJ58Y*+>UJNxwjkW_?:ʪ@Dt,ymQTN&[\:jJ3%1'$>R"NDznU }io)7jLJ[OjDs|5RܺEZh?I+1_+c hb!}wa=X}V,@x)Ɩ}؂7&4W]%\g4bK.(\,ښ~A6mLa$Bd8y$L&CR|@35SiMOcmuA'wdxN; ÒļHG-T%_M"A#KIȘ:":o݉Ȉ.xMTanI&-ބgK/5DEL_f#jm'z2`yD2ٙ/`B}X,86>e ӥl}u'mO/& }SNF@Jj(k$t$+iLwRgjNA7iЙ@!g P'GA?(duFüV 1o0oPg|V{noYg̓՟wQWQhE0o0OmWBoΈVheC<UPRK:C(%A1̒64hll3Ŝko{~"Yt`?s%k+ad2K?CיȖ8hq-\sͱc/~?b|377>w_uU\s]wXҊhgT9 *PL_8dF$HVBJ' @%Է7u *$|9;(dD%23놺auϠZm e[<`0?3;?52 :șf0OJel:LX¤VWo[j5 Ҥ ,ЊVJ`QD|  %x>` Ey }o1č]pѮȝ7 0\w&~k_ =y>#Gu~7|{=s-{vww_W?gF(0%.B4 m˶P(MQ-w[fC[;kLD_mk|}exVpA α]dLչBm3@Xd5S;M֔"цԶO0KӽJ2/H:y#CH"|o 3?KK(( 0"ZEPb3clXMغ[VanSd|*ZGex!eG7/Ї>Tg?# Ek_+_\WUz?[֝~t7ٳy3ϼ/\/{vkܮm=׎ܘQ  DDiOKJ E:[.(#'xskÏSurfP-'g[+eQj0f0@ק$ݾSpg i1P.:MDBʪ} Wt>Ye3weDFRÄ:hHH1Wbc+MNS4gZ)7/@0Yp[ YmՁy+w7x??z;wܾѾ=מX_i ".ٛ$sq/uH[Ny7S=vZ*.BxSugbz0P8:bR'&\xsm Y5h=8_Pg2 }~}p> PV M `p%Al#}8^2s 4͉\ʗmK>ŭҋޡEtS!:ɌO67o}taLc-~[NyPڭ8qBU_+o>u]wu77xcѣ]%.yK6@(BZyuI.ߊ=i޵{N۪d[V`$d hH`wyκi)GW`& L@$ ע PzaFqJ AtlM0lj⊎֟N %t.߮qAt4kDA]|Q:tk~%|AboA  ˄]%'?tK;mysW\ѯN0Dj42:uX&&gcFv{^خHL``mA12UרgT+]{Fv1\DSH=a? }o%?Tr 蒥Na&od*Ʊص IDAT+:Vbh-ߏ WPeԧx UdGS|_;wvm6{G%ϋAcLJH_s &2qE,NRj2&&^n'| aze+٩JKrv_ص-he0i)v\Aj9Uۧ*);luȹ@̀_ðʯ]Kh;h߰. ! 0Ͼ)-Qw\0>g6K+ǩHq~Sn)-CU{r$=8~mvw]:otNtL6=EP}=xh&1Psz3SB}>uL=v_bn$qEGGMO ]w+c+2<:m9Sb e0FHG*"wJ ) e 4>+=Kee^ ċe\E`pk߾5,4;58ӑ5M̋߇H8wB!7 4^Ƌj/af8ž6϶) aN2cRYtFru+ xqƕW^ ɓW]uU|f.| ^:QۇagCJF  <#dLY줕uhG5gD(%@g>#vvUܺ"nw}N<Ȱg'2JjPґ8K!Dj6j2^M̒/(P4+AqdG^7@V395e `?^&_DgFlNn!y!0~( d4ʊ[4\g|JX4 PK(ap8!_AȎ^}87|s|J)W_}Y_׿GƱ9*Isg✞ &[=侈Oh(^)yGPmY]^VZpf!gr718ubݣP'.{==]]Xo:Q7w9rg ll V{PQ؞ ]Nԙ:sڣn5oۅΘwY9ϕ\JUyg8 u:N@ `+ЙZ:yNP@g=Z$/ޑYRb ep{([xSA̹}V_#F ~?b{> .m$o| ƞx??}{Wz뭷5G?Z8`}uD4Vѱu8a_`eRxhkN$ϣyΙ9e|)siFsKv0ŝRۻ; R`${82)SW"C+hR3ŠA7Ad0 e D(*\hC7f!z% j7DZO8DZ|S:p޿Sva!;kCo:"Kt nqA-uO[۾t ~^Omo+|>^oyO77 W\qoo~ _蟲j?:E,s;gG: YJAشhη0Ģ,f۲pv] .TN '9lfXu#jp)D&mISdv5~i  Pl "  Qly} eJBΘ+eD_(53u &gaVz,~~ ʊ+IE&3O 0֎ùIRo5EK6iy@[f hۓ\D&;m_hLdˋ M7WW[kk;;;yk>Oo|'N8q[osFa,F r ."zB_(E1wd.J{ EVz(jk+YŨ8' # GrNnb, Z)SKF/<`'0~6Ys6Ul HniQn[~"$"!~p\4=X@P@_ -#c,(y.G*9"p]0"K p߲ ; ̯$2 8MG(}_7 ]5SC +CYK/nFx~-?iFxˋjޚ̫k2H2yU@ p$Th_UZ.$0ԍ1SNrv2S$?u75Hv7m G<(vOsU`q"bm2ҲwjEg*=z*e9PUd0Ls T`c @&{nlRP6m# @mNOh&r]ݴlm^R I<ŁKlF{}-n} %%!62Uώ.,cCyYGgOUO(̈qDtXe,ngJQ SF)Pi Ua3 eE?H(7O<zWt 0Qw rBYI'vGPV@=j)Vm)k҉3ʺe/aZ3-|EWfr "e83K^ [wޝҥ.k3Wp@w9{(>[L؟gR#\yJ1/!WBUJޫ+Xݚ= zw*^:_L@7ya ζKN~&<'~Rg$F]vƁaiP0 \&*s5vh6P80Z!Kfd .u1EWAg3Z :n,ZY3!`%"񿵛+B#iц4Aa?mbv;cj-GJQ@;4)Z@˅D%^^ݐJ! X?yAV#z+L$00(+a1jJYv3J;e-FeND BdDRd+h( xh R;p(#{&Hdd:5/_ peC5Udq_5!<dɎXX~It\tGK*QG̯RDoWSAU, %7,BT=Z pJcΌӻўwTƕXZQ>*u[PBp<"qR7(#/#*%T);fNt ežڜ& P yQo2nb EIAXɄFjDG5 bȆorelxɍXpp/7y ЁY&PxGk"zFz $05[m!p'5gϻVV+cΌSMz.~ K\\! OA3B^,("h]֬yVXTmSYJTlyO>~HƘ] MǡȺ'RR7$}D(:APYFщ Vم$e32D #JW틋?;{K[K ~wJ?<1F8e#v#=8%npD\PIV[.4´Rv%],5%_h5ɝ*pձR_P:ԦVFטbyQ>8)JMBQwY OZ%-IUUtUkAEޏfuTӔpxTĨJJ/#"5뒶BͿ2:Bgb@Yf M4Wk gV̩@ Y#)] hDj`Lo 4,^V,#9y5YT 0+@>D%Q,@xc*zhr[SDKOmZSibh02rv?FR}RuO|?:N+ _T 7 k ˔UkTG(#PW7 lv!z  Qk qĴ7ĚNٛ]UIH%(س=+b(`HNZ8 |DJ1CdIS8*]#>KvP1$rTT9*-"P1򇢮e|VCA7E[1@2XP z-QYT7<}igAQ(b:.j= *TeV+BwP{ =g| (.חtŤ4q>-eMA ub]+e%jloVndjgJP &հ4a^4kJ]%2~ d Ĉ-w AMeIZxtju>a_5ZkwĢjrP׎(PTe 0(gEPBRR8ޓă_W׿P0Pĥ4@7*}xaǺ#cQ8EHF+!@)w PCTZSBD]}Gn 555ݜ /9i8Kdymv$7훂 !Ȅ-`9cmR0Ru^.!L%K m9t^TR VНQ51=eIn< JApX|e-sxR_#8CF`аTE @KB*('!0)9 {s=D&+BDpAP~h RՖȌhI,zvdInc҉-K"n(8La =sQjeB"* 4˷TIu|{E Ȳ«2N%EZI<jLw&z%X Ag_BT[PXtc Ysu{r Bқ֍5[ eTU!)C X?RzPd,M hpGN J19!ofZʨώz*C5 ;t R6 B#ti>c"k2/"9Qws,p/m `ZC`H[K(Z()ʩrrrOo~a?:Sg}+ @l"0D* J+ {Ǘ0|??&+nQ(;3enE 0 +Δ$ f1IeTNfΔ2x} Q TB }4@v6Nܱ@ώJ IF{ve"!s"@K"j~xCu.qN#Q@1Wd& HjTZB*7MՍiBL|=/HYAgϋY&Vޕ22:kD2_沘#e:NS ':b 45kś_e2+Q*܂F5d@a{ʆvHgs&v%E,@xXB#=7]FA(N:!tJR(*6 䉅=^ GuRYݣDzQ f8l#oV 8BϚ O*d5PD@H!uh8 a>픥){r!ЊF0 w Aibaam{pYD"6<4|!keu0̯@D VAr i\Q+j}bAo~4e4)mP)5vHQA@Ԍ8(d/(#-jPP]#ڹFRvH2!-M8j|[AV=Z|iDej#Ku\"Fxh^ dE!@PDˇX-^ŬO>27\$2FpC5 G]D#. 6ܦlkU4J!J̝g_=ɔ?xF G;7 tF@gPgJZe1aVaX`";o">zWOQޥ" EQgT eUw<'pÛdr)[d_@IDATE1TKƂRB Da3$. DjYP6EG8 'lY nw uLcHF>@gO|j4&,Ȥ$[i0ϗ1B ?}%v,@xcxɛ!AZ!P%=kPgkYSz 9xOw]meX}6&RJ `zEC"'3^kLxFj)cB84kCeS}i?vJ4#&ZlS /+)TÆ5 6?owy|GHKJ &:(VO~kAK7xɯ١efXƝB%ʐ8hQ XGA2pFwC@F1G)JT%2F7yC5=MRRtsve0XDVaM)gCpV4tFAY( ŗ:u~"op]?3pVq62`3pjhS)a5n%>͂FP)90 Y r0pp`?m8Dᰀ65bDFjtk| EtI)ЍX.781UvP֡ "+8raXAb(?= }K\G $ ]yĨ:( &!  iqGٔVV8ޏzu&ѽPY24)>8f5+ u=ťtTL@3)elR5u tgO'>Ew 'jRJд UmG)#-}25mB,B-A68h3(}|R6l,1fXT7ʟac$!,<ХFY;!"b&#b8Q΀.(ӏ{ OtJ amEm`DГn<.EX2";˔~lE%gh_jѤ{DƤyobZ45iG'.ґx职n}ĸlT TRw_/.q {_\֟f`dJr⒙R*{z/7 J$u=@87Q $y 2; d t7q=稬>y%c,b5J 5KCHM (]C]`q&ҘRq&v+/2RC)Qrkm-ރ,+`MjK|Vt]#0+MjVO) t[k7Yf+d<dM uN#0Fx cxɿT4,V,8_+ZjTe!2*)]0Ź ) ,fM߸{Nb3#EB ZYE=aL gȎBfɎE,5%6blnPEWQB-5>7,䣙hCvѴ nmB#=(6M;B ]к#Qc=XhۮYo@`=eKKjp?9r6}00pqߺЇġO|λpAUeH-@ ҫj.@YM @-9+f3L9ӡ@51Cs!d,ny)tRvu#!ԉ(DA 0Fx@c"-9_Pp'?RpPDʹ31kR#?&:eR҆&t{.rP"xa4W!#Kf d=x'6ݣ=b< %.xo Nd %2d2JAY,LC̎όZSwYQHA kҪ}$dڇB LV`BdC)7U@OC`,@xb`r- fϋJG%O_lҠ#c|1 \w"m VJ/6oF'ZC8eLiςG6i)LkpC9yRuwՇ?\exN1zy/-qI~)+! 8$%:sXW$3l̰7؈1s#:UWÙwhc '@= Q%N,@xТ1~LǴ> HDGP)?18i}6H*D%͕t%t%Mdc@'-#pxt;'pX,уOn!8wj%Ǔ7O?}p/T@ GCةX+rR:O:@ 9X-GrQT!W3x8 PP7@A9*rDL#0pp\/ag #5l[5k"epstv(|ϗk  2?+VsOCvLnz "(CzO{xb1/ bxKe>%1)JfF*`V<@8ΙT϶a78\qsAWC7_g1g\Ac&PT2* n f{: /ys.N: <8!pBK<X)M^>tEr`:/%6P2TZJJiB = 8kQCW:)(t2T3c1.qnb]Xb5wP  蚗ְ-ҡ[Oh5D!)> [BZg|>/,(>k.s;GR.z1.cƒË#υ>%xﶅՍoп#:A9BKoJ  )hHa߃ޤƫM!kGDkI3}@|wxm=l|j`DwBK˘[]ZȒjRpN0So:W\;!L)mU؆,4g<.{߬Q;e+ A7(1P0rv|9Ǐ[r5;v;Go}oꪫ暻}^&/}ibXb ӗ5}7s-YWau(y11G5h0ݳ# T ^\N\F jPy (/%{(8rsp?Ͽ#G^w}g=s-{vww_W?So]8øBTK,./AЧ@MG2 k ǽ^F҆ 6pT'LGSSOCOՇ7M/x >b=G?L7~+_Wx>ַugg0o>q _gy}\?g{ I<yXb.¡yշl#!Dlf XBSQJŻF30\(k㘾[yggs嗾oqwwwggo|ԩ?;#?wr0eg꣟e],*,}t*P1P1r0A܃(/''C9;Q'NP՗n>zu=y~#G~{߳ǏO|;W^y_~vqR#\b%.ިj]VjR5Q3v8Bmغ&m^ L} F_e AA>"8 9;ry}]y\qcǎ8ujTGoҗOO}7t-?~ 7𒗼رc??|,".{oz-[VHz] }o!~$bb_HA@ P}! }!7`ᷝb_Ҫt~{}wm?~߻OcǏ[o~ ?s?l6>3:0 \b%OwTy};0f@-GjM--r#}gW_}87ߜ+xRW_}_}׿#86g?}k_Z_WrW\s5|?r[`f+ؤd2m۶֖t-F 344TSSEǏ>}EիZ^dq:qɓ'_[1b'\ϟ痽|2H}/nܸ%#v`娬lmmp琹\n``"L&3::ZdqEӃǏ////Ft,=z{{3Lggg"=t:1S*(JRSSS]]]h+X[[[MMM}}o߾=ӧO_8644tww/F t5fF@!AM4A@!AM4A@!AM4A@!AM4A@!AM4A@!AM4A@!AM=R6IENDB`demo/documented/auto-adaptive-poisson/u_unrefined.png000066400000000000000000000762101412460263600234070ustar00rootroot00000000000000PNG  IHDRXW IDATx{eU}͵}$FVHiF R\n]i7܌hctڑqǽ cn F8i4&2;\RX%(`Ի{?7Z{SEU*3s܇]͹((ÊYPEQDPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQFPQEjTEQmmoÆ [ly'Tַu7._|Æ r / ٳ7~7;＋.n{WN@*(0?;N?ώ]}[nm裏^{?O]~/[wޫjΝ{G?oۣЁ-EQnXzow#+_z饗]vك>+|v<;;׾V`~~wBPQ\[^q'++Wݖ-[b#D'IШ(ʹʮ]\r, ޽R}{߳gݻڳgϾ}N@>EQ$9|0iY8;; ѣ_|C=T)|ᇯJkc:9:BEQs,c=v}}#nݺx5k֬ZU,G(0SOmٲvD++x58+{?xZOhaTEQmҜYkd۶m7o馛X?s?˿˿;c{x≿ۿ}5:'x[EQ!dffeC,[V۶m۴iӵ^}NF;?o_>򑏸܁TEQUVZj}YYcb^۷_wu\s7^PrE=CЇ>7CIBPQ\ettt{oR2>믿މܑ#G۷oߴiƍx~}??Ji PEf瞫ȑ#z1_8ˎ;n&7qs=wuMOOqwNik>[n^N MQEyqW~߼뮻>7~_5oڵk׮]6mSSO=/}tΡS)(K3lt>BEQeШ(d3Gh*(C (2Ԩ*(C*(K#lD(2Ԩ*(C (2h(dgż#TEQBEQeQ!TEQBEQedEQezEQEYZTEQFPQEjPQEY2z:^QEQBEQeQ!TEQ#TEQn{@(2*(C (2Ԩ*(C&(J3npv_–O%>?EyMm/zb>EYz˿@?0>؂_ocEE9I~ș4!@س=S9TBEy|_Yp=d ׌M]c.\*}m݇{B`XvT%FxIb*ʹwK`tT008Dx r, ?ϟ(K '\,}_kL<1ɍ8/(;>B|4@&_ 'L (?UQBE91n¹l _}amEŤ(p^);`"~U3 ,wSyk *1>(JI 5,bTS\}! zs W^!Y8E uϑ3pyzACN?maaEYbd@KEP]["H/E4ѽ{YA Q] ݇V!CrVsz(¡`,|(;>)UT0y<;G(@D3{WA\(|oHeKirf9 r/òm(U oy WŎ@,p^? jIZJ"ǜ<[(gBEi=w/] ‚Bɺ .A& HqBtA VUܝwqNؗA(JFzջ (rkhA+(ʙAPQWDkbVJv0,O ;Hi`uZ4F-Y{A_ ¾=N=: /R_4#Nۯ(o;j\Pe_UƢ1)-+׷6D#R 2LLO$)Y}e/d@ط4l_,%p  Xr# RiB5ʂs~EyB,= DaV)5؀ SA QAi`U Y/z LT>kEP4Hbhi)B`6;;U(dKniʎqw)ؿqŸyC@fbvfS y*ʗGPjl9H'%_=?(*K7\Iv\kAQ[,[7ZNLj@2( '!eDBL>B'SafF?'* 9Ym^8?s`__dJg11V<E rF9u(WmlD 2JCƀ zhAƀdXP^z[vwI}(8u8jp t`=X|sAHN'vn6+ƛ.kٚtr?Q!Tp)Y֛ {6gQk,'KiƀLCa()#‚0awR5TҷkxYFHۻμ&Y8?TGw1~o75;~2E9̵, (†_W\2Y&kZbkćL׶eAAiP* `  DQiҏʗ~XavӖAnzXH)' Nw0c8\nbXRX+1%~? j iZc2cX(#R6C~[^ƋNO-l۶}{߆ fgglO o}o\| n^xaz_O9O>i3 r&X݅Dm˽ z-4V(05Y|eP>kOdoO/?m9j%E.㘛$RE꒪EEu4dXr`7v$' KjSM#mP:VD%ןYYw>꫷nXGkGGG?O򓟜_|ѣ??<&xpFS) JS+޶ n8mG-MlC[6L<c3 #0Av,XqW?|zUʮ쉽29 ݹT!lQ 5lm|GVna13߹s#`|7 j֭W]uծ]֬Ys k&Nft}id?Kx[VY.3q=^Ħ>ppjC/iYa2!Âa@qthEG tPdp1[GG-kt`IL$Ts1/~y7ӬG tPjٚ}AOʷvmݶ]m۶mvvvէ,}`r@ye53eAXquO[/}ғ01L#SÛDu"):dPZZS_s8U7_mmc&AEZcTY_(K+2]7/xɮ]\r, ޽R}{ Y8>>gϞj۶mo|yΝG9 Wd#TN 6 &71G48h܂-&6>)C0@`br\1:e #mi,WBm3:s15[@9D?a1 ;d8繰@ {^ִ0*%!X ox쩓8ee 9|0iY8;; ѣ_|C=T)|ᇯj۶m/^ccƍ/o}멽%AP9,r*JS0ϼiREbrxil%H1"6~$-.\8'"mJ B Ϻ*na\e }yGA$%t9;Fmh)f=ƠLeY6kCNV9[ `blsA{^̮mv??<x;n7BT+$3Zbq/lcM7#Sُg!~awER_ ˯Rz 7_5'N3y~n꒩ l'gv.'T^ uӇ`OOaa8O iC ؊Aak}rb@+!;v<]83牃BOIS_'"c?9o~!,Y.?肕%bժUVgꪫb?oYjU&۷o뮹/| V˿?D7==aÆpegP*&.y)J*J*(gp^uԼ)a,"XX?N{!6n\A|t1a"&D c2q ʅq+Cn|*/UD8ϭE<1..&vx7Dz 'Itg&:DMdQ3neVMxi;SY6.py닺J e˖˗Qۿ/QG=7mڴq|۷og>|Uz7p\ׯԙy5(7#TNm p\`^==1\`/0.&M0pWBiD{Qо7}*.H):;%{Րg|L;/4?tgR4\8 οz8~38 2`7XY{~ܫќ]s=W_}#GnVc̗/~qZ;vtMvmO=ԍ7޸o߾O}S;vx^-:P9I.DEiDmfFH0-v}Ɯ 1 0.F/H (>DZ@'58t l"|tWD.xvh@=:b4[: ~$#eP}gaX|nb6ԖabN3wf޸qp nO?}ev_=D!+_W'Xj_}lʕ^߾o Ufd?3W4r⋪W¹f_P_,2fC8ԅIɒb, ,W'卢c{lGL}6KH&xhO8nEhbi,oIӨ =/&+YKpMЦBB}uqR?'Qkt^^Z5t]е`L1C8J$r'=W?yCVX G@L:#[q&xp\{1݊/ i@Vqr.U<2wd )X NCk[T:DȀ-!lMl IDAT lxN1fbC;?{&O@9GQ!TK=Txt&QxLInrcܐ7iWLjy 2I E5㫹AJgiYP\EJXPbl~0퍛|m V?.ԩ~L@ 6W+f'vN01_.fրx޹+s7-0p:P!TM$&Zph;ɔ(k[+-B:c]`p+;2:Yfժ& sVHԽ]~'8 p5B43L A_CqW\8Tzn@5#8_ـLU:2Yc[kW}LgH6Ԛb6Dl[k'Rmp3$ӊj>P!T #3M(z/¸v[+Aֿ ӣ De ;%b22 ttƀj;v!iԿM婚|v89Av;h窒$05H!^Ŵ+#ۙYTn @z$c:HŚU`&TU3 k ?E@{o%6M!@5:, (UVPoQRoO`,VX1AѰ{s_AMi~<&-xBf9U0_E?LxU "kTS8%7cs`>%Gp{ó`8IÌn 0qoC[KQٲ%2Z je7՘AOo}~Gnz֕-C3̑&( qM>R=/ā .[7= ՐSc;%s¨Aq2V J_#}?wS/_E r 2CzO[(?̭V @d69 \)En#d3%btTʂT73*/qC'QT05l 5!7? Z E6?#SY F:`0Èx&n_yZ/&n/4/9SBѶO v³Vu!iՋiHn;;А 2YTҧX,jkYp_V4RuB*m ?rs!Gbv9غ;Ga,$ & wR؆ 2I` yʤ\(Fe' `P ;2* MarzjVM:bba,|M [r?u1dL8 'M3}(ncb4Q]as #T̪-|R~-bf9ev΁ "t2ւ˽DŽb"~E0,#2:QyD9 sGO;Y@S@C жUƇ[3dX817E6K,?Ճfgl6pÀf\ "}0q[}0<=XitT DfygĠ~Q"fMksȘVw,3?8 *eK-SF:Ik)s~qbp*Qx"NI#Nӿ@h"j"ԱQ4JsJ-]#h2IܶAcR;s$8ȔZiUumQLHA_ #q0{~:WqCõ;K62|saʥ1$5 F ђ%!h܍4 N}vv$QPWN+* 57#z7ha5 dQ 1Yj*}`Fn@jO5݁|_fᛳn@h$A) K0:*4/-(;unWD*"$:CHkkw v]rM] @Z=v݇Na+'iY3I5A|//9^|p*h *!$0x!/&H`mԠ=td]4 JQ40#`4BQ;b4"‘kW q45J+瞏ct@g1!ijʿŤ} jLd2@szs᪚n|J"?vMoq6lf F.c.rQC2+)՝?7^d*0i!J>_~tD>j9ߠ;8pD'8[%B1 GGk;qFPd@h 3WM }݅$J V`z*]TA^ p5ZC7$˞$PI#>4x!(J6Y0E6\P-gE`J:ԊS 0*N]l˜uY~ L:ƎEPKf>Qgߑ>d| ؖ[c Fk{ִRj"(50@hhVD@B[T >.yh15MNxRg Bɏea ,#fs( e%Vp9h ł&f@9B&t z/8ڏcx d=zLK FFDſH4 d[h?v0\ Jg11EVhiI 2 TAvF85-R󶺪i `Bf %A(ۆ̞(GmU#ԏ&p# !FHYRJfdF&/&^X´BFpjPQB4S; f+GGd,9VABtJYz_PtDjcOuNQ<%djOA=_̫Q fLM1!2oz5L*P]AgM,|5/E3E0L1j- o(3Z?q ["71[ȝq ̶D<5:]}WUQ!T_(4&S+ &4H ƅC+~G镩(??_O!"d 19f0\!u%QZFqocS*bL%"&0XO ^ESo]jVd ?|r0,Ȱn~boeШq]֎> k Ǎ:2U篪`VQj*} ،u/Oz f){ݤ3)" wmݪgt[#0_Tɪsͣ`MQД6`rImh, TPH@`$v]HM.< ]rJtd…;ޒsiL >8{=AS+sa,2}`MB{Pp֓?Hkm/]@J2FwbD_`̓D*duT@J6{/(rS/DM*(# 2ЛX9ӇVORX\a 7g1un(lhlѨJo;AoSu6v ]("(ww$ݔtZ?)gy{feV!T u}dl-'##DF0A:";|hȵ]+Ŝk_:]TuP l^o.ǵ—B\YU ct=R o^"nYQ<*JyޢvCNImҶ$udb oG3-$;&24 [fLQiz#8ILBzY!`b2Q#:u|fOb/~P`~\U[ xpG/&D 2 #$υc`0bkkíoւ TF-LgA@k: #lBP(g U֨#QWY6y fX=uBxx>$V0Ƽk㦯)i;J2u!}a2()${nUЏX fj~KGJ緘ɂ%!Lbp3 ӹp e?btfİ%SD)h_.˚[ jMpxR؈H4G,_ ʐBT`F"vcPQ5!i1VqF1!4gLfMU= z4P@Qؼ k^9Aw2/u#1+EM^;-HY: z"RhX%B' t!+4/~>nn)Hh4:0H?u+QBH Ec`,veeƣDnǃ$)@ԝ.}mOI6(*) nb&I\&_(z BUOQ;fX %[ÊyuD|~ 1a䑈ݴߊZ5OWSTX)o 5*'N[vӍJ(29״3=H(:,ܻխz ɬ,Y"115U_pH(a`Z;n}TB'>uY[C/`TZalCf:R K@!ɑsz rL#ҏlb/* 9T@PnQW;mxQ{$ r;| Km/=!DȳY{j!h(:;8>C 1a*T"a슊FڲS:پV3V3 F5=Ѫv [َe3FW%f(S qqfS+M kJ}8)c!T>TeRCP F04^j!PT`RATD!,ZoRAፃЗ#3*}l\۹sʟ] 3-=~ktT*؜rO6}U[ r# bf5\ LLΨMVM`Gz]I(mTr0>u e+iL&& 2T/ I1R5u;D[NM`O܋P=ȩlÝEf;Qҟr6E g;O`A4 ^S0p"eMn@)8z#vG4JWD#`fe*ZdCyU|.- 3$0VR`*#}*eNn/AB3DOLP>%Y`cbzLCfC=:6i6̎pSkR=j+IQ*J A;/]=Jf$l8A| 2 (\G*E o G̀|ANC rR8f/[nq0k)/!:裔/F~2b^./r 89ۖbzԽwAHQԧ# _Cb&sT* Xk0ӄ[ \g@DdpJ d, A I;֤x蔩O+R!?X~txM7/@Z&-azB->PH?'fa8;!tv`qK23P{#C15e_:Et8`3.͓ ʓSF *J$[ka"%ȐOFM1)V2D~u5ojzf@_#!*_\h|)^eYjI~|BmA#_U)lEPbGԝoQ/nptSmG:⍆0eװIR`WRV\\=5L}فs=pƦ5g(0%Uh$F%z)JWYIً18cnVԼRC +(([fpBVLߊduU*b^l3TGh*^V oפ jDp)y'm^u[*s *5 b+,`Pp*ljFL?_e#aI.&t_ˌ rȞ%*iA3QL7JbbyD{t~(ǢnNC ƿUnT\2;aؽd՗ئ2A7vvԜ)3 o1Nlj{aE.i!m-DM Z8}.P;Bʵ-& IDATuXSJTbJ [XXHYr_i$ 7he&K.fb+9wjQq5KtW!%k19*C/.ZO xd 0jS{3!HyE>¨L#0C 8#N%sI0PU]ZD@0|@Qw~R nQ?,J"܁8PrI )5tKi|0=o*̒|ײ[1]::ݥWR!jB\*Mȩ ?FuL4|h,LL,\f!Y -fbҟId8.JiLխhw)~JaZé)C Ru8$D>!'cM} ծ_lkbUyڲ\ |*%Pf D%iUeaKK&پ-WDU/o[}U+, {g/o,vgrOL.pjJL8n^L. -(KG-. Z-jVA'r:gɳ&Gl'>"FH.F&WV&u}9V4e ̕,EA&)#:]G)pr`i3{ߧdvӪ| 7#T˴QMKAj;:Ĩ1h6'c/leS\DK/ZI!{YRLͭ2,Bu_eYs;1w(!]^ I.'N<,|ª̈{OeP)Z|#aUC?nX确L l˺y谣B8~!. d^0}п_ ht oN/34XT/w<")o,94nW 0|1Q^T7au+E1Ӳ]o"Joqjq;o%˩aRl/W6P !fP\t RCL"dG0[βuJɒ *ȗOнzDJ4\˩R'-A8Z(gAU&,N3o&\U ٮ%Ġ(3ޡ [[~/}aZDĖ`K[iXQ!FqQU9cyid%.ꚛK$ltGF(\Icz}f򏈗:'Y,Vҏ!<es~_,ALAS NBߦXL{{ _(֑q_hVgZ"vzjrtFtR(%~=Ӌ/r[m3EPFWV6/; O,d']?~T?ʧ3gvv-& ]FWW&6dTŽִ]].SJ:mEFLȋaP15ZLSьxMujp}UPhFd۶m{6l0;;e˖'xb@}kx+kox˗/߰a- /!T.uՀg!]/zRtQADNF*MJ3Ҥl9V/>Yd'{;dII$א )8fy}Rp" 6N^yDz}:row\E4&Sm3.fx(A~kvŚ=xw?~vllꫯ޺ukW]uc=cW=^{?O~sss_~/xr:oUbݯXX" &0 %(aja+*@(x"& #S0a|eAW6E%.+ԸeSOvʼneN&S-&]BkE̺ DVԅ{ ^P8~]/<}HJnU6;DeߐR]e<ҩya_Zje ^ ϭnna1!ܹG!?Kcɥ^ze=qW7|s?j4_^'.z!&GH 0RwbY1iRa%4G9O`'ih:9cڔWI+T;Ka[vq qQ TDƨfʔ]ӻ^EPA ?ˈ* Հw*!{ 39#^nڀb0sMrg3^_֭[8 o+o w#g>O]vmv۩=PTB8|8|,.ʀ)WD1Y TR0#E6x+MU/?ՕRgr/E D҄ty3xr5T=&h^^j'%pŭ3οZ7!]xCWB24,qٙJ×: 1?Ryt. }T-=c wڵZ{% /ݻ/}{ Y8>>gϞS{"s>_<!srh]CT6P'c,9p;TW(\ShT,#BRk[az(BmKf- k(*׷1&,_;PjPJ oIGuA :+_ZWJ0՟j™gӶb.,e,GЮ.zR_y啧@g!*F539.a"0ܸ7@rێm}p`8͍[5yj^ZeBrX@{$Ղ[5߶7j8HrG|X]+jx3̼CeׅCYZrag Ƒ!iE0#MfQeM$clj|j[gS:݋Xԡl>|?nEÍg&CGO=Ԗ-[͛7u~ ѫ-Ӫӊ)?G ݎKѐ$~!> ku$d(@t:K]?KF06HdMAt Qfu %OK01 Wg0B,.,#`471ޢjFhqm+lbx~# &־-!lZ+͙v@Űm۶͛7tMwyi=Y P!/J[%GhȿyAn&UAFSiSܭ"vDlX׾~e &sǹp֌`ZsTmiPǺԝN5ϊմ|5-děZ[Xt䲾IR+ 3Œ0i@}5545}9a+;\vg;*AAE X:exUv010U ξr#itщV sbdUZֳ>+ yc̪UNb۷o뮹/| VrJ@g*B!xqD" $d{J;HAbCCs9J - B(5A4ٶ~^Fx Č*)&YWQȂHCa0 B&VIP?((aγ"$фThŸQ0")JhW>)A&^ wK蕕ǒڳJذ&G&)bQb4,cttt{oR2>믿ؑ#G,ro۷oߴiƍxltNs_r$UA>U{& hA|gjm =Бy,u7:YEd:1P@RuC^\*_lZI$o.ǑC4I6~ /rfu-DzQ@ð/`HplB?A"/Fo_^nٷ\ L dαl{ꫯ>rȭj/~1cǎni13=s]ww~Wr3 >Id;2|. ,8P2,(R乄#B`'D->L*rjB\4T|H2B+9i}}?p e/[*- i42rtնw7q^y7~v{ƍ_WϷ]vڵkӦMUNGOՁBtѡXk iP7㨟8+3r9O~|~0)G48ԉ\yh>GO%꾖|Fп(F%0 `m|>KPL,npmPĆyaX?X$&axJTl촀ZI؉狹-D z9j@#EbJҔSgQJစ+^,qZ!9Z_u =3yＣ:izLZ`Pv8R0E `hL>/9 hw:LI-lO}Ơ, Z(v Too%W mʋ-USX{ \^l.TJ!~?Ly߄ 9딏Z&]ܵpjAO~aFʁhM19BʫGOVUл0ta8F9M8R = S847.: aǜV<V UԚ𜈎tP9^d0TN7zR2;ǀJDT}/T0:SЗaړ~ʬ'[8n8{ FҳZ(o>|!=se!?0388^dfMbf`)Ody *vg7rmM-]*N@L Skvbؘ`[-ɖdIW}ѧþRV龧s 2EW7K6JIg?Byк+snj唎zϣ$3Km/^t :C0̋,~g I*f(P yAVI IEM8Oz3)Qhb}ħ>] *]y -RrK9ѫCwNT7re0+9"TRP<+[;(VDSҩ$'hn~"#tc ˜VdwaX+aE!^k)w5͑2Q dOz7~JO"}|2k7(6Gr[T׋8~0^NdԸt([5%fVܝ:@4%$dw X6쳲)@(tN#qп!&!WW8tށ"° UX \8*g ςE ᠁꠹㎜nB*aoG&ǃy%K "ryXDGO̰kOof$o\5jͣNٜ|f>_o9D,x/8 7sFg$?s= "; zD^M:?LjY r.Q E#F%?=,%vQ)!V>JF?,yC.Tlz ٠Lg^ww4Ӥ֫ئ Ad3+LD\`25 H++ MiND3& *㼲hlNoP ΍E{vfG;jPYH&2@,fĎjh${0icd(=7CIW$GF烦/^'-#>V3AX/z7Qb@ӈ.\3CcJ{o,fR89wksi/a1"kta[Ps#ϝ-ݵFd  NJ1n x+%vog=?b(#oLЋzj52g_ezsd?L4G\h.hxHeUWfL6և:lȉET33e?w J$+]UPze:zCeQSF )*`ҠnoB́*(S](EK1+19m猰/KdGcDX$I )9KN,8rі֡lFu sB/ƹ޸x&GZ /}1]tg)ֹL$ҽC%+IDATYG*KM-u1_PxD<.RA+[Rt4M͋=G ;5I^v|̩ۅ%e%A?}ɋ;S09K&Dt"5
{CFVTB~ ǝnv2Ĭo#lAᣢiٌa]ݝ/<≰Zc#/JjL B.tY"ڴѵ>'5h6>KxMD-E8fd4r{Fck9R*<#Gk{6{n #SXЏ)))qg a]Xd0Y,/F,E'6 K4(9xL^0KϏ_<૮haP;HscND\06^t˘C}I#~A;E!UhA>J"/  EhQ RI)s8r&/+#yNvE4NF?̝}cõthp쨹-("f,HS./c8(?Exf! &ARDBpj{%?r:4X! kG3%Z[̼hD9P섾%?kb@~~gY%ɀ&dA%@DX?$m+6Mˋɺt"t~39 $"=2A9 @34JD\WT |x2"`%HO%x wFѬ W0PW6aAA$(x7MARUѡ:@JHN&3ӿTRsș8͏RDt㶖-*/S]Dh#EВ C#70aRP:wg9)F!;ZO@u;<2/ڂʑ9N&JHl2' cύͻ䯤uAm$d%XI;R1"(gs_NFK%r(YG9W2.&"t^-yQӏtI/JHDITҳ ` 0J+NIV]iHޥĬŭ̂d%yrIbRx;T4 Vy:ə̷K &ԃiY"8 j Cli!LDSHdǂfSP`mr!"̿-X V9Y_T'[;E٘r'=# e1Xhn966EI ϛp_6DXyQ%%'洺!4w1ج >@ XDF?YZo 2KF)lYMNg%Q(h@XdG/#iʋS+  (>5V[ kfgU ~+vc &B3REA? 5MuCTςvHi"ú"}̼hǙ//g7(3U;~hfDOVFԾ~"3rE>KΑ9vGx\v!E'}hH1=7p漑,(ղъ jY!ɲyhK%\~ẗcǻG^Vv^Fd, B;1%4/*`,bӥhXH ahXU 9}3EuB=S`恈яȜcɲy: tgZ tGghHoTEDJϩ='93˔SJX>ٟW\A,h"h"$fp;ydGg 5B0USG4-tG@a(0q7(FJp7fDV*6;«$kj"F ]p{iM,XKl Xp ;TD.46kh\d.(0L X>ND+?cZ*b0X,/WZ$lvH$͈؎-[or:m#N!Ǝ:a X)T`8/>%%Â,zگiT'Cz3\aMrV+=Pf8$ DE8Sļ["Nzc~P šxDɼh^Ft{3!g_UfJY-z\hɅdZ#E{SH@p*̄!F2X&P` /;,&z-RJ%W"es21>q֬DB=$ D%&Y ݗ &^_ k/PPHsxѱOcPDt?tIe" .7m1?Gu HVяDw:vb9⧄#B~]` DXxpWR*P.ThD}'pg14Rf|L4εF弈r`?Y>B~d4D&Zh#wT FkĒ.;(=;siLg~ɳFZAYMI,ϯ`NtFS6l 5&0+V8RoA_Ȏ.k J{wfJ`9h7F$Xf3VӴN(0*J(3Q!CQ>ϩ7Zk#W@~܄Go|@)Yds~x8zPY),B=zڳ7H\pn4wD|?tTȦكkB_eTʾxQsM \K@gg=ܳ|M69rdҍnݺhѢOӏ=3GjasucFub,j̑bF22%E)Zt7ٽđw77|o&G}'ljjZn]GG$+??A{{7{玎vuu=1Xr$1KbVJH?jix:ؙRcΈ Sxƍ?˗Ѯ]{Ç;vtt]wɒ%S> '<5I0,t6f#83(Y}eCC .|>G?D$hoo_fM&illPG^{[oݱcwzgggkkŋ؍j|d~@j6H,#-?OF΋Y,`QpϣUIkДlPZooRk1wX&ڸw:ujҥޏVbgϦRIwcSܻ)~`dXd E1bq(X$+=LM^###Dblmm%щ6N$d2>|駟~>egggOOϊ+[nرc Q#p69hQ0 UEZ| GKeG =OOf3^~rro|>x{;;;lܸqhhM7qO3 0sɟxN^(#jM_q/lW#fGM"4POM>g-fw^~/|m޽{-[zj"Ztݻs\{{K/T.OPO~H㥢@΄E^XbMbzgPJRj˖-ַJokD~@znfπ !(t;g#q#@~ѡ%3o<"Z`sxxϟ?]]]ǏߴiyʽSOѡCyf}}} fr/t9/jB~UYr5x\ |O |o&[ڒɓ'͝ORM#G6o<66f^l>``cZZZ/_>n@ B@S텳K M9A]u1u15|=~ٻ?y]vyyHf޳gφ $RToohhصkwqݻ"ڲeɓ'W ;vزel7f85E޶l{]4s n5vxG֭[Jm&|yo=͛7{\ .|Guuum޼y||?qľ}۹s<;lܸϞ=lQΖnykPۼ;vx7oƯwus_z9_18p`ΝGYhц vi.%soGikks.Z+ߚb?_ 3A53F@@ P50X2!X5kv7!X5Y5!X!Y"B"k B"k0X@a PU B"kP#P58_} !"k B"k_P# D @b D TJ p>Q. "o B"kP#P= ՏǪ@b D ֠FzFT@Tv7!X5!X2c i{Y|ykkM92W_}9zhNU"7߼曉G}'֭[1ƣ]]]O6ŋ?3RJ"b۷={_h㎎k.YdV qKE~󍍍k֬v=zt͚5tqB>ÃB+yM$w 5 CooRk1wXPƝVbgϦRϝP7D;[[[httt;;;{zzVXqWr-ǎ u@Po2Nn;;;y䑞Ǐ]n&ԍ*yٻweV^MDK.ݽ{w.koo饗ݵ"Ze``,yc;Rf*qׯ_hCp lP7 Te߾} 7o<"2 n|СCNꪫl___s'ԍ@mmmdɓfӧOK)n?)vǎkiiY|ys'ԍ@pwڵC2={6lؐL&(J8p[l9y޽{;vlٲEJYܲݘQ̸ <ȺuRԶmۤ/?ݽyf/+۹s<;lܸϞ=JY0 _¼y/^|w?~<_13ΝO}_ *?љXkP#k B"k B"k B"k B"k B"k B"k B"k B"k B"k B"k B"k B"k B"k B0ZIENDB`demo/documented/bcs/000077500000000000000000000000001412460263600147045ustar00rootroot00000000000000demo/documented/bcs/aneurysm.xml.gz000066400000000000000000025353501412460263600177250ustar00rootroot00000000000000JQ|[n0 Eg)REӮe ҤHcئe#p ˧^Oݿz;^λ/Ͽܕq3qc\Ͽ}ut?]?p^}w88+7xv)7".GχkCߕo *w19d{q8ӄ[yqr< 8-)6g<&Lb0I;ϴXaZ"G TiqRٵxGsQ!kސ=o\qPm'uuNjgC6YB8SIC4zW%Vg\yRq(H %$M|Ā|t޲V^c q?Wޫw/՟y ֣?-S g, >9˜Q[3Ϋz4򪯍Gs-'YﮯԊ?ENj˚=%g/W|,(8%F}eaqr>81;V+2xqrv }9/Zm[^XOyxϕgTcZ{?vP V¼"#tXО{]jK,B| xe3coۭ}^Ca}1uԃ>ުCzBc / %ٝiڲz7;}Rbh/7}m?\5h{|s8&=\FuJlm]饁|,=ޖAX5hv9m4_SS^h;s.&WamI FS*h{E% Hѭ!&yxOoY]]:&zT\^^uqGJ|btKcŐm=C#ۢo$>^b0VI:Wxw *c=#EVǏO'ua['vkSt[;~Rsh,JcIR>K!]q~9^-MSw'X!~U-={ԀΕi&5_Ùi8 6_ȋg}l>r9-%# ABS3M֜LT=a:3px7}MA3ta)}D~w TWLpxc&w.5燤uc 8ZntmCxc *]Ofӧb`:x"%yGU.ɄrE44~;-J(ӛINƾoVa}^8.db)SȤoF,$~xWly}8G_Bu4gB,ݗ&}'7~K8JWrvh!  nPL+o{M BFkxt,^0f Q<<. fOq?2<$ {|ɰ(CbiZ _v;ā62H~~ )#e2#*O_?e)1l ^Y|u c(ߤiqCsu}=c}_Zx(J4"6> &EQL6]bޕ(s``ؖ~hkyJR `&EVWo=|wL׵:D6B}umjDr`<$?cCտ$>JI32x :JeGP-hC~2$TF~Ӯ JeR99twVmP{AeW7aWE:1Mo-dTe6ΨvD+{ B3p&З=kQ_\d$@pD4A14#B f%'pϾtt ri Frڒ13;އaej쉃D8T@>vЦl.fIYlUB§ ':J\q8Ēvȡe%vȔEτZ5R- !x'A'Dvuo\[dVc#;%L^O$so&^$H7f~t+FTK`sce8'6-NV-CěY4aXi1R!)sKo*+б 4[vJir 6&EQZj9=X1NmOF?ɞ74d=ɔ_.KÝxno4#đ^ѯӅAړc;К9}BQ } ";v#0j2jEwMR;kU/ft-AЖt^O )@J ʲ^o(#Zi hY w RZ8<*VL1TU ^p"X4_{XV H2؇-?ri eȌ_w=R9\#?n=X"3Nu7]|ʃ,5o*Ei=BJRTl;' ,$%2q^:s+МN|v?`F[mi)}NT*F =ѿ3ݴ*\az "( [o,^M` ^-@R!HAzu&l ;*Pr SMt< Ǣ? e !-u8.3e-:auX sDbI&6V/f6T@ \m)$X]. 4H{D8 3뽂ASuU܆2{ 0|[] X,mB~,]JiƱo >f{VGqE+R80䜔 )Ofa}YJF9N[cNE6b=g*4']sbhAj!2|ytACY?MX)i?2[^^ke:|߁( USp*w(.XRO*ikd$+w0F֔UjQ^Mಙ(+zޓCN8fd7+Eq{x 7pC" i}UVP6i6<|t94&L&n(kx8/ͦ Pv\1:{m-בŤyLY^5ywh1[ƈ@'# WPl|v7<;KO ڲZphɗ5>/J?"!z~%n~(|8ue(74]&li3FZI(p}8,A^IA@}L*C/Pc3Şn)ZH]?Bʫ pN=I 憆PCP%Pel +գ/ =50H?Ha1W ]/{#@mGC>B8Q_BAZ1OhY55x *q/ [2`ʱjWVhiZP"`yU+LO7-t "?v<^]3>+b@8Tj,Tq$^CگW ͉h{Muh818,Ebhc,OkE<R,:cSq||z'R^s}c.s r埇&DծP* Uۦ8f}^_)`)3gULƝh@+F {tDfL[M؆'ԏ݉0C3a\H&}!.:eJtOd hJTŠR1V[@ɷa!T%)4O%>bD?9w`)r!HcZ w ]csW|aq\Z!9BQ\`xjdBQEmDYL|%K`8A$ /~RAw({2ɘ݆PJniS^T%q3KCt ̩sυcyuFI 1/6KH]$d?Tۨk@3 'Boc?MPz}hϤ]k0&z BC}xm"=/e|nõ'*&9jw- ٲT΂c %~, 3?Y5[{(qv.}b2 Xk2151[z\qo`"NDnRLJ({ڙ#(2zYRe$G>=>銍\;/5W6jIsKx UChKf_Or% OPϹ (h I8Li2**#Z70M#ͺG5̦V4!i@2ܱ}ii8T}H<^yr_rGG~ aBO ".ɄȒbO%dNWߊ׹6 0F-_mda<@4q}ȧ a^IﻹJ~e;ȠĭUC.ShL% iLb82Rws0?'E?`/$؇954ؠ6` ,씘K" `Ty[a+fыZą +\h0Zt6u:%ş$AI W pܦ:q &xf<얚mV[0ɖ< 4wЕ iHOlp4:l߹[[ /I5Y65 -$d"cГ:5ǣ؃ ]U(!ٴX05!Gx?'N.s3! DI$zx YSwy]X/ 40ߍӻg)Ǚt9}IŋBacML#k=† sn˾U$I,] ݞ`K>g4A~ȭ,FGunÃ?_{K޶mf&Q&Y >zW`^+{4pYqF!'sڅ]f߁٦˄|ϕ DгOZ-ø7"Nd5$ >P.׶^q%4JX$DSeԝ!HN>e:)GJB&7Hg Fʋ0,BMM$~&c&9yn4nUkNm,ͥȅҌNPSwܷʆM7UR58'Z`WU[2Y'hd<ɵ2*s@l~@[B(PhUI+𧻓!bYRy74`3CIrm„7sZ>Y6t k裗[=:t\-9ywd*dM8ӫ+H}q/g|I[p%f> l~rdT1;ph^j]ѡ3`>׹%J 0tKdb$x{Lvsz+ 3>%S| twq{ $ 'ѹ0UN38O|\jZg;R TVѪ[ Q3rFJ|THw}KIAxhY`B!t X9/w0g(D4J#\A^;5x~AXHDAH 3i B%ó< ˴PBz=y6YI6/A B΢`X%\eQ!7b@ ɫ9'-ECq:BZM`k8l&s"ZMWD,}]RWDրJmѵe;Z ,5IhhZ;i)-#GDd4O6bZ@T}*N Щ-/ f{=ipְS7 3wnhc y&}lOCCN\BIg#EZ+),\ W Voصbc`F=CʓjI@}{}v]R~q)&l~,\FboY|u'=I.m+LpH#B!Nt(Ji|In0 CAu5Jl@OI^Wu:}0,/;D#'v+ҩМy-|M{:%|>D[Ͼݲy2+ EN3,R.gI0"Ŕ|J⠜Jz2PG5(ZzBZUwe AHxyya3iuT|._< ߍIFi _7 ]ϲDT(#Bՠ(-c&BeS/EN ťW2lȵ|]孹?F+1tP׸b5+_(Y MT@Zh-fsa95 מw-)J[jAfOH L +BŹet% J '{IBDɇL2#U3aZGՊ;UK} dK6#Sؖf zfi7A%ۀu$:u?݄`YǯtGѺkSM\}boS!խBc-H[6j!+4F1C@N{ m fiRCMsYC6փO/cVC^Læ0Q@iH<įA l,{r q@o{_2E;'UlZ w*CHm*W[ pdEP2&Ǹ\,12H E8d̕UprɚvX-꒏ a]B%Ckj XZf2J2 WpnHZY]AI. s*֙7{GN˟d O`ʋleܕ *8͎><1c!_ҸAA`*ΈY -cNsmTkW*qJINFuFI@ RM_lğI/Z=Sp씽S--aπCH{"͛P'ts;cn!ue,> FK./nM(%ИW~۰^~JP_g۸EUI_Q\2N; 5U)^31ܠ6Ԅ l"S#EIgsz1=geFt!M>CB~m0߅l8Gf[}!Sɫ?̤9h% n; wA[j<|b\VW9EޅP]KYwy2kȧ\+M6wաԺqUG v*ۦ1wD &=0 o_%CA>Ne_?&flt7&, tvu "9mj`9|")%vByJ)*i4@r )cΨdʤ ؅,sdPvn@f唻_!eyOŇtX<YD1=w. 8R[6y'-û2:/Ũ 3{rQ)skd2aY\n jDY5!6uIm'TG'+8lĩdI?`pOYykt11~t4"z(;z-p [A*6%>? +=@{P>ZY}1 0_:GT["xg~٨OQaѴʃpPeʅ^v:jgJ|/~3پ>$Sz`O~YW]eoG17G[CBTD= x9,16 ⏰+a-olEgb׿DL QnWyЫU~XW޲ҒQ$qԞJ}^yX8F<2xۦzJŖ-'&Tuh;?ʕ-a0[ob+ sI€%]=ސtX]G ?|i5iLCl_-&Iہ./TԮ^6\ރFvV;Nz%4k+ꆦq$>h/medu0$k R}%B3p&cM^?=_!d*L&l##}(x N9c_<"PJ-AM|N±%Jfnur>!_Ί(DF/kxd2J?Kjj'B].5[='myz!O55h3 ![3TY#-@t_^-'Gl^ A]~غE_b夿8Z$PVNr%&Onc95Ri_d(4w֋R,&_ rkwDy?buc|7Ŗ2CHr1KMEG?vdrIEjBAyb5;4a_4<,v}PkHosHfekql9`RR|: ۚ!O{ɩlqafK| ,|H(,Rc4e(-e5D UFCa)_@L$t娞N_AkyOikQjbzFgC|wcF BrO0)ȲfE!0k.㗎^kLoRXsH (JyMQn&aWk7,hZdɢ,j0y~@(6uo)x,m&5G7ګ0~ hn];}@GHQv}Q•" wxI #v; j>* ;#a$ShB 'q24g"fWz ! 62BX}P>rs0K$#6ӑ|e Bڬ4/wƒ7"rf%=Ep+uQ8& R@?z-0ꩾu`e/밵B&.J1m;S +ClOMbKli@JO!̓e6\߭Q#8dt aƸ5hs:rOp]!OeHq NQR<.۞rWu"_ӣ-P~ImDoKX=UɎMGǴu8E)߫L,Pmִ- !<Q$?~9>S/kiHJ "뷡S0ՖG=~61lRmZ_ӈdm,UADQ(aC?]xjiʠ_!ID}/E F"U%"5bWD* (VMզvUYb>a.0] sZOؕ I/%$vjv{S`̪"I>"3LFwBdmwq42( 5JFB9j!ePb#QNtveR0u6CH$1 8pDߺ C a%dY؉WЯt8J>EG8A>9)(|7iNDNQlI  GıWi_ ~*CcG4賮etb?B%<_B ^öslKf~7>Sjw> }-"АtqXC XQGђyM]+%#*w:͜߆yP ϧQUw qZa 0`׮h"MYr5z@p^^^@r+TUaOm+}J{tTtPhj !IV͔:@(!)JDE8>U˂L+uä| 29}I4Ǵ7Bβ/5bt0Mœ^p*&2ݕi(+ q?gGQ/\ĭ 6!XsW(6]+u 2b"ԘvLEh]s=NfB. 1!cs 6Ǔ&`OsyI/7g,'F[ܼMS=vhE tsxJU9r7L^(ᖽ^2"ӤOTON"S-.Ǭ??g~/H wh~ ?fg`lխZ]$ኘG0mh{qhAT΍K++4GOȽ0Qp}.jN} ~;>]`A국 ܽe".ȗ@KD8*PO*GJ1s;_9*eg6 /q3mϻ!~V`2Ҹ$D x׳SY3QvJf9Q#(_{DjRUH4]1l^E0CWuT;ze1#}:L|o\z/D +ʊۙ|3e^]:JLs*x]Gؕe[ -(7&ۀU F^]ސ/puԿpKى.rJo:Ttch|FiܤdMl2Uv-w#]H o h1Aoը)uuat rnZK PTL{dzZ1Z<(aMGDnW@âL (=Ivj?$2 e5>mLMv<]ה曏Ml t J qxi $FvbdH pܷY'}RʀhPdB|s 9X`I>e,Ơȿw·r -ȯsx%dh q.GHG@q1m$;?|ml?쏛ov*k>/?w@{0{lG4 '_^%ez0!ޛ㏰sIr荦GbRV7+*(MGm ߔg~tynZk'Bcٽ[6lNo@{3uu"l|8)'?r`< -1$Pth} *\go[/82oE M;a `whXH]|T''^c%}TLJ9c>b5veelB kW ; -@ 4 ?~TPO4D="X;X2d]VJ`Zuf\ . Cu58gn$~;|PNO:sq'G情Z2WyIëꢩ‹ {2*v4!_]Z9 #r=2 / z?tؖE?m C$6釭HuY?CB^%E}0/H|T%1,g-"~=Gc0/q ܏PeMN"v4 uεc'4sikVOE_ӟj*ҟL3r!f>VGm^M +]c2pJVr,2p.n}d% ~2I=ZI1yz݌!Cj;r7,WQ6ɖأB1ۻ0dp'N0Heޯx;>8ZPRsbKu{/R&^,%H Z{V>'@xB}B%**ϻcZW!p~d՞ o@c(7A%# ڊP k.B}Ó>A<`X2e'!uel]zDʍ|Q Ddc3dBwVn4@pq@5DK/ˡ~B m8OkpGcfJrӦp.`*XH2- s]Rcň\])ߐܼJ/}g !v]am_hd(܏>35w^M3͈ٸM=F%u\!nw;jo(+1A3vS*s1!\pa z/!g"U^MS-Ld,՞⚫o[/Ɍ*JjVEOwP%-86qz>^`([O))_[C̮s\cf`U-Ĩ#^qO,}ze%cIsσ,$4܎Gͺ`EؤNci5!ͨ!mi 9fL<ÜiHvޤE, j-^AjȒE'eppmVݧhIX]v&s Ɛ#<אN\nsԮT;1kP~_b%qU[cȧUs3,&P''c6pKUw.-ɓ k㊪#* 3=( urߡ`2ӥinV*hZkE_^ RnCSB)h$v~‹'8J3Av8%k˲a[jӂvA+wA?ݘ_wr+ټ.~ߍoaqse/]2}-uJz 8Ł, `'ؒ0i}xlꀎ UN_0~A4Pj-N,(}.>lil]{)sݏ{ [RR3I,E|2^ޝY^7Nc]3̶mV"lˈNͤ#D6-uGbL84OZw/z䙞DW~<,i$J { |r/;< ՑmPF̅GkzLN$U+Xu_f^?6ہ[Ro=:%_<2 7Ӌ wa@`sᬺ8-?0v[RK{C+wԶ Nz2-qI6{_@A;Z?nI.O2PζݫjzZM EU JMc՛: 1N6)RA/(d Ծj͋y8tq߱Z3cGCbb\Ñ;Oo;[,|.>0%T/)e,1{5Tc0\_ Ug*y9S ";HB `0\q=#ݪ]ۑ0k)cwŒ?n31I".qu^$d8y-4l+r,q- (yI(~. ect"\.a6gpEqcUHR7 Pq?J)#\>T!v9k@6װ/8>W<niJ=q8޽ iv :4 &ƃ0͌sDw%]GAJ>ɟwpk`F}YS:|l݆0(h>З| ͜{0ي {rPgu+yZ(Hh'7r٥ \r̂xy\*:Y(9>US Ea vɾ|8@CߔN@'ʬ=.wT33ע>5e@I dHau1V`brAʗ/"lgXN3H#ȅ@{# $-Տwu5i.s: 5MLʔES:#I+J (# k0{"D}P)bIW |6sH=*3Im2oU)9F`'"̨ID!Mє02:m8FU V@[HXo`8<\٭ctg8ؾOeAY3q Îhڝ-$L|d*K@ԍT '>V*ˌ`LªasG20)OCoɃo#)Hzi*>J#n{KQ6=37 oGEb-V{E,`p|+ /QPq?+]}XZ?®,bhJE@&}@*A7Gys;^yK3́dkg/R߾}+g__ƊDӏAZ .IkM HFZ^$[MFX<XY ɫ \zM FWx: C>I/wCFLTᆧHFzIPUvSCE'E4:#Y/:l&\-a}`1T,I-ܵ^:揖[bINIsǞ?[$d =E+}l0.?$ZeI.%+2XhUÛ"lE@W\q\1ƗOq{<0ggh )1A"55|$phQT)ݼTR֛1tGܛLH+r02/OWKX⭑Q D +ya/zZp'l3QC\gl+ggQe_K<z\r5J |Iȥ%X aEkWf: ,=RØv\(`^4!3 FqJIc pn\USjYD* &5`8)1"; N[[hId:s䨔u.ؤAZ@v_a!߂PcWuя ?bc_1lCx)S 9}d&yk(N B6/?DݞLF mM&>ןIO%e-݉V)YbL8C\ hVavyfb5A{ЏGa}\e`$\rpvFG0 lqݐ,_J,K`LQ_;tCtLfP\EFftl,W:i$ QM*UaJئvk(H~KRA3P6@AntahbtkI3Tl86O8en5J1 Ì|k15Mʵ:[_Ğd?J=irYTs2K?I2 vlap0+ڳ.v4ӌ6<-]rS8VX"AыeO]| 8&g<| fk~wC7@٩K;x#P@fhN +t̿=ޅfeQ|p[.A;+?=].͂:y ٲ&6\QS|zws`?ag-1-@o<3S" 7dTx$FCY08kT>1/ͿLi`[>.ԝ(׫١|xG&_@偩$Y+-7nd.+%.਩KDd Bn=?{YbaE؎XtJ󎁗C6i|&<: 8Hs,mJ۟k(C(?8í7 ڐ9?o|w~vj?yH\S8v@[ t7ua M҉Qlނ %$r~l~LO_4Vh6RV9u>#Y= +Ϳ!m"NK&H8^Hv|;̾h?}gL᷒ ]byhbkyPg)Y 5n?aW#AA۶j0E)4'  wd‰@;Gϫ 3?d.p~ёzY| {Z |A܏>#Y^iijJ 'Uy`!Jv>a {׀L453zVi]Ŋ";vҟ룿j 487gSDįTk(W;]#bc2/w{i4$^Y<( )nGDy%;~-P~)d/4g 94#˽< BznR9f{(rCϡ#32߮0);sړJ QC2^l+of$0o=ˡxx sa H-'IML [ܬ@%A%9x1ƞ/age1A0Pۚ݀ FcR0Tx_gnEyqxBȫcu-$IS 6i;_;ff5M%="_[#7"a,C.yPď[J @#h ʫS9)quyD9I*  ԑpWA}J^DNl ۃuŰ~IQ纝+ ibƮej J0-ߒP(P@.f5[B354{-#eo7Z[[ha=/RvDd_ޣ͒!oE6_O@/-!d RɡS %394Z~x3>bUJF` <I{!.y5Y$9" _he=m䭲!C|!뭀ψؽVI)umG %DO'Du>}>a$42lop#LL&=6YСgh ;8GyUB,F%VP'rxx DEog͊Zu60Tx0Ί)ʞ?Um퐕oż74 s(YRVٗMϾuQ+ +zG2c= ٕ+|+Y]x-F)XhaEA ץèf тwez`>c=2yV9>͛ۇsDA5kLÌ[e 3<_\my!Pl{]FZ--3zfr4 F% (DMk&/qQpKn/$P;S |"+{sFrp:eE_D+Ώ;a+Q ' Oq\7w7R}EI%N=}#L[4ƢTf= D6boֳl.ӳQNiCG{uk7e5MNW%t=Nc!*znغO}:jeK_O3akYxPM'SQiv|9$KmYk $: O@5n.z#'zFt=d%idaK gy~E6w"čN^AW\`:%55vN)NeCxִm> (v\mD-@<1G>e\KT̑6%:(HڂA~$>blv1'<lHcm3`J+7J'5ëPvDW5ׅp,Av%x=SM\@Hr2V!}.r |Vlh 賳%l lE nbJ.^3>ٸLf\ХƗjF,"^fP_M/m@GKBQ(YT `Є:߆JNވ``#, Oh?z'ɋL>]r0\)/MmH{2g!lc>w"BR hi$-aWc}UNjzM'[xjMӾ`TuFÇ3zpu7O غ"GKwu0f %v>j_v ڱ{͡H%3ສ D+s)אi0ZϹE.g(4Ym(Kf5@JjJv5:AR׸k[ɱoWT#TŘVFMI}`OsEvCgoO^qV\H7 !fMS*5ѢxN0Pm3],Q<_yZj(\v  =$)ltL*RpMƯ1N~iG-cƧF:T+6v^nTQMoww*s JU,U,^c B֒o=\ {s3]EE a+c1AWPWxB=g5>YX4 k-'53O?x)O0,E2^SV'Ѐ-5tN?`d#OYFCw6z(/f|)@{ /r]0j<Ay$*nBOJ!sf`\fy^]ormjNWOND$>fG|2$nM[dfJ7-$E"Ôbd,T,je(L㝤rT׋vv%Zto&'=G]/($y^/>gi tvN=R6jDĆE \FXv Y=Є2E.bȝ~CɪlCahOlVH8d}{hY1jOnF;+AưbI. y䫞,p̊'y!K9h1o͢29k@PN>dX#:J zy'bL9ѼŝRdnt@MȘ5lz&rKۤ^P)PH}7੤zNju 6+앟 bX!7`GO\],;'w;^ФdwRzNl{ vwPk.'׏APf.#F@TF O?K*?){kX$aӌ#nύRUπ!©xsAhVcFsawGc -EVAȫUMfMO.4kLn=2``, 'h:d*q Jpod@=7³F4=E@ s XO޶JOX,Cص1 °_u_KcYT>jޑyPXM, qk0ݻaءǢt肔ig'-rJc! 1 i$Z S!udpv)).hŲoخ E{ PʩQӣq At|;7T\ 𷼰zxO[)`)| #4h7^s[Q㺔^_I1}63T b[EWL@)vw\z&$ 1p˳S_ӻa5El({Q!;(^:ӂwH[S|~ NEOjLÓ;}Nz6\|  y Rdaa5y7Gصe; #[o25Y@I#(~NJBME{#`5bb_ }fsXUn9uVC{tdv.il\)y+i̛=BM\gXbWh@^&LU.飰4S x0IGV*eZ;Ő|qY^N˶+!j骷tgƗWkv+0ae)V`Ӫ.']H&čKgҖ@M+xYysh<<וi<^`Oˤz̯8.\;_CB ۃ"I&8C;e@NUh}bP 0}nze񃏍I $"j9+"/)32uϷ#IJvqԫe#T+ (,d+; {˸՛圂}9s8p£)\(ԭ0nȚax()kN#[rs5'# 'с_>[K0W95.j-ӁӌV(}T(WC;mWzlI`3$ܿW3t#:;6r)āx9&,]n<\꫱lGG ,Lξ/j:/-pMb݈/~8ځ5<v})yV>'.BWqP},`}+!8/ԁnMN@xK l +vD%=k5ː0yiՁh\ 1ƃ(fJmJ{_ !\PyV]&%SD&͙L U޿s3-^P2 Eξ2m"*M\/s3l6C>C{;Z6)[r*cПD\Qnf9vWY9X{ӬKTFu! }@Ɠw g) ׵1 °za_ė#z;Q_.AjGXδ>ԜCW! 8OӅK@M-.#sH x?!ghUo 72&M}GET&> #iNH^_"/P@yqA jO%sy[if9!  C5F f@L݂bgtzk+W2}>Rfl*g49xuB *fIo=?UcV/R>d6n.^K]i!IpR#ni=Ajv|!WMl,if7j<j݈_$9yIi \S7Ӟɘ, -2Ҧ^ʲsJxVYtr4 b/ j{< B/ZKؙA 0%0ol_JL[)ac`@:5]LCBg;ye% t9kZH0)AU#9Ϻx=ҕ\nl>౱|&-ۈ摤ha$ >#wԻ?͍5d F|Vhh .eȍeAۊaE'Ad83,aUj4(:10ޱ$a0S`?M5\/O}6!>X[ 9/ o,D:EҬ:3(- O\ TWwf#{*z{?XAGɓBUBx夡'zR?i^iY/Y;"t{ 4K*m?f]f<#~g-:?=A⵱{%&٢юN[qst?®aw$a2`@'g~2[rKu>ui>}bUBkU֣gh']CfowNt^MYPߵۀIqjIњϮԁ^8\'tuҧX*@}8HߕNP|(G4}ȐyyexeE ˅V%ZZ"<_6"̓.aRVeﳲ%lH|I4zWCbȬؕ=L!GB'N+rݨ,)y tI=Ei[!*Fl}<šzIyZ ;֋m*=(2͙߬d+05j3J)WE#efPgL8Sމy zq%c2h̤Bhw>hچ}#ʲAqhsiQ9@H-P ͉))C~ABQ~$F4#yUqzJmKc=Vrc$*b!BErr_HHK=#˼󱋼PP0lUǵk3v>1p.\p{ Zz 5qQ/(^[M oiFk6 .ݗD(; 6ɈS1Q00Kk2(?0g{Rkݪ&:ZUj4v%6 % c`nRY q=Yѫ>>#h% bz#pfqWYUGgoۢrӔw='^(ѯqiDAħa[>ˏ*~Rؒ)ꬪ`FkP;JiizkjܿD45IɎy,9Kˏ4~@)hZpt\@|ͤ;Z> h?}g[g&4;/o-dom2vEW l%Q@]Wn>[bf]Aj#L]=4:U~K֓'\aB8&B V9h1/hYoZ ZwDSjA؛^Z밃b@NO&򻮴5ۛ.>7re 'nW;~'o hHi/Ǘh,C\ɺ| Prz`wt%| }*ɿP3p$<!R@·@X(Q5|Yd ,`ɇfH?)PY#Ɲy^#{6IDV(w*{@Լ+@}%.h(nB!jo|2=CW6Q\pWބ4O~'슑-dVR LxUzh%m7.ֽNw]K @%$c/$a/5& s;Wq ' qYqt瑚UffKC7A̾Uڷj#}ӵDJ O ,q&í Tn.WSVUN{x&k$Sq丨OwiO!5hxo R:YuG'3S;.obq`}y;2R}.@|єra*׆Yc R/vsoxÁMs:nO@0 ZY$.vɻ+wɤ]'̠Ӵl#~i$scS ٦1H% #HD 0.({5q1POJ_m b(d(7vIK[^ve/&TNlyp_/GؕK ° ؃Mr Xf$`:lڧ?{d3u. CQf7ڴV8h§MPZh fӑT]9lutDz>BngՊt]P`1k1l|v:(W2`&2HKH a|]`WPB.'{]bW>4۟|صWjWZYijVS7v(OS1٣Ay [>pBBBU؁Ricjx6Oo;Xz8`0t Z"C VP( 8$®iGkLӤ952BGCJrƧqQ`J RҬvMq4F(#1|~`|&k ko&h!b|k/}Դ4TРv1dyU$\1?aW`#1 V ! }i]_ڈ1v& )8y =l"p˩r7(ѕfٚџQ. wڙvmpAMH\<Ҿ}Mihe‡sN?#%v:xF{ĞG /)00>/Ӱ#?76ݽǗ'"Y -#\rе㠤rvt. t-Eݧ5eM ͵H#H/ɡ!{@[løHjN-"x]2sOjѐ ͳ I8[lFS`x2je5SA˳9+Dί<e谆?q[=qO:sٰ|&)JENc|C:(>͹# >n4'.4=Ǒb< kq2K#%CKm迱 {mq@ ?'f]SMr4(zPFfVt x6 6~^=7$J=*lr^œ]PL/a$Mk5o=@He ٝDQ;ǭ^'U~ :%7%508䓴]MŗSEH:,~T\Ogi]À"!  0'׀vP}v .k$گl>&cj.vЕ^KTc碏b{%ڒa /kQW,k8iF]mI|T  L @͓o?6ldc_Lb!|k4!{=8($ۯ oP{e<@*1ߌ2&ɽ'M[lJJ*kDDE 8g# 2YsEotxRo<ʔ+*+4qNFF вhֱ[>-BtrhFpPSh?PP΋yb?σ3xth_>FlK8g+S;t;0-iUOC/'[fĺRyNg76ڽ\4$tgͫj7m8mrz ;k7[%vGȣx$uG0@wjhNVa+ef10Q'Hx $lNF|ٶt QUNɒ*ffDKصe; - b`Œ?%4ִ2|'*iie&]HnǶkj0\^b^B_g}|:[iܘ6=3urē,=Mu;gJ̌' m'Ҩ'Uq;[]ӯ64~FbCP~!%$SJgAuz\^8 uKQҮ[7GFre0!r WT_ ;=Y)pܹ~kZA_򑁆)hd8 Iffō*s Bbq_FdBZHC\WX( 4Iw*iD  .Jf4dQ(=DvOv!DMx;i9ٞ+WђgYH  ?ܥ ɛӟax!IcbB&R2s^26W  $avZ;xf\Y o) r@bZ1MeҴMRԞ+9[{+}^f(q-w s+rOBmFϹ5eiFBa0麦H'`ۃ#={yixl H岀3p輮@tc?lHZv\FPebwykgM 31 `;c8],g/HpY߽@aDFO9~7]r1S@>J'hxCVYp{E mM_!%ti$=_tw"\ F2,~cG(::}-ϢBʸ7+YsԢ@Hknbg@zJ1dtEb{ !xh܋^CU[厛ZPT!A<9 g;vF0 ]) 0f^-8i{}˚Qnq,6e?jϣtCb3+FZln_&`C5j3CHYq|SnS ϜWDkbKkhCbN4F:@"z]dIa ]p{Kಓ qβaryCv+`Y<"@) B8wT8B!gBCF{seeW3cۧg+K~-a,*xi,` `upPVJEP׮,m97\ɷ.x* ~xF caFSHf"G ^1K Ҽ 8񢭃eʜ90t&jսf&i|{8jM\*sa o"lepgƔXf=lZ#(^+p\J ^$=O#ڎ$aXK6`o9LdXM8Ϋ1 " rg Yqt_f_&בNt|"1 yz~\D?"3#SXSY ! 7hfzG!dKw7Ct]bʥS tD B;%ugEfV z\C&Z| v,Sfj"ثF]OGМfE^|C=]VAfx`!fs"y >엂 ^ g=DQl:QgU-=B@'!{̆i_r#)$uЭx WN `~n?lp8"L4qjD$HӒ#)Q=elJlW]y ҖP)}_8?ㇰkKraW b/%~L`.<4fv~ٳ$ Q[7HKu 6d5_>D70*\Ԗoo˓A||]`[Y_`stԽ!uI0CzCx=JR^xp/WóJKMq nB)5%#:y2q 7oȫtƭyGyg$}˸m%5OӶڷVTn *weH bwT:ypdmcH(~qx?żyߏ殿g*=ͧ5?PT @{ 4O>2mu H6Z82{ sL✄G_di|ٗ!@k]b̭~ ҭ;Im_Af&,9,CQ=%Y2#ڒA؍vbb[Aʗzf&`W#=S 9|?ѬG&*,{7|$I Ԍ ƶ?]̄QAt>u4mzMF~f>N;Be; E$5ĹadߏY'EGy"Tvv I1I wH|)[GuڋP4MA½ʧ RYXG6/ЦԎI>lmνJ;|S7Jfy63H(S`3mL^CzG f^ ҢK34<rwSI0I6ZԴLj/OѢSu?Hisw`C?CA2gPA*IuDºʘB;QvC7g`f祟 Zw4@Kw+Yy2p332!jNDj,-UI_n3\?a,Ao=Me# '?VJ͙a,L߅0h:HK ϺZ-ck FiEdl26;kˏ"p3|!h.#a6B c%ԜQ9H'!/NK&v7 0eʔ'__aLHG=lcT}Ģ]:&;0]H"MAv\r^!n;SK= ډ"R+!ntstc&\[DoI4>ft*DGWfZc~Z[1gHsKl8d}@:b(h7l/[5u+4_eap\: 6shӹ}]9"F4CiϨΡ3jD^cC/;gj\cAYAPvmG %7v"4IclIH@(rtzu{eK„ENaR=`ܑrѱZ"/W I'I~O[H"R|6'SmQfg1v'd]QE 8kr"P4arjK]o+`0V,J/AlʃP3ghpi+K{Q'uڰf$pZM gh;m_L8nu3He$ygGa5_(d KO/Div#~S?6>Bj7r&FlGL~8ӷIĠ^(CK~oLJf(g'EWK΃`GBVXuBH ҳpRGLZ-!bAs8nTV);ۈanT$vhI/SZ8i>H>.n'=z,η/m5cgp.}virˆт Nfi;XP[:H읿K/_mܿp9:zr) x|CzO%.x!gU\S9V\&E;I`q=ep}\{FI4-κy1xU4;%3S^p qdT=!^ECgܱ4'l)kaulx|.^W9}~W+DucUٽ*#^KxY'>c4 Ů,ʣԶCg@/2.[+Z>*٦@ ֤a!àZ[Tu5l['G}d<Ͱ՚c{:#}I8"l4B:aM E2aˡ8hY* kAؒR]" MW41_Fi5OD?ѡ%l<;P p@E+MO˾]Y:É>pcz + g>hVVIB#b:fdV`4~}zȧg.ig y7@Hn0&piЖjWj>ShZBYM^n|OK\ ?XSzY`BX4R3 f_qR i662v9Ӭ3tW^JnE* SA5@:]#f 4-?ie. &CVz~,G8@?;%?M5 0f)lH J͡EcX౟LT1 2cM ov&8MlJ=Ҳ9 Jl~?AX8gշ6Ykґ^ӓ;/AS\"J5 y-W²54k!.j֡zy P5?#o^!o0!_wv:젨5!h񃄗OS-DpN6^`:|,|\ÂhF+m:9OfkMs5K IDlSڟd|^(t-芲 ״ѷ 7Y?ׄv ZVFGص Q °+і8($M}[=Hߟg]q'-JX|,~e<>6bcфsF+Zè'h1|$]wShpۦr)(6a64g׋`U|IQ?=䀽r U*iCh)Ge8ul80f3,qq4 2?s#Жbz䘜+[7[鋞c }a,ŒS\544[yGȗq2}ضmX| uXo!d㿒LȮƜD۷?5UI_x$a1mtzt{Cٳ smEI'Q~N2Dc77L#{5\/9k/ߚh nN 1_іZt=3VUTx;Wx'wS2D= [5y^࢑J\j}SaPj|\Tج<-QeF%%674/]c9] Iq\~ <f\={X>Hlf0-V)V6/vm3} {@S3&J΋~INL,,:]([20Hó1mwPղ%WhMb~?af"B^OB ?]u l Ѕo,#]ck`NM:ݩOaeݨry#u}xkf]VΗ:㝱ndpbuthu5u!mpMO8I]qIg%ӘjʗuY7}g5Z+WĠe7QDC%#X_'.l #Ri0FpA<?{ש&PG6 wb\. {R :r#xNqmI` /۲Xhel3 jVizO|jEi1rayk4!O0~1zKm,+\GTg Yl~9 GT^{!Nס{üi=Rۚ5*auS!ܮ A DQ迱f䡂+Xޘ!u+Kbl*v^5$ Rt~+w|n^ _C]1!qB}{/S)vHY蓜]%(]v% u ABk7lI)7ɤ_P``W5cccG_6 Q$-؏Ԟ\;$ʧV6"َ&=5`@v؏1Enw^s*L|E^YlA郜d_51 9m~_qPݞOk&֗c>m=kTxLO۴5ɮsކ$%Ÿ&]ٗo/]){I>t,~NjUʢ57?m%h" (tdڄZap|ytE#J aXK-olul]E:Jte tN`EHcѥҦj..dBks8cwXӁ Tzt}$!qC[<> Wdpq@e?ƍԬ}> 3Rut0k.תLF5%Q7[v7`|\Vh,0r"$)\ݺeI8,pS+ @T>H20։GNUW3zi o/멮&9 Od QȰM`Wӎ 2Mplgg5YN6e:ԋKQA}v mof|חm; !Z-kyd !x&a* 4N*(=;O?)ϡٸ7qva͛[ = 줿{]rk3H#3?NeVӻfǠg+Ka7jYXX <ز(QUR>C9JCn&t<n8j:"s` ^ xǟRAQ~N 4>/ 4)`l0cJ@l8?-gVFO_lV^d]ѢU_&Fn3I+w=w&1>bsL`@U)@1mEEc i#K:3b[3b?0RdMTVH+#rB|RӣQZ Ѕ8+oPŔ!P;7mGQ8l?5IGEY(!$n8^ŏܴ6t9D=7&6k\sh|o\*ܭ/Z`-ϏJJxH\NԦޯlMwP9$/j٬?®G]I]]mM&\`KG`uYd@IRaA4Mfia -<ƖKRh pb`AP)D,wRMRjqݦ67 ^*5#Y[3BƆcڍU0Y.iJlf29Hc`Ax`5 HQy4XVB8n?V e6\Is.!JK ߃LJ>]HڸGӂn,ʌAB#vB/ie% yJ("O. kZ^:ɄojK_*C<ZnPȎ;u65lN%q|pcQM%32zgthQVk7/x4h?靊Mkh||ðLZuPv. R|/V3V Xoo@!KCNeh+IT8:N*-l\\ٶ)=O +}R_?- i|d~L3,H-ZQ?ITd+M4@NNͺү5|~ɦC] ="$)Re$Πd|'^3X MB*\۠nhLD{(:R:YkYw+/ngC8v#GJKxwK{ƨ,P9O ȧ*#/`+5waWQTOvWQ@Vl9 .q'\[龝t΀Vs*g;[]#ܬAԱ),NEz0s2k>U%I8t.  Eш5q 0Bfz%NnX]9"Ģ=YYiD@C㪉Zk=WjsnDAٸ87aajϋ{kKB 4*y5 p7lFp/B5iƯyo.|JNzܾY y A3l {G(ظC˒q>JǹhZYGbߞe^*Mli .DVp 5tMQBmB#>JI)Sѫ~fsr(McIH159L0;u+;BviDQT4o.M50ES)&T?{r{ (^7LՃ@fv;D"ۏgx3ݡtVnU-}8fP"?nSPR8|2-KK/︆ˢ 8~{QMwAk[@>FJ핻C4[!OK_E$p(^ U:]MMZxƼ)`e"#:a\PsDX(tϏdΟߠBw 1K;tQfЊ57;l,}qZJE}-ǹTjVB'̞9`ϝՒ'a ˹Y}poYXjt[i4qW$DxeeC}Gu4XͲ续MbwQ^ԷKu凤 >E򷀦nXehZ5*\ZuЏt~XNWрJ Jg\TҮJ 8igNN]!| *(<ũ {Ms~wL^^9qOS1+2ӞGGNgSlvmY lGsP76Gҟ,rn[D!YLaQꜵTTz'4F~ V2!w6o2~xHf->(N1gS[wg\'U(+fљZS:hUMHHs,LyMZMT&q- zTp9yBd.ڻ =|"DwBSj)% 5vhI1^~ +;MVkY~W~I]G;I7`x&mYNZY#7Qfco_8Oׯ* \rR$#:㴦cO=K!Gw(GΥZw!PUּ_ȏ[LJ`nؼTw:4qƬ~fTq8T*;XWhۤ ~BBjEh֤;>ZR ȭp=+NV[~ aHjj9"CrfXHl`p]dI+ 0 bժ}^W)Vm)(X\U -2_Eatz³~V l9EAwDm6u!eX짝8eslOiӟC`ENji^"Qqك7CfWbsiK A3SgJ+kOmFSyV +hD2Ӹ~8Ia =oCk!ӿ/ zOa򸊁3_J]6ƦK*-G9Лy6kLAn9͠Rm6P敊f6ح&s7~VFey%ˋf/b(.Ӱ 8eo׏og(rH oY#aYE)whs`օ H, u8/ag0 +۹~I nꙦ H<^zF'STh A#B~`f,?d`=?&T4F>1:o`+hiê#/mlaAj>|l׽@!>]5Ey ,i fEx44Yk^ }TSTEtvO^R \E-ulKy& Z8jOE[u{$zfZJ)Q 5;[%=*ۛ􅌮ClLHxMm5юJy$ǖ+늢ن4%`*0 vzՀl@K_и@-GJc7Q-P |.[B~ǖd]"t矚-0[2r˅; x66#9 _&C aglI- X";{Ɓ+y:Z_2fivL}* MGI}M$<<[\޻2@ϭNh3 SMfRN ~A~X\c=U{T>t wOUn& XgQՍ;؉^]U q4F 3 O-xz?|]W۬6]8g\+8lVnuMl߲~~@tl•o|MGLTh\inp^Cݑ9EM~QvŊؕ &jvOa-,S8{IdG'M`~ @9L~5~xf|ZYEmb">} bS:]y "@zdPٛk;ba+`0& ėK0OI;{iҧFJw<+eޖn@Et!;N$&1_RQ&5Ot(?\l+Gʸ,REx*-E-}<֌J}u-Q*p_SUCjaǼv.l^Fnr 3`dn / ZJ j=kCg]/<u"W%(C!ʁ2z3UJfE)Sĝѧ\$p6N`S͐ȴO*yrh'_[zZ ZOAڥg]k !Rd 4!ڎKwzv Ժ8LZf+7zx3B\f(y}X~ ҲΏ+GSt="yAp¯UMjR<u ߘAM55Ո ?aM3i  nP! l$AJH_^^ PԦ-!صZ X9Xxo]IN.ae{'KKcHMU[D>v9T.d/5p Np(Gq;5rj d 8|{+!b !]|`'5xSې_ P\avM\x&jwyÑ%bVg,mAbS"*[o+l|L~x D-tO'@ 1QzrI+@,yU* ;tCNm~F>3H|It-CQ+,^>3Fw GGf3V՞s+<h &hi2ޑ!S6C2UItAě>H4 9W g)k 2oXa(ˋnGCؕe9+/6M+U LbN*:!JPisآ04q kٗ|KI].7؃[NҤTZHE4=!fp|7ޜ$6>E:j?椩miz5/! CkhS#"yzJ2] XQyᘮ NDZ[ivLr} e3sC4ڐH*:#-%PèkqH:I3Mf?I%:=nlD._BTN3~!᷐c_2%+8??9Ú\ 谆9+T?-b[ؽX!P%Wr2',UiN1>#9UR{\i>,8<$Ē<ǬO|LD[@l?YΓONkC[xw`NvڜfQRk-}r>ep.~ox#S]맭7xl{(OW6FoF8VP/X2,ĞYDdѓ]C@fNc렖ZyA'4"r} ߎV~V݅gaXZee;dZ?GI,aǃ*OYE P5)5&}xQsT٩;K߼IySZ!US74QC($@9zl>GWcf\)5|mL^k d3m13KReƏs;hGw"h]Mצ8/҂H3B" NGSԌv59 0?8_J-@7 y QPHnwUޠtJ'ˀŊmg كY{kR=" :8L`',fb, ###sB~r%YJv%f೉\p:D|/==d :ʥ'2оjMP|Fd_?ꓽ{{hp m&a[(հ;=;MR GG_zp5Nnkx`(- ;1j7;ӈBBkx4'Hw.$(ZG^ԓ uBXȺ -sK(b[Aol2>k {h<e(L2x~ca=.8[3v,KdSB gӮu[is:C)7#D\ңTR$Ӝf,Lz'MVΎ;_' 8ywJerR>LG.>L@ |u{Nrh(äw 3Nlʶ-@Y xHTKH ~-bpG+[ +a%Ф+agn5у |^Wm^Hl{#fȋk$ɍ7Zu:gkg nrݦv?}vIAEu 4yR0wfKfrS!H)Ó pъ=zYI49Ī}Gt)4Y96zOTјY&;q®,aިOlZW0h/ ؄XΎPd}.︴pVZ6o^]t~(D-^/"*R2jMn+kIeXP2|&^)],9Y 4Y=]/vCf9t]G}$5t8gJDŽHqRisHߡǙXkQgRVt(?*2ʠ4=={$qVQ(aukj&NK aLQfMg^ri34B1ڂ66Bt32gr.! nfJ&JIP9S^L J%p;6gA/VF < -А+ /#2i~C>< .!etLUw3 )|& ?Y;y+o®Ȃf% 'S Q׆)M_.ϦJ|FK5f}&ՖZJ1~T H@MP\>>X&<JPv6?@IժM_/8v0Q@j*фqH.Օ b.%Af3r$a^-៰ka++}Ůt] RA_z"ȂYsxb/0}V16WS_HWn lHF:ʂ&$?DŽo \ ?ߧ~Z%Np7pԐ~&hCҌ}ʦ#nB5Ly~6}ᄡO5rg;b4&DU :~H*<.r,c;Pi䩷[ꀰR3\;fdKTh $Rxq,1>O]iM{:ٝvĊOYN~է'-9`MNO;( q(oula=ɗ:p7C[D]x iFb -#b :3C{i$[gAj>C q݂ώGؕK °loIz x62N~30fUxC\v} 6[[Sq:Ldz\'501t(r}; '&ds;O'&8M}'۾&t u[`f g8aL; 'dM(Lӓ@d=-I9e;L?:!x,'GQFACmJPI d4fcsuirE)`fcY`g&9x9YΟԊx)zOeCu!#$|Vrc?g+ilؽesmf:g:/}8&Z ` wMLJ1 m#eiRtc2+iۻg []68}?1uDe;&j&'bb3!M͚TxYӗ $!a&8AFAGC;lA螊v2ar*6˜!yqM'49bU%/hRX8} ޝ oE'qg[szZccƎ_|-M jgyuʈL'AlO ~_ N''qb4~{AY}^y]iz$gâU٨/:uOAxfÒaOs w?PIT#nh!> Ƨ0):WSG@8a/6V4WG_&nr%(86K>U,7dF%7>? tcN=U[YD p)V#1O5c ݧy.-#Ek߫ cl"|ϸd+ԣ*4e\l82M)E(>& mZ'uCQqT*)GO a\BǹrITFRE;x.?ab0 ѕ/ֺ"U" u1Zc!Xp++0AH SUj iePS3 Vj0Q#}"=oV`&{ڬKĿJKQy%@^#j8CA)ggAf,9Yk5|$'7S_;EԻzM?!OQܺpt~oI;d;>z 0t:qgS07Wb.>ْXbÜЅ/D_glL%# =?v|R?7^|l.e!\`KG0Cdp/mы](=g?^u\3ynCZ5g7o nj/-[(2*;wZQ4Ikb% K.?\_/wA 0n*ވag0 }mR4mRV41At';+ZʬoG؄mwѡ( 7@ @J|(@gdg|J=:~n?t삧oCV佹>ȹH:Ɵۨ ,I[ꋬ 7BFЃ# |5Ny4*wcnMI=63}}->Y~F}Jhmdunݵ=\/+Yp 'W{+k4G3pݱ\߅! #c)8{c՛ShK! ȲF(ݒ06՞eㅐsXo=6E襏A+r GN\rXi&wƘQ>M}N{3)yڽHϨ"e 8~]7n{]aI nL $TQ^%Z{rOؕ8[X46S9v^3EqQ^Sv(^kM r( QqH x%fi(u߮#G;{;o itjN5{Lp}J:{22YtJ h;rF]h>FfCiWWMQ Ҹh`g_w"X'}>]%&ù$Ms}Hj"C a6>i7faR6Z ma|5mrYIhO'KPc:YI'F| wۥ/DKͲ⽜3n3YFz+Uv-)~IA' OұM}JKѴBڶHJ'mKڝA߽E!%ka+%,җcgCh:➾h,-ifg-A *Q45I%5 jK{~!ѹ\V'6 MM`t.DrɖЩj'y'v%9 G#*# + 66*0 izMjY&*cCZ(Mhb<'JǪ_vJň~9Qo-T@*ưQV7&hڤԋ2V(()JCBrSsa6&ve`4I[HgI!hl G\Huh5ۂ+r s):'S@Y1zgau5KڕE'R#߇JOAi:S6%Nyuy|h<#ȔH%Y^:씞4S!`4v 6Aw9>+O{=dlDžf eqZsCPku׸D%;nw'°vѸ"u[%X䧝fP27"Iz ͓4;PxR+48WK{MuJ5`8d] [ Bbi%AI0BNa"4.?GuvzeOoڭzDHD|<J_7],c'~.-QCJd_GȁTMg_~44f8U0hF7*4t5dqz&*&L0uٿd$ ax _lD۟HE@# jp]ީS]ab0j~vkJP W~=ZqP0y#X^3{y%m~4#[#Q.E=VF(G+lvjC 2MP$UvLBB)Ӭ̶ 6u;vhđOlDQHSNNO$wՏnInA:_GІv-#1>>a { -J<9&:m*&ըߗEIJSn,Qmp_4'r)ѿ* ^iL6?hH"`x2nV4OI٩Zbe c hԈz5j4݇"rjJ8e v6r쇔?av%1Ж0WB@S@8 u=Eb!iSTItE\eeLkX)səqXFrt5^Nj=u!L;\pF5.S)%{6>u}(j:?9rnR{u[UI7^G8  r7`mvitكz'iuQgjO4&mJɶrydZ[ Ahd8TVq}oM,)Tut3L`l+0(熮?Ȣۭr#(A ǎgW\XWÄLrȳ6ʏD!Jh{Ͳ!Ĺ ]9fPdN t8'47֡AYH{l,'Cp 12fNsP7XCc)=(#Ђ4,~H'f>v pK LۀSoħ$Cנ3{A[D/?AM̄޴^^E`go0"S(-`;;vY\JwLx.:,}Q@j 5Im]Z[0]&㫇jpI+w0INuNKi+mqzwNp(y^=\}10kf[ߗg< j>?4)ȃ!hZf"2EdX@fV%!tFß[w$pS`ҤTЇI33F -dkj2@>mgnAe- x9{׶.:9Ϋ;ԞLY ْ3w22y-ce^9u0~ٳmG vT>_Bk#܎ aۘ[D IB0j˔ %~?A ->FᨻsT?as: !YdJ͸ai"e &wRZs}Rg} íTkFM:劕kc0.G'8w?,Ib7 Ŧ!Q_ X'~SǷP\յnR\G~tON*+*(K)H ̫#xÍSS@9~)O~ZW#Ϧ^qv*:АM3BocDi{Y]T2֜:C|-f^?. QÄ6"54UεkpHeөA4whE@G':3& B6U:.g/3{My~W%t[Ҧ܍"' &_V7xjԴ>}`86դЍ L`)9zEN5#JvK6o(+}r4P$ڬo>+ai ]I'*'WjcXI ~ͪ1j^㖇쮒eyDTm</O.充t΀m\6 #ޣ1`R8N[^]ܷNh3gu9B2CcZ~2$x8^B'ˏy\C3T;=%`P2>(ʒ@}>п|m0 C7*b=,2@Q.`䒋#Scqd#IZ d;0m:ܘ!u0> }՟[H9'ئ>h]I[VIT@4i7|i0;Cr ȯ-8c~x,\g7}O}@3p 18M1$P|ΨeT< XN)FoP91s9 xq_E -15o }E$\5$,BG5h3zm?d"k>R~$ ި|fܷ~'o{&uSs!ut3y*Gvjm}l2i^b[-4o{&̶$#@|oٔ:.;43<)M>آ٩6nJ٭[xNYy.Yeq;zU%M)/eJO+<9(+|6 }#KؕH@],H'@;Y`} f&Niz!O#_2ȵZuh H\r˲%#@^Oʋ8\kQ_,\D|Bl)Ȯ#6g v!դ6nδ1+أ%38$s"vpN:NHvhf-m2:y>W d,ww!ZT)PN4@r4-LbW亘c[fMj F狨sG5D^rNCA%IFLȕ`S8̊b|4Rs><6K6XϘW BeŠH$ 옍п *b5LO20!'؟1=Lo,iV@D ($~jOjM$ȉ6 WPh,ϥ&'b_1I[(VҌezvmI0J_lexg>&GPƽ9{M^i¤g49Z'PDm:OP<\fn֭X)G獶no*thpDHCՐec?i֓F`&aԵawfRrK})+If8K2w,7nO_2Z h%?e'2ubwܴܔ"!ױٌQ&oU@>[8Ƞ~g1#,K? lf6oF׵dLvvť u{l@U,4QH)׭nV‹&|u;rF4}3;ug Dt/ bnFG7o E*ī5_gFK%L|3[u*Q %272D+aa0?FΎfEZ_gCH ]9|o ףP x= ,YI~[gFWT%jRK#- m4JOfP;b T-Lt3o{vvm 7bO: 5|mNoI(LeZX{N_ika+]I=hcݻULoةYԴIwMDhRڥbb{^/2}q9B8_ߏgqJOC w4nd`39ʦI]  q? M+g,$fsE sm~1|ar۷phg~VAElljbԖLw*aʈ+r0hx:oE_TE}|풷:;B!P?.pqԙzUa'jB>4CZsfv=FiId xDM2IY1K!3XX+EZ14Rӻ1$i7[·ܹOݖSXaJnoti]?u(ʏ:UfO[v$͜0T `U =3IREBBTu] !/JOj-|0s|j+;R{WhhxH99s>g6QnH'\8LXDqO{(]L`8 ܐ?FFďhp4XuwK`)ߚuMSdJvDolo9oi0Ѡqp KU~G^;u) r)bdkт5PWǫ=#|@lIX:wL{=I|G>i?yw_z.<"Z$VVDENX_􂵱d?_+kcy|D/8Al ʦ %TFwT>6`}7bSKm: S&' :Yv$gr/dEV߯ T.&t5t].d]_tVGعK 0%co^ѧKuz͠{{GW`A,"0ULw[U>%?ڢ$`8TKҍ0hTirQFsXR.c?8bex쿱Hk )`9>֖Lx7^'iߜU'*tvHLN3%?FH]1Az?=R%DulM?կF NmLLZ # FN*CA[P?}-Ig6|u"Sal mNm`$DMLrrv䦔 M*$Hجvn\.ۂsUmjcE3me^Ã~&.v9aRKpêmU"wUa,5}wPlXot&;qhVg*ve<6o `sh32G0Ы.0|zPMWx5_sv;Z2QcVLf6L>UQ!8(@cK7hv;R|%ڒ$Aؕ/KhE!QڏXH=. nR wi^mSy^CYh'=ع_#w@j )͈)T =iW%::B@x|6$P޷\9  gm.A /w27vBx~Qc琹fG-ϠeRoUW?79 >㸱]lT#( O{Ώ찴R5#g oZ-:$OlxY3 `?08`f̤bB2$w{Dm=+a'~_'gJsJ>6Q;m'qDr!ęp.JkE1kXtYZ,JҿC*B4{践S@|t ` ,-vf,!uR M3Psabii<`[ 7}~ۉ(u;z^Mc)wI@(ȠFuަCF^D}ĎiH=6Ygt~vDaKBA+f0rt\J.U;^K7#hL$U+  \=$bf^qYkdoay9U'7aL޹60[Ӡۍ.,@maJMe @~9ZqtGHf`Of^txo 'u@b}Li6ΖD?x)av036]\|fd^pB@րd仚E w:r[nfJo@o}^_&c@Lk%lڂ9᣸2JL86>PzkGtܳ8jgM)gk^E=!f#Еۉ^7R N]L&r'r#azB[$+<z @ FM\ 0^1~&FGq?o~ d`c̎K'Ikae.7C>::yd-f!Upy8UoYJ2IA3/"7eBV^:\4A7c'NG9D]P5e,./2|ЅL vD'~Pv0G )mǭ^>~ o@ 724l%ŨA=닭esAYk{?>A}\rqgݠ*ȼ8I¢Rb؈-`ԾmB>.؎j@sU9lKq:ilӒ+_RlC+L~؆Zd.+ΈP^Q{xHŤSc?(]Wpثhcg\-ҌNʏIsҨtK-HJšíAl6K6P[Zhh|CjISc"A u#_C t;`IJw#Pݟ,0mv%G!0%9Ol,h=P GASuG 1#F}°_?{ib E-H\"T3[ rs 9WYV;pC$Ѳ0 xvNOm >Mڏ̔dЪmz \ ƌeu۸@D9ZPvC2i*nTûhWPJ.2v|I$@˃xM4*n>!iG8{:JԏiBS%װ$Tbc^Bʌ4V|֮Ƒg'SjN0!#F1^FGhd{;)\"B!]_鏖DD4DszM*pR5YCڌkzr zxY9,I9# ȥ-Ԏ_%NʛPTr:|hy`I٫\x]ٱ M[{K&HR YB"j'nw^dC3Nε#,ְ!~^>MӞWE!umB_j:}& &bhv-vJ;k,UZDA@\fo@ㅙxol H;eH;ψ߬(cGI *;da"Ayҷ v\v(]Ns [¥Mp Y 6Y/[ tfR;٦Qnm l3'슲Aؕ+oubc3z9SU[;}L̖ozHģOn-zW0M{'$ͺkzO`wdmMZ3mb*e46k"SHzCWK ȥckxQH}Y"uͤ{,o(# E.vY7l:+B-yp!q<8zYyCoAܰ#i(\H8v8 Ck`;\4c yMGH֜X_Ţ$MnػK x0<۩宔S kNG[7}QbRohE uwRҨ[ Tl\ٲ2 'j8Ζww+MI*+e;!茣Jٱ%! C3HE?M7H|&@0^ttk w\,NDvƿ^/{ VQ:ytҶVCy0֌@Ŧ3jlmgs"6KA>'JK0_}"3a #}t C]k5SYxj4/,=y-khn'OzGU07߆3`C!0t5hǍ,B Lwx;4zRʆ:ةMM /v^fW~f;+ګr jj`.r#kWKfPS3k 6Z5ͫlg<+g c :t8|v 6>əX!XRfz#®%Yb^IF3&ݬRT@brV @G]uy7q`9Vok!א]Nvw-pV-;'yOp&/gr6CV<[?Nieյ.ڵ5 .Jӷ&'31dF@8E;]4 iN}]NsO>ċ-G)?Mw(ܙt X~/JE D6_d}֨l4s< A)F=SrpA\*%Zn7fVӈ]GIFdc8M_}J`yL6 ;;gWa]q&.5ϸ I{RT!(]O_ |] 0-خZJgg4iJ "˴_* !Il8)@{T)]it6G=ini<n:Jo}+T~iҔyjL+ |Ba tJAR^Ɉ" XDbmKZ+\idֶ<u|zC4k+OAU M |J4a>tΏ7ZBxY+~l#6D(1;ڦ͔kZ"`\GVȇ>$>fe y} D-ZZOE"IG0c.S͏v'Opz͕_@Eݟw \vRLHpVW<}_(w;|V܌=M4Oj}+3`l햨H.`*X\pCdA 0J@/6Cդt; >EH>Mr8aJϩIU$ 8b#2e/P}p=20XЏ:xwU7!Ӈi\Il`eMoiԄ#ieWI51o\G Ά|(c:^IQmD3B:fT=wnmGX䮐tҠK{Zܺ?QHADso6'x-!:~z#rRGy5 }<dgQa( LeSxfN|Wt߯]Ay@sJ1I˹7;bc}ʰˎL"b+4 0t%᣷ ÞO.&T,f͎y|s޸rG:4-##0[q 0 Y6ϰ=Kς?^Z?®:`m8b,.akOW ƒ0^,rEgi:j2n+0s1# gr/˶aF[UmGv/$օa~^Tj9+a60]19Z\ɒuѩٺaTдVar=l3j od-ӹFg3(Йdo&NKҍ`M|JxiD| tWpi3у9e$6C痰+;a$AҀ'9ʺWYw#7'@bkMVZ"hVͽ1kO,%fJeOJf8B[~ @ns%!_`CG.Y#m1(Ha10ܦӺђz=^:c3 ׸ fCGޱQҏ~fa?t# H&QtyN:/jnVq7ӶV̬m'8hјs6[fH*L&oJ!мSf\Ui+@CMۭ-Muަ.mLdA=Z#$cuk̈)`R1@0\\P=ƟY[k)f`G~Xm#4XQ$B8RQ6)aӻI[C_ؓtJ*mJ:LE ;$ ahmW t:UBҬz&=0x M6/qE4GK|eA6}S0gE^M|Mc"R46A1s_ y/ Xq~c)ރ>W 0z)qHȲsDz0uPMpgGh7̔;ZP^~<HafLJZ3Esk(OB>_uD^.)+쨤ϳcm$?Ж-Fh~&زW[Jgpjxfޓ}5<'3 1 B¡@Y=N)gT{^~ա1J>>+[Io'/$?k;OagĢ&SBP<2akk%f5iy1Ε֣6[4쏤KؕF / cLr80V(Mwr#Jn%hWtSJ??l6-`x5du$a//ў%CsA}szpeB ĖqL~fA:cL4?+hc Q Bm m; u~*6z[~Lѷ+`/ N;l@8˞=׏lV #6?pW/f4>&Ո(NF9uRS 1{~[@_R/2Hr4iYq5.8MXB~csu~: 㻽^O3n$/e?mX"uh7`ٔT-CpD}i>I^wU;r,ȇwd)$'6'SfХ ‡F5 r3Mm3 |T?<(Ib7_lc"8DPIi9/{E)"⽞r#iYo3 W&\WF [$`[!8Ch7ο Yd󆃢d%C'*(x?s>!D%*LD;ig04QmWjB鈰;pWjl5sYP%V"Z='9OU&I38}3d@|I~uՋ@9Rvo< QK]]~ lp~-"Xa K줝(ᘤ|]Ih8 Woj|YtǭƲ1NC}Ռlc'?"PJK[2O=c[!Gc㿶Uef].Z'X6GN%ظ6MKVDq)$igfm> ͨO̰aȺH؆ )qȼQZ ׏HKi<ԣaNܦD:_FK''ШX5.}Wdڎ$-<*(2_vΠ ֟+ i|ڰ/'KϏkS+$_b -Y/I0nMEKds2Rj5tRT8_>mU.(]lrےhM v6La2?o&wtܨL94+>lx\ G+u  ;[kZ }82 **@9􇏜Ә紫>νeI֛fA MA=Jy$ygf9cp kָ{LU[>7);S`BYwl @Cz-2*.H7'ܮ#aEe,_Js2`$J#SM~Aʮ"v#9 d.(\^^5dPDp$CSVJNyN-o`5|\ɯiT ހ<DҩrK>wyn"K@*+|2Q9:H>$Kgo{#@@FpGK7Wvd˸&jrēK؄ [7`tAs`ݥj5k~y)/)>O);0' {в @ D5#U8\fp tLzBjXn,_]e2Ve&3__H.<#5=Ɩ[v%QXL2vb59*S c_@_hǤj31.R|Ċ \qfոME!;BXlFK4 a|H nR^"N9Æ(2~v'p+8Ι$W*-[.哩jˈJ&j뢣a|GH*玤)ED.~;A% j_%IVW|/Y: uMH!:x@78C_@i|PCy} {x{6:G0H ףZ.Y~٣0X-틎(8QjhnU0MD.LWDVhת.ήht~i1+)]v°%;56ޓ('oҖgx7> uGg*rUDbDOeK1vF0 /:-; 0$zAQ>P7z'vwAb?6v8*0m j2'3:Y?a;:s9Xl s4$ʼ\ Eȷ"Ð?IEGN-hiCapwKeF !En {.=#̞Rg&;OU}}j_}ZrB'ye?~Dn$ !Y[?k ."yC]@<Ϋ[|D qq^Rvp4uQ6 >ba(zi* CجOA^fupt؞6!ʋCR5kHMʪ/6(Uc?-api.anַϡtnǩr~Y'1W䇰+ba+q/G$kl]ue뉴q/O腖dl=]bR -WvM OCVZ*V(#i~3nPƗ+'ȳйgRngț"G%.w+j| Sg5ȼN~)2$"_^ ob&KB+PXl K%E-Y7^f֓9zg/-7͍Xvb$<-] rKUӞ@$ຼ'/i9lm~4Awq0ǎ< ޫo6\K UVB)O}]\kl"i:7kW{,99;:ڦh~f7gXlga,T-SK6* J-) =CIWL#ܮ$aڒGm5 p&L~W?$!:חgJ0M/]XFMQ?7O^rc&]\/K:*c 2A1mp)9O@g!AVÕZĒ1Èq|ԾН)a}`,[Md0@.XNE}!Z׶zh^1.QkP.zFIdG)Z`ӗ{}_TMU̠T<7y*OP|(ez ؤyv̰RQ4Vc`x>v-stoDFbhAG>%A.ſHOd-Df'lclq)Ӗ& L/9}i'lkC,߫lfii>XJ3EX\5VvX8#ʒ(Aؕ{> 0*eK̬+eФ2NQ'bu(V]#Usd>Q(~փ/ׯ?z|F"tzi-#Cwzn Ȍ+˭FI^rA`GR2>]\(h PG奸4Np<:0׹ȀM2F]zvWMoe RI>+U|D0Z-o2B87 f 6ҧȝ&Z[䦄R[)M$!civ/8%ʏy6R 0T#ܒ%A [(]ҝ!ST&QDH Ho0&[J9&yjZWs#3qP*DLˁ]=E<-4Nd7bPF\m Yf7p= }g<GBHw`{qR,ɧ3UaXp~[N#qcx$ cYo 9[fx&I[i,j@K6`lsڞMg3Ki"3trxT)Ò|& ,Q 5Qޢ;A´4!GtZ~]8퐎%i]E+%{FH?qN9$ pLcdӬW Hϧ1}`=Pj6K1 HZtKD7~/HbRo ~eJv1 3I@|#{{%4WySg[l~FXnɣjM5E,tkhDًm*E'Ez B:m Gi8|ˡϰug o3ʲaEegI2=VD #`s4WY092ߒwXV>G'840PBe׆~Vdb=9MZ5;/OLiVc+SK3Bݱ6j l݄Ewb~ r`) f#0eOF,쑯ZD7Vq&MfkcᰥUS6=.OLTdJJ|Cźͽ/UXw&yi&46\ ^h?cwKduA2dt"::=n[)b98:l# ΃M^Mve 0JB 78hHl0f<9{c РbƺT;dmK6efKeΈ u@ UX.rgu"elNdXHyVҁ5̃fRb4h>?yY1`Ҩ; }⳿b{8z wk+8kz٨wlQ Y:]'CG<ǦXaPu4F F; I)8 {7[':ys9z2DbϮz γ `w$BcQF@-x>VY(yh48ˑh.aqpy}JOj#H;q[2t 2ez_4̼*v;Obx5m.v{NUa9Mܑٕez-Rhxf@y'6F `3baJ`_InZ~4EO1t0kr0z.Ge]Qʂk 4x5LoFĔ B8I /9$^Y|-zim#w@^^(gI/tMB O iU:/QKyKT+ޛAۄw89m+گogX/ig7s#LÙ#< Re'M'~S2ɡ gnf$4X$qmzd<]i}saY kבKg3ModfJMY?+[>s踡 lm0p #*ڙD;`P#tuVB9%0|hB!Ŭlqiu&꿥cǶ% ԝUhP{)Bٱtaזe1¶$Q[?SO[IH~W /m{S?\YRxW8QHs\4.[ 8xdw)iFhsOVxLoBc"qIǦF+iF|Gۦ5bq[gXw 9߃$tqSDҡ_˕AE_ +in5мTMd;أOkoa #uc!{`(kRir3T Uj!C%%&@3U0F-M[x ٬]$"fK#Sx6Xw&sQ6"n);$jṼ-sMVRwxsl|?VUȟO4h9>мqjW&} l\%U(GiL\\ Z^gLL3i\-(8??®$ׂGA>;!vF '8= A( }E3s # r4w7%%\W<+ccb+8u ¬_-!RYUWOW!@e*L :![݂Wv#7eҢ|E4v*o:Yh5x-퇳A3껨D@~]{ I^bx#$ۦ*9*/.xUы N?עo95!AWG~,Hf;!7*Yg͎;l|eDfk&~2+Xv O%ɿx4Rz8?Wڎ/5.|HDZg>P>v9 TjY1%LVT]p `<%#mTiTFNtn,q"5:Y#?݆8wWACO.'Ӂqd$c/ H sË VRX۽7гMm[$f*m+*jdfR:gيGdu#|EmH/$iX03%9=aWv\1 [B@XȰ S$0jQ|j1$cvn9HЯv8HYY:0 \Bȡ_qw6f ]L;^>_;C?t_c#YO[6ḣ*\T[lUj:iW6G3&dsA3-]}O~ө _w?3`mҚ^iId)2<@;shcf7ԞoCt\N|[CѶJ^=ի@8w."y}\ЄSQg? ar/֏IQE.<~i|ʢ$m!wQI QsZC$Av@/q 2?U/&zqH?)y ˷);z~Mpi3K٦d2@SIwLӢEXM1H+mo+#qLbR=KQr2̜`ߦhr 8lхe4?Zn i?Gݰњazccv3h0 !q E䱃A6_}3 dzE;-N08z^E"O^K<^hXABKj{y2^!_aHGERpJ Ϥ~T6} _C =}zVh28tQa{mQ-+,Əw\|Ije]|J.`lͭ]S)7]O<zBz@NϧO< 9&@ܭ#%Ր r}NSuњhhXJ?aW%1®vjWZBE` u>,^r`i&.OIxnfZ{_Isfjo!}#niʌf\$2Zӽ}9/>Y~\k15Mp=I 7k-:0:M]:5PϘN+ kCBQsUTr˼':#CÍ0\c`Bl id .KSg9dlG7-*W&9eFfQ2N5[E=iO G63҃XML@^0;4^9W](^E~Rwť<QcINVkkQW"4t4DVOn={v- J 5n)r0*RH2&Ә?1dx^x:w]]eJ9vr Y (J^Aqi|_Ǧmop{&iўZF&,.JѦu᧡n*d;:=PYJg,d :e]j3sỹ6Wɷ'lJ_lȨtQ Q+ if5IU=bbx<fCWG-V> B8" $ZƷ3br/6NlfՀ4Pi^ԕ>ۄvP XYuw _tQQZl;6 }ȧw[~+L#r$azBBi% b(SB<ܔ%cRsFM5.W-˫O}TM!%٭n-̓<"QCʅdc^cBg"v+;^*ŒthGZ=f$:7Cd!T:GO`^41չu03p g9C"~OXrק0tivF:p_`|f_z3FS[_ {K=T>>XKi8y6Pdǀ7h-+/T jlL /6遑LIs?"۱|v}`.V19F+5+G?{ }jFkM+(ݗG~ ;#Af6j 5:^,f})Lit Q/tJS]]Vk}eBnpCV6@|;5 OL_ۭ> 5YtVѤtVI(j4\.n&eRD:Gcc'ѪSdO7R#Dp FWpSa0B؜uD8^* 凛LS# \NR0jIΪf}B1 63f7zf0LE9\.:5UpqnPԘ`g F/ gW@^u}y%)Rh_~#ss|#,^b<[`䛈1UbWY(Pq/F?Y orB#|D>E?vwrԛ 5%Th;$A^m/q%¤bғچBR"p6tLܼ~dE՝Э[#~|0羑"NݳIST3[x:$%Cջ34ݿl Cg;@ v@PaeOݍF;2>FfQXG^>1:pyM~8is5 HyGm X/䴎13"MKnlM揹uytFmv3lU8]Kq4[0csC :ixݣ) .%THSܡb[PXM揢̏1HH|rkvDE~?eoͺE7JM#55*4Lvhi&Ri:#J{w4$m0ޒ%,DuKckr'O=fTBStoMw+# B%QvL&K?`&}ؠ{G_*9~H9y)PFcu #YX]x7 t o7ILkO9S<Ʊ5yB+2k9_va=Υ6}Gw hgS/a2M{,u,M x3N CBM_[ҙc`7HgT4髼s EusgϠ y2o +)wOQ $sf)/`6"{݇^Iy>=E0l6Mxnuctl&`+a~;d3kI=}N~>%NN)Z|פZ@`H0\~J'7p}ƾ>Nzsl#*kGH%I0Jrmr- y`Ů68 nX;b?\Ȗwa`WsEO W:'j.}(-`a5Gz)A_A 8m$ fS<)_CA.=Vtʾ|Jkzfb'#|@cS<=ڸ8g < >k%9FF5^B^8ҴjU=]{3wJ.Ih $^ޖq&߽˦Y~Y z|h@*SG|l( AOe9ay zp,ir6 qF 4Cʸo"00-;L_=qn@,xMA `IdN [Thoqʩ%>S.l8l jI;'_#K0y,ܼˑ DKWav0V2 Rr jy=y?Ω\TQhj6%ZURnNMDj ŕu5?h$bvKEj|%`Ӷ1a&n1 ViUݚ69sp>2F5x {F:C4/+Ae-Qt{ńv^Kefάr 2n)Lk4cv>Kxꁛs係1L$2y+hհ*Hs>kaYh4X頻܈3BԠ˗-}4'Eo@*|v,S>H$|E3,T6Uj_@xftwH|X5hOA$9ϞOZ F-3PDC{^F5G<ڼ1ܜ3[+]|#J3{8:y]dav%/_4Hyi, c`jN27Um׊HizZT" ޠ>͑$uw=mmZf:%4Z\!E$]ÔRtЬBS!Ӝ t)ޫ_.duܮNu;#2>g SE2VA½ jfv,$8Ǽ!NxǏ gIŒkW&FLlHÜ˧x&y]ۙV_V)Qz^ 5?vL\>Ǥ8z4BkKEGgHiM$’)ΐ*1KA[ǡpNdl ۙ>Ii΀ˆV\L ]"l0zlB++tПw?_3;ȧ+9-:@7VǦFe#`QuX2}邞/j7^ٞP&~|:'ޣSӄsiĈ N K1+cԥS Oߧ2p11@6/m4l]Alh:p႟Kc_#+q4Dʯ*H%:g 8qEPiphեb,s(i0S,"4T?]LSdi7͏\]ߔC{茽~{t@;wS$3៦RōflTW9.ifjQs4%kB@]&Lj]:BAl%v<%[%j2%KRgԜ.| v+MYF@ZÏf]S[v-0J@!+h.ѱ T:~+Ӑ<[r%IO nV :pD|fN >G3]C|LW xUrTjS[!\Vc#`$nfw?v"O ӕ%JuV1$evi,gs~aoӾT^~YaO z ~j\'9 C€f]*u-SsAv,[dn** YY0=}i-:'.xا?^1UAq r$mp}N6J,yӿpPrg ˚A^:#2A ̈́Qym^"q`XMGh䉉Z:XF9IYkqh=eIrKDErGi&3:%ְGعeA0tK()؈į8>PIn]=21L(HaP;&y^g)HҶ)]6]kbn1Re[UHRa,N5%/7n- w'&lD*>{qk&tN2}Gls-Pk@- /d74{gҁIsLRXkC<S{,%@i~PaS?]d uL_h);zJC4}}DFNNA=I$Z:O P{ĥ e~bkv,gRP#ʮ#aPKY*-g~47m ?Y`ٶ{yl䅎kyȗ*iEb:9"dY566؎X@_/7t D6N w{.*an YIO}@88$WH'8sSҟ;*i]ؚ~>qBE~EEl7.gioI9aЮHs6ٚy.IOݓrqzTр'я$4giMd^7f0g,K?ou_`:pT*[B(i®UzDŽ .u1/²ٷL9οX.ƒ_#[E_I/콅N`;ᐶb6J!v1Qwe ҟUsqُ5Ji}IR獏7Z;[~. Xo.z#DqHSd [ NXFJ"*;ӭ XS`{HX rRSʢ]%wPbzOhqst%Fŵ3UH "?-`i3V[""0MA2̧p$J`1@(x*; XDFc={4Y5ӯN:WMa`F5y/xAͭF.rGg/I5p0lL]؃ F\/÷ĉ[W6dBEK^i @P 1J)D?U[ٚc;݀P\]u"3g|QDu1_}Z!I;X69BC罜 ˕=b ZxE&PхN;;jg EܵLHv3f.K}ďg`she,UG( =SJ-"'3 6v>]zz.yͯ׶΀3%\<=qoj|=}.0Nd6O'@?/)H9r- |ttj\r1Mjfx0~>~Nh&/uAY}h*R2`Dg]CAꃠ3bAbN?V3Y%ԈD爦k$P kX!ZRW0℘˙,p- |kư^&;kA6k^!ʗ唤%%_+vD$Aک5_CʍFW'Yev88==F/Ж4(Ӿ8<30Hyfkh0៿%ha#zr2ݰ^}:)ij\}f)b2Zg4cVWrےde822lRe"qjF=}t }53tbi>hR/JXH-$%Kc\uf!bj_J^+ΜQ(|peW9Zٹ^XS\amLdSs㑌1$lpu~P[z.id D7/"3{Y cs $c&֞%:~N($@ً)2YLLӡ<av,1Ўv. qt H&Ld̶]'u# C693uZw~\/B8ˍ\ϋF MTz@:4ZT3=٣(͊[3JY yeJqlHWS1&!հ=CïwÓ,ו:K SڜrhU]Vc_3X(!b^bP{7hz8V˲:Ne%AqQ3l{^(8[5DjV.D :ЏUb7NۻNzt}T0e.{r$!#L,hHʔM,!Bvv";]C[3}:~ɘ"*&n#)Ƚϗ`N=f2fj/uIMm9X Eͥux޴ "(LlifN4a!I›n qLՎ(5~& x/H=*}M*@qf8[ .DRѾ*W>,~w9)ߍ72Qg0Nc>F4 D-6%5~f&F 45;ְ`.Zס-0nE2dBx,b/DmW_z+(.hp a}v ( D &wCͷ'Gxk?Ɠ0ɘ&L<*SLÃߛt&lN%"45T`X g +宯ˋ1O`zS 1KPQM`e=] > w;Zӕt2pB{[@ĢAth5gvF|?-TfANŻ 8!GtnNF:^BO ipW=K9 Az{% ]hG Ϡ2|?|H.Xڝ؁9 m+RR\NN)ŎۜBozԏPK\͘8gGKX @2ν ?4ln;:o˕h-!.(4z4*po)u&h A2l!pȔ,ꢐw]Sdr+L0,C< z5ֲ?c:h?UfBlXBEq6:ipfecPMLZy;̂z}`T(W@鈴6;5Ul7)e|D%݌vSZ[㓙ӥU:[Tb1.^}YZnf cs=ii&QC56<AQ+tcڒR=-)$7)1ȨK'|`y oP<4tlSG\ 60}Xш2fa~ ;aDRDX8Ի G2:oddUM` >L-ÐT\5)|2M&y@3yFylKͦ̎A4j<a9/+ʷ)bev:C`}TsMˋphLN8xJa{J=s5Grd W`BѐvH32'QS A%;? 1W@aȯs \X˗.xkخ'0ma;yFh#$~&e g.%-7#{־>"@X ~cN( uXO*,Uaa(Kv`ÉOi@)pBl͂A* o؊P˹5Znr4cC.uSIac얃WL#"d!mnim{^G?][ Bnmt* gbP(#۷]DDj##A! B}iaFOOSw`+VRKX5VGЬ+e!D'/U|0q94AՏy[r 2lч6|L}Q~4$R{ TIlsH3fʈFx?&.tj 8 Ո6ׁL._IwE27gAU'+6l^5|E >㟠\E7Q| Dit:& lF4ە~6l%N jœk[TNųĥa X\zba^AMAO. ݲn+`N'""EXJRizg8q}XDZAԛ> ,d SEUR+'¬.7YStAU,m>"\M*~R!COt;/+t M{zpL^`lgd쮃Z} '0$4 ^H׉OH񱥁)SA0i(SLΖZ(f2bV_UfJr"$֮)Yk|J|:{\k YhOO%&/CG$,FaؕH/ـ9w:H(m)ѤFt.Ϭ$hef5p o`9ZɈ0:H6gZ IܘO407'Ihg: :d61tCǾ v+G]`bWFw;֫+MǦ;Lr g٫`[$]2F3~|^c2dnESGK1b)&LwH.Ľt\*QJZWu?.0~|n"$o5$+"i+׷XnyPhjC_ܕ%eR/l$(pK`o}yBF̗TϰQqK1H=9u5w&GY)PLixz3b|#KWvaW1T#O[D4@ l)B6%?FQs('@,71&)/#.!1@l:f>em6AN;C*Q t2M+IӤïx1iAWvZxaS)]~m){ECI$v͂tVLBl4Mf&y8|=~_7}v"f3gnF5zT4u*YeG,/ԅ6qJCь?ma{{`M[/44K0$iw'#T16o+e,w{e]3dN^xb~eJv@Iscچ$&ޑMffCbh7`o-F~h[N6x*e]F| D'#(hݰCՃ-mڠCsff?7a#16|lզ(BJbAj3ۦ(ǯsX`"6 V^0flHbE";l[;n -Il畞;zT} *T@Q-NL4Fn_lAjB$*Ъ^ɓzzzb8>f#QhEf䳏lb>i =J쟟xo_®(b]IEE V $Y{p/u F/aZEC#Nn9WW&}Y8gZ@w_6[7nϬIÉRu4m*K ;`1k%7Bdw$ 4ݏ5>3PMy>UI2zot<[7I7PC-gd(i>D& x(xcI |[7GsɊ2#}&V{ "ے6j Y>F5zB 7%X껎BZRboZXx;7fPJ4MYwmuhMK4!{+7aFذۊ9d ]ӽ2BO2alHq0ufX|M'.n6 Km%.;4J>Lwr2-ړ7QPǛYvn*I~揰3vaJ6`_=D@N8Ae ǥ^SH3F:M͈b[nG\}@֒>s-aDH]P1WpR_LбYWY89;s_pe~\MTIGkYg_7`n\% @aP96ݿmGIjlӫi>t6 zM|>E\|۹\YPT32qZ)hk$C-OheLnC_HbOjhXQX[ܔX\>pvfEfNES_K=oH}t =r`'zF?fqлW07@XѤr^ j4 Rֻ`&sA#L$a%D.e qqFmϠ 2mtŶ!5p<P]546:)"X[3@[7-<-C1Bⶹx"\#K.w ^wz&@jd\BStY1o.b}"?7C5 Ͼm i6d5H?~ i>rq^ ,jjnu ȐfSy۷] 48%I!iiu} )i0O[AII}95Mn1?D)2rv^.U%mD"KmZWC ˮqMWeb"ozS.}'"!{z KnHk^2'd-#)қ*?] "bʘ^X*0FLJ-+2gr^_C5J օY>@F`]%@"p4\7/MBBe;# >[ 4JY.Y=$paJ,v59&/y%D̨FrQT$֥?NþX3G pOAH1C1[Q;n @> `׵lR] [ tB!FѾ8bdy ;{+UK1yXz%nm3ז`t7%Ѝ)}SsED MRű4+1v<N&M~-3iF=MvP9d&KMv02Ⱦ+<ōo) cjN2`,>Qm;ttx NT)vzF`/5"WRj %YU$t eӇzNKsK,Iu'~Lbx>V`n]ʁCr ::###8ůivSo߫Wg[-PiqFI\RiD=c!{K߱ro4,.TL @)j .sUyٞaOjk*Z]-0{QA3Lfk q߃!ܮ$aہu c_W'\{~'Ex{5Oi櫧jMkz#/ ІiA҆:J!} ]xgn͈!dq}\Ԍ:9/)'MC;<^ ѹ#6F *vjp~&+SiGp^өڍ粀x5u*_a[~W9.XX?*O]py(\^L,cCJdBk} (A7rt&N]M_LsO`~Q%=m9Z}%&Ql_XzWL /e` z$f{,fֈ?t$|n" jq ]uHFN< /|,{>sU(R9/3FR,ZfRÌJFvYlC_Z@g@XI!ŹeU% }B1`չi Po{:^qr3>.q8ѓJAf)ŝc-_m+e^j *xw!Ś2b_ž^#5JY~˂n4м+~ 0>IɭY6*R>^~u=#ve0%w%kK@& زD)}ww~%ɡ)2Nxͷ~]P 7H Ғ2eň@q H?j5N{ȥ?3}26 H)9E0)h$Ҳ5vWdEq>ka $Z01f=Tvr&ۑNA?[D;qFjet!kC㎖M>oZ"Y oAoؗeU6`}+'5У]Mⶫp825HY*͹|NjJᗏ+-Wt5{}`P*rݽjq_DG>67k94zFČeG?9?]ّ0 hǹlcK+ x 8X]-Ў9a} e0ylYw'&0CNyڏi|AןG4 =~?4cܙL@hǶ`P}ͽލT܊N9++4S /N@sBOE6.XJ'0*.AI 1q0]L:z1S"GDmBwP3Q}PjhzЦ-;-B/VDFg.Ζ-FIMi$G"gCW2BD<@O.VsQ#6 &ٚ4376RnQB"!6cԗ$T7O8NPmvfP/ͥEb(p-OQ_11MW 6\˒r3ag YaV%캎,A`K07vk@cɶHVM tq qNw!RR !ϡ.dAИ:D ߔ!skTJ>Eszp\Ç=;qv29xIO ?sԻ,? ~O.zؚ`O9Jav14D?3Vzn!<xTVd/zL"v/OxE :|z4 #+e!XFO,Cʆٓ.eA^P@'GI(O6y:wO@`IJ‹?㝛VFo5Rۙ ]&_Ʊz ug)10 r(#v#Fu1B}0DqA u^Qr\D:| ?'뼡T7T>iao:1Z,*;#ab-P.I}ctb0 sIل2F̳4XyHx6m<H ΐ+(%p?U5#zAFfWi%,`40N#}YKtAY9,Bcsq; IAٳWr &{̹h-@>ה(n c\FԜagi?/=bM$<,1M8%q^[_tV v(:&DB x:Wz Y>^[ૢ*y!: Pҭ#!o)4LpH-B>iXc;6$92Zuv fi\h/쮁#.U ЬVĻC G Ч ]uދw>][ J`k(4 УyjHVĪRQCӈǢCxԐ!M<:M_$!BNb uH ﺩq!i3׀࢝@͚LwKx>r}dj0'Q >2RFd>?R%յ7Ҵd66M@3o/Q xӏ5ٞyNoڦ M $1@5*?107. HӒl3%l = ᐓ}I>׹mrXw(zFSN1A Mmhcmӕ~Jh8Y|$j1d;`:Mû;[ik݈ʰ,Sf]Ac'Ú:[TfeW)-0I& ?aז0$VXK1Zts&y mY 4=.UkzT?hz I&EQkn0z&g3ni-<3/x#Sߙ̳YׁEhM|(9+'8AG ѣ_vR6F +8˽QsBn\1uw:jz\oEśxyY #(߇)7-4lAP< tX^6qw_r[ |vEH..lotӡkF+VB`1M>[3$[4 ě˟Vc(6bE0$kr3ED\ۅ=kCL)uH k}܏Ũk;Qn8&3.T3Y?ّ! CSC=D&> gWHe*g{;Ŀ_Mv)`BӔǃ [`.N{_%AhgMNdڍ|$ @}!a8{$,q@`k6TNm ,H zoKiA԰ҺFcG's_'̐:v[ZhՇIņ Z %O#̎$a /YRxhPH~aNv962&|,]? ݶ-ְKtA4g*zJ,V|'i8xL*_K:Hgt9 J473-I~im`xP}ўhEZC5 r 0<*:m< 1w8ya/ՊOZS/Ӎjwvҭ6by.KM 0|JM[o7"Jox) RH|NCl<~3fݧ^>g|6q\zQ^o#Fg5#ntr>t2O(%Tiflþt^3I1) V`ŇGޒzհӢlxFvn HB_,Q9>~ L x (dP/4r<|\# +qnj?GܴU@h7Ki4kIzfU$Pi? ث;HltznǨ:Sԟ&F-`/zLf `|rv_&as`Ǖ0kvz5YG Tc1Q_E U6]'c\ n!EEs4;< zX]0љu+)@V۸ I܋r/`Fsa?| Co|VlK\i%`@\v0zBNgӥ8F+rk񢤺?'D|#DH=fk|G{[gAJk=c:>lS%iXsl_ES..HRd\fQk:3xoMA٨5c_Mv.ǡg2D6Mͫ&TvRԽ3|FtZWF nן'"$F,#,'˶U}"G= dξKަw;#"2N҈oG!Pu6sJ\tCndGLgJfx̷7X`ξɐ% ء ʛz&8s\:0NYij pX ?U$Fv_:b-Xl6`. w}BO d}!G60k k6¹iM/f^4O0_J,ӞxѼ!*QkҁD5_ńf]ms S'CٗO=9 ?Emsq>t=R3J|-'^DXc֭ZTlsR)Wa4?%͙B&MӪGD:S/LvB*|ĻLdشgOcZȗ)B\  p Ҿ4QaW 0cZMQy{'o}Gk*xh_f̃zB(^!l%pS>> kX(ѐA:Z \9 d(] vn0RHn)o"@!?0u"xס+6'[.dN%o6i<_.;џiwmrݹl K2mz5}Ylָ)UtCY$Rdtu\i;)l$.c[Ty\Neǽ?,PpM3VD<{;<3 ǮJ ;܆bn;(c@n "eYW_2H 6r.zgR㘣F>-N1MPP>Pd;C:'R }wO6'T@$a:IYͮN{A0'B֒V !:VVWQU?Bչۇlz텡虲4C?o`em88(N\Qq z"4D.} :Vy(1W׎}RAeI1x!Cmhucc`@Um Z-bY;pFS1YKe\YN`kY/gI<;yUDG5?r ֔:PFuě _oz|߯/0v6 1KO`=fȪ|ћ78 UvI$:~߾O;q>}~<ֱUv<Y:bKB@&(|N==Kӷ$DxށM j&Hmc Yd r8F8H@B؂*`8? 5 EllYA2#9i*#3yiڀ8!=t8(NydrVa"FOMLt21JJsY^Z˾o-G,#`Q)V,j|-=jq^P] X '] "㑼̵e^Iū{sM,baYv: Y&=y!G102U~;lüCv)[`ba|0005i^a j" BYx? $x'"6_l JYFJ=ɽ'%%"6*PTTPM48<5x"~SFYz)D敶(I/52s̗(Z?[6 =$g˼6wL,3 wn箷ö8riqT[eZ9*9oN a+AH @$Ə+v\>/oϳ}ndE;7IAEۉ PHBmG} /jv|( ™3ʂ2R3}]va6yc%ˣЉymdUmbE~U8clJ2و"I$+٨+j@+~oQ giP=VKa8 ;xCV'l/li_MLEze 5&Ta 6oGf0}LE9X M~Td+2*Rc@ +/j`5Z#~?Hd@EHAcVfv 9umёSl2;AN )lm:ֲt+xNab7Cw4;EXW{C,wdb02ae 2>/C {׃޾(>.o=JBx>Ȯ,,i02^\6pU3er1YGF#JU5W=e_Y#jL;P}M.m%!N=2 ¿B*>3U=4Mq+Uٝ9*RJ`4th˳04%XWN:hz֭;!M߱?1 g{ R]^8hX]y^b,fm^|Zrnv'K*ֻDay鋔vvu/iX{6ov/ֹDaYORME³t{ òܛy{% rnv'S*ֻb+t<dfLJ`7XwxY  $Bhnt%lqBоp˩8 0V]_$8dACs''h:k#Gh5Р9r&hy=@gv(5AP;k[pM5Q lwvr>(9YW&tg I;9j;*Ł>ah,OM?q SjH y!G}d0{I>F({E16MK0 0RRRIl"|9˺*Ni HV u7 6i9~6GƴTxYi}霎i )%fBh_;`J6\R|CIQ+DS1)R<8i ׁi*dpR$̺vmBi?pTE*`8)IM۷]MWU6y`t'Z36*շFT)۵Lc%NRs1` :$׻_=Iь`I NuTcd*L?wS5͝`CUK'6bKh%P}?kjvd U0+WBm?AQ5r`H[{?~T>beUS-?AO?ėԶq|89a^q1~ c'6 .U͌!أjUb*Aˈ)Ae9DYOl.z 5W$?A"?G Z 9YHJA*pa= xY^"nnupȉ;O9S2zp 1=G^/lBYձ1Qd9yUz_4?8:N|ch|0M [38lmg''惕y\rtFAdxv2m-&td@B&t}K=0kB܈ڛXg3aNS/֟k$Cg>X4QmG='T.O'bXt1 nS/ SaP9w5Ķ2x.2İfpm5A܍p I4wEi'H7b=a9Ѯ?ZJKSZJwߕ\1I!|u[-z}\/ymz^) 7,@]WbS׌eH]CVz5p`\I݉x+3xpyϫP fv!PtXgȀ 9,pTP0|+:Y:|YWe՚2 L>sSuy--mX7@1.gَƸt1(Ză>Y$~6A4S! tٳ[7UPD2+ϳP/c ݿD^-Z,O-īЛs'*Izr&aِ8 įehUY|}2w*yZx,??AŏRyPY9Q}^s^NX;yϩCD6+To&w?qQ9C;zZGc_7>n (R՝kM;aB ؆?)-{ ?P!l4!(f篿ERA4N8Z6Kţ>.IT7qQEoC¹dS/AoocU+GAMKq?"0f8~::vROjQHoRiŢɇvY:tnUA7hZ:~7Â^U?eW,8!V+D'qi.t||'гhjeoyBQ^l zSyJqOl=.1{?~wb;OD/ı3NwjX-4wc,3Ϟq zzM&_c cq/A2[c~n,-._D[\HDS\Th $_Q:>$pնߠ>GQZM k J!;[ 5tH3_[A5pVj,o쌒A z`u~^ i$L+m@Xdg,pDgԿ Bd{7"+LAp:{Q!pc3xU=W=_yamc^7Yu}cv;8`Ѿ>[GuwJĿY$kH/\-jb%TY|! _/  /.[^ aՋr'`ּ|8UƽED@K]>7}L৆uW\nR7߱8sH_\87WԃG: 0J˗bK7%Tq,P# d&DsH5)@&M'tsOsDwG ]sG{GA2b67OA@;zr^GLa9S1EiGEiWt"p6El.: qWn kIJ~4I CeNPT>>UP|$ΟٗE'}:׎J2)h&c@#2"$YS_bpYPcdvkVqI&!$zWܹ7?ՍEc7 T28j`; }8{tdV~gg0+a)~ٞ¦J_\=QP' ?8@z lϣY`yr D%}<9.8TFDQŧ@VTN2T zR.뻵8TlyP% d߉gx,fTmM-R рcſSj뮷wJm3};5@2_92e@w9 WF k&U0xxGmf8Gb r=aؚ/C0n(DQ8LfMf|ݽn@tgXivfgdR*bJnc"'`U1'@r{>"yA>8ZH.+z Sz¢m(k"a@(j3|ϒ:w.+;t)~0;}k"ư0 "R>َf rEkR *n힙HiÀvLx7P4&s(L2=ap"ɰ Gey +v[3E%5u1kpK|J* %L8-.|qyCP0;mF; v{\9d  E,bᵈϱX(E,|6ЏlQxBf`h g\M$y=oŹP| r, CJe! 5~pg;N^wfn@WԷO$OѓXsD؀ R'ev^A^9_ϫ˙@j /&B W-y%{ωǮP9p@66 Mm n8ܯxb6',|i T:A9:y̐O (r|_'ۆl?*͐cMDjWQCAQvӣ,@]_{HZII2[9d=^'Fߛ+aa_*zҰSVnw녈8N~kO3N|I6fn [罢01Ry;ㄙܥP yaC^m0 Z`,䆟?Zp`ЫYAӟeozQ]D<Xf^Vf1OP ˛N֑~Fe4*'%R`4z DM)^%Ч4@ 51آ ##*zA+3PkG~[1UR)ާYK5W.J4Pv& ̂ɂiEש$ 6_iRvFI /Vgt@% }[* eKM* UKeBeD;s9㴧~{s]9z39^u7u5FokzΗaOnq8]! -N56n @B KyuJ_ĀkxYsG(UPO3Pۣ^o;{|mdb}s[aV#tV H][b[@$-)rt.V^T7m|vvOPzzg>Y䞱sAEtL@#o EscdC>D&i #Ƥz# Ŀggt!ЖP}m&o?gu;ݖw[ L]X#@u`G.{",8Um4 Y Jpm, /ͯC.-Dp|-;b`c(mt:mee-Lt!Eo>(T1šز?'|.Qk GkcZ uɵ4,:^īJDZ L;Y^Ǹ)BeC<1& Ne"wm9+3ӔHBv9g5)e\?gg0+ db{J6.g؀@9)A30)7w6Ic7wrN*=+!{R_z O.>(]Dcy5tY{h듭8X8'0!uTq|em5橫Oqk>a2dW tL2G=?a:_'0~ȸ5/u(+Lv`!/a{)r`6=LպX@hM:7 w.3+=a R:|rGV쌒#az% J{u$uI[@ekyku@ WP &#~rh2e s/'؍s̨s @ָ[Bnkϙ@ z[v roN%[97_|AlɦW-mBȖWze*&w-4N9uD S #8,Ax@Qxxp |sn!‘y2,A#s _ylXtcݧ(G⿱.Pk9u e{ه5e BGG2s>R #Ur٢:ul7rU{e0 0K[j@ۅQMEj.H ͺFTFU1H*ՍCu#6@,X:C TqAťQz\:Oa+,O1.Ս8rW_X >7FbhC#^m~$:NcʧRt/Ĝ$f.qx3PL$ my1^o4PO~~{\H+PKɶ?= iՓV"+{#ZHDl>pma }bG~>Q CT _l+Λuڿf/5c'sEC՜GUiih^! _"!si\@ÃR#Q5{I ;(7@s]5n'i(X4ݱ= kLe/}Нf~CB3fH60b)p̍f_+lq=q~w\@%QGl`V1(1+VTҁqʩSnKpu|0hhpwGh)ƥE|w^"Ёˉ5ي xXGߟcIΉr<"p(aWj /)MW˒d6S4}xYN k:{ah85~5,~YZQ7 ,3Bc. ;.˖ 0wpҫzB*lp'Îjg8x KRIXR#瑫#( D+2t+yHt%o'W ^71T[M03L + ɪ5Z}ޜA̜UkHw ߏjTvdըVSS]쌒A zXΘ NJ#Vϱ4xXa9peڇ.7qBG j`T<v֍Ad꿩 x/xþxP5PvŠ#%ɬ>\=1J>OfPƒP!bP73BT0 7ıxY'szakFys1*vk* ķ?DZV|9 CP\/ݦ@t+㟮 AM H*u_[?GF&:K`XCpڬ%AplϖZ~` وr3LiX@A % A%Y{r'7F4'wrsPBmIg0)Ɇܯ 'r)*?Tq@":|Yn 2`JG:5#qB@ثJ\nQk Ӟs:k͝/=ϲbF7kra z%\bb ?Lⱟ5Hlmqέ(v} ֵQɁ4BuՓksEa5yGAjmx"Y_5n&fޣ!C#,Zvs!U e7bm:dd7bu:٦"} J/+vEm%%07h5(w'.ͅgQp'?oڅHVB5dXEa苒s\Pp.X峩 1+"kQ . m\:.\1e nхį: Uauёu> }r)Qx5z}r ," FTt`aE>u>].KʣԿva1ſ4?881< @IGWXnY2څGߜ]0[*/GȑK >+12ONڣ4T 2y~w ,/>kuk)1dƖXs^ B XaNԘ&ieΎR m Pl#H)?|frY B h:Xy|Ԇ1X"jח%^Ύ!r 먰߼UNҼ\3x=4/$60 S &cc{飏ofk0H9P_YcO@;r X8L2[ܣeX;{cˁ]'j {ʟ2d<İ7gg#1 + zZcԌ^  8ȅ5rF5"ą?;kGp6(Aa8sO`JVi+ VT6"%B0# y\H72}YzڹU*vGQ~*a/:EQʝz Uh+jruu8U@)y$bo+.k&髮ғv HO]YzG=\dl rܐ nHNȣ6grr D>nsrٿyOkˈ|d'!tI!*3r# Dh}R @o|H'$=.BY>EH JvnE^b97rB'x{ #]T"Ą|6HC|?)>#WcWYc~CıZ<V|., $CԲXCKc萌zc#1ek˰;m~uc:Q{z&Бhs7"C 8s;n a`K]e&1&H||d^:ԄXifHԋ5ė@n9!;ȥu߳u lx:"/͵ul ,ځ _!+ b#zdZlEui<$2+a ϬiϺ&KRZFڦg?=VCQ D?,ڂ%#FTg,b1HgEL$Y{]gpzY#bkϒ$B_ ,ھ>(l0I f 6`n+k "(A6pPx"-:rc9_u$~䇲3JraBSC|VO8c<DwGy,;f[φ|nkdP _S lY?d4~ɇykX[gā([q,',Ɩ!fÏͅŲ!a_,_߶ !0 H *8ҼN4U>]ۃJ=L6X:l!ͥJW *8Htjh$9#82jgOOe*xάLBL.7ťP!8ZhWlZWd+kBo8t#^-T8}q:}_XP%%fw<]A a7)Sf:V!MwzBiX1 V+oZWLJ5Zo^t)v XD7ts8;"HƤwHwigi9H+06 1ۓmiMQh/,cuvYWywN*۸VE]R(rbACz.#<(t ԀFMJHR#oAt#}ǞOH6.)rn(KwWF;3fΐVΪa̴WSHܵAuN~#j9J!TcsT-9@Y! 9Ecjч3JBJ MiwWq'!Yx3S"_+;j)2ԸVnxt>=5{O,Êƪ1[eXu`Sj*gX5<_4ހj Ө4Ӌiu@Rj<ƿƴuֈWǞuu]-0uSvJ#MQKnAea=Gv=NzBfd9#xuԘ:1:V[}QfT D=~N3_lK_ *;`,1X cfվxA}\ 2$y:k);lHe=_5\M>F BUucg!}٩ow0WBW*Ub: FEpnY[o6X"K' a.t®:te@7d!+vH*CVLjG2d^02*B]Q.'Gkn ('gs hgJRiBBiGn0Z\q&+fa QGlbbuڴc nia/&k 4Ʈ aH{)U?NʳV?FZ>d`+j|:vPQ7 GKS͟7JQfƟٶH6 D<ΗGr-g&9kiߜl G?)q쌒 Az6z<u R$ -{mMh hPyMoPyhƑߡ*u5RR^Z@syUsm!O\5\Sܗ}&]h \xZpB;v!ۑH݃PHW\hh̞˷x9rmšcr9s?bWǺ$#δ$Im[W% }cPR9֙ LS^#GOR m!m)q4;)芐H!=ԕD&gW@þVk{!l#+2(&l~Tz%ТQьhT -VOm^urFK%^d:¶^T"̺dUpmHJlF̖(L\R^ӤQR䟍wDcDFHF߂6G6v3Pu6CFҶ#Ni=G-dkk^[ưj5)^Jl,/)4QS^N i[z)\څ#xNs~B;[# lH855+b zkr!kHv>kq5!>1YCuZhζ^[~ASqW=FV]{bgh\BhW#)|j=rwH4C`CEa0sc33]ՌLMtjԢ8183/؏Bid~֯_1`553[ }LjfT5xmGq;*>r\GFF#ԇ*8拲3蕔Yz}/Sٰ݀byX8CPK +)RZXS}y4cM ZXk쑐Mi \#M`ydc%R;#$EIHDX[.(kd Ec qPcܸeqƇ_ȏ;6~-B H˘)b$oe~ӺE&DzK òc!;mNact/#蔐@[.}Gu #`Dzw>lOպLnAX %юP\+ZJ\paz%h)6m~)T6\6.#"}sC G>1E$*&gerˡiŹίub6j7 ?680~ HX185k>`<^,GI2{!v6AA5Àtw9ۋΦ )EgʹdY0†$ZWgD#f$XhkX~_7+aDǖ'n~K "r[P=GH.GnȜT9P|V C> !|oʖȪ˒THo~L~: :\MӒ꥞:ٳԁȪBQ=u@"x[Ona R/֏Ԇ*](=m^d[Z+-GHk*l9:w6lH cO_%i|HX_4>%i, H4yy heQ>Wc>/L5LqQ1qF=N7yvg;G56剶y 0"?u؎ˆ܈Ȅ*5 '(hyRV6PcV2(_%s}?BۅMhR6NhV#-.REuŅPW*Qk`V:I$/%F;,BҠA^@^hA=NAW҂(ؒ-f?\|\d52/نBd^"hL r`Mَ3qhӭh1gFז7j F~RZ0\Nc.~Xr=Z|tֱUk`F_=We8#5-xCC21"7F! (; A^#&R0;7:}=bȤ[3 #`WҸWW٫,YHѽ%< ^Zr+%{3aux]9WL#i6>mlH@Nwty#q&Ǣs!` udy؄q`#ĸ4a|P(u9EE3>,^ZAGjeGaMA  0G.=y!m?S~Cnf $Ϳ (PA`JD]X#E( 3aٺ  pa%;*e֑ " R R(i6Cd>n)b4O6$?<|UF#*}wCv6- W*p*gZ.sΣr\ūC}o*JJ`@¬B%Tթ1i*Aje$#~?ZkmK }wZ74˦kloW6]{g=Î+]ßRo#p{GL@Y*W9?BMfNs" Z# ga,ȲҢE=ҠIrv8 Ҭز4|Ɓ=ʪ~qaޅ'.d{x{v7Ko#BWlTXEB%BT]_DAGy7>JZ(S1Gy$N5ƈjOMf4V( DQ5r9~rvI Rӂ=LDم=m4Ui&ɣGNKv}u 31HxŅa444-4憤E^ګ+PàO>^x5jԘR{(Wih/;1h6 sFn4G7&<~ ~A.Uk UhA-p@ h'~ԻfoeD'J=CX^ ш!Ma:}h'WS ]Fއ&?kS򪟵ƻA}+hFpY* N0 0JE#Vh~])Iy?j@NՀZS,1Y;Ţs/{wp_bQ'q%'>`nWA?>`H+aQBˮliֲk::GI?j5KٵERu8UxDFWO1\O'*U#DF^R0_*"|e/UDw4~4Z_K}RK}WZljIW#T#Z!>S ddo$1kI>F3Gk>*4g~Vkf% w4e1 +٢laO{ ˜C v҄Bh6E&рQ#uƎ-V[~gǏ m3&|w&Hhn,A1m;^mljA|',*|cCA:瘏pM>97|clx H~K*?)(Gk7Uhe#4WX)3EXnK؜L },̑ګ fȌ>I"?J OZOtF=6l|(;b^ɍcbeAw1c_FWѧǍLîifM".dvM6Uw qiҦڵվ !:VdO'`#{ܠMӷ ]=0-ݩ/[wˣ瑅 ڌ3Q h>K3SʶP^McJ#Ulna5y\}ZF׍4؈3qp?;,oIp%GܜDlsf8ݏWFh5wH W:~2|?f}~p_$q^ !"2w 6"h $rA %ORCT'/?A_30I6MU[rlhAjㄎcTdz4nٹx@wkRU#1Ih: G!N/l(&6a=8!/"n\E0d6֯vn~& $5JB2fWBVrە# _95B?qxz9x</ "#xyP_EWug9pMh7nB/}håק } M_ qoDZ~Ë631v+rzA;~쌒a z2`X?l2V6y\ϱIZ׬I#9ՕYl1STW{bv0҂\xRV(ƝHs@` x0.bEqdGNSU݂0ŸETTk?y۸ #[iF1U;4*?U>45Wwiԇ+;-;L bN'HynDŽb'Յ!oi玴~v' ((-_F_od"QU;Pf!ǏzhHT2!Y[Hz{Sv60\%q_ ^4ШTui~X 2 Vcg.8U[Ѹ0 r*oi2=0:쏍h@y菍h^vԡp d X .7q* Qě@$qVhۍ&E$OH~܏uѲ gu+?#ƶRGB4(q?FHLQyFc~Olʢ^k9B×Wu/|1;̼ֈlhScVcG.Z dtԵ必}gmE& r"vJ{bYWIp^c7VyewbSF><\ٕ@/6u>FH嘙1SmnF76~:D,ۆ"Zm\P'qr6b v1TmR2޶c+ģ$\'ں8!?GdTC:]ZsX@ZKkllxvig/Y=lhĠeqg~f䫞MJWU4)#w!;6@C L?6^kv K:4BgJL*?NL+[]1ذ^?< 96z> a_j6 -6"ɼ|:FQ3~zG|ړ9y%Fr-Hjrd0HMȑy dmIE<yFnKkNj[V ̧U0L*)Hj>VWr9xz,fXkW]]lhq|UHMD@Z"DD͵:Sq m.xz_NF _HB _435[}}VO _O=RO;F<~ϒGLG} Т1uR:>NGUVj>:}Og +٠La3T"OߕxD.Ԗo j?",86EzkGe mG > mi"§D"t?:~߳@Y?T5B8nQ Yz|GV09raGNTN6=8L?: >01uN(B_Z1=թdi5k}IE lE=ʵBdMbaQ,GOhu[>ڱ?ӭW5[O;$5ưD0(${CGA7ĴkoGu0vI RCMK1u~8L)^nFp_fC4eFʼ3~4r*>^Y v̌U#CԻgVCFEQ>D[>3![96CH"҉ؽz$␭x-L[WQg~>!\ RTӦoNCRq(YHN$UMdeOVdCm֜ȓ4|v _ZC40f!SIT3J#4v=.[v֌dS4}7'%3p|Ծz}C%~E# ɭiX_u39mF,W-Eni6laKQsRÈsa1oA2;] 0R $ئTlHD9ȇBV4Db,?|XDy 0dO?g#o-qmi) :KID~ZZG 0]ZZ0-!u;u:}u t"5P|\5kCk֋=Y?F UUG/6˯"m!$]MW-x~LW-x?hD-Hrc.6zZn,r6s7v, 02l `L?;2Zgx)Ց#Qn:&:9\uQ?H R0L#K0k,hrWߜ] N`q;Pp$M&rGFgΉ(B;GLWfcj?M:gsya ;GOM΃PPPI~F->$zcY5*L\"pB wjՖJ U@DYcNag@1k΃XͮJ IVy&*1x,<of/h7ٗg?3}bgr%j%u+gr}>BV!o/^A)Fڠ_Lh9$gcej$> q'uL]cESZǔz^1_7gb\1V 1b.B_upHGRJؖZΙ ;? ]J4ZIGED '窑ylHYiSp~Mlq(Vl2i}52מES)] @<=ҝ΍[*;Ob5Pv&V?3o7%5^-5N-ٙ#r dgj8|54 ލU@Cj߈ccScp1M{T űq`;m(űJ @>u88= z@m=^ 7FرGF5wќ_~׿;aTb/H=Q Y8Ő>(?dsG`@{HSqCR-rnHFg8όMǦ IPGSwz ?#͈[ʱY(`ߔv򵴃Ji:J\#H:E4ߵ2Al[d>ѪS=r$ gu}G+Gh1JiՙPl 0 # s#nidHWER1ڟ[y11W"pk>R;]e+|h=b.?!?~ oaN>vt4HCKT6޴ᣡ> PC(t /( 5@Џ P8DF*FE@"gMSSl?TZt+=Ebt ?Z՘>Gq),1K%Dz>%ɺP[(FE?vWc}: 6i)ko(IbWZ/6e>` e A+x]c>F+-jGbϺv=R6`iu>z\FXjt{HCITM9kk݆aTCՈl pyǕ!嫭p ._jO1zX\7ƌk$^.lHGnNȚ}p|? 3m_}OjGv6cQ}TY8ү d8B_8pAE,߈ 2za2E2^/٣٘Px?IH0X+W95=\B_t2=BUw>~H8hIF=ͶƣMIY pa %c*y% 8 ׁ>QEqE63hG![PkmƖy#T!k'#>΀e>4~`g2w)H*;Gw6Wx\! skoNk$LሾGuwN@ں;$9AJuAǠ^)=Իjѹ@;C/fL;kYNqu9[ H4^DMſq}A/g BH4~!`ߜ TLglp>8Z.WEܭLD BOk:z3MD~n6$[4K[j$&-*0?FhOyqPx9࠽ɳH|׷Wfv%&x2Pi, o(!%p?DC/tG6 $B{dpEm!Aq@+K!@T:^y>P +\!ArzAsPĵ hkpnLs4A^Ae-+g3`U5oKYW#<<%V_<@/[xfTw P#0 0M@i?i/J5d;6H^E : d-1K6,xwkKHX(ן[[d1>I/q7Byfd7fU 9wS3A 2g6.l MncAlW%}ZF6~/|'ؽdB@>rA1!|$^9߷pOZW*P;0che$gr*#m)H2\ o{Winm֊?D[cY!l'  F 'Cčv+apr* VAp2*rMmb0R._&߯ }($av%;$)euBںl̀h놲5b3piKUP @-Y^]*C2>^i֮]@0kW,A/Yf~IXo)sȘ7.R6³͏G r'lIhi&} $P-$[9膼5#<5#jFxͮdA#HhF ׈땝gHk\1(W:6O>-HMz>4(+-D_rƒƋWMC@䚨q$ٸ"o EE6rmgMtЈL] rϼ3QƁm#%6fH7ʚAdy ?t{:QV'j5­NjO8aҭ)kepK2rļVP"7hɆ C!FC1D$Xic  + vls(A9i0#(sT;aԙ0߉C 0Fy Nl~ tUQ9O )l!*=[\ lϰҸ<~f a_ìn?$F4~?H᩵Y ZK>Rں#Glc~BZ?! D7eg1+U:ۏ D1{_#i+/me಺Z&? .ZcmZu&QQCͮU@rv-jaٖZCl!V~hʵ|Jٱgk|$AhL9nc4@Mv0Q4Y0׈C"fKH4/ ڢ=@ 5R$Y1 B/]-zn 戱KpQOv]RwwσZP*V䪆\N5A`,cb[~,aIueCrT +Wky46wqǵ_ژ$tm5,6"tmZAVO*hAnW"U+Nw~w#{_MLc_& z?H~48mip8Ljr ф5iMyyày_v3PPyPP0ec0eOc*,_ǁkYco# 7+ҵI&2-jkAAd|MZpC|~6WyY)C_l|wk>sOe\#8"( s˒QK~Hf#=@/ز'vcMN"BuNy ='Ie-^hyP`}ëh= C||Eaa? pn&10zss/f8==R{T`;{0 HQL6P$ +V>IJ Υu/#eVkB{m`+΄rN~$>!>@H#tka#!Y 6WCX>!$ڊ~|Ro!̋@A%9 2K6r\(#Оc-Be&qI| y.ťtwt)B=o> \Z'<-`IO'Tß__(aWZ:L_l :PDP1y~^HKUXWy` vPCRV"R خ"6_O7B͑BCdJdY7o/ s#hx yjCP$OM9ĵnAӏS>^M"Rn+nXXgtI)ϡ3 =Ҙ>{sڙ՗oTBˁP}B+!o(4+G.%/ ;bw\$^ fo ]MZ/GlҴ.Ǧur]WLwh .m- JE9!}8$a %u>NމjZԒA?Ԓ-ՇZ2[nnِH!hD@bkxwkl͜]#j(\ħ֯ѲNCj!mb v?ҳh>[lȂWgުk IQ;hb!h̖+7w|Ih8wJ$R=l({n?Ng%@ ,q յmN)-^7WX)Di:xQ|<(ѝS<G2J"\rE^ &7`3 4(? Mgg!+b׶$  I.̲\g^ٵ*i[UHbnAu\X![rO-P>z=1]g/$7c/0`#{uGq &5?Ěo6KkJ7{44 1 ,i^ ip%I|2kWpl2>W5z~0) 4SiB>vѣA~#L"/`8)Fem-z\XP+;΅hi~Q jt1Y#k;Cp>Ī0B:!?^ď  *>ij7)ӜeGi^(8 à/%Y!?v:]4=Q֪ l^X)ް%ofiؒڗV%oFUw ;xfMm=Y  .ϰg9F$?>9ϔ|p8=EͨFZ3ZhKT`عAkzlZ<@VQޕd.ޑѶ|SanKZ}{#|KjBP7!~x}ibN#RU|H_Dw*NIH$\LY5H&j<-?.}0b?gY(vkwvß gg +Q5 +vV 0qj~i87&P~ǤSτQ[O†Ȧv͞>PYGI͚uFpqP#t"THD#7Z>@%vr{a :1oRN! QW5DpA _n0 41c8t=E4_HkHKi+9FN"Hj_ǟ ,]^"o`x%<}_4Jli?|SZ&=j~5z>Ӹ|_|f-\<4k<@G#Vv4b]>nQd eO`4. W(.-5G  벾h+^=ˢˑGgF0|U'%6zhϮ]߭~6L?fT iňFDe(Y2SHR{>P: az 2ˠWs*<&}FU E;khY~1_Q D&BŶv3He>`"t{U;}\=3O}>R{` g$%ݤ0$ d-d02F򪑁ȸ5FgO3#7 (L q4c`<4vms&vms5vMtX?b>Z?nE(UtBI#=uR~\ci:6Ň Kޝ PFjZ!Uj "G-*ߖ-PfTCm2P<5*F6Y{gg=S|}^ZEsޢҮSBKFoY$ᇢ<]xxIJҢd{RHH]V(fEGuWU273raUf& hg!ue1 =lCf.fJ}o03ٮeJ~̨/eUQy~C+2#n" ^-"PQn} > _v9^Wʠ_G=QqeПϩ&z@9pۨЇ#!b[ A.Bw`{SmdhhB8ɞ*7]򵩜hJwC(#0X&=?67@Vnۯl2&{TXPbAQȎ= AEC,uk]4ZA'WFhN>C>FDd瘏(~L"/~KMc䣧'9G KVWʹ)aԎ.V8B娥Qjrԧ rmsw n%N=ʪc7ԫZuA>:m~)\q?&*rbp\-Gɧ_؋zlgM2sVU= `&Y~] 9&GwxWZupZ/ܱ0?v4Pv90 X<1$N ?jDZХ]R tRUh sAr?95~2ĉKYʹ=N`h @|\6U+ѭb@'*Lscap.,㓽8ɖI'gg0 /UiU␒}  ~I}(%1b'=%:SvA켺4rSOBuulMālMVnu nD34^7׻ΏTQD)PW#pI[~хj-S6"h9p=(RǣϾV?9Q2m Vȼ]Z/%2?6XUj 0D^hH'G 2Cǚ1f5Bt>f 6@y"8&l^H Ky#l^H KyygƊl~ʬSf/ t pa%%ؤv0  jI {&\kj|u5_yl;v!P|wVjs;5g54*lt5#<Arh,d,ԅz }GJGhq}$}Иw!4S;²6AV#0~pUBVc{|[;''#:kl#tV0h F!Q;ƫ,** )VRh(JU& Zi%K`Z9t(fC(. Z1qz8P%mEFg+@dn"}w}Z٬E lv3:7k Fe=CROhWQ%A8Z$xN%ZBt>>A{UC.TOS:w>7<+c))+Ǿa,)vO[4=4}&]h' ȻtIwh' Hڕ5a$eFV*%U=Zl_ |:դ|:7p=Z4qBZCUԅെIxbO*[XɏECFSzW3>@>F*o7?FRe[S'3i$H>zUkAKH PJh_l'~x5QW( )˦<^E6 q5 hǦ^շk[UGBky{v R5Gf8ڪU][_Ĭj>Ĭ]+fv@g G}ۘ9׮G}۠9J ȥ;q3{!@d<ǜѰxn"dCA_~ǃN327,8Vũ1 cQxo$7 Y>.XgNi7ɶ7Uxv*B^ȯvu7ȿvǨ.!<19wv9X֥C2^ߵ:ťD462>(]A0 Rc vJ !Պzv@3evvF|SggwcAひbǤJ4ArtIaњAA\ EK@\\}͢ Vf-6HJRnY.X mi^j3 Enjm+Id!7?J:.j% H͠q±<MO_<~*( @ۑٛAU?ٝ4Vʏ*x7 U?aP(":z,Í ztlkb}զmPJ4ve.Pr[&= ʢq24L|nb>/O0k>zqv.H R/fG1L7ewQ1NTI@QA}ʶOݮҬd/cĭ.tHDTwa!B%gN9MwBCΆ+pH6,Js ^(Ax)gCm_tJj\Wm+<WzԜ WB2g`ح0U, '# rFes)@59@߫gV?W Ǫcm+g*0pp j8wz›JVúBփN y<㣑7-zu%8 dThէ9*AR& ,%Rι4O6kR6@8 Dh/pғEY"I]"o8sMVX߶LR[c*_Oˇtйե"8GsbTo%7xEmA8~MRݙp .w,*L1f[GRKz`~XJbp|v#wkb ``X7vj@|y%IMVLg{} G]?L@PE& .0Gxc}9@|:GCs݃ISJܔk˷C_I0 x=x^})8ˎ9xPp.[b'Aa9%`=0k0Lv= `ҥ88 ]bԭ( V(,za$œb$(λ ah~8; B^z@}ǎL ^ *UI!jr-C(FBu4[ƢohZs &"ӽ$G |<-@< |"(6˕P\#]Yc|dP$օ\-|KxL *Z4&2}_.hhWyq22:nM WF7,Il5* mwk! =nwr!Y Qk  |'#w~iXwWtz#/{$g,N3&ט`.wlyv*9XT%eQ` C0ð_vkSlH6*=`5qMPi($T5RJ`<4cDTxNbW  G= \ ,,HK$HbO?\zlPcĿT,S!ۙyB@h91eߙ:٢1+:AUA*?cIn3wlx"J# !H>Spޯo6(3\qs’$^Me;6lgTQ{&nU`Q}Y|hZmEmUh. v EdRhv^?=T[IHĉx}8A%vmTJv#D|Q |w/  ϳW<+h67Ft <ڎj4Ų^:'|ĚӜ@5g˜zյY m ]*:tn]m17-捄5N8{\$q}ѷn*Q ~JhlN SW_^n« k )Ќ H‚ <5Tv-C &5IGcH|V'̸ 9:C \K^_߶5Զ^51jAؕ'/! o4W+^!~+ \"Wx溬Gt?&[ )@t0}5@8XG)Oxs g{ cHu'%d4ɽhX2h^! BDC+PX ?7 ܭBE촗B\{TkY Z!d.k<+]ʴBZ`V\$QĄɬVZ\-20ǥ;By)c.Nv՝Q E58JqR5,qw(Q$}L=;Y~YNTiPn*j0 °تiw ሲ ;T䩛%t<T`{Ј!D2 8am64_`2/Lq6T&Mq?Lq܂1>FhuА$@{uQ"K>hK6'yB-L@Ö]¶MRxדSRII)T{3Z+]wuhjG{+a uݡc݇y"9LA7ꄮ";!;N6[ks,1w2<7&(nӠHP) Ss[x7M :MyjHMn$;fi }Z\(՚؃̎f́!7i-d?%]1@vދb/'"ٵ~DoBgC_|!Q7=KJ=&eN`ks?A_~㯈&zp}h)䅴!ױ[iNLI4HLI'#zGJ)N̅o6>4UߴE&DYPH]#zzLHmė9()i_"/0 CZX{HTMNL$^ ; 'ӘĆӜRmxOlPLJiv2}v&x[2Ufoszk͠\+acΠ͘i)u(:.^]3.0@Ԃc3q rkmJ{b[傰()}}}i (X/O2m0ERh6 џ!uX$.z\&kش#30ްiݘ 9ߍY_69lܡs(SOaQK0Vާg?N5PxYpۋiJCJ43RJMdD3#ZI ݟ͌Hib2tq&&:MRi5y~ 1AJy^!;xȤDډnG1Lnuf(.fIӄ6c?-i+!gNuf8^Ģ X]8wvߵdYT]iМ)4"4oiPiM"LS[]]ouh+lu a,w6fjx@2irmٳKҜK $Zi\Y5(CDH#ks6g.2{/D9{x9$p3u}Ù?5#D]{K=0QIG +8gU*/Vf|OzS!-euesfd=:v2Г+ a_Q5W} eclg ;6poHqa&z⁝EA 4I\į`c)Ѫwg7Ln!7n *H'$DSǔHGo &h V:Y2qeB Mf^4$WldI:xh=JI.jyi{BfǞbV ɚmO`)4=H@a poP4uI<g]6ڈ)9ްӗ>:`G0 CŅecbvIӢ:J^ʛb9̴:,ԯ+!L;ȿ(R[:+ZGCa:>Po۹:9,Fa8pqrYHc酽fNx^O<Ms67MͽD@̛fU*U6s1RsYwse5ҙCOݍ\xY:Йn70fzJS5y?UZgg0/EXg٨292ש9N:1mYx-@V 6$izRih:7Ine}6$"ܨ[6$0ueOJר:.u !Ul[56my%J>wNX*]\ivޚwΚg`|iXu%X5u5nl`鈷:ʜ)YoϾWǡ۲6M1${ A'AM4tUS:樢Quɹl~C-ul  A_`Cf: $g ªW ?{roAe36HSx22C5$`K+z +3cd /=V f&zl =Ͷ/ÂʎiTU *g1 *9JgG \wj:ӸBRgh\> h<"DSC9xB!47mjm*)Aj-ҘlBjn -K KYݰv~)hаfl!mAKm[ZFëͫWiÕ|-Cٹ0 0JIV7ۦ;J6A0U|PXTai4W56%UM#ZghZ[Rtm$ee..N \J j'5+R#V{OdMs٭kCF KpC.uaK \C[;7a<eM~U 1 ĔζbzV]1$O`! gx"Tzd{fM.-3 29?EOݸ)8=$k[h#0ial\rШP<]`"+[И?ȓ)~$'cZ1+T]i]Q7oVb%Ʈwj>;DJ6}TO3&tŸMFg xdԀ4'!OԀT*y $Ę|Mp ,쩹~XX؞fHH(lV#7f+0UP*SMTuUb*)iU}uGP4`FYwÃChAlUmuu':qE^~ :7EaSc^uJ"04T<_U27a+쿩^@3(6@#U Tvh &t L&PvH R@Q{m;qw 8-$|x̊vP7+EFMk+KY@>Eˢon}78Y#…5ݼNi/Js(>t ?x؅͎z|lއpn+Ka ^蛿e(W2ʟFY.=4N QN -:`3({9_rӪ \c< q:gF|#@ TBei/nvfB% ٩_YII"i'%O-e=ncT|YqĊ!E+‡XD9v}޵,yDz;^>o?Q D XI@zQ]v4{Erh26Q4iOEͫB٢SP:e fӢ|s7}4wM,MuolKI]|YҸ_?*)s^:ՁGiTX$ 8 Geeb$O MikG[7l;H[;I>mi ٤IaN%;qm4)2QJblRth/B~]U˩$s7fL?hvCU|7Ã<$}F#Ѳ$IL[K69 n?Q gG.^G:MńABvsj+Aw~=J/(agrS cWOL 012doRM~Ѩ{7i78<5oRtgr;Lupߓ}G4ܒdۼ×{3I_u]}<>mh qmA mm1?^ᨪ65a>dgLz(]I{rGE'.g'$~l=; zM@H.fW*+jal<ĚI*D_Q)I@GM&7!$nl4%ntk7E4瀐9̳>r}W!Lۂ{pis7$ln\ҐD&4%>H8SVhRq&uNp%"TȘ:|N$N^k1RU 6C!5Ԓ GE&-LOr/<>=Z=/C0]3t3x"tpf 8h @c@廊ү eUl#Aqx9XΙw0x6pM͟OL!K[\$ dAT1kV > 5x0B+CuSҺ.Ŀ Wњ 3ItG3\.{)8r=<:9KwXD#THW0(E9L )I`D9̼PҚFJNh`6` fV(B IrXio V6:$]`glFr(AؕP/>&;5&lo,3Sj|IHkS RQ+yj;-fm_iPMC3'>/ETLS*r&(L6#~H*gbMU}LHbeWtߑ;Z$mIƴ>q_ 8d$TQLJ0Uj&m 7v,H ;iOڳTvX մ _--A +!/WWR#e8|b6 ' HdVk^S-l,, 13V9ԀCS'UϯH3taqZs m2x6ю?eg1/Ӡ?\%0!c,Y2u2]3dc;Ƈύ{zpyF'#Azaގug9yx 0G SwOMv0qRy b (%> o&dEh5Rs7-ZF17b)p3FcE= &шZtE1 ss51p 8AOfxXw1ga]hnW@uI&tR(8wP)J}/C'E78Džܪ VU!|T:]:RpNxϽiF4Wp.g8,Y;c='fA*[臲3JaHc0{,I`ǃHZ,S +Eh\[D#2rjx V"}l)|Ty+aƔ I倫Y0hcCJ ) Xɖz%мˆ'} ׌Ĭ2#xgutE{ ?S(z>rO4u2g|h2d6.Cnz(R]H-ХCtB璦oѝDYϚT55XVNUvjj.j,0't㿔,%h!#0 "Ǣ, h't^ )8v1-ʜMe[tL”P]/[4@l psU}LSD2pץ'ǻQ2԰ge/ʩA1e7zQ=HN4@OgբepC|"ף“4}{̧cd:@/e3!ZWYԤlBv&g+zK"0VQrb- Ff nW4 kNBI,gr2ڌ\.@°/ Q%K8.kWV+ԑR[8< !g% $2;OCpb=? t1. KA"әy]ԹyO5Lg<,z%4߀6 hص"aclײTصklgKuJ|*3<@:qU`:ԋӔt^(0AJs-Tl> $4wbdnd/ͩ٢y)M%J2Ml\(͖p7 xR #9 ]ϙy7( Tm5:f:.KBaAyjLt m'h w-o2{ ][0 R[%b J?X`#}Be/}!(T۵NCabl r1aw"ϣ~"$n 3%OAQe.ztIN%;Nv0ĽP0IbC$FSD8vFZţRgZ3VJ&l *;%N?{hySi~{TO;QwTT/H/^lu_d= 5ffbM[Y}4d}4=E ,u#9XHTSp#QKٍoze A  X;M85?1ENH2clk;v&]i0Js\bgS叺Ą!grk9c}~mXSXqC?ccrO@+*b!{ms;XuV8]6M{eC}ϫ,Vd6ŠLvs=,}7:q U(<:MM}=80u1dZ0V*++#A}˭h Aw1IQ_24h]nELRHCnڭm\6ykk;Th<8U6}xqb> Lu2ɧ: ӣ\fd붥pã K"T-[ѫUvA=Msk"|7&h|p+s]O0rF T)G=LwW4hQ9WҤ[aߙGu>]ө:obVd gbFdW* ϮP"0~&F|_ ]AXHZAء4;^43n@;1uf&@YNK ~>x%)6$JpG 'POU1݆Dp?Vbpά[1vMj`ن+"+X-x?@tNcN,5lj.f֘slf cy_ήĆaDIRdV\$g;Wbߒ@tt,wӜS0-,΍p-̾sKtS-Çwt Dv(pL kJ1=h&z!=<:bKHd78(ݹ_kܡdNp޹_+QkbI~F]qcUo\F8B>>I8a*RIQP (%q(;|%%[l{5܃,FmGbώ96*3??(~N){^ikvӇז͒_b-;d=5`dǞbF_(kZ-={eMӧs'O_)ٓ%yPwEn6\Ҽdόd q!3q p%vl7+Dyѧp@V}HY+4̀=и4^vH xdP,,C$?P[3) BA|#ШkNP2䙓< = 'K)Y1⢔,4R2W@a桔Y9.6yEa,mZ6}l=ֹQwW&rzy[Gȏ3:baJ$Xa.CIm%B%Y?)z?PuT {1aT!! R̠K<1Ju1(edBB7MaL3gߦ oU<µ6୊'")'MHy4f}vfn Č7q @1n8[Hm¡ w_h)Hԟd`!쎖Xh* Ч3oSyַQ'= FpQgHf}A]<5;K(`fAaR<1^F^=s̞Pݗ+A_ZdW0evVn,'w.v8~2z.Y4\4^GAgv@Sh80Pdh PsZ{E`!sO>NVKe*2K_4Wm ɕJωWGDy:ede|TQ=^ A 8@P=:([EɲA\b ~୏&|X>6 %MP4mmBڄPݛR<>j =qs|T>-lu7=t3 i1;cfA11P a(x%P,/&_-{fi4 sejGs,Scs830&4`hڳ' ;9ڃ*Mع~<3Cj!aHת*vSZ8J`[z+kih‰[|P.-H Եx8 Zb]E,ַuL/'BM[Z5"mWwV,AM`8]욱0kD:>̯ jw-/\Ru- ! UԵ82tKSN0*SJV't@F[ bk \UVe}vî] tL&eT`C3hY9;؝?Э2t&jT/=ؑ1 85Sk9ZX풓=.NI\7JDV{}P֐u͗eBSUc "ؑd툝D؉SRgۇA$9LkD_+GAx?j,\U }x RPC9(9a۽'G*@E(ӄւJ]?uAUԎԞ)i9:Ds̝ڵAwjoH4  LH:褭rv68  XŶ #㕤<:vVbC'B6'fb[ mo3_ktJR睦\a: KpU DT8`x67|yo Z0SSyvT(;9Nco⤋]C xW>Oxl#4ܩ;]Tr=~QWh[)gd p7 ۣ Sý0l -p{P{͇i>YԲ:R }B$_I"9n Bpv /:ϬBD*e2knN2 @jE<}V)#c+e?ス VjFGRбuH>բܾ{|-hzٽ? 'd6Sמ}#_6:<:TB,>E e2ujw۩kw7NM;@G e7S'@:+[ 潕Љ weU{KߑtY$M#۴Ī.Rxʽh3Pw=ь+Pwu&P4 |HiܶOUmdm]" qv80ɔ'>аjn-}h++_o"kmE/͎&T7R~<*Tc7JB ߮U9Bɽh߷Q G!G hDh@ _ą3r~.8Jbh:[y@'D䤱4oŋP%'%c'Xl@c<ʔ3_>qUla- \w̪%;fHUHot'4%CC+(+ m^l|֍OeSm* *0wgW0¾TSmw+ev G3L?㫉l[uUgl[]elK]¥ɥJnS.ҹ~%x"D<8lsS&5+ lh(sFv6% sBg ޔ)S9%KM7tee]ڨ: RoXs ʤ OI/a##Ji՟МL2,w'TEeF*Tw! *s=l}VE }P5~l ] W^1jНU+?H"-Y |OH(27, tKf8kޜ]A R Z=,I[c;eHH Cg7[0Hc4'G->|eءu8N2,fԁbXL[aD͝ %t-l,Ft4Cw^"boT$`%.9N|(9WޡoXNj6$B,r=1[bL,-h?yV]A+W~g4qwl>Gwy*Qzt%.Nd,1s]"&Ae]"ECK?|&45MiehB}8;a1!eŊ^DV$>gPVBnhd$MҘR҈ $\ųЗx̶z'g+??}r_tƶ'fz}f|hK ߋՋR߻  ^&0Jkp38'],ԡ4rHX8Lȶu} yKlq_ÔmQ[#1mdjdAD)QѯB˚8WXH;'u,(ly i)}N p jCCY䔉lUf䔖Wf-norJ[)>Ez}[;]Q?_paqɎ:^S_yO|]FeL\̽0־VZ{'mlRn{ ?a_j?6igV:C Li6'A>ӝkAQY\emKFm?%ۢɗW`z,u51dȜ{sɵ 24|'Uc4|14JT@ N؉#w (OQ&PNӵvK?\8>uKRDڞ#$"Q[^ԯ{W*IWU{GfMYOI@:Nܦy* 1cs/.-J]ܮ*8*'0\ն4}0\v^n\쒥dpJ1:r7>Gf Iٕ0 \gZBRPDs_eA;{LqyH{~Iz $$|*Mҋcaȱ.@zbn= 7+w|z@ cڿe\&8ϽeVz5ezu^-SzM?kzzO)[DX_-pUk\jϽXRvgfmtxt(0H99ay%ޠ,r[_#{.ti#[)/V1ABwRx #8q%"8Pomq%"89ZAaB:W"Kyz]4UX^g8 @M&8Xw]RAA%U0f@X{9A8CuEO}.?R+!*NS+15 +y4BHl:ܷn vLsܷ*&#A59Ϻi@V]8hM0杺9lq49߁$um`6+]`FVq@'rtԓ|gSbNe?fA^+/[] 4DfMsayqtn/@h]FCCN +@B?؁ Wϛ3u4_;a~z~%fYФt=dkB>g*3I6Z^3;0}/(a[+އzԴL!C.w)~ZΙa7t&}"K)QO:n*:Gym/| EAhu@QiYiLVQPZ6ѻb%ߘ OyA8ȓ Wq<8\XdK@8YN3 cg 3qϚgW`0 ^j t6iLPT"'c\3!י@L m!ya'ʞޱMͷwt2Tn(&O1+àWH4 a`JP9[AaŠ38۹P !w@{KTFg9yri N:+CG1r{B:+'Qecĵu9^f@,%$NaȔo$۵E/-"×yd1ʤ”5#\MPaj@fTRrHd5T'LmN®1c=^8y.%|ޱR10L~9a%.Q% mN"X-gAEvڹ,IEn\VHiEocs9ycԽ5%bS2S]KbSglZ8Cl&j!pMP5Ʉlt7n7@4Ww`+ (hK22#@R*ΝĈ)t HqgdLQ xCv>ٸk<¸h\xqU)xq4S GeЙv^v$K0;YAɥ6/b7ꂑTb7)TriB#Gİ|mrB16M0B.Mە@`ɞ >] `%7Z7?XȔR<;T[2 eBj ~ q@."ysx,{'$YcdA,2pNԕ޶C ݨ&btV6TaWrU[NHK_i9csu]8USz }UGe$$t:ަ3cW{L(NpT6WgBPb֖L a-Q D5@>Q $E5Ilr,N>:4/%nA7v-v}agd17.bo/ًl: 0JM/ HOw4,us漓9{]zX ]1Vh3$p%[KF#Dqk.euSn=8>ݮ{>Ђp4+N2q 6UYnm&o 8P>~|b^):j>Z(zsm1T,r9/YSѷW+\kh}'eAz<vo5-XaRHE ðŕÖyT떁)852\A]N+Om 48g薁q h9MS7ioz+nOعV 0tK epr+ I;Ld ŇL, UT(=AǪ0(:Ҩ'e* )< f,@;a͂>#=Sr $aXKv迱}pH{v\0$ K[zK IQ7Syȶїꘀ1:5=نe2sk/ۡnra[<:Iqt e@nGcr(8 }CCpI1N 4 9: P{S TCPP{ Z0\8 0 @$=^xeZmL'4&]CcG1q8ukh8:N7u$[>JM/]x?ܞt՟4_f<惌DŽ*ʌWc6\s A |W_l̘<@I h\mKgѝd&;YuLvӘ MDҵӘNcViugdwTnvD~nO"w)$ cAbTE; 5 iš΁!;2} cF{";}2OFY扺*Zd3j&j3PL1qW!J =ͽ y& Of|¨“ %޶d7dy$Zg*^S&ɏ8Lϋ??]I=g2%B_LH'n&L_ r$a %dbH#W ۡhpeeGѴ eDtC[K̹3HHDc;57t_&`t^UӜy68v~y&/lMIqZ̮3kI%CgR אŜ\,_C3yCC Sr̩>ǭ ji"Zs6F iMZP]tq1}]l}>ZxVo $&@"Y3 $ldHgw.ѭ@vg Nȍ7xHAWnl}!!cj<@Zt;w4*Q@L3Jb]zBGl*Q^a1/y:bW'#D:C7vRxިȻ 𤌼8#n47FA>t+}o=?W]*C[ AP%Try`qcyG|:07HT7PWmOC>7e&EmM B@× [>(> ķ/^9;+^ 5Z1g'jHM9;FuƁb؈UHv^ ۰#G,ޜQ Dd/Ri^ qd qmOߐ)(i>͒(a.86$Qx5j(<&9CP kteG0ZА:9|" (hNPa}InL\%-IrfnJe&GYr1(I}y:B+[DPf|B:F.TdÚ"3Igc86TgmЪs0`SP=;<!2)ٞ>o F_W^o)i49ʜ&k)sA~] \ɀf*]Pl#*79=@ҍeǂHtwX=ςwݝ aOtZAKϥ BC+H t %hJlI̊BP f{"3܄mSGs:dUz[U0`M-PT}z%΁`s@$\&U[bOS o]wq:v"38r8x8fZ63?"fE`HtFDd0de&Q~uyqY{en֢IMǦܬL~fd+U7 OAY_a8[~ e8;a^k5@bv,J x'3؞k>綻VTwkK(%oP'%j-%oMUr{{{*Uf"r{@gRy-9L%oHeQm O,' ԝ:LQ<)v{I$J:Tm>TeIjH-M,6*r=d:'`$t41N? `RYYބq/3.\o¤@*S-U aW-RR!-y"Lk0$^>B_x>QC!C$X?H:5v0VLKN؋"M;`ODP6gToVt'7eMR|jgOA%ėtJSm:95v 3,_.²O7(p`I_ $4@n`D;kqَh(18h5 0bewe]MtU((RJ_PP"Z;C ^@E{@<4Εcig5`6r½`EH3L^Q CjG Ts4ikl0H`{9ʽTeLYst!ķKхp`P5 2:=} *#j\ݓ ˲uIМDX@,5/ӨRgx:';!1+P>dp Jna$0-ḑgPuR۵OIA~CwDJꚓlK_^G0KW }PYYVA P2afPD({~P uDvtS6pv%I0KhIcAk1T,[JN-DSl| eMAsWgc?Rr5R,) BDzqdN|HiW7bP8T$mkF}VS]kLZESg_%gS(I=1nOPZUc.$-=Ḁ{K&~VNZ'*vjXDE  93{gX !TLϝ*( (az%rUFQ¿CFi^qRbsLQ OΩv+9QNq'!aJB>'Q_ƩzQ( 5`t ͂7s F=EktBtl8 J9l;8n\oJum@dRT1& g͉JSekR _uO_}U' *ȝ>#Tx 1*pF[RG'K1jqJ1C"tSwra֞pFO˚K$ .q_.\|t]e/pFI:PK#TixɄ3JuE==uLwu/-gW0 ¾چlp=, 5 N[:#}q#T戗& r K EIEy͍& wFO:v=c9;rZ"x@wMUcubR5v;>G-Kn- yv eW 5Pa dr-m $Z+9ji u<8+ձ{=vY´fGN q#;z2VN+HO+li J3̦ŽpB^21d,l#WuxG;md#q$9d|;YGB'Q'hRY/eWb! VB _zGQJ vW)8C{uح&M GbQZiRsƇ0ͪ YPʈ|*)YeZ4*Eӽɺ6s RhWdVb)%Vyh)֫W&q@ %08XbK*Ja =׸Sz(!)tMM{HuDzq7zrn4h1R"ȈoqJ *PP-N_(`հʸ6uOnmWyma5~Bڧ|\O)TeׂP®_fGqʛpS^ky[e5޸ʺ?$<𬲞چD]wdj`4;Ƞ19 ׌Ct }f~3H\)uoa>UV_sqJlí:K3RqVT=,` @.0~:ɜi{ǠnYqL9/ayAj=YC)P]]udkhgWFI45g퓄IS;}10iI%RDR0H0 h>tKN CǺ'Dꈏw pvE9 JS/LeOƺLA)ibMqV~! dZ?\q2 ;(_ Rg^E)-l\LuWEXXJ=!V'DEH% ?\AGӋ?}O’`> (4!?O Ed1~*4"n X)nrURGȫT}S#Ö` N }3"tHe? ׅ{ο8D)@jsK lR.,cG;^f ~8؀.tƏ9_4n=njXQ 5vsO@=p%{:l;KxT~xy2 ;A |@kfZvXS2^+z ǩ6(!j-LΕqN^R, K3#OxW كHFM+jxuD5ђ29/;m&1@NeOHuGiA-ͤYR_2qyH=1 ͒8,Q_%UYTc)p\_Z|Cb|%Uo @,G&$}Jw/woqQuu{w *OjlJimùj-Ph]~vB"@=*"6@"*YM4/ pOzT} $];H#Y̮~U>!%Y$jgc~H[ C2wLK,;̝ Vv2$]gq<3@<ƺY±l5MBnJ\OBCy?l8(Zr_;mrjPid{ ؉"twњGv@_6L() p$abJUw͂Iv[ VH F'vIM(dk.yS0z0(HKQBI^?O1qq9x,Z`tdJ`NUR",*l!@}<ďL]\u-qlNӛck@7}^r_~ѧť>Ӿ4oa˳ZKu8nv${z|iB>AAdhI9¿ϱ`(,4>%{}[qb-/e,(x_3O@tQsCG Ƥ>P^re~L/:K|ᇲsm aJ/ ЈuY҉< Rݩ%qOlTic:B0OVǪai0Ư"e=/ai֚z锓$+}U,h{6?V/]9Q-t2)K[N&kjN+Dvv*yŊ o+:n6/7KjSĽP[1 t{5o˫ ~5w,bOݭ;2Ͷ6G4P`|m` ƇDm|st:tŠ |ZBXG4ŠSWz-g:7f8~^Kr0 D4X@DbNJqa}_!b3t7.RpLجxv@5J7O<-vO7$G6N(gO/>tBr /εC\섞ynKchi>1U/z Ͱmi; Kݗ^l: Ý%:[S0}PÝ%; c_Udy*7(6(2ήaTL0bh$GҢvD@-/ +ݿC}Ȟ'n $byyP㓒lIܫ3xN 0Z,!p4=-5jp>h#ΜoE};h!EɂVh!AKhB^jF ȜaZ" |6&kyQ/z tڿA$;v nԣ`8zs1(rfFlh$X76IxFS^ 4!z碰H\~*{-oX * ߼1aM#Yay)r7Fdx=9;dB_I({?vw;A4MT Q({ʩ.󦿥@J㭿@OÎȳ}8܅؏/ \P`: afΨ< :D/4YQG*r+uᝧX 6(bB-j S[J@Aa>2 RS5cX:~=U"1t= dh<'s"DJIkj>5ΆCΫ}f,h\D~maDBc?ߞnq]&+sZ |$|꘠# ,rB)+G:0JX7=jhK8QŎsRœv?SvW9cɫƉ=wt&?-F8ޝޡ }ɱ>+4I2d2UXbPCN+x(M{o TeC,&Cyoz_nFӱqP|L%`L/5E$lsL%E^O߽@m׿. šD?\, ̯0V@ړ[4IxxwCrkOvڣ(urM4厖3)5teKsrDa@s6V/g +$pTF82Wz]^0>ٯ!øEh@}-G[;rw\Fe(b.g񀼲v al~[(".-z[CBMRuMR):.ws _@Qbjs$ۛ0?9‚wT:疗!B8{$ĺfX840TVq>'g𩢿0ZRc S)3>5\|/ u)p^*NXc~Ώl [OQ P [8xV gC)iqvG 0lEp.a.I8-N_ 'e ][tme6[%-][(Ik Rð'jOлQM)G5ƢM)MMEy߿PćGjvM8uZR2\pm nkSEC/W'0!s/ 8ugEU~_+%idϤ7]JҀc昤$:̑']g+0 4 eoGU en/{5r*]^_WN*3LpLz,W.2cà3<б:tFCGJYA3LL}c*!&XSʂˬ'Nak OfCpy<7zr[h4X{A4XPsm3[Zjg\>nZjX7SX [ܺ1dn@P^0vm9 Jvv`"HmGosA6j8~y- ASO+8I],1t,5NK\ r2|,@ ڛ]ƺ`[/ߺu6"jc .Z7r `{N݇x! SB,%5I8VyRX*Il1'Ux_9Btgw-IeR@%<$&1Ңq.1xNe13({) @~+J4 j1TP`% g|/^%VٵI2З *sjn0*ioힳ![o3|9;aԉ=D",ΏQ ?8JIQTNn}?ТyXL)-]FЩTNaӹTm)P hgn8 ~S/v-^9`׍Idn| xq m2a}B\8d)jD/r%! \q֜&hO_(mLܪvmDigQR謞z1c%NfQxNQG0RqTYq=JF^կnX~n,`kp%*ƠJmY>DsDYt =6ͳ<);$ A_Iyu?۔zk(. r Oo;4 CߒT4fu:;WcҙtlLW[b>Ƅtv+T-]YT?>m:V}GC5Xš":nXq0ǒ|K5S'<@|ck*`-\lk]!VL٢L@IƎR l+D/oN*>o AG׃( pR;V2& / :Qo _Qө OsK9oʮ aI6inp žPؙ/Tu[x#P4|)@{"]Quhl>J$B'iW `v$! UniPzgՓKeMTIqCLB'2nH6URLCe 2 #PW #K}' %&ZLP"s^tJt|n~۟ס2n,avyxYBhg)X?Jk(-)Y +k*&(? %#-uǫ@!4P$h߯0 °RKMZcWe-a4)Rl'(xO}OR.;Nڸ-먍wAm、Q? mDp\Ký؂58.9Nq`=r@\6Pg=Q:DRz/HO?|>Wh'ܾ4\u8ϪugYG||m ]%'T`\[#%%.bi ^0ޔY0D/֏*v >@P_U6}y];b1/U"Ofc\ 1ŀa̿{x0 RW|(+M >C&o/CSPemj,'bPPN67 5oYN+/tߤW%]AIm) Pef54R]L3#X}av`~NP=@\(RQ([d3vJM$M;H#Xa=CJְQW>GFTQJa] L+:@u2WuӵV8b:>O1`ٵ@ð b4jS@?^S.O_T59}lticԭÇw"\ RN%;:;Pcj4ArOӖ-Ѝ}.*GZQHQE9)\KL"|%nYk,1I3|.)Q)jOh)ӊo0SN+R"\-—0:hO>ѐ'璌\͵.QEd|%^g\.r5pTE|RAE—X 8ѢUP27=eb0ѕ X+ 'si,sXŜK!<WCq/4l`.L Qf40x;gtb\pt0^乌R^F٧'".eΧV%X }ǰiЁ[ 4 ʎPQ^:.tRL3Vz*+EH+iE25GIB;L6Lr/ D|$y_DsL=HE(?x >. hd _cH{=dFW}o:W1ܾk8,Av z%Mq7xuiBm,J1(ضXl_Ȃ>Cx\@,uֲg૿9QȅGDjyeV 0m E8*J/n Mॾ<_ $:ҁUR)a@ƛiiA(orpH.~.+ 8c} Upʯ^q)q.m6̥DԷ'7.\N^إS#i\܈S$7'tilt3jڷ$%_J)^c+!/бb3./vwD*9wDW0n1?n+8)r J@ r9waZoe007J[0)i|QĨn9iB5:_S)n 1RJ:RkuePW073*o Au @tPz *m"*W"4A%EjDD\TEZIPr@ ҊafDT$pu$iBPn%aB '[`I&ǹ]&?6MSXF_SEMO0'N0 N3sP~쌒 az%))~hW])@0VLJKjf\pM.6*<]@LPXʐ8 \}ЯkgtfKH3\YfK7 [V7TZ/kLJg;0|&CUKn{٣>PW =qɓV기  {"@Up1ȁmo:/ᏌsG/fLCG޶\9Jq5i ]q賩y<uC0%!C@ 0tJ9䚰HE|G!Ng$07`=;17b'`%(=}F6ɧڻE۔=cl.PaN>E8~F~x-h!7FCȯz*o$ )^чKtƂۅaPcCp]@u_~ > 3xTV+ݛpg*Y ʻfFr%Ѭ5?)hIH`[`Ng)XW> rsSb|M~);,A^Ipޔ(#O%?W=d 6N"^2SV2}rO" k&$l>P.hWOFF-EpN?mA(G >#Fg yA)߫}mTFY /E{ŷ< | 8/$zG88/;9 *,#p*qr\9*  hhe+5ӟ:lEN.[%6>$5lPEhL{)B:slYъvr$'$2>$%QA,I b"'#d}&A2{j\eAFfF h5b}frC%QXx=Ң! B!rYx%jW%.[OiyЇH=}`{Gٕ0 qJ쨐z*uܷANgQ et hɑ:^0ݏ꤀G=*UA 3Bs*֣3]Crs= P?wAJrWi:˕ti:2ݍ$4$ʚb[$!QvhL·R@*_OM:k`*&9Ck`boRϝ~ cCS59IҨ ӟE Q4Ya03R::{<竎NԕMvPvq7{5G^q75<R?OPsiB ~Br#*M 1~),AvК_l}o&k?`W0p:>FD47>Y9zRsJ (|v" vxF$~W2>4>ɇ2 ;!d4٬K]Li- .̂hGԑ ¸hSR0 pPn`|D; ߴ!awڗcr_s5p/ ..r 9QQ0pnN Sɭǧɍ$*@`tY,$A{!*ʗ,4۾Ӿ*A b+;AD27`udaDꐷ qA;BDM"l5?`Z5-`U0.,,_Rv8 RUj운̚ 6h,,l=PMoV YP_ EjSQ5?TO1N]I5ԢȖjEY3P[ګA͵BG ]n$ॽ:_C ɑ+|>p exMXcG3"j!{tkh e)TxToA,lyP/y dy IAUh>RT7* yz%3Έh(`opZuAu:)jAf(!']]!(tEдQH荻U#ZX=^<'J N+TŖ0 =žC8(q._PPzѤwC֤!);a^ XFX*٤ _fp~qB] ,ŋܐpB`OA[t I7s@kk,uE7 xއI2χNk\!SN|4RNp+-­\ 4'&Gpm7$uC\\ 6 >(lk \Et 8mT,1qA&o]0BC}&jC1B%n!jc0jRBYcc@jRBK7$:n9Psa$4 aYPA}-=i0ȯ鍥ؼNd Ӷz Ram4TA|_] RDu&\zT RqK]d7W0!kBH7PUGkڻxP@k&7t㙈Ul{e4(M)5(]k (ih9\qȆ#mJ˵^YЅzQvjsL i ]@:ƪC5|j*vI[q`4K)8D hqԡ %QcytӀyQLTtDCڠktU FGoux!x(;b\ryX#]+A@ŀ |16`sx 'LopU;Viԩ(ď1>\w!e۾X& F<00!x͞EMhK7gΚCiTd QFY?ⓔ%ZRĉZ9m K}sv.H 0R#/VN!f#fwxRb:T4MQcw('rlo?+;ݣQ:ISmKl?Hm{CtL ׽.ȡ7Kv{u<{Y__ǙĒ..錡~K>?R(R0)[9d%]$R5a ]eGMT*;b w~VJ c AUvw@9e #),](@9] g?Qm&wy_c) Z%o=BrF1IgKEuAf)?]Jؼ9ARRBlبtM cuȗ~<C"|LflݏG܏dVh}Kސd(|6869p RP!AY/FwTN~^N ӌz H'򢹶8T pn \Pu3n?jŠU+9=9sV!|AN3/,59lC;.OrAUMv…I1MR|-w;MP  gߐ5t96T(?K drsCc'[pT1W^i*TlJ@JR[_lMaFp/`JEKf(Gg~ߨFt_2:ёu%-x. BZnDxэ sF[t;'%C ECgk`'$AxAKJd?J B y..Py4fʪ]p΍Rn7J P8Եn`P8Q}O08:&)RC xjӁ|o*,k>ķ>voqDŽ܌or|ZP cp:QnxIEL%N7mZu'Y:7׃zQ97.gg0+t҆_P%8|Bd/hSÓyjXAd,w)32ȷbT^ ޕmcOwRlW KeZR*N9lnOi\h,̂:L EΗ*@KBa! =ӍT> kdvfP%)uK95& P BٞkYAX4v'?UrGd[HZ %yxׅ$IYh>8 &#y ;nQ];x=莥;o}@ ClizY&: 0J5&aO"@QU|3LLn00w)շ!_*xv5kQĴU0]er>J!.J(K$`AWB)7}dU@>(w hKX!-e2]zU}ʣZ0&jFmla $Vދ֞ Rb9;=&Kb"c%9c{`;.ɑE1.]JGE9 {AҰsl:UוlUua<ѷdMC FĢM_|2+:N?y?ۨ~g(;B ^/&-lm"-i23FW̋oR4Oe?\]|x/-dgtgS' _bQ/>}?ݤU;ːaaOa*l2蝆 [LzznP3M?MP}MҺN])+Gkw;^?JW9Q5n$L1}zhPpM'nF4Ϫ[%Sf"VˋB%+*rB%R,W\緡K4f>c(\#kW|8`,kf%&_܊BĢt>酤$Q*eN_KPa+$1b9]>o>9u-G8 TS7ӽx"OܧEo+R%+XxRsbu2hg"ѾJ |NFC|&X"|.?`p鎃9! 0aIn,+En~FrGL.XVWE:J~$N43=ߏ[3$;ᢟwf zX@+?.~ J&)Gh><(Bm*{BspQPas>;LVߜQ C&m3HvL] ~\ "FVuAidҍ ^9ɚX4*(]eBM@E5Ҏ3Hē{"$71'SA jѥP9t5ہ x>MŹ [XJ!zںP?p5 Cv¡F( (9*υH "M(L$\DPJU\qA ^?9iP &Cw36tC78Q>uw N }#ql^J[GhkRt<*ЧT ~˿hN.Ki2.칿y~>iG_Ak)pqL5 K+h_Q DdǪbM7z&z]"턬02-Yr?id5 F9{] |UUEeKV!{EeE%pqpM:8@(/j7 8WqED"cK=ڃRz/4gKEKKEj)\!B;2:BDQ%V!-eVpoї7 a @;dtq7* , 1H(Bej2-O'%Ra՘eq+Vbυ >M-\FZ"Yثw"dvNJ"iGי~;6 N4/ As?0ԄdئNْYLB}* u$"@X0"6 ZC<*c×y:4q}0vjׇZb[)q\Ԯ'')SgYF`..бC }!OO oCا:^䐏5C*U ou6^LKZX6-|GZa٨&TV6:D)lߚ]{v&]pOzb#6{u.-eF75~舮N\SݏOr=J⪫]gD"= pARUڰR RkEi6AuHAy%Qtc^Hc6 p+T.p։]:Rcctb\4dߒ+ub6% -&8/v !s\R[l]D u{cI*3U'Tt |MByCuPD@ y+̵Q]E0d9.ѥh..jK}B2 cu{k8qU60`p~HYv8vGh1tַ؈̺'qaaK6HKj8vG[KS3+*H. /m4S`Աq=5:0tH=1+lxۛxIu+6n7oʮ%A^)v4ŊLoji(=q0cJ.֩ E1X_I䲠ZT^eۻp}7Pп̚%0)7, @`]`a#؂Xt01F(K#\\zACLO7{qiŘ#6G:ѯPvz. jmbQZ,k|^pX^|-: X7ڠCÜiDYrCyZӯ|ͥ^HyBn|z! э YL^ȍY.rɎ ("gl3L80M6n @#) ㋣nǭ\:lYn3ռpvI0KFlc`\mx(R2t%n:m63ꍚD?Gybd,F7gG}:tgcb]7zCȚyQJvoz7̵ߺ׍|JFtJ>;G]+>ؤf=Yљ"n`cEP_>``XЁ :R}sʵ\~QVY8P7 m RWb\;/P6%g/Gq :%E /9mn_ɗǏ3:`K `o;PDF%,l^:M+8|m?C^&?Ui%}%vJLD]o *Z*k0}IIEqL_ *:gW$׆*anC{jץ=ꞏ`7<㢮\IkࡨynsH;O)!Qwg+P}0Vz ZB$Ѓ"m 'O 0A-1'&BEY[`"PO2Bs㍱5m\xci0_x37B%:݅88:=qn582Acn8_ ux|"2AUTSn(_ƣ>- tK9}r7br&œd\IL[ʩ[Il*Ou7-Sy ZE-ӆ@? [k7% rI; 5ꨤ$& 7 GwAPeH\?Z/,.tI,js ^ Dd!`hZLP;W:-s䡤yIu ^_`q܅uϵPbVi.C;, W3hTBЧTgz.e>]]#e֜qA'b:ez.B $Y@WnF+C ceVV?iM7,B̗m |-}BCފ}EB[V-}(-Y >U#YՇRښUι;C?;~Bz5;J@\*(~Otlu 9ݭ W ۤ#j $}y(#mԜ2;m9CewZ>o.B۔ڔc;ѽEM9VyF¤ЧnqalC@yA{# ѹ`?mP$F]<=-z 96Xok$F3NBi68 9]mggC!+Mtsb?JȔJK?8:i{@iiV}F}#%}]v(YP'#J G!7xAu\J-!`Dǻ"h (ON=@]a8#.eG"JQQir]sϐҝ x$8 DCfu>Zd8eVm3~Ka.իZO.jyHZv{{.uZǧ7q~#q|zԠ$8JBqHI=ɒP,$KNBAIg00g颤E});$a^)u~$O^sQro( S20$86OvYv)ɮ12= eDVx[7X(|0S@WCqLQ>(tLQA0toso5[Vs  > A@v m_ȺCaF]R(9W] ]2A :>.CM&!Ǘ: 9~ Qw'SΥzn a(dF)U pF49@{ew9 O;} n q}h&|MKb&"f$f&x(ѹ@$vaLV @@o|n)qX-u 6hva^i+7kT0ƅ𖁕 P\Us'"f">: %oE*[B0C̀H g(..0O)SU5s;XUMs; kV0v6nTmN?a_ZM=T r|y/;H`_o%nbXDZvD#Bu] Ѳ"~H\hL9@ LY5j'nCJTʵ72K!DsM 9)N/dl?ofZÅ%6坋^IFHԱlIF@C3["5MQ(յԹ7:V]LKv:/] {l6?{۫Nm,  &i1wESsSƢN=T>ͧ8_yŸşO񛽹=3n3@Bb(K,\ӽ$glnvR;f?IZrHe"}"wvD1*~D}fsk}qmd ygTl15LtACƑ ۡ4RA)pPX ML#sp|f˄@;q\1̟,1zBO/3SM MJc'5AXnPƚkSA u<*==as J`_}}RPI+F8Idp̦yT@MΈ7U33sq3JlAJ)X#ܥ C;~Ws Z$nqPE4VvL/|w:uցG pPKP+4[#g:ƪLIfCYf;N2CtN@'`o۠tX;~hCӞZ$u(xXkZ?AJB%VT/3U7 geߍfa j8feyU.[b9SURG,sh#Aq:')zckltہI]Es1]!UcG ĴU:{VSb!qj}JX(1JcKrAz4isvU_WԘ^]*QcAР<%+isSٰYΖhn*_kwAқg儎^$.=.ևc>dWܚ婣zeh"ڑpyGʐD46nfSQ7tipquq !/&y j9xhr)b) ʈ?u"]_~uU Q^h~UD"WNK$66FVČ 14`xOd@P^]*.l]ɮRrp%&׹w?܇8577nX '˾"{`jX=O֝W"ek# (=# zYcg|L=ώ%yvYxN,\zn }n%: p W}PCvr fBg?B*=lFaxϤCCJo%k~ ]n$JvbCeЇ;.|v߲Qj^y [QvaeiX6N[ gMeXE b4b|lk> C]xQ㳽}|Q( .ے 9,D^xRˈx `BeD QvF9 Ҳh]GycM B"cC|+V ]rF9N6%lh"w+u˘mbT}-yw1 /ܢ!T{ y0/P\/uYz&{ݦ !jQDACC񦫥\[7]-eΰGG> c>nB?iި;w(n+䛭@wojx.MWjma9bkubg mp}5mBGUgc ~N-7NkC}KɫR= cRpz]O2P_18]t4UOs'T+sFęgU3oUWޜ#ozsv8 ҨҎ_l&K7SHU(N" iO!?HC (5z!<_s&hߠlКC hm'G\m3.SWa ӷ24pS >'ܷq/9?S!_z j|MCh;kJYPuh߿4ϔj{s k\y9: ՍLR!V&]>{s#SiON1HxK1H盞VHg.kω~3dR ڬzqh2PT8LeBUQt|} 6g{~'(;$A^kab,lLu9y6ϑp Q'w_݇:G$uu\U|mI GxRb0NEU)07OCm6y(-zd8g0UVo2C}n"~C!F_]*e Fe[NM 7Xl Y:@dt䁣҂6F7d&֢ebKEB2X˾"cz+K"L:eKtʄhY paz%@C߯il%@H@+ ::CWM濉I .mط>T؅|"*c]91CVƺrOD),E!{ cca<+fV1+Ԥ ?8;Fm@>_+X3.MQpH5[>kPE+ȅ֩} ZdCO*՞`R?Tlh 6@R#mor|Iޚ,_/Iw]dB~o{$Bu?K&jH&Lvo3 ɦ Ԇ ԥ1lݚd!\ Ax/tC 0_$H 0_0P pA(zU[?$hHM^mWѫnO%\s.Y] 1UtF3w17(>w1#S`F by R]3? 1d+?5GcBg 6:OK:؀J˲hH,Z*BY҉wB$ upb ڵmÉOKwmHcL\^685QjE\8:^8kKy ^@u8k3%=/-QMb]8'Lқ;w>-sZ@oɦv&(W˕h*?IDWvרO )z^FMT!Eo۳ljMfݿ);$A^)BݙGYx~ P(^a82m+,]xmfIiyQ&iS(|f,qzfK¢~yb!nB=hy_?z3"t@QW %~= >+c$-X,tV4t0$mE\b@|.P:Az_/yjd)q rA `;Za6UAo E1fYy5J}/G':&iFTBj9=we?mvŽj@uNWZd 'f>*PO.S[7g0-%8%eAGLӎGb,$uրw4_ua漇Q>"$sGǸ}'/ '}ҶO?"Pe}SS!$[[ Vο Wtn^) 9=@WtJÆ :SrPLRmR.^\xb6O.Soa;|IW{0@b4W\>B\,m qݹ,Df6u5u~ 2x]m> !U;1;3͢_ x̃yq1s+̛m ۦqgNY;}RC?\k rQs|i:\oA k#2Q! T탏 j#Qbz-5Q3N]2ցۜ\?6y 6E -yxD(9ڷ|ʩm-.k8)lje[K")NJ,+ndb䆯_M_:`%:晔y*)yilgkqx'X>57ɻiGviK6\R҆k"Crs ( (h")䙕g&RbNR)Y(BqѧщeW,1®"b}.@Pg-$!=;zsep@!iN f'y֖_hn|!H[ՅQ@N!ń-N -sLEk^-˜UI,(\a8 LaH5Ѷ[=l"Hv 9ج['#sAa6Ll-Xaz>xΩ:QLQkƚ2 ƚRMT+ I z{DVNxgo7tjߴ~4?R٨J8r1oǤT̰xO$W 'Q|>JW^Cn<p8%2#;NgQgrYNgۏq(h[yF<}͸ @y~&*Y&׻SX`1W;gKRP 4B:ZDtxP "YKYh!cVaJypN =[|Lޟrv.H 0 ڙ-&z3Y50'DJΗ3:\3(m"W0z|KK0R]*D]’ִyZ2zK*-`~"~͒|S(dI(@ɾc<lQJ?J7lࡕ7̾| /NP"X<2؛];ɡ &_ O>O\W^N( V%N=%behRllG ' 7Fhrj՝]}er 6 %McA+u+?,:2.`$Q!/n}Aˬ1  d%dZ@@K[^X'rxiXYdب.NĶC2we$9rXJ^1x✃AŷCM! s[wiÝgiP=&yeL\:d#*n̔o",aq7Va-%y"t'քC3F!gZd|Zw ZPSX(~.TX(dոjCH$ NDQl`gbFT9=c5,~2#"CCwy7ǻK-``=S38m p(az%&X&` X2TĺӖe@4.][|\i->KtiqR5@o Fۡ@,Gη(:* q6 +~X\>1 wJd a*3J|+dFi@Tf#lߟ .$X(&2PP+~t!`eP+8L%}.M1h."io UF-{H破937X̂Q`No{At(07iY> t~fL(XJKK3C 'GLF"g@+y7 (z(;dA^)zV߶M~ 0һh$&rB NSo"{4XLb:ki/pҼ}řg僭N*aڃg1y3նO'VӞV\cG,>kmr}ֆm$G@ȥjK'#!!2)MKoEd[=bA4vzN<*wT\KMn=6n} 5@=zF[^qvF7 0],_%N1rλ=\Ru#H͐.!>2lgjGgp\Bp458c) OT"K | r%NT찏pJ6W Tӹp sUA<tyfOT4c G]cB`@/ 녝9:ۓTIrpL$%}n*t )P%%eUªoԺ(ciή KH0}RXH<ۓ EAHsC @Z%tYڀPR:(+9xq{zHc'8tj)#u,=&>ڞ  KkPË,ThP X3'rMC{^MUTA )=+1GPKX%NuTQ<&|^1 =r36ȭKv˭:HvmB+)i!mx4[aoZZyki0/f6NFcr?"v8EHi;6ՋQĸF5i>A c#Tױ.*|Uu{JpaؗUYA0mvp :Zڇo:GڍG5/Hgk5|- lK VėﲪT]:Rt]9EEtʢʓnRtV_Gk II};.Is/u2ZXR[T7%Je}ǽ&^s٫!+R RV?=+ W#M o#zύӤ8<h#@F#u(uuT?aD4QRq|F7 cP(]7BSVҮTU nWޔ] {nul 6>`JH u > aclqH|vFqdKFSH;8R?*o_WDȓ4%/-*uh|UAP=ghأ?DLI2rϔDjL= h=)"R=d+_z!);s(&/d:+>ܭ9nK*vOE]+vOEu寬x}Q>UI=|"['穘fx*<𘧂.ʋ:4 8͏J<߶B߶‡sKaHqKұ:h+%9k[Ddq==񨸫G#QK yU Azq~,]Jx+4.435*7"5Z,6 uU}O06}MpYUǨA+cnR $hƝy7 ZI0ģ90=RLG\K>!CvP`8PVFQ$b 7d%0Q ;d(09qؔWpdArG3~#›53Y.#)dm3h$-"f~|,<| ۣW烫\5[KbQڶbI?GٵJ °JR~/;{)O8 vb~ee#YgBp@Xj9EmmH3G%C4ܶz 3Gion۠ dRG' _ :.u|c7oFl_FF3<'=w'ƫ?kja8xE˲p|pס\-&%.x¤ȽIUe78]gޔHEO}"Y)NNaŗNGd`yO.+)=%a-IeX>L$h5E׆~ETC-5S"[K`]`RZ:o:Yek䤇$:~WJR_HB+_] GkynMb;Z[Q2Z +:޸ 'u-&o2Ogٸuoi7k߸f;+9cfiea:{MAt5 XPDtMsvI.3l)E4lL$\um )|J6@\uw|l ^9Sb4'y62YH:މL(#F=@#BraW/y0DZ;vB>FTR^#d|VEcZc1UPU6{by3-[ U{j%65حᖂ舯*`[YSV6F2GL2s366sRyS͂s<"3|f!cNrߪ 쓼 ]ƩKO8}Qe iuy(APNpb崃Q!geg+1+Ѳpɮoc/@%MeY5Ћ>t&{/[XS?MzET~ܠk47(=d2?8+_Do(YabOMc_ާj+ԅ;EҚ.]ذEu1jFѰኺ8nD6UCQBoyPl倗0ZEfR` Hgͬ_a(O^H03P6sA$$N9M8_u(h sl _D꼺8vڜB6 dil(/bC_*JoΫ `Ac?? G[ma[5km^׬C;5krye|7n謐4s7tz]NRXv9Lu64 4+.h 4)y1 QŊB|vJd`/w&)==?N E%@hr͌rUhpfMɗzܵfR?'#rn־Emrp/B&ɍ8)9T7uott_uE R˸~VXzV{y.8C+hV#}Ͻ|4Ɯ] ^٘sv18s8ӡl7u[:tKM~);an_Uޡ*dE(`>wL12uHA"׹2˔Ĉ?"RF8%r=^ĤP8$WA+WWmsu(qФAޚ{!ҥAޚ\.̼y!&v ά3zu,^1<(L@@u/n  |G@,DQ 1bT8܌cv@mjh2FtPFw`ԅ YH)-q1F *ːXy#eH"qJ(pxpJ(}rH9ι |a~ ;ۡ}=a=coRt|bɶQΕrBGݼ#RG oS- \Նn!n`ᴁSa`i`kf{`73lFqv9 u.3mĨW&,U9W,u-oўtU]=]Utծ} H tst@]5+KB 3`^Y X⚏ KHf?% GٕYTWX kUKX+0H)bgDsk%'u򬋎rú(:X|f]Z⮏9pDN/]䴉n0 9mT8ćGiA><*]k BWIlI#Nٓ3=#ڟԢ{+ -O֊IԼ~%/m 5AZ$ҟʝy*Ɲn_ aWJ Ѱ-a;YxI> đ;S$ER}yuϥ1TKc ubZo(\xlT J/Ufe(//)V x-"r@ZԔ@H"[C!p8;LF.G ʬYq"̍oflie mEFA!¸0ԧTDJf"}~Jʅ[qA]$B>&U>h*[o|\V1ҬgԾ lgկ8 F=銽Q(H-;냳3ʍbCk]D6/A"P\<'{XY׳#_ sdX2YQx[ 1!dV;9߿$pL )M1(z]A(L̖ܓ#FJMx># J (o "GUX3> 8^KW&L}ZTחKeؤחKUga)=~ -3}w&|POl&3ȇ7}d|, J6LR RlOsX\y"-d NA 4'p :!,LғD!lrEJvu*uB)qw˜]i t`* *w^0GM\ B=G*>yX}L}Y u4er6ZT:DͣF6A2Rf]|8aR i_Njv܉`PrR;Y}Uk@<@UYdI҃lo_d*,]ټě Z6r pH'eO,;cqY|<2w\)\ GϸTpZ+3c3>@r3=J  ]du:\VYNf#:,)^XM/%W w 6ozY"+4չE`3WJ p Ļ Ժ>lZ đ[ĦJYzJD9ְr|xZ0 @p%k(d2Ϭ@!tYA:|]A«"kEt5z6R.ȉ:޻@y߄j R/p0 L鶨ب3W*6jvlts7`Wp//-7`H @M f>`&67. Ħ4.Ң)"Xd=%bULصL$''H d$H@#A{Akv&1f xlRc@ƯcSe i˘ܯr蛳3al_l*d{b-)DUW(z t[)Ĝ/FϔN|c@3<*?7FV,e3_rDVd59]3!-aLQ )W88b/C V:bJ {7L8wp~ Op]Eຶ 8Cʄ#=26ZOC]Plq`{mI8\󚎸PQٹby |Fh~fr|*Y037v'mW5}'Y$Z]p.N#JF!\ή-a]@/I%T&o?0BUdzjpF8O *_fǹơ ]9Ox ޶:<)uCIʕkEiʇ^yēZQ}W~A ]bݘi.sw-݅ʱ 7Ɋk ?_5tNG5$;P. 9NG5Gn%ֹS`T.q eSORnO7;H!QH YM{?lqԚwqO&|ٓ>ٓ'Rv܅5v<1W$/;J> r0Cd/άyƝXXP$/@iBK,Ե#|ʟo7.ut3"m!ƄK.}*]7Jp4z^ GPBNHjNNfbnY#lBI Akhhѝ NП?J6bc"HTG A:j@(  Pհ`)*jaAEf(H nv@P7Jd6Qܹk̨bxX;VȈB$hq-*K#QUhɣ:GUwE 0l 8$Av%p퇐0:hiRkNcǗCtTRh#7r/p#'.s\QtJe+V~ӕ[K@TQ7תEth @i]24#1 ٻG! l4n1l>TDpQ-JzE[+ 1T/և^9}Qrٱhޙ1k`Q䝦Ąk@_cDU@jQ6Q*V`"l*%K;{pBAɻ g疃@C-90i"K!jhnO'1^I"-~R k H> ᛒyHJ/ 4 o$( +IiVהA[9]lz/o|m dMRnV vdKچK伭K C >rRʁ `G·@Mnj^ ьc[*7k/aT֥tS?(U:pWؕ"nrVe*q/Hg aiRL: '~&mw(3aa`&u@C*)NR)`N q.eDI"P:Q$al̜?x𶾞j&@jYO5TSM ]MˇU V|Xm1ﲉnd1g||hr/> P6J rƥ'}B)F0he~(iۗO@ܟI9jbc&]މi5UX1ܳ.?DS!J( ]qbI,tE[PHׇkKaaWxKZIMXFd#&%" '_|=5Wdjo~ *+'] W,pPR9Rڜ)nPKm\e6gXʒs ghqEPJ 8?Igh MRp'߭+&jj]8 (+ IUOqSJ@wG; VôJpa*JH(gע(qrEwsF@2кTb6ݡ%Ra4$A&ҹT jY ݏ3aa: h6pWݒVq@S3}c3-vS6V2ɈN|>dM,ΈnuL1^Wu{ћG6.ؕD e]af#rY/Gob5IT]]UNLGYXWo!V@;4ܥ^m[vcof6)q;@cB(JpdVq,Ods2V|n^BJ$kj7*1G4ҦyneF$N֚N j 0Y0geKl\"=;AIJG (] {M=HZ`VJ.\[#Љ4u|-{i]5*b|J]kT֝SgIT*k(-rP/U9Xŕ!C_xjsQAgKRRmz^ m >z^u9Tp1l_ `KŽ*2wYBnVuWZHͣY*QBuTɘCJr:(;ҡj|hY"@t, .ҩD:GH'uv7Ru.|#\Bzhپf%T,Ez tYY YՍnVg нwIRQZ=Vhp}RvGp>kJuHu hUP<@EXhRnֻpw_܏Kk} 6輫YP/ݩ~gAV}!lM;uTmM{ښ۶ )x1d/mw?oJ%FVUCl[]Zժ/GZ<)c:)KQ`zIi*ng]T䒴6X#wl+CQ[ T^bgӦ N/Rvm:C2ꂓ ?ʐ[ L:jޔ.C#RbQC],< }+yoiґk\:W:~d./W:~Ľ~4Uȃ }O(6'P )TZ.,G"LY`Ҧ8&˹skI+/.љ%iaYL4I&/Kuٹ8 @J`[b+G5:*3 JH](vIE.xҩ8M 8׌F@QWtF7ި:V.^bcڙ>IW ~lקb*0xСG _;xgk_~Vl.yF 78 IO ,GbF LNbND3jEt%oFz@7ѝ/ʡ3}N41Qf\GK'NI$'Spp/f+ & ahNbjHN\KAwucKFdz`˒F[Μ}ZF~?]A@]fz$Z};Z [Xle%{JʫX%m~۬☮"{O>qƧԏȉr v$r}qխ_֚WPVg7Аs_Am4A];(tn4(,h÷=o,hRp ;,+({chq݆͂vP i>4z՝^- n7evk?T5bн_9F>K`|^ U{-rP 3r)RRAciA:WC> aJ H= B9:\;W),'A K7㳪S i 7cߐ|Xos*lv~rV;Q颵~rj'qus'p :X{b_:89O*fdQF E-ucӸ=HܶدlDhΏ3mLIyAw"'ƤcpsՉn>07FNT FA4ANݕqkl} \i)׍ƘB#`\7Xy7`2EϨJVAԕ} |Hw֔"uE! QW̆jQCckQ/PY "nJ}}˖{ڽ2:_N'ʽԧ|c`TC/ϲxw} WF}{e"uGFe֟@p5--TrhJv%)٪ó;~{q^Q=J\gg0 /UVjX6" ϝ}@0 HL _@K&.ЈҬywiui3iOQUv_/ J#t|!.JViM=*3Ѧg7ec8˿٣b'r|q £."R <#!+I0W=*IdޚN5Σtf9;Ù(Z4 +Ւi ~ Q P]Lij/xv!.ձz3r` /`(S}On?0aҾ'D[Ӿ(v ;e`Fkju/b-%}$.\t"^1FY4H$ $1/E&g5— uy VQ$r$"o$$ k6[F\θS6stb6?AΨ Q 8e_?ץ.4ԀJ'Z *Zؔ+]\ ,r=@H[ȝn\yigd"0sk.lj@Ēu~C%O%\5 D, F)=F^;wj/>s4-}b6"ip u`SZ۔We~"J2>ru/eg0+}Oft5k` +3-5wnĆWHI?.xZэ:#qP zp`4E6SsG4RM.|ɊZ@UhnU d#p~#R_ώFDcu7h\GTl'ի.<+{ 9 ޓ̈́M{8;ŸMgR_NDR=1QSAc` SY60]kYF?Zsx d$S7]X 4F`HC7X-sZZ-sm2cl@:,'gW0¾YnBj7>k ta+ ^: K!|Dmu֡lóϳDZ(MUo(`;?Z2 =~=PkAKIA<'֎VRܞ ֓_JÐV I17z1wԡQΠ*G)FNl5lHtVP \+U{&OyO(CE~tτ~g2\0?"'āmK.FlHHObWPb Q8HKH $訑8Q#A/XBbC5QS97eb0 љ_RU޹u[*RjBbJ7> աKl,-J(EKμIIFWٮߞE*ėcFzi/i|ҽx+T)Λ{W@Z,J4"GZiG#Lt;wW,Z {VV Vά?!]#:R-C[(1SRԜ}/PK9^}&~.7%Z*7%W 4ͺpj"^6f/ i ~q[pv8 RiMӖsLHQA`g(Z_ &BG6&&uGZ>8.]^T*hvb1N6¼3.>6n?1 ¼g"T>~|§~ > >:*^\㪼Ոuqg(V-.L_`9D34ץ j Jg!N^ҩb[ w[2 vU~(LD,ݺ(D P|D(2 W14@㧀dh4۰8V&MmXk)vFnZw;CFGx %kVaR<ޖq ^:Þ"˃3aaJ aQhoZ7;HzM^֤gaInj/QEu;t۹G!#p6x2TRܚFpltG'QnnM G13E7$Rcg@wGFtC=:G.d9 Ql~&swP0=}߿2C$woS|B")KkkEY(QthŢ\*^ ra_uf`G.-`vF|[k; v/B١V&_i7Wb@}FԴN|BMC"ևkaW>bDiM 4)Z=NR)iCMqhI*D5n κ^@'(T ~cN~RE/tu2Nc6ДA*21*Tfd݊0xTy)¤&sNplku|K,X[2J7ôs {0-k*3xg~i)q~63k(47/3H:ʪ 9@PV0wu&J6-h>JY RDT(~'LI*a#`N/+u^ށܜ^VS?AWJ"sթh[h E b׶W񣆋~f(ZP KǘscV='_}QHX|>]d/Q53@mDwR_s<|O AmhbT!(X u/_F1Q'XAe^~'%Nܨ KTOX.gtUXZ*H.>%CAђ16*mF>g|G4>cF]Ϳ'H\82lkݷ5> #..W:Ø>tI ʓ9Ӄ+@_*kFY:KƂ;bC R-CbJdJ-C:!zt\PPjjy+z o'ѕTy4|Qͅ.٥j.vʧ˶Vs9^ui< ֋A2GEZzeڴP?^zQm GmF@z5]at8{5>ι"܁J9QE-j{IAxu@/twUQ+'hN-U Zk$tSE#궵-NyuZ@S8>n*R&W_a_M3H?lIVnCr]e,(47M_ .#Dh\Nrʕ&!oⶇR萾7=" ԝily@.P&©Ch)Cn'P *',,p%PozKf0Xj|Z(qK>-՞R^<~OEyğgQ5>VV '5VV*BA^: rԍBQly藲3:䁑 -tK靳$ k )888ة4|d ٳܿ᨞:7gׂC! ®$/L㜫^d165Mƀh 1DKKu!z/U⯣QtCv=1bϖQ6vf8ٴ ;Ah9;寪& [^I vV@R; MW7 QAeP*#%(\YzP/pؘMwx07_•kx!om}C" G _u7OZPx$㡅e#E"p,'-3hQea}v&tL<~ E-b[P7/K6\F(_%A|as^ռ:64J¥64ʓ;e*Wt9T XkF#0}2-qEK*W-塞\a+-e5dRc6P ʳDPNynGP To{Oxgz4=Oĭ۝; 47pN!nd) f:A?n ѝ\ΨQ DwTl'w&S*f;ɓYOнPD2%y|1BNY2YǨm -4qZ"i}Qvn0 RL o> "yȖŧEP:BRғ8 s gMs+X(|<{os,BEy'έ'Ks a#-&s*F}$kJ"7!›*ބP1ٰnIH [[൚7F ]cۨ:q4LBv0)ʷzm-D)Nɮ|[d:K^ᝉ7Ћ+Ha_ZaKҵΚ~1 3k6» zʂw:ȑQHQT s8qdk"d85FۡhP;Eg EZj#۟ѴwEp[28_ơXl|]J֦I%,ɏk~ uyR^ ݋]pO!8g0(Mw^?;;+Zz:Q~Rjhua~RJ5&9ҍtt^ĒfmkƳzI? Tթ#~ur_'Dᖎf|W>͌n`PZuKl ]y@lz'R ݧ0\$J}z0C,h Xٞx>yO|g|:E>ڮ9C@\ S؅aq/O#zR8FmD mD2 ;?H+[[`pk$FZQޅC?3  Z?!pL tPߟwt5K, 5.f:& R5k޴P*Ɓh{4Ͽ);a8'/FQwP,`R%wڀ/A CyݍU坍*#wi65ژqKᑄۃ8 X89Ck|СE[\uƗupȲhq>e)A`c 1 t'@\_Jn׻:,Nwv<_/cJ5o)R2 : -PMV & 9CL׃ 墄n/PKb}P`4rDã )htbrjSU5_8eg \=P D5R'GTSk KכQ/8ctÉ_wMoH!y񰗐3I?[/tm"*Nq*S*P)Fc=wW_d⥇kwआ6YK`x9>qy!U.tߍI =JkH R/qy2Bqie$֣ 0 _ {gh l['h!=c0SD%L5L0P$Zڡ;J⪅~_4h$M'K3BG{uԶM1 0t%G^9p?{t0hRp='޿F—ŀBI(BD|M$G| # ]fOoWb[!M\Q hF T-H:OQ,V-Zzɮ?)@<6J[`g[`JHt qO|ۇܒ `7躮\`~lZ;w:0o_>np,4)&iSQ4E5N&Pƀ&1_\\,&1}tc = } &F1GnYbhHM!秙J }jZ.b^\= @5ܤ9k9Sfldja,HՑM$~}$(ti=]BYW/ F" !"Rh;ٹ0 @t%_wS |PlA1ߊߚ*Wtvp#X!H:$S:|T%BK®F?̹ǒmEiR,/v:KM?0JKyPcXlen|jwPTAo(E Ǹ<:@iSM=OMT.A5~='Q wQQm'ԏ7lv-?z-Radi 4^4> fz w 6 >==U7j{n|vCPvFG 0 ])G'ZҢ q>b,K*y]QC63U@! ZKwF>7ʀ>ð-x{6_E5-Tfw2P} [nl ?hK"PA"Ʋv+>]6Cu>I.9ҮHI~.o;)':{N;َT*cs;c &ѫ\iI-1n҂';b4cC)sʡDkܛc9bp{s,G{s,GZH,궼J7MD p(8E%9 0JpHؽ<– ߔ ,F' M Fo2U_YV㹕8̻e@~m*xwH@[o1u)aq)=Lu>.R~zLBфrkCǕ^Vh&&aL+wtTn4czk h 6 L-8]%8.3C~ɪu$ m0JІG33jPJb9 nⷖNO9-䠔5(ahםo@\6>2 TGhV{i6/Ft0h4' =Nt',P#Ǐ;cjjW[ ͖u@}pvm90JK߻نQ-CTc{+s>Х$ [t>tlf*:llr.͆M6 oE.R)u cC%Zf~7'ORw9o zEOR/NY (ac't.64l9'IZjm-(H}.m+zD݌vF( z]%W \ /3%1$6B7r FJ)x?ə/+ H}{(hEO]G2Oa+%8xQNJBIls{Hi#sIKsd ⣴:|=i4ʕkuRCu^;ʞhv;{{ZkSI7oHB=*Hz)3[#'FQ7=ϑ!Ѿv7 + &]ڗc~4#m\K! q9N)֧`8vo0换p`X#v9u竁ЎTՀ^ԩ*[U,*0dx9kO C;Sdl C;S[!ddB=_okGh~g Io;o :K}ņA+/d*5⬊I,2?̂!J\Bo͠=Rгw#D_%(6~N]=`<.m7NYߝ[)9ekڝ~M.< D^مg!ѫ>IQG)K9 bXpz[n4ꄮ/~KN*2r“kξ+_*1pmLyX6I w7p< O^Yggt0Е X?O-N!dAI_nPodUXG8*ִJ ePUr,s;[,P`} FO pV%> V ]+2pVK&zIVDI,Ow"~d: [QUSbU#]i7΅ .q( !cS_U{NLC~~ S-X>KCkk60'|$o9uBAMzSHlH!z6ϯ4}Eٵ@ °IbqĮ )F:HGZ̓a8B=5@A}$<+ϐX9#S+dX ?=5CőƑ~kXxj41/6۫<6XA9Vftx$tuRx#$<1Z) }7̂4y} d>_:[UNSQ5lħE?6x\xU"% .*P~@t6F= 17\?Ȃk3+KVgAYV(Fj4lT *6*L*:\Ad,@KM  ^ U{17bSBǂkI9&Dp~#Xo{ѓ:mOB#q-4If;_2" F~ p y>O"p_`;͡i4۹i&g< ` ~KFK*٫/(aWj_q[%`0#afd1Ct{jh}O(sC_]ԋb~yĩ:p4L8˾03ZyٛjegYvȣb?Eya L-<(,Zt{ޅz(ya %x=G{ڙdVCo4fe$i$ܙdvpWI䀌j/q@>%zYl2$BH 9=U+A:vAF~rpRǬdRO$+ORY? ?Wi(ŁWqhru!ӧ.PAn rdT?*T$2\@۝.Cj,COXUgcUTg5FqJGlQg^>VE󖫜,M Y9Ki{p8nr |5Fen{MiǪR5 4*,U5Fe]0?ǪR@ej27pQ,RouUAUesߴ_@?TMm{jZr/=UenW7yVR9ր@vFPV4*󻌏,U\@NFvV*͞~Q0 C|mB:*J^fR eP.~iu(K\Ҍr5YA 努R *}F,ՠ\f*gب:3TATzfn/|ng㖚]kVwoAVTyzd3,U_nho KNB媬r ,UNB*|ʦR Y*?T*_,U _ԍX\zPWscݳZ}QdokWn{vlj;se_msa_u_l6;]?Q ph{Pɠ,  UB< BHU_R4rYY*D.QmlY{h:K-^XtZ1};K- .pJb0e+]Y* 3\ɨM}RP0:"\ɨM`a;ӭ\h^R&<KeefoM,LQ(T?8v*,IMF`LD&=D,u8rCБYW7T؋܄~%]>ͽ ꖚޓ3a,cmx`?@8YԈKe͑om?=8ہXΞK&+NPvM4Ts)=7:ІH< mwGtB6TTKZ4˭:Z φ2^qʩEdQ㔲 Nu(e;G3P<ɀS8%ࣱmGRF]AqJKMW)C NF_w<8egUJ쥂SpVH_S^*8e@8ecUnQ)&,I06|TІ9x~WPEUnxц fs*OoY*-9K[詜z\ANS9Ku3@[4T !r*b!"KmӶ3UFOE [VFOEh!"KmӶ3UFOE=]c ,dO_l,AOT`oSRvv >d;y'DjKO 6@A~}_j>\y>Ks*VP;Q̻;ԞXs9ۭR0+~ӾO(<=k9WOAT >YSpvT9)IP-(>R~e.X({A2Y({cշ>T H+2RRlrLTBTxدo}p<{5g7{`K} ] w/@<䇳)Wpe tprK.ũ~ /gTmr(RYA O՗3\t} ¥ 73qabjVa 10#?3gpƓ-Հ@5įfR k_i&~-fⷣ*?CS T-UZECZP}kYLGK}߬_7;Z*^d}6mTB:m ZɊjˊR/J]%N/*0Q:ܯj. Z7Z5 Z7Z Z7ZsU+ܯR3hh>A#v8B͝!Z*;qvk-Zaf;gf-a3q` 53ϻAb~=ZUwEQv 0ܥD'K&kDRx4x?Kv%N9UT`j'Pr-Q07jV ZwvZdIOXq%ӲZxN0=SEwO-\ϞQ1c-Ʃfm+q{8b\3t  ?]Rm79s*9{Xw :{^0vѨW|ϛGJ:M|@qCq9V}#ubӓtGΫPNF~1b5kGJh|O#?˟S @QLY t#ϐ] 0{im@l4y ^:,=#}&p}Vc6c>h:Iᭅ_wF#mT0Պ{N1 j{+0C.pi_>yO}B7=j#&+:ƞ1e묑S^>&6L\g tIYTblAk0 8hd>+!Y(j/V 9AC఻.sa'kmy1붽a-^#`T9^-,0+8i {tH1ki+З3ALCA_]ScdG݀G.=bI.YtN}&C~IS]tFdžMif4(avrĈ;^%Gc]89}  Ðrh6K^l /#F_[)-Do)tDݝQMG>0_|İNS +WKpj^>56*l2R٢~ /ѥm/LYѥa~jZpxGѿeWV}]3ž.z^H0rs;gYČu8Quk Y؁'g`! AثzahU~-V^?bW^?5n泫OcGhs67nT\t~9bC+%iW(J9=Zˑ 2+GaZpvfهuBCc}b>KX;xs?!R,~qj((<F!XK Arȫܹ/Y9dVsMxʡZ] F!hǔۯLZ#c_NΡ.dǦڌX{zcS}eT {W~(;^\_ ʘZ5{ޓ~zxO, =5{rnw5ZENw5B-0lfW{_kٽM_`kM:Pd :{Z1Ƭh[CdaguOfʌ=*Ł框}ʵ-jZx*Z9FXoƃ`!|ި,5auwf{XFjm4+0;3~#pv(@ |wJ:2>`Q"K}4ƃdcFOSxϝ7yRWpd4CUz-̏'"^hM]?B591DdpG;#O{g 3yw| BكEoܿ㓳+aa/- 3c[ʮ L  ~iN.QK|5'_:Z_;"V9vuPM?t0:hyi|a 97+V5} w#Aʯf`1AHB{ۘW(k|'{4'9#{+ԕ=nNhK|-9yNAITdҊZbExSvfI0 881~3C\ %S-֓g`_;֜u_|m/u _ZkrW} F^ Eg%8Um`ΪMM_+~^AU5_Cj؂C$h:_+ھ.D-Z[5ѹw[Zz"+ik"6*ik7d;9OǑk|jW?0は瀯_ [G^Ǭ K;btZk;}{'&Jz4'hş&|sȾ7/{D*4kt/,xʄg 赂EZ~,RYl5GW'z`EV"^+fjXx껍&ޗfb׳w=}Hs퀇)C #z;twZ@?RsQ̢{nc.RԜJ>9#ARPRX%͝tc# &B&˜cŵibչ0a5sa~ bU|-ӽA1_;d;hGp ׫NwՒr@7wPQkI5.+Y/{;Jj^`_4Qo%&foeVU D?HQǦ3HδU':Jt|@: 8C_Rsl78C_;s@X9 &_;tEz^EJjw QOv \x`#m">_=b /ήa dQ݇t&A),s)8Pb:^ݨ9BeOjq)^mk$XsckB.z7>b}^DxGm]cU^۹G |ʮBD`q`s D =ɳ{yt:CyNћH5NX#ܱ|e?+Ѿ1:r1Wr/_Q6_F]'TPnTԊ<;V$XƷVZy7/}h^;`}^^k'y[{ɽ5s tvMMPh^L:䛎w!H'7v +ϼ0yh^`,y#}ϼ0\Nh/wZJ}ܽZvy2|Anz4ꑩMjO\paz%h4)d DXT|s٭;5/F<+*qᜃgܯ,}K_k፥}`LG㫴6{TX)Fh4y0y_i``C[z>D<>9pEc_nW57'|}rsX= ~-}dxG]T~IcȽPp^ouҷ2`Q¢[r$|+_qy4*B8iĿy|svF 0A0X:Sig?i @E F!ͣ~M:ͱui/ >?1tG&qh`Z< FkkHj c6q)_xp |{mq>V:rq>ehF |5_:_ Bg{tzJ3sDc:lo _faLje`v0R{|NW!.N<|9-eQ#^0k]_O#{ ]~o#R>@6:;>@zyy]ԛ-VߵN vы3ʑahqS\ jPbZy= nڹyx`Vkp0}Z:|_}/A-t+86<рCZsg2=ywCadVwme >,.Ԃ!ˢ˻ dYs9#y^ڽw{u5<n^0yMyM_M6 ^ _t\7p-N^KJH^kV _;~Bƺ-;%: ]}<-y!ө jEZb50 tVvqb{Dú CiÜv:qW@fWW {;uTN2u>¾:lYǙ]O֑39|M&x39o }4xUT"ynp|t VQx,o^8)Ԫ9m<9-&\i.{zem+n_lLb~L rTIƾeG~"8 WC>lw|EBNG"\tX<7@Oޯ&IjrMw9 j75~zY=97=`Yk}0~56@+E3uX\-x עRݶ<mso;Ѭoɹt[uN˭`aLXrX/@{Mk{a=kmGׄ-}Z=^⼯[xxwk/y^k߭=¿W⻥uN%k+{{0>wQ|;e03mXLs/*aXz7+_s'0vyV$'[j}mNoXGO&7cA0HغR0x@svj;Zq;s8xmh?ċy}|Y:|kޜ4oNrbO4oNZ|G'^v?g:z1B͎Is۩i~s~wx۞9xziOAb]|uz퀇\_EnR94'71WSlhe!x?C:s}9?=nE_(aW"[wrJyrZZnQ;g=gڀdNr?wg^_M0e1;s5)g1Fww G c}=*_!Y#91[WrcT|4t-?d99!:^n 98)gۊQz~%7/xN 0{aI3?5XOM`^_4&׶zʔ{c:z`L9%?d0z&Q:dx^ƭ߳šq{pvF 0 KOP b+M_ B‘__{pN n=/[ Ɯ\p+xַد+~sܯk?{ȅۤy'--qϪ[g{i ߝ8ӳo%kofkiυY~yقҞoCwٯWYZ:,|%pN+z 4tm>,5Vo4]ANN[:9DWC.Zˮ?ZbGb|}dyvKk=1@͹=~(;܆a^,R?Y~/j J g<r-sg hZI8hZԏ=Z~3z;9=c_9=ǀGkzsIY^@1o!>9vmp1C+%f|=%f8rעi{pIУbP?ǝ.<47x9< !I|}E^ ~m]">yE|VTIZTMv?xż}w?Mx-_ 6쌒az b؝زQ/$dYe>z\n MFnΉ=#I8?qkkK|:!ǽCUyWJw~WɛBk91yȡrA_o:Ʒ K߂uW|}R̸}m8Gok l YW}AŹ݌anz/e$͙i4?i)vk=ۑ6dOo^_.|s^)xk\EsCMy^ 3~"_5v1;?+8;܆a~m5@ۙUo> RDFUpsxvͥx;ڡo5yv[e^|[3鸿~W36<_; /Y |mB_{Z5+z] q^\ͪ"_{ul8?yq?.|c/Z !k~;zonj{cl36lM3yZU9kr:XE{t&ڃ`WMMo}Eٹ%10Ly!Ѡv x Nbk*xj|Gp;#Ʌe_a&{^c-`&-3:߳ws횬s#yGSa zNkM\o_kiFgXkyw6#>6׆>9Ԇ6Gm([/8\X΅-w&xybFX縉{7ar&yŽLJs?a?f™Z8,5μ该7н53 rg.6u'%GS`cG ׾8;a Ċ}\(.TX&t}AҾn50g޵߿7~&MWo;knګҷa;wk _ Kvt*_+4C <وEVj$gHVjFV7Cƣ;o8߷3?VadS<VXuz %μ[UkqV?zFN%\Q`4Yu`p0ޡ ʸK+񐻸+}Rraz%ұb m}.+!Tq<&9ri^;,~XŞBr;z,,bO K_kY f|^+;&A,9x9#\ Kg+V{|wa+|yx=2~`_^L<%^x0vf<x%՗9ّVHf{0yȭq:idngy'^k6N9#\#HJαZe J-@J}յJ vZA%0{0J>vϱkAoa- aqJ'~7ɺA y򯕖ZH霿fu12Z/x&Ye[coGם:y9-v/J'7N`z lݯ#2$}̛ޑbvIb 99a:k#Zξ}8yF9-~sz?ޯ+au3~sͥDגo.X9Λ\oK^pU*$j3^Xh:`6ԥz_<"G9ǭK~s6k^Gh{ e9;܊a^uJC/oH!1kKCk`Cj\ֳ ѳ/Zt;VнWuZ$gxOj{? |(7(fh%9ZQjfBY;XzC-*xwt]ikwE;Z>k^+-9A ׅG_y~yhLwګs| u㞳.pc^9VY;Q_Ak~`o5w7 rc^M?_;q-9~}_C!ヱgcn൞/색cqƸ5"nԈ Vxt_`M \?Va:ˍ]_]pV{ԟ_A׊jILS{jW%Zu|8#ZyсKl~OuΙ;߅Z~X9dc^ =rZʅO;Ѽì<ԌkwK܍}Qn aR ^9HTIŹ't~mꝐ_Ԑ-Y :{dF$_{dF$u'q pNy'MY\Z=9hd.-ʢ_3̼*B++й/4|:iڒ/3юX\\pkJX:9i=wܣ僧QoQ=;y'\Vws;9{.Nԙ!'SY9.[U71trK]uty_ڶqm/}bw' ]wh׺ęwy}(;A^K*~#] cy/X){9|Ji5jx%y>#hh[ϼȯ_3?gg߯'~aZ_2#~<*cy:o Aؗ,cs.b? -E Xy+4oհr*_sF9eec5F_Xm?[_UqB؞9 Иp/B~흗QkSe#/./9ЗC}pa)ʜ)~#B4PC*& Ԑ)/$ /v_'I"q?̅`?u?Q0_;՞ab'!/=fKFM%FC9˘z]a[<';gossv 62kV}5+'xٕxm=d֬R8Өi NJ{ 3@bXk3g?8r. _[ua ,s=cP?FS_^mVb;5yj/tT砕 ֗%6ȵ2;n~-= 83 H {į  -V;skoj&Xxt!!;e97va_g!XB\}uUZe~ |YKߊ,sc8;a~kK 3ͪ4\ 78Gr: su7T)t>h^e'>h^eϩWX׫_]4~Na^[w !v /kH\!=DZ >9:q*XR?Yq^~~>nppT?a`G}GLSX~ wt'.k/ _߱`əsű9(? }8>>(?d ȼvN}3(/^AjEXҞ:5HyqǸBq% Gib?R.@o7gWb1 V:_*gGGT]- 1&3!ё-c>`B ss]ޜ<?] ozATs8 Re~r2 q60_HmƠCk=R neV(JX;* _=쌎 AU c_'Nl =浥X `5_~7}xQx ^R&އ}Z!+hkBkFwm/ZkFd(qpW=rN}HNzUv~af:y9B׸;j lx fj-CʩQ S9MЉ-s8i#/)DZs~d6]3q^  Y̻1k;JXB3 {a8j`g9vf¼6ˑ,}-Gsa AK\{LUr!ǖpcS,gρbыp:!OjVy#ʩY.< {haϺJmh?䋼޿杼:>#<ɋzNP_ൃ5{F;gE*½3#.t8ktN;5:9ij9ɜ)Vo䗡Mo<cj~-y]魼[)/Go۸HoC>|ܲrE-m _[`6w9{}D`.gD_=5e=&|m_XjX=.0kV#aF_( AW[/)%fۦqz>0̃ ~/.Xzf]8g5Xkwkih̐[bìֻ5H}j˳/Zede\N5: 53d#g5 , @oI,}hͱ;Z{sw{ڭo_ۃ9!zr|)gOj=32^aM&Z Lu|-k-j+wZ{3-{[,Iw^;;v^'6[=9;$A~I?wQs. J ;yR}[v[[ b,o-06/pGNX|WhOr8iQ=UiۏGgkFμ) ʺ{ӺWi 0Ј_ '_uD豄3Skz|Z[3&F&jaM }|g2Ƭ9ƻw3c(mfr%a6w%Jد]G1/k%X<3 ѯ Wk<@?ӄr GKBW oz-3S0 ,o4OJq/pƇ,\ïI={`7,ko8,>I :rOK0 LLiBbQjVlՇzd}+'Bx&6W.0J_ mr2Jm2!|wW&p&?d]q_8}#؈G`{zK?ɕ^ p a %`?v]"h@S+vzXmة_v"c?_.94q;}l2Qk}gHNXZ׎\9״|FF>Sľǫz>4އN{Ȏ_^em;1t`Af95`v†? !rU>ׂ̮*wÖϘ [1ī?c^W1θNXxA`ߊM|`@Fl VʥqvFI @ l(_?i'zKZ{Z^A}B|mًz;k5͡r&D!z~Ⱥbu5.Xݻϋdß jC2_mnIIeΐU4 LEF^GOyBy>ZcvtIS tQ_խ5zѾQWk#Y#} 5X}瘭{5 ׊I y󝓼3)kg^r'HOtNLsOOtNߠ'P'5x^kɼWGcX|-}s.ҝ.k7"?Vp|r.RПnaRFNbic,WeҤtGӯbP*CI׊وN^_(t:JzE5~&~9[`󑙩ɺcb^;V=~"1&*g_6uߣ 96*k5[Cɺs)߇BUQ@ՁO} `/ g'Mk ~ex#bo'gڿ3$Vmz=C9z,G!ߛϼ%C%z3/ݳ9 #NǸ;k ]ط ` =A2c#||3c.ry* y<Uy<NC zΰk3lnwA CNc&r>q9aiG^c+מz3s5\n;s.c*uheK1 olMXr۵c,!z[؈W?0;U[p[-(ȓ©7S#3_"OG.!s'cp?Ro_58;%ARHi uVo2,xI1Ɗ-FP௕wڜg ~N௕lvqqhiTv@\X!+ RyprAJ8]`Wy3Hm> P| w۵Ԭ:N=~mik5+xhԬ<[%Α$y;qk[qQZ BKc9W.mи[ddU G_;#<>B#S#sOuXh#h|k{`,ul0G,گnxuس_uë@K7 1kJWna_x!o|>f`FM6>e!SfÙk g#nC B=QD9V.ݟPKbc<#>k֞f$x'961q:8s=sj55Za-@7^ J7<䕩 jyș۹M4:ob+koڬeilu.\F]rUwk&s҈F~{k4=P_9Z}Y3쵹V TN -cPG棭Q==ŏNzml?9Cs.֭4̓Qx&sOqM"9 k;>&?yٛa`~0~=᮶fVSkz[ux…3B_}"`ݫMpN *}-Z0oH~ȫ!/~ܭ;s&k ^:p1[^{t?I6e˝7jX7U=DwCu׮3}wk#[_d 5ޝ"u^u^^ٕ0 °/5!۴.6Z9,uޡ:ϙ:'~xko2#}^?'C2*`zm@;%z`@Bxc)1C퇞{;>}CA{ޯ]hd5X"GvP=[8?/Z@k^՝E^oyW׷j OķәGV><-{9|qH9xY$aȂM9sk & |ȝ G~N~퉇J<${/|:BqQ&qV ._ VoBkU98|^%8|%Qُs&-j}kOb ?DܯEw\*Z98j=]f=\`[cr_u;a:ϱ}g`>Njqg/ɏWsPX!/ī;V;2@'Ak˸hZI_:J{UWEWR˙ūw; a^!IHPfV~-!U!_c~O^o0$ɹO[ßXB'ODD'sq9{A_|(vK8 1;뎁_>23v~tr.q'*yVn_˚o&b.ͺ9oh%u|Y{u>Y J쌒az%0/~}jVEZ.t>Vah!koknB4ϭBZ;>[zS]0x %=dv:TҪ;Ъ">㊄ZW\'7t΁k {\7_9A9 tU9M{!\򯅃^-V6j;539 yCy_ήb]i1_}ZK01 i{-_Gɽ,$H)}NE՗`+2ֲWj>fK8_xjO1ksz!;}m$pr_%OC<<ͨmEK2^UPE{p!"a# ;H`^Ĉ=dr&F,PC&fKf..udO{',m Xtbܠma  (䫋1ިtK絣;͉z9{iAi1?eXb|-);w$A^ 3`_,iVXw._G/Wxȇ|dhu=̳Vw;y-Y3 pֵZFܔVWޑ5[ޜ2b-o.9u9ys!?}'/ͼ6d_%pk׮@O^k#)O|r0wO׊OOkJp9xfShR2pԸvz_9yǷS#}egОFɯ#hٺXwϑkOws7a^=ę匞+ot.<\y]W̤WC.i\OQ3ӜkC0 0J &< ll˻;.Q3 O}ƻ wk1ەww!g|{/o!~ p| 9k\xcp;!VZi_JS:X-|mHwҔ9}mŶw5[~pZw+swy?>19k+_u蔟š+_K g&O!ޓwR9'vu0є?&w+es^U~m(QNߋn KtVkWB]=L-ƹa&|mQf6h?6|mϪh?2Sh4iެ׏Yo߿9;A b꜆2] %|Y//z[z&+^;a=Mx =o֓^^зߪQ @}Qvb_11S'eq }Lg< |^})Y3nzVm,pWb<u6Zz @8*@8/,Lá9*gj>2;ke89;'K inBtoA/a - #o,Ff8@6 Drw~H?ai͸[KXlr𦹇o,9x3MgB>G"QݣئtԻ7Mv`N'k3?AA_ze6.fPq& " oP=.:>w$㢮xGfk`#URGWQZG=\K"GExT_'< W<6k;A\ZFZuFl}֋zb녾vd#.vU!g9rw^݁'o^9y=W3.7yߛ7b5%׍^l15?뛲3aaLv܈~l^=,`҇Ծk9;SS&svN̔)ך)3ep:Be>ܗ+_|kNсv"!l0 3[= ǣ^x4u~ ^ oV' z-$p&'k7'Iı {yUWr/=yUė$f0 &km˳IVYHkߊzWs $°P8@+zsC=? CfIw8qoVw;<goz:g pa%ujۀnG:$-Q$߃}p*n㵧\74wGT9'18ku}[Wsm$ߣsMNX#y.u;л\kZ \JjQ!wtIsȿ?<sm}+CKvk .z'9cR,1YA #! >2fmbs̹n"߻Wݤ𶨑{EѫLXFȫA2T>$!kA>T&+wz_RW.!+^{H൞ (Ev*3(;A O_l~PwV,9lU{myjq;bNx+v22~'"]Q0 R;vŘDc^r3I;X:YpCwFko~d(;~^˾eGv( ?`=ڼ𱑵C~sSfPEaӄE1h $O$օ\u>pVCMusx`xz.9u4UpF까:s8] UuqйO.Db]n\_+2DXƹ^̿G"L,k-˼`oyou1Oy3f!zq# , עS abr=-8:םs^{jy'pj^.˛X5LTdyg o,oMeMkKzR.N[sؓG zax95dadn@7xTזBy+Ha_*PFǶ'RǸ=1.LcL*= . /9j+6|-sLx"l,:neБ )}4!_tdpC:7 \]5bٌ.:B(ԉA{SX#(gon;oF,9NkG}؟~{k3Yjs）7C=Tr\֞@n>dHo/^ 'zcVXBwb?&Qs/(%^Y= ~xceFxYT{_aE u O 9ȧO~7xg?2&rs_f=F9뉁a`)??ȭ kz%kw=rq2mʺb5{kr#_q5{̭1/V?'gז1®DA>'LyPV52#׼G^Ӻz.>ҿk^ XR5mΦ 8nC1NwrxD3q7ś;y>gZ)kJy KUk;}/,֪[QZe_7u- wZiJě,B\2>r6C]!';r; ydX)_~xJ@=dbq9Kc\9/47k@W?Zlz>0w>{+V}дʛ(rv9A% Jتi2[OQP ZxZNS˟:з:y}"{;rȷ>Nr->Np+=kps0b^;0u[`Z7Bjzy[c*uUupV.#V FV|"Y E}~Șb4Ku"3-^ɞj+kyQ;M81r#/x9`x9[`Z^X#8;a~)%7ǶE!] 9Gюe}9[;-׶Z|䮅܍ ~|>Bݸ7qy{L_a_+k/c[1,1:Ơg%?'p+{^+RtÙGZYl mz]9yܕg]2}c6ϐyoXC_!NZkg{kbs"Xs $kO459e~Rv0aX+fNX1l3&>xq_i!ۖ/,k?qINb0a*k+1&ɟp7bYp&QGdZxB8œGcsN<9ʝsN*o%~K.c+O1}܉=>~w~GZ%_ۗ?ȃY1F2+gǤ~ͩb8hN#9u4gkrM>Dځc|Tϊ}(L5Ġ>GL˃[!cn>/};8wNU?ρ~:/8Q^S{Ms~9;#A qbJ.$=% Gk㧡9!;}Q{y$coUjH(lPB ѯəCc,yċ{T8]=3/ ypucuq o1=) UZBΔ@` ג gCB~Ę%!|߱V۵u}V Ouވ>FZ|Yy# <3oDλ !|-sYݔ=-녆Y]ve]pvF9 0 RIhbC߾Fm~c*sϾ{З3:5jXe\1v֋I#;^Fgʹ_?Y3}{`_Y3.x ,׎Y35[y %Y2/18yUc`f>[ #u5tFPZcJĄ$/#& Ue^L=27ג_ SH>&d豷- 8!kWCff{ \Ugk]-܅5/+vF&vDncBcfw+cwN`oW̯s\l aRIءkkWpLj Mp^bEeݣ_$gVB罷GWׅG[&x\5P|#smwRP3Mº/#sM+oҥ P[rnn8?컹D v$skɜj?y;_˜j?GcNEd>&s,OM,}?x6#^&zjpj흷m/,oo,qDuvIK~N6*3C>{<"j{x|d.pW6-2pWZ8yg]i9s91R<;Ǽ^d̙kMZ@YKn^dY{UV0;௯M7V}qjlMuWv~bS> 3 x \. ~Yڭ|me*n-)"cMFٗs<rhԍ̳+>rh7i|j]YۏNjLX5__~y;D&h kS*sX׮G׮Jsy=ډp`u+&!CΙf`qə*ʷ?ϑgD?mߎүyMB;ܼ}B6wY[Xג&ƺKc/e9X,n7G]opsQ+gX!~u +aRIxI{'dҊ:e˛|<'ia i:ϑ@H. C MJOZJk?=2N:{è!pbk0N,=灞U*QW|ga~y3HZGxAp)5y ɿWWhQyWwmf߿_5ku|57or^[XxW^N0Dֿ6:x{ $iᬉڴqkp}0{|rv 0|D˔m<-'#Ndką?g6,N~/=ٰ,~ fVޡOa$n>  +;Jr ;eC~ g/2W/ϯm~̆}~̆6I߮e1KoTwג-c6X_-cBc=yך]hR!𬆞+{#6VG~g2_dտudڤCd \aNM/לceC>ˡ0;Vr9~K\k'sccΔ/x罷Dc&{+ί=17ZcOs>gB<3(aWRXѼMts&E%4T_E3ɇ\27p(~_ۈMqN\_W9 ?Jvr vRC>3S2:>f@4Av N=$[#:'gg@+ D_Wx旍]W@iK~7qf0C<^}6鑍_N$ o_yKgL+>}ޟU(xyNaR|>}y2Нa{ih$t&knD0ܽp"Nk{6x2ZwlAzIWy;Xqdf| 4kM>}{s|f1S~kOa"Bg^!j|0S9ƒe&Q_kO?+?O}mԏ~yјNMj`tc3QbH&/HC#%H.;VF@ogi` fv\ng謶`d1es1ǔ7K-0Y w͸#Zw͸NL8g Tk;O`gK v e׊y3N]*2m'}/[ɳmcy(k|'ƒPCr^[N _߫o\5zmLJO^`S<9>}id4sN:gr͉ 4i׶Zj=~(h=9z-BA @<_d-@=;y謁oߔɑ! CSb1?9"(8`^`T~mVV_+.5/oͅ P<y/qv=[mi23qwѝފcC;fC򍂋ak;aRQ?䤏n tB0>øLqw}mqn"|x]<\ #=\f\|Wv|;o6Oo+%&oQK~Ww4މJq[ʂq_廙Cox=Ie'ٹ0 0JYC)bGz4ҌXcu>m&yNquwL4NoN1­F] V@= x(\'{sۊߚw~ڨkS!k{6u/tӢ:yUGx^൥Z|Gf7DO!$Zh൉& gae2.<>^[yP-D5hf;ʱeyr!!(|ˑ}C"9Eлׄg*=dj5ЪiĢZWN1f}Vnʩ9pbWNA,x#VsߟrRvF90RkHvMW/FLbgXyF3/R_b>'۫/YlW_+5/O|r ˌ߳KxٜCta)aYy1~m/5.y9#Z(;ū{Ȼү dK9p{ XkeIOoO-2;1fqe'1^bZhg;v{ߏx_0s<鏚E0͜zLNj9ח˟9Cʬ鲐\k]wЫDoHkOf |Q3_/".hBQbl_GIDc,ܶy{&lr;:u^s]k4:~}j+~ů?BY6~Gfs 1di}|qvE;@e($LyŲdWڢ;y.MV[mu& > ⤍𵺏E* UϽrα6wiìzqըsi^[3xH!CZZp9FCc!aHa%}-ޤ=l '>x4ЏV~-=hkoX?άBӟά_˼?#d9gp!n%CRj1:Ɯ0Nc{: pV:fg%C3Pk\a tG)`_ӼlKnqc$u3ls3l p,4^Y(4&9 kE>!|EVGk>t^{G'  PM% xۅ}YTIϏ;F>?ZLJ}~zpwIFv/kH߷y瑾/xZ{+Q-VW7/+xlWb xeqg_1-څ96c#qُ9@}XF@~#~\cꬅx[Hh!k_U 1(Z-ZP-z&0 °:œc&jO 6I|a|-N 02#Z=ehW;OyΧk9|{9;~[(߯5-Pk3u8ZќѩZh`QG;9:\sts_[ ~VXc4 )va|.8VjnpIpXX_\pU<C9o^mo+y|hCkWd_3 FkQ= oGm\kh[wN.(݇jrcIo n aJEq{\i%s DJ!c[VzXmohŃmⵕIMRB7!^{;3w_yM:0)G\q(~rF|ȑX0+GNį54@~mg]bC/vQ^N}I7-dGn.Q2ƿe(ºQk@Ζ=XԢ*9>ȯMP?rs4<C 61F,VSusKjC=cEqW{ϱGs$^G?rp+z[쓇gʲO.0 =dKk 'Pvn 0R虠,AdD|dL:ύ|dձE64cԗ{FdSkʯ=ՅӮ[9mpN8=WGi'PIkFd&xc}$}i5Zr*!ޚBP+LJ̲(u\33\AȌp"1-6aI @u'N ]Rz_C?_/1ECxV1%eWwdr~͘RE*U_"ndQwVa?l4wڮ_F/0/ CFNCkc6Vu1 :wĈs b`:-t.>֚3ޜ <&)~\srwx.$<Yl,}j/'/kza0Żk9/4F;hVHs)>Xb*0'tDh645MIS+I~4&M*pؤ9){;){|Լvb3,4:lxUf41k[ㇲ3q*/iߠV,mqǂOxyw+SCxiAL{i܂QkE**"|jËt\}Ë$='so߉:ADV\2UF-,WW1a JTrbN xVde־f5>}W+_UׯCVVQӯ^ `nZ %/@dy[U9ߜڂ>Gv}fYsyVZγxs^3yukymz;L^WGז5j5Gs_G]Gz)wkVonzQSo<%n!+3"9n׻p4ڷ%d_KGd C00K+QcDwʐ@T6Mr>Ƣy؞A>F.f|ޛX1,9!uGQ>!C~AB+Ө;%I<_;r2-keIοFL7K[|84s+$I`}yw0c ydj +x hI, ;j'HODYWt^WpYa%ٯ忏A>jc#<1yN>37G3T^[+ M;ɺå#v[\"/s^+#q[R;q[]>8y`QX jA/|Va2wZ15asT0=1ޒg`ۨ6}3%5ƕ8JXpZ(ٵ(yw4%QRw09:J>#uX=l׺ƖdxvTqp z*t zӘ5PY zo*3  CDp ] D]J!~^kթ'0xyg^w=j}-}ά3quf<=% 'sO[9]? .]-qq_k$.֓$gHUW ugТߊ7 5<=ؤoz -ڕah/W-*zG'Soha^|g6zf%.:Sg^@^g ;_GTޑ<7=љCFy$;U!3*dZp_+3n;_@+h쿘$bP$ \zE V%q q ?qf c}UP)s}bp/LԹ>1'VٛC!> ,{3 Σģ.H~x9zU||5ވc>C~TQ> cUaeo죸dN}b^m=_| <|-^o)G_`V}>< *Z[ib\zȉ>dVJ8Dz%Z)!MfAT<8>j,WT_uUXNUji *5[ "?i*6*luD֦9߯ݪ՟u(|}I:p'=,z9hsZ >-ث ~ϋ`)`A>]'z?jO ^j+CBfPZٟ51Uc:mK5>:g'Bkk4z܊)JXxOO(gߗ=Vf"Tw6xCW>TxxUyC=8@pل {P *61_gW!þ6zq4jlmX^x}퀯//6 ^嫟nc9[X9%V9*(*=|R#3@crtl=2<(}G+*pF\PM0/kEH21XE ,'i~i(E}ya7|/*gv|?f:X;V=Xc}s]8yMk_.V̷6᰷ҳdDgDӊz_AVz [ey#7.pz a_q?VYDZusiC1kEJM:gnEJ ?y9k/@ R݆_T37>\o!76֥Ze^ .kKkc]Vmqfv=7]\gL=3p2&2^{,NŁo=?-Z3_aκ#=f}s4VEݓ|L7|ˢZ;1Zy7'wZFUWsfkNrU⻖>WPV0CBgU8HOCn{ RqZ2/rՇ>24W3Y9f,7gW`0^Bcbڼ=`hqh`y[dUq~׍?tVZ+JZkiE[G!:r*׽L0+m7wv<0L,~ȷ{ K0 ;dqc#'ZMh܅ܯa3|OaʯUuo~ ǝDZ%r|(A~U5uuTP\v0fU;; up/k;g҅Ut>"u`Τs8V_G-9/k|Wh2OήƁNZS'.Ũ\_࣡IOvcn,%I(ＪCR7r9;}*P# ~׎Nr _u6zS{y_;nߜ]^)>g#=n쥇,O&҄s0FfxEkR;˜GR'p]z`VzɃa=_k;vQr>ucZyXr cL8ckAW-ĹXU q.y k81@ /V/w<ޅcL]xs^~i3¬ƾI ∰GW([wP\؜Y-֜^ ]20_0 ]yv{=Bs L27Jg=YvjX@} x]}9踥3m`ƳKz+Zx?}:oٳO3>ub/7eg0+= ۏIYqOb j%,U*Ĭf?e0_l1o9eN^gH]rb#,߅ⶍbGq<!70Σ'Jk #s֤;wGkr8QZaFF-5_+<ݜoay[Xw"/}ntWԤ9赍Jl¯y'赕Y>leԊ v6=#,9K>cTsvd!y 4YxNͰkK|՞Zq_9u4!kx - kyU^Z;v*zw;eb ѕ$eZ Eju] 1qwd5n(Y<䁇w%QjwEWٓя$/pN'㡧ky2+$=dVے?\3B൮kɫ"|֘=k^)8Q^ȞK^-#)8*Z9/Gy%yMb1?.bm*B_*VpKЂCfQ,d^VPXf_q  ]Jp>Y_K Ȟ=?Q^kܓx~/By#w? }qv0 ҂a<2*(ɵba#,Dxc^!<3|"FwkIG=>̨o vqY[\5aj>iGG4-/p5-(kwo4-=߮%3+bμ{ds GZ1sO0Gz}K+k5uV𵽜ER =9\{pU^4m-'/]Wk.ԫr;_-I!^Yc?̊|m'YsiI.9 k+gN 1_yL4,m`(g2|a>Z׫#^k Y=A~?ibS(2ΉI_[ +6W~шK'`䫱1c fڣU3[V{lNMAZfT{lc!CG=m#|s?sRXGzV=};=+_#ڷzVDC^:"B]k?at7%lv8蝨!.D:}ײۂ:wG=UػIٻ !M uY;yֻacv;_sE|ǻ/J|0Kp0b-LB]b0KFO4\piޣOr ZY3T:nj~=͓eUC!+Uxm>^Ilq+J~ٝ8W_K~M _s5/C[jC_YC0g%9`'eg@/!4?vƕ;HAԋc[3r9g~! 1˸Wk[}K30 _[;nU]ah#|6nfWt;s㾇盗.&9_c늨Go]QGtUG7wףs78ȐHk +,䇼qºs  _%V/LdnZeɿ(ɗ1|0S3kzd4ikkem Z}=<$ڧCZo{dxٕ;gW*Q$|mٕdx] _#7B/Om#9p?? n D/Jnդ@10 }#>v֞}O {i <6&C/<T2z౵WG |imz75[&}[YhC';w^>#vOnB(/%2^!82`/ }3f"/j k]_ⳮK] ky4i!)cn#kS+ <gg! +A@b`󔶔gfeIϼO6*yڼ/L2{}|n2;Z%|mъ,ֺ#{ϐ[G3QGU!{? >=W?1eMju{_>{Ww"8{kٟ(rU+mB>ƭY3_y~'GrʦYG.ysؙ`^(ag՛cy׷7'kIa9Zr8@/*bxXь1x-#;e}=x˸Je$NnG7Jw<2]B#razM C'& D vbEgWS;ٕI3 0:߯7Oݯ)簏<ѝ LNv3赓݇ eo0k_Ze\<nv/x"gBzmCM{Zxyeƪpr>\btar8,kK;FV߱,Zƪ`k)?䒗 ')凬l">'¹.R-M휵`ik2's S9x*1CNc;pBZaDÿQd_`DQvF0+ cɼ^ h,Dt{*xFx#0I&& g*6k& gbuېg.Zݞy6ƢI_ڭ<}2 Vh{E=:f}O$gAC%we$i)4!G Q"vd:{5x;2{>7X}Yǣ_r2sdY5f@wR3N*5g xaa'+Ͼtl+iu3۱Օ4+z-;yykZyyT9^ޡ~Tn^_*|d?5yCf>Zy{EY=)u |)#mwW /1 9W54vjڄQq[ȼ0ެ_o=Z{,eCk3F2e&)fTpN =nPF^;D;T '3*ƞBC2aym8ȼV26;g =\O#;v\uNtVWg-ϡ=uFfwDӹVgdw<8;a^%-$vd TXȟ7m</j}nw ~mc .,I7pp_NY_[œޯ_뙳ײS_kk]o9/{כS6bz3̃ Za`MWe|2_' i5?5kTi 6 '0ymm)(zoy82շI%! @J2Mϯ *6j^ OP5FgZg cQшz?Lk;`i\< ?e\4>ZGh1P:g ?&jgGb^;YG7)ξH}~fdkfdR4ِw\=g,|mI=߿HZCw|VwzRȭW$֭ܓ]akaݴ|7O»<ݫv8 v`Wk9nv( {E㋳sa蕂 8U<Zi+I\WS! UQ_fםc?6b1@}ʼnu(] }?=f^G]经 .FC%sum{ʯEckh%7dMMA$!g-[qV±QRεgSRxF& {H~m3Ww2Gxȅ]_e]kus]WU46j岫OA^S/}b9\^92k^`RkŽ+7Ff_7FzD5#7h_ {M,~ ̉oAWZp{M.+.M|%=kK ז%=kg1{ |i͹ҀaZU?j- ܇>׊<[Krkίkuxu#x~̠Bq lc"]lU&7koyiToZ0WעM!t %juYb|_,1ܯf\S]n.C^#ndĥkje(Wb?_<&}~Vk[' <hZad16+\`r1*_-\@UfV~ٕ0 /e)I?IMmVV,La‰XEϊ@Xu9YHUVpOz"L,.̭>@w,Jbւ{բԵa^jPW:v5]]sjGw!bԨcfMF)|J.`!z `a9`m_c_ؓ4-dԮ, lR/VPtW.Q^d=I{.{[zn&#c[Sadrߵ9"⽴lWO> w ϵX~{Q\qs =,ó\Qy7,GKzmO #̢^댉նMY-0vMqVߗ3UK~_kӋ\S8Q/1 0S֘X0;VJG׮'27]Fudk=cvJ,yYy[2>u);A^ Fu,ӶPe٩y,zo=ƜS l1[VrɇrA sNS!œsB)a;7;x*Pμ6# 0:gv_e>#u ym0Uf:Sܑ^`\nq_nD[ލhKr/y-= ~o%=#yثȦ9Zd_Wt-;[-]C!3#{rOpyș< p\D^kצ]RE^΄. y>ڊEglB.kyؐ<.sNW`]y{'DkCO9m ^_,d~Ǿv~c{FQa:/G{s^,u۶} ef$:}8ϗu!_n]هz<^x,Ǯ#nĹsv-6Ph%;,u1ipuzQezt .ľLܧ7x7F:m^kaLxØ.FeU#t+W#ONZG9^/:"rt=yre]mc+zG[SybWNMM_Cv;y~/+Yد>k1LfTveUau|'{mf1!&\HLs?Ɖg0Z|&FSV=ƒ9gϙGx>x=fe]s.#CP+mcy=<~(>auIsrMauV&|s_@MKЗ}5\;e8B?ugs:?!0=t3)П?{{kg;Hk`#c&Ɇo295?m/ {9*y\摣 yGul^KN2G|-v?bjJd6}%vP|O .! GR/!qM-x Z5쿷0I-Ldx^'sO\?bWhzk}>QCipIl?'c-<9VN!*"KٜXDŽ̀ӛ40&wN"F,s.O7p/'c_圏_%tbѷZ`ry\Čo~eJKLܨ9CNV%L>}ͮl3y3Gpyc7^zO9Sc&:Hcn͊s@h4M^'p־6UkV%Oy5F/ȋ - >I׮U]=}lK^u^{_[?rG6ݯjFwxkS3CV_ub]tʽSֱ=ד(AR _ ,`mDz_k%Z7|vk\kWrm˽u,||E>etZN >GxGyt4:2_НП ABzLpٻl#as>[#H:,u bO%AmT+eU3aY cD] >\sB#KɩߎuD}Rs-]ǃ3ba(K0ys VHo4'`_GU@;H޷Z5R{F~%uLc%c0"59VjW{q֘{iD}k;wD!0z;óWsת~ЯSvPs5~XONXbaϟ, ?1Ka-Hj!cZ#ֆ!Ck$ךwCօ<B{ryE{I{x]*r׊2~XㆱkCxsvH0K,;l5H {P k*-p2|D豄5Fŭk=߷ M7evG^}?;U9}-;Jz;1)Lמal0n fqcpΩiXpkٗC/'^娇k{·M=jK_X^ۖ{i5_f9rȋk/{kc>"X¼6$GޣPs_Kh{l{W;N0Stkb F_.z\paz%&0b[/L]@|4;3^wQkUw1zu|׺H]X%ƽWRKl:$X'\F#_L͝/r5u;_rKg*Zrᇜk:T{B| bG1 P׮#bG8{ƿaܷ7|$sg3#|mWHF]{8k/2>H2X%VzrvF70 ]~'! DuUνvjk~bVj x+{\KVn\ E"ﵚڂW]sO_[S38 pζ+qG c% `$dT; d>{ =" z-4BPX]}xk| Ga\k?Ngg[!+uw/&~7i2 @Pq`[j ~-u;Mfu_vزͽʳA׶XxaVvu4XXmG(_?{ - ^9z+z6r:n O#u1dߪj1ymm5[9=y&1橾\uꩾ la_]3icM08s|>ǚ l~}7ou~=ni_̷#ǵY|,?Fż{cP_k N{%~#Nhx!n׼ NF-㋱3ʑavfYi=4" vb{aI#o뇌/FuF,gEv] [[{Zb\=Tb\JCAbUVd]6ppwHkpdWfkofnoW0P#*\B#R赽1*\SSH?fz}G1NIΣzm3O^yL0uE'p~㱮p !7Sż0Cҿ:kXuVCub5-00K!4MِT*$3gϬswyǼ63lcgؕFyF54j%Þ'-dge1FdMkdO$N^G{3k։{.Zx߾~jC%4vSk-40{-RxM5`!`+5-)4יoYWVE o8WV E0 0JMKQe5j8~ [1ә<*1O|e`7kމby{'Gy=XY*ʶ_|?NڍǣkA^;yX1FfG k ]kܻ`^59}'EWEB[95£ǺrjSk gVոxuL̯&dW޷ޟC5};%{_q C>4Rl&1&'wͤ|199,&|m4ts9 maE^f knn~j:8"-&~'oe-L2p4_HbJ_=?d}-H8|Vk@#88s/ Wi1Μ 4Vr,}MsɁaN$$;L rfǪ¥"g7XǯƺVS#Yy%{ڍk#EZGࢊ'x2"GvLGX^#xgM.ym5|Y 1Y;kwcJ_jT;k+>|GG+u82<,eO^;E` $%hɞӈ|-=[gxr<[ƗI#Wr'Cr'ֹl ;עnW~JeX O1r^)s?3,Z!RAJeXkAdXF^ɰ arvF9 xǮQ{34o+&tC6iE|{C5ʫlR~gx;Cӯ~GtPC̏15\(9Y;#BdFl W[lZXJ[~-r-a) _{豮,^T'> Ϭz1K_dbfEd (ZץX# |'bSWaz|mqޫ=(߁=~ZA>fw h18;&=|mfJ^ %"mzwprjk76rM5 _{Y&Fky_ҍ'3O[d ]_׬C6!eM:a] kgPk9:EO%";+9Wu@ZjR9$ȿ͜aN^{^7\ F='#B4ֽZʹ>'1*9YfZ:9YfZjg-m=~~`~m_@_g,w+YrazvI{c`#!w@8Z<^-oEnn{_ Pܫ3{,ܼM6M'xAVGo^Լ;6xd\~퍹.(b!V%+sKy+s}~me ]x0`@V(l^k'wb.x~4vevmjy29 _[<]MBsɯ ]A~}f}p:{msG6pg8A% -* t٭(~OLW.}9cCV/G^W6ˍzY(ڢ56^+=>nEh_G#/ !yuQ?{W뾧;ѹM~׌kҹm|kF{!LMEƹ|÷vђf*69[\7:5៼ LG#B5cwt*N ݠFzdxmO'*MƬ}GLf܇@GLkr~b4q.eW⵪-ܩWyx㋳3aJ-iv;jPϹP,A0<~:f!oLK0-ci Vuss|t4Y ?w#.Q1L\y8䪧{r +Q/.qg]lXF~\?^7'SѯM=Z;Wq{E=~IO' Ok9]xt@V2stG!'6QwW8ukK.ÛٷSѯ{OErNN\ƍV5ҷ-L#Я4>Q CE[v:Xo_HR;(^28mk8 ʅYkc~V9ά:&C& 2ʧF85+`cdߊ֝^> l "0{7/D7^k앧w+^9yf rQu(ٯt+DuSqZnz~2@fƶ;@>\!y+`62[fYra}\@cb!d 8ͫ~s^7O,aؗrC^\o?/w)\d/r^y擗M5AzmO:Ʒ>N?2|MCvk[6Yϵz&F% nz: z<-Idrt?_y0BS|&̚,Y Rr$yxk2z!qaV?9suisU"Enq.mggC!+6b%jd!C~m+CF7fx)k ?:F>FkJ3?Zb>#}vҘg5j>v^i$lLv!of3A6XO% yƘwbo*n52i/񿊃~QЯWƼ_;.{O W_%!2#T8/bX˧.ڰI7]nqh2n0qȸi˒?j/uךRbe%^_Ҿ<ȱ/G~?ήb_N*:4TGv z6SﰰpSzyޡLC7(y; FzK#r2};1f ^ۉy#|;~؝7Gv N?d3.̡v9eyQ4Sȿ"/ ~m!KX1IH!|C̯]SfOsv(;K[1g עCO{&^~mCO~WB%Lkۘk 8=b>'(x^! υ>9#ߣpO\KC!}p׆pg}pv.8 0 /$ ^ J$?[٢M*GH}qpE`!Hsƾ6FW&=uƲ8",Jଶ{^FYޫ2YMʿx=z!EYЛľ\dw^AZ^\o79~ZOaz+$q)ޤX}$@& vCʍ~M:9ү~sJτ}a7)+qzj,׼k 0JkZs+_ yO=V9T^+WA=^>Ør7gP^K|z.xymG0>`^{cd]1#Zkc}~O܍ZǺWy\ Afjkŏ]r58h(%.F~Ytz䷊['M'Bp  ξ!O"^wNo6)+|&h(`3V=3QV9c ̳b5brrrP^[z{rz_r{{:,1D򬮱ĠWggt! Е( OvPpro(F繱gu} .1߹d!dXw}X}X|ԢsX|V6νxܝ,r _Yrw~1e E_;=qߏgGp^{oF !Y7q4iyP>é6qLp8V|K q|d~hL )1S>IMxWn:r+|0/n:Cwec sXB^;}\YN_|(;%B 1d 7O,ĢeIfp^WGY־:r9;ȯP_mVҙSVd:&*|2Vf?wX"u:1ob,Bl58=^xUY酜~[E9blfBڠ?Ԍ _0sUbp 2bvkǿ RjZ\\,rmq8#>@.< .BY>@qr!\Ew9yhtV =F Nk_urp^kR^9=F^ƚWNY+5}svFG0 ݅ Ӵ|5mؑ,M#慨VHfWǓy_sxRKO$x]:a9ᓫ)ڷF-T[w^]>9Uc_[4S'̋.]cх̈́s\4f(k|dznw@;|G:wC!H8HXk'`'WWh_sf"%v?*N? ݕWx Mc8y=m=6}0ځyUPܝw^6Agɫ!od/yksS yAx9>?!ϋgЈ|-ҖqSxmӤ-3?䬱 CW:@\ t2@8Y!ӂ&_Jyίy9U"Z}u@pدq!yvq0j8f#|m/c/W0z!ז*ϙolc9x_{9ȝ%q>r'6Ќ|~sAͧZ+rY_n+#踧+O=תF8V\9UM{MoWnop9ʅ#Ʊb#qc? r4InS&koS$ 6ۉ0 D[ۯ&ۀa@ؖ42zK$ ]G.S~ >ysV~ >юcI_ \h=ۮd~Bt U-N'5RBԜ!~aR>xSP<9&~ꑧr?' FL+F0Z3ȷ^hЋph-|ap }m=s9Z<=y3 5s4z?/_i(h}(zCsC8>&"?/#ik'Z@kPWEe1'k=^)ĴǛg1+/V1-tgս; Hc[5+=1bV }5@X~QDh|3F4G ĸ}i|Gr + o!,u:-!+G$zl_x׃ |9Rh]U;,ٮʻ.; ڻUE{'%zx߼:݂Ģi^`]8k O|,<.޵Y=;mڱmG; ?䘿m4<6+Wfl{|L~'Vٹ_G7;sZ Ϯ`żrB^{+yϯ\pazHUjyFe X'ٱ顼Dp='Vưqg"~B ]:u0|KpRP'Q_{!Dy o:n,#>kkܑß_{bwdL]ᬋ|u]Uᜯ|h9ǥÑZql{FR:Xԝ>H)oqAJf:X} kfP3!kfj:Ή˳uVL&#p#Q/kѫht֥ZUI*n;zU ɥW^[ƌi%Ts'91my'Q >] \IM/ g806rcC(FXM&U4bǂNdIx5~~&;>黨YcowU CD;VadgZ02k0K5ԎU5y~:ݛ~ v6eƶr;oyY%|k_2w}gvǒƁF1} {u*3j/ g|aHUks 9 Sjݠ9-?_PaHk3jh |_9#H_47bW /֕}cfr$߱qө9C +|^j;O>Hy|8/3G|b if!څ^5"͸jhEA::^ZCڡU{W,U|( #VrLS=ǜه=ǟr (}x!sN_a0fC^;^'+2=y#a'JG1njнG7GO~Hk`s!?dv~>VJ,v:w"-Xˮ[34^y{Փۺsԯ#rcתF#MH 0KM]1w*,K'; H?zJyq2|W@ 68\w_[ kC z<\^ZtnߞzC^yΝN yiߐk>eF %sv!>l씕q>mfl}6{l[W}C6k>4^wBzS>ev~@8/GiYI JpM~81~{[CU8|Ti9s_7B.9%ơXҿoo1ι[ڝb_Z'G8rR~yB+h?٣zTě"`b~SOԢ0ak;a&VX}ic迢sVrWUn;} a.> EG|mW`r*=02C>3o^0'WΜ<=nN>ovpwspw(8'wv >coEϹ pv8 X>Z;iM!gBʫx9WpptOiגdlwzžS0x絨=}WQEV4bf8K88Vp.Eɋ}LpDx) av)bqwo}H Zvv%'}F=u.TF(_bh|NŌ} d<2^|&O}5'Z0v8_x}` _0\kY<Ձr#굧ږKfeB}-'cbC:~N1t+SW9bc^ι >~%J|_LظZ||{x  s@"gU}!xAcp0Gu`' %] 9V@{34繗^[|w0[ꇳsa蕘[iUE#3-dr9?gYw+?Š<DZaWC>a,F]|^a}@{xb84pP.vλ:7 k^OK5ΎvXaalǣ[aB|-{/\p z%bj4`3xc\[_ve=g V}wWVZ+"[C FKC׎5JwoGEk:񕣃AkmC|-wkCk3f$[FAǥT>@q.3 mqVB|mlW _;x%kx1!}\ykY΃kg9QZew<ߛ )g͹/_=@>xalXׂ5ٕ0ð/A\zcf#Z*D FL0fCW+nTī^iUA6[f59 KnUk[}%sz+yh[sG+VZ2V-YoƋÈ;D2Fo^kًtV𿣵PJu͋tG:F#;[u¸||ml9;1UϑEpsiSMNлF-k 5Ќg _+5 _!55IZ@˹;F\yG8;,Ab9 ^(Ұה֥|^†ƶ1Q1A6qc"y~$A6fO/'iO|MAXOq)="RJ(ǘqimd= <+ЯRxV(mqgr<<+E|ٶ5Acm LACvOW0П9s]S#}GՄ׎ yO!;CbLZOCNMkVߕWN4^64bQKڎaJ/t^%zxguP>&CpC W#&f^yƩ=V k^nKy E+no~d/ +^rGZWS2__eZ*',@r_)SXJ>/k"}1@zL/tݑ,oH<:pߑ;ڍ'c:g:v8}t>W*#CL]Gx!tClt6TC!ZxZ|gYX3> tFq~I ¶Ʋ DŽ!xfYHk֫@%{ϡ7jW6zz5أ!5\͵h ma`y4fe\ z5XkX[M$wZV~en_{@y*9]g5{ wsWyY=㮨:Ds}s}ZϥWgٯ-j{Kk!euc:u9kq("y&BMjk]A0 ˾?6mcwњqb)B8G3$_!&?d[ջ|﹯]=Bu_ǁ&sFB5Lp䜓Sr44*}}-9W&3Lk)8G.aN9v>O8jӳ+צgWHS0*\$Yѳk7a}#hg%XpgvFUex6 VexQg%ml]b~)V~ We[Y.>Ye[%?cVY9Gp~^a0 Y{?vՠ=wAV_f&F ƁiTު{lF-K;'>_3Mڧ +uO!*sڗ~_O_u|˸:.ܻ}l̻_3(_KVJ^Tm0_~Ic;%6Ŵ4ʯ}ٝr93ʵbo}<870D##eڐ^KHJSvJ,0 >+Uaƞ&;F#C"4_c{2@&4ifGC9z11clFz#9UuAu9CD_]@W[9#OG=@~ʯ Gy:ޞ^K6tXSNx!#;o ㍿񇿕0ZVcJZ|<л~ʉ" 1g=}dΪ9=wZBgѝԌVn+/jrvl4Sv)A_{8Yq)Ĉvaڏ7gg0+Pr`W .4mZS鐽Vvr:xke1'yȋs齜y>m q*^ʝzyc"gysA9;yΝtsx˯)]ckC5g1W0w8߮Q!fU kP=ZU(_{|:TC<۳A6X.׮Ӂ wiNo(󐃞-}:F.צ-ƜDbd*2=AO4~M la 8;a*)T}%,J\}u|ލ.!"kBֆY"6MG%~ QCE_!X~5vPsCsQKfk'gLKE3k3-LނHY̯r&odG~<%BcYұwl!Ln!1_9^𵘳21Kyk1ge#^*? hB-Ioe>CBE͓Nj|m>k'yr_ךù^3[?ypW; ZCv o':k:uD:udfjPy=_! r/@ mVet+ LX?5v2ӯkEFxgxtگkuy!]Qs 5>ks^;V?S~A^E[?:с?:[?yF9Լp(k׿F9iۮ <0Zzc>zukw9,mH{uފKbv\ߗwG0/ksM{Uji st< j". ַg;oOj!\XAɫ0MB>q!B7|u³+uZm~[^:^Q0DTz7&D¥tU:'؝G fp_Vٯ.>&`aK>} {ѱ7_.M\w36_ /|'aB7w?>yܶ1G'd6l9&6u)PMNsOzYO G#j^ܡ9[)whoNF9 Lphr{H~D'ۂnwx-NrE+"\wUrZ9k;:_ĢRfCk{sP%|dOQ~y_a6_݃z:1+Wxmeϗ1뀎Hz0tD2{>W:>,}ᜱ|/8OGatp09q`8sw%PoBm%=g2V2ڳhF̱ȱgg0B+IE_lɪKm)*)ro9w7GϠkJ,G6Wr!3 :"ge${~T=dZsjWZVcG~+tz+J65x,k3U\f댠W<29Si$nەe3Йߵ^C=ܚƻon{t-17Z9і1C]'~N8~sF=ݑzF= \9=k+wUSCq&Irg#a(aWhJۦg"\>l'~3U@!~o#9j`vEJΓ#5e?m^KԔ4y [`V.F|p+%{D6_3~{ `?@՞@sZk eT8S^1~6F/ׁ^89dT2ёk*|kkё eTud6rAzĽQ)](NJ 6o'{Ew,}m)>\ZV/?rҹ/t'(MkU2 Ƽ9!xrr;59~!xrrSTZrS F _;7LC׮?`d7lӞpUs Ƿ'x ?dO^{Ɠj{n ιmQhĊsoLݨMDv0.ڤܐj WޙNcNkag7.`0]2a29|o0҈5o0F-C'F+ޜY!D_,kN.@ Ye_96^o,#D,7ľvl;"XF/I Dg~Gv ܣwBV :L!چdztD_k,y*X2B-G\Nr\ҝVq _~oX }.=o_cn7, _7&afSr [̱{m}-zc/_J^౶2Kߡ̆kѫᓡ~⃗* KUfiqֵ 4kkEžzE?X@awo=17z>>zcncy O(aWjB/I[fܿ}E1:`zVoĞ~@ط ` T3j`&N܄q_1d_Kf{>=0}v\cg6ї<|ї<ً]7Vy߫^Ե\G}zC%=_~KK j0~;x_]{r .`Pϊ d.-Գb>u9t!afm sV2@[2`l}W\G~m2בpZy_Swط3أۊ9^FF8;b_}U~,% &~/ޯ2^@3/ yS~FܩF[sфq 4"Z3x#-|i9x杵dgY2?'x.x'<5S#:eץ}p<֫+?8jL_r~M;gaVcqo۟5rd#K,M|_Xb_ɾ9#˨+k >Tckok$3A憜UYZXr~RXm Cίab׶gu|qg%jb=0>GG*Cs+_/ٕ:.g/-9[9 Pz0TӍPሜjVC!o4CSㇳ3@ra L*ޥj?Ai׏XV~k-G~b-)/PWCcCQ+/Zj1|ٯ]# 3`4 ֘UW^~cKO!ϯ5C9,(ac7_nLrk͗9ړuQpɺ`1\Yi]#`wyb _; u~L?LkF {EJ:G0-+Rߣ(;$a~$?Vgjt7%p8}l̰d-s_ܱxϑG-^2_ {?%=d#*`Rp(#F'mzMjݝ[z _M9(sn+/ 5_{ۺGfĉMnm#<]ލxz|6;===kOP-sA88!vHT;%hec?puOPXqr>''?j` ~?.䎍i}rxӨN5؟٨ZqVkc{biVz0w: Zf @8z ns 3yGMٹ0 0J!< ~شk"X>wx7=%O`^[E}G0y:BmǼvFHa֣V?5;o4Ƽv̏K0W·iVWƇs ߌaU>";8+y-8 ;q_[FCܤg W7YJ߸ ^HF%/ʗwoyA##wB?xPu2UjdDBϡ28O2klo?4FC܌~ȻFr?K DK/6 N,zvYlG Y Iwc0ޅk<6v=c?2 ?rkf5~1zbM*q{g6c2*Į?p9<3 cm3Rv<۹G|D><>|r!*Į k癫_Z{Vl&?}]SgCuÏޝy->d3ֶ' P|ե}W>:^9h%< ;2H;&?diu~9*»Ϭ?ήa}6i`#:w4&9Vl^ ī]kU|5pU**mk[ 6!ipxLnNN!} D_˳ qDsxģG4#~mZ_^Nqd ꋗ{Cf|O!Std7|-u t@˱׎!#_Jm;߱2e20dP9q=SF8f狜ysX{|#hϙ1ǚXɱˑ|r?AX,wA'7gg!+p|uf^ Mjdㅣxة ck/;9őfўv}D_k#Ӟž8@a` k~^sfH^;2kR? Dz^+xQ+dSWN sV>$!ob>+'oRʙ=8%=8_r:}U#Z˜Pi-3SP!'?j@c5HX5D`SլעmnЪ6_hh]I\Pz-q8DUrv9 `0{KԲ8]@?h׵ʯWff5X3|;#2C_}+oJB`,1u`F.q:fKSlEh_-=oSz8U8U9p#m:j<)rkZz"k Zċxuǵ~3?' 3쯵<5e9޶}'A?G!Wr]dq٧O;⊾W=ݱ9G[>razl+5t8yD߶xi^ZuF^l^Cknk۾%/ 6*{ j@U^aBcx;4wy~q\]u!ãSVi WW9CJ,tH}{fD.̰W*a0>a@M#lY#y74J}]-5 ג}+ޛ(a3{u]`ZCc֚V{kMu6[0KR9Ә_k'> /a Df.:ʮ}YwW2Sbބ[/gW`0^&M̞Lj(8uC~܇(~D6 j~l8}VrhƷv_د]WjАw zN"Cs ڈE~(+!_<&De|Ϧ's o-gP~έ̫5^9}:<^)(#!SZb.v\ф!F w!hyr;|Vʹ,;lu] b+ALy\sU*0a= zKs:^]=ե9ӺFb*sָsk忛f#epo}{,?}If`[|}N|\IʯzIc8Y/zys@kWM 7b T>~@kE%2 G|22k̠FfPGƽ_=54:*"^4nOvwt,xNsݠ_ŲX#9|cwG88_;2b6ZfAF2 -?3S9b17nY7n< /ņa+ObmU.p gi_ c|bwkcݭ;@ݺ nX{Tztq0j!g#w?;)3<[ ^%kkV}ƵͯV\NG#3׺2]>[L3œ2b\攉;Ü2|G=fzT8vG-8@xFCCq [y>/{5foc븦9Eì׺؝I:j!O;W[Zks0v}ky0s^ A_*D85AN zI GfԒy,G߉Me; Us=ry-P{ш<_Nqoaw r_]F.b~"M?&e\_+a"#(q| Y>pi9(C֟SNRj<ܕ +x^Usa1wƒc!7fwh<}иW5x}YSxjmߏOc !RpD L4g~e2SO\%o.ucMkYż>ʛKgq]ɾv/}~ȣz/FVfO`>wvg=;]9K%ٕYK+cvO1yV#ڔo^c_͟}gg1 /]&m;hڄ> .5;AΏV^' :B~{97~rVC_rZ5s75J,ol\c k_`;Q`%x'`}mHd`me+4"jt6OV#}) _gKxeWpFkZK1ϫf3ᏼ<[]uψ*@?dzD^U6d5,G<9feT> >0 %0  φ`voXZnW딾Y DT_-4h D1YX-vZK >ދq򯍋éɯYW㜏_J^(]xg>:J=d{B9{#+G3_#ٕkkKGFC v n׊^۩BZӜڑN]}r΋}펻%0wK_ D`q>>jyM1y61j9//F|~pp zC+Fs)-꒸Z~{>Oim+ie|+fgɯ|!]vk7+S6voaWBb[bytu~wObxx4zqWrܿNqךIǶ5|ZO283NP=|{FiʓjOZA2<?s6{ 7#zm~#BG,.;s: ƩV;0`l(2ڝy.:0{Ɗ`;g_;ggy'xZeG:^5 vכVmɗwNh ۚ9vޙ]M2FQ=iS:Qb{kW'ֹ:QKxkㆷݩm?( n DD_lfVEys0f*IaLY vE- ]Yv'=gB9[1jǪԫxX)"'0}|Qvn 0c}? \@*D1Zז>pj#qlI5=AymעA$k [f\+;Aīl]̕2 YYAī]y/g00h|pI4R]qm\ r9Ƶ.rDz-\K&/Z Rܨu$kKH#~'wZP]xrq֭ȯrޜ_h$zk-8Hzk-Ø|,9j3_מ'՛x-=f6 4KOt_ʡ^0\|)뇳saa(ixbڴI' T /o^2d9UssӰI9|ːs4^ 9g/r/xsr9vrkSi=jɮrFĝg@I8N2kM 8&Ź3oK}+s1k(O< <+o5hJR҈=?ss z(BΑpFL v֎.F7ӯFk$-i=ʝT=&kf#-P0#sQErH_(aWjvڨ֙+¨Ciqb4r9"x¹ ~的 y{UA{4RaF![Wy4nY#kwzj1J v(#gV%uu.E?+0ׂz Pȷ C5) =`P;Zǜu1&YIcjsү⾶9N jQ/!9™dl浩w֌raz% kUht_"Ejb-sc-φo E cX(Xa,[I 5R ^g3025?欋s|\WN:w__\WNzYsx'R pֵό)Nn _DcV{`}_[{ [~Z+4A}m1&_{Ř11&䇌/30sVs(w9ֹ!3w9:՘EמVetjm~ye_;2i)cƳכsaaۏgT*ͽ@D&$w=#!fb_{]X!ۙ fï aF;mk9w'Sʨk}O9CrDyˑYQ;5}X{j0望c㎊mvx~vr-9nr_%G4/rD^=[ɏs+Qݻ<s+8, wkcP~ \&_9мvqg"؍X+ o>yb7g$>e}/ќs~7t~4fM?Gb_uߩTUx v8,+pX[g9_kv=W=+ƒm.kr:X?Y!is,g+9Ojfm] էs͜U!o>d~VIͱ2w|þIU:'ڂ mzDbV~߮`z*%XP'Kf/L]9}__$Gt?':}ti&r <\ώCk" GkoAך;쇌ށ-aZx'~ O'x×}y:/w/(7bg v biU 3}4WCozӿ:/g"M5~\Gkt)|+j+>-G= ϼt<#9kGkfc ubhr'}IO7r ^-\Xceģ >^B+pwŘIk$Ż2Ļb-ޕ!ݝVr N3%xms5VлmġVüzXLQn­N< ^[s:gڀw%Y<[ep$xmP x*eX/ᵧ3g|m{S('kgӧP㋲shKq迱 g3i yfKﾆ?DwtzrS+ޜu /mGMٮFh_wG?wD:w~ oҐ;^[pq-׮CܨO4-?=׾_ od wE{? JצhO](,6qWGC+R!hW&Bѭ3QW&Bd8USzd" g)N~W^|6ֵ#/ y>燼}ByE*ᵏ<wSkL ?d ܽC^ M5 褿z9Ze@^u),@^p3qz&Sn>fapβ08Qywzӟηȫkѧ Do^;|Y![! m`R z-<8br^z_m`z^;W\;ܶ%"N.\9¸,<Âa&^iNQx9>R+.^8Y%9y(C8nh̗X7!>'GC8h.{arv%x5 LC^2Jjhƿ#I2x5=" }ꄏW;LJƛֹȫ9F^moۍ>Ѧ^^_ ήhB]gL힚Cg[^^[+|Zyʵ%FK/&/P]czג8iyQ xYǁ0Q15|ÐC_F )}'Ї^8^9_"ӭ;v mqe/ g}0[1gdNޏ) S=!&%|V:ZhG?C)X!FCTPQWrAjq.^W۔ss.lNq`<*bwDDw!Wjg]+NG3@R(aP1^p /\y7S<4WuzwS N`:3s=*:c7rOr |d{: /_[:TV))kJaGVtp6<;J߽W<~wU8~S<Ә~WXk4!_9[@K^rVsVLUe^ ,{qڣ8"Gc_Z#9L 9kdCՇ}`-'O΁\)kf0]Iٹ0 @J1X+%I캲i00 BN?\CV]o,zOY_ND 8_9ɣ<iŅK_(v"_(4n`y|Ym'ֻVn{x/u?/>jw;W~UV`rek$;k\la k&nIc'9au|S\XrئɅrI{- k6r`q)ï-kCy0Ę a>jF%~O注sk3_;z6;(/1+~OY;'e;܌4÷2zϹ>;<p^- f~y dIaFEc`YP[iʲqZ\901,2L\Kq[&|{ 6%f3q|kS-'4q~>dze>_73Ja{N!O۔UǗ'@HlY:cQǔ(;޶4cwU+^?˙;a|`j&9_2f/ |+BWaO>9if1XyǪWXWM_/9.lF{0|ؿ g'2=zk0BmxEFk Ư' (d0ĒtH[Fe|Ck/aL|/9|/0ċuat0u35f+hZR'fw]g}Ř Wٹ%;@tKkFi3I/ P4U%f*Z,M̮*UG1 vŰGk`vEacC~+b5|- LrӰ.ʻSv1DBh|8-xRIawVU"g"EVuMFp akw'+N|rǗ^ۆfI砯:_* qDI<YZkF_kw2dzm9ЛyGW\[ƛ68/ #Kks֢Pªo;|{lUG}b+굕*+ 9bi?[?ʮB]iz=}1em|ڻ BY}oH>7~ߎ7)gۑ\8,rZG5ȼ*ʇ|ycݗڈ|ڠvpNЗF,^E?f[ |-fuAS~e ~ lCF_oA_ pˌ,7DڑE2`0]aOl%hS~?\ cV݇ܯB¸ex[1O.ܿ.Z;yr)oqrWr r}(#굌Mk`gD^{|Z(;A__lWgh}GLbyٵlIjk=rD1󛏑{Ϲ/Us nj21/xQ)^N<^mˉ)'>V-.bQsQ3Oc^xi&maB7sS}sXʍX9k|-ǂ[~QjR7a+V  Q6/ #{ip4vifwlW.MvՄFxDWMSF.D70VFn!RO|対bbQʓyZ,O !7[:~VO᪓{-x_{a,SsKva(9bB<'!1*y4y\c 'm>{W:D+B#=rf^P};59{cOoFc\\$ffu U'/se<Ƨ$y`48=3UYv`J>a0a25̝5ScOÊPaCײ5Ыpb^K6A^V Y03(4Itb;&B]ƷCzȷԤI2>CFllGH>2.d9s ﷢KVu|,~-[C eӏ tKr"c[2 `{&#}IC=xj|C4Opȼդ+!w8uaUaDW0zDc xɷz ƽckfjw$7V\;|m`&:B}¨Zo 9SSruSSru9Gw%R~ EWZR0nu>1zB:&됦cש8#]oa/t5|GzVpz&o傓y7F2Jb};{b?da侇/$_/BWBP~g#.btk{ڡDxzQ *:Ox V9ksosvOo;:}9o@oeC>7B~w yc112XNIV6iXqK;w L7vϫjL/8Tc{cM켫N^ҕ'd` a޷B}55)ߴ1Wp4f\o,!s+ Yѷ f .Jӷ}rN OM435>=8q{7վ9moq9Iҝ\ G~iν̼i܈*{\G%.tuk1rpdCGk1z^=cPCcnv+Gc>OO, ՞4 Wru<U -Xeg0 +#/oZ0ҴF>!w`$pX`@޷3}![zon3 mx6sQ}ܪw oۆ_ Rd/y^cv2ك dloAV1gǔ絳DIF!eu?Gըvux瘟!;ｴMIc{oC_ e?q= ^KמkQ}ͷ:/=}B_[U˙ܷr{_Ό^߷g&pe#! +Qv Q>r8gMsb]y5Ik@7‹z`O, .ٕ>sД-̮t?e;זu:rus@s;tׂs\=αNr tԞ~:O}myfmoɹНtc Ι;p>\;0^Ty ^j9orF&jCﰇWy<ë<!wS8VufcOޯUz]r[UȱoQ,Gx#wdv\.wdv8+|mXUcܒX[dF0K9^nP6 ؆W|U>ϋkDŽS|,}m+7K5'oN7 7V9V.ښYX> F- v.GfcE3uGvssuG=F-*Q]^A'<8! OvjבAmkRϿgoT=]ޱ[%:Go5WWe'TllY{?"/i4|3〕+~Xhx-:x+>@[>ǤgI: 0J@hBcyڛ&QV4Ďîrb'׀̅O}̤6ZΉ>&^^oaT^ݩMCƒ.9Cu>`p>`9QSwcti_MoU|N'y2>+~z)F+˩WCW-׮ >MnM u;8v,,yab*'Ƃ;0ϑ Zyעn J3(I4"9goFf~ C<4ӫ]a/KJw/e0+amVrj,o~U1oĩ9ڏ MڨΥ&,±,\ku}#zʉca|<*lWV76ߑC~$L≭KDFh&7|>_+,L'8 k{(JXl9А,ȍ-v6 qxb6q xb68,*d?cE[`3>d5ͼn8&/CF:8dp%ϙ饁KQ/ͨbKFI0 ° 5l6f戆OpV#B/D-z`Q6P]4T99_T9ԔQW.o86Xe2Vr xxcS{F~y-5,#BFq0jnriXMފ\GwUk\GFʊ9j[b\;w 's>5I2}|/o[{CrCd༶T~ș[RVcU!'F8R?$U7|yyuEI%ΑaqLψ!3\la qX+CJN6M0!/Z7.|-K_+>/GۗZ&BG.|є} xʵ!+ YGpԣ. }?{TF ZSs+_ԔvNDSS9S}퓤~F%B)V!^\ܤ˄9t3?GO͵*'I-@Ó$!$ #Rt_BIpD)k׺Ѫ/=.u5>{z$]yy&+/!woaz8Uwo҉/Mrazbbbn_n5LO/Ƽ*q k >Zs3t(_YkvҜYk9]@g}¾eֹ`o+[H}%+6% .CB sggdcNPO3.XyEg]{raz?Y.G5kYQ q-ɼY/CNȢ~5AӕF>C,Vz [w/gx P;җ#9xA_;޿eg 7BMvfMQҢڎXyҖҹuK+ҹ5aiᜫCN88=|/s^'KxNO53,k/~ ګV$n>]coN^묵Z_ fkvf~VZkh+폞n=ɯjt%?'jGDE|+BaDxa q2!m:zv!7ة}T^G/r0bW9EC;3g5/N,m`V؄-CqKuk?F//tiFFoᇬ[z_~ܮ#aR1X>W mo,t՘>3\9q#l`}>(|DoN=eM~wm)kߜr >eZCS@9Gㅻs*u{Ы׾fif l-zC#oe|-! pMz"&6r=E>Ӊފ)_]܏{\1*Fo\P/TW:BZŸ>{YiC^GV-0w@c`٩Ę;F vx#>? NgI-`W>oӊQh}#}\ߔ WQu+\mlg?kԯrgVdvj}.61jG4[՘FQ8 lYpNeuѯVHתVHex1̳Zitr0ų4| U>ګ}د3yfWXoBL.9gjn[{`X{O kcesc ײ0j:35rF(ð_2CzȉsO!#3"aڒ w?؛N\կ]#@BG+دo8Kv_{SZܘA/E0~mk&ȑ s bs ȑGEv]qLo.!'Zbk*6ugQYM]sR='\@ /9jt~cc'GvlsgWʒҕC^p}5|y2Q$eY:̑;An<׺A8V"mrĜ!gY}8$qDrF&r w|!@sMMDt^C1cU:Gi,>d~-s Fm!5Yp~y8_eD,YE6.ksïEl @wQa߇_k=lk^_\pKXC<ǜ:zA;)蘯eg=3"%ra z%_ o&&CѬO/j]kWvI7jȝZ]CC^1_+mwGKy|M940b^_'(_zm1*0zc1稗'Zc74zzma98˿;ߣ985m 17(ʧԭ? .9>s4_?w>89!1VSbdGcWOFiXr440 + p3zSz+>Nh/g۪jW[,bn1q?1>_r lu{I0 $f˂^/˂^Z({wO3_dO-;2Xﷅy)m0P0J "&+1xfMvaAM;SaC{cv}G6!?҃s{c\ۄM8*.ځ#p9<5g2j`m|NƟI3lA>Ls}88?rG}?:X?džXɉ%=Y%cWV=Cǃ*CvHsw(q ycG‘:gJUzVn6)WY:\Y?ή b}EEm┎ qJK$2Ǿv.k_ɝ0քɝ?Ęl9 !ۢ\s~ڗ -Hyj4/砶'zFv(ݱjB#hdD;u^&Bq?3J/FkO|~a0Ǵ/J*ruXH-uә0fu~s:FU#Zc,9|GUCo(h<}~$G'Ha}NjهMߏ7M!?bC=&3s'=tkiܘ;g}EoC5$k|䇼 ]+>H]oz_I]ύ!M~?}qv6 @ <~Zᜆ5]!#Z<Ǣ9MkEsN˹'4鄰4Z8rDwM]w1ҭ ,k_ ǐneҭ`qDr=n8מއ`pDr _9l|9 $yrkhuc8;a^Q1$+V8v0΃yG2-l 2?ޫv9*K~xJύϬ܇ u|f\ruc9dC(npj~ȅܭH2.&F!㲫oc8gwqHS~0:R c(ad^[Eg%erKYFּה)ޓcFEqyoxm3wmTvc*;\{\ra z/J o"VCwYY 1>[̹99 LGhss*e7и C.nMsMN<`LqZs/C6 _[l8Żx|\bJlG{q-0_7"g]c7zLf:>lÇ|dJ]0Q5 K'316prD=kۧwgΑ9|N;}߿9~-7/Ɋ b }Q"9h YF^6X!lpIOT,rKEZ$#DŽdGU6#ԁΣ+wmikXb?N0*ǖs0ڱ?nb4ʑWY݉^!c^Nav]9tNʺbv%5,ØA_% ]+|avř%ʞhoO?C(dHTVU'|DS„{Ǜ.'u9wUm]uWu-ꏳ3Ba蕠b"+md,r9v9Αo+9`܏|[Q9Ϸ-gߊzpDxΨ !/H'0Jل1C&OFO~ufʺ॥'(wt[Qs8uv0ֽy\cl## 3ϡP!f~/773/--q+y+ۯ1P]c<",`=V;0Jſ?L W1:L4݁211_0>8ƿbKYHIRp)xWbKK/\g#1+IXrH4lvܹC8~b cVDOབÿe?o_rqϸ0m@<עyV̻KgޙZb}-v?@ C,0Kfa}-=KFsn4~ؐS12g+c]kBBK5o4PhpY)sqqU.#3"#ۇ=`^['|i%{op>fE}-BKu}i< F?3c}8~WB?YٿX5Fqg`ݧ2.~O[Zr dCnVhlbzC[=4oG^C>\8zRpԺyG+#s9 ,Zޓ0&+kyit)Ht#đnC{tgtJLW3j9~_\bljsZ8^(4Gʈk;cpnEGk_֕X8z"Q*g+۱p8G9 IwF pa ?!-΄$ 0̔^~cЃ׶p z_Gs4,?>}__ DH?I[Q⋙1+ّݢ U iLnhL%CN2wb@' >Vc`C LZj,PcʩFSjF%xV mZ2>})دTkK/7S( B҈r[;ĭw]~}+!]˯m=eqzqv0 O!pmR+dv K-jmys<68c;f.̏1L>чA8p"|p:#G.į}G GtMזAbI~msrD Ή)9(>qV<ɇ~9;¨eƺMRCF|D'{w褓]g;WW݊]mt'͹7~ üP,FlD_{Q=H}q(6 7#n߫7ȉkƨ~8y/|-F4rU"'^:jH~\~ݸ[%~#!xJSFކ|i `E_ZWVɗ?cΊ*-·ñȬ҂9BϬRˬ;Sd}b47I|M-|X0Z/# ,,HБ1uȝ~3_Ce#4"̈JǫsAJi&a@3-+ D=˭R-AY[ <`= FOSF1T=sc 5;䇜6D=:w9!SyjCŜ}=jtڎzدK~Ic?ӈr7q',6;A8}QÏ/s&,6{! FgF] g*k(!  ]_[bL ͕3LwGx%Nw^I׆_t__3{Z\ڷ\0wZi, g&N:0t%Ґ*ߪsJ֝Pc0ʜgc}m识|ӻKYps'w޾SwK(78]K~sҳbNt_1_mus9W|ݤge k0n<;'/0Rb}m{2pKWFqpWK'_Eg>o_s+?aLC1=cØw1VXh_o9عPjlky0:y%zc+/C=u_ Fџ66]0tӓ}Wnڨ/t[.F¾#qvH 0BSe*g?E$o"?[Jע Xb8xcZZQY݂?0מ;F'<`!nX9ת/:ѳ_`FjW~M{hX=ccI?L\[81-qޯQG^ǷYvwG.MjCcUXOU7CnYYxOo }ffLh~- }ힱXň`4ﵬc^kyˏ9(w@_ CT PzM*3.`P4&(*>/k?|<'?CcKW>ĕ9}NL>h }N:ԚDϚW,PkJUeS?{=/8Ks}8ځ&G[ݽsk4=!o+OPH&ˍ>;qqɱΞFǁ0^Ǔ>^*1ϩx8qQ s*^3ĵ9x09ĕ۔sR\˓WvrNOA?}NWzsi={S9XCNr֣<'ؾs<߰z틳3ma]zF-ۀ֏A l%F`E K~`l/ #~T&tc5 vNJ9\cE@-7rN&BjVre"kn3^n\r~K;o+Wn;it|ўN-s:sJ:䅱7κy_yt4 }tүhfN'CГtc:<9;#c_goVnN͐C50ҟOev[~ۑh 1;.F9OTc 9y]\W=~8;A~@ەQ쭧(JXր4<osms0؍';'a?1K⹃DyZm5*3xFڍFx-iԈZU^3X &9ߕCGaE^[^u ?u8kCh{7P)ysNk}W70}1?_@bq&|*oN&U472CqFHq_E'|mh%iuޮW/p.raz.mq<_RibEQ%+GbuKV>mCؽ9Z9: RVFxptGă1'k^Ocx]э [)M_>W*pFvEߨksUX/b#НL{yPor ]SC^f/cY)*ezW*l{ D~xc ̒_,Q#= c1?#C漯Ĉ]2}-1bWyJ-~=IQC_[~ ]GǗ1﹛Kjm+k-t02J%vrLvA?A5:ڽW}m|/͜2KEc_:s|VWjjbO\o AR/v?9=]nEH[vKs7=/ #WZUuΎ}+Eb9ϥ:mX:7mkXRX|򿰰8zo#'^ut(OFEkX^0ėQ>?hsi˘'׶f9[V$C7rt/ܡ~5 @Kl;+G-!O=c|ȿV9Zz̀'Gӯ y>ѳ8go 3'F||`/ kYqn̒ m/7q3I)}YkpOq>>a?ㇳsˁat{~@ܽ@Ǿ_; mg?0j^'nk\]kOn݃!;xF [v"#{'xwZɻu}|S>:מٛGrV8Q+c"c{?NO!bdJ@ M`h^VVޜ4nM7'M Zط' nÄk';0#}z6[ Iv& 7i]Y>9[u[$텱n'I0 ? OJ3n0tȧw[iRvF7 0] 1=Xq `wy,>*SW=Kjｶ\2x4gzMdzEx%zyYҽvy̘k5/kTg $ij2rJs1V3<9Vv9{.zbK&=!xa{/E_E9ڋr&_$G#q__rg;i,W4꽶_0|׊yM#mg,޶|2}cw!Mc-xX˞Ƒ4Q{1ob,l;k6f}p}vq%~NvOF3_]1nbmN0򾶪wOM裮ݸIpnx_ ?gOvP1^60' FY9ͅD,x0l` =daM|<5{OKs~"=#|۠'ʽe?r|Ρ, 0}H'xXGqv.I ,:yJ;*/@Y,Fz՟1~"8VG_0|NF]篺Sp\m+Z}pө!q0=dfKњ}5zy8=JX*ɪϽON %8>}mX`}0][?z#7F]GaLǔ5G<@JGĨ9ɜ# #BqxAt7`}F3_3Oۊ M;_ܰ{솧^GyGjr 0"|]04@|(7! Pizȍ!oQvF 0 ܥ$&-pY|Z=~Qׁ`rO#Q-W1r0k06t9c`Oy1!#Lx⿎eDĺ<:8f`p0;o-=J_گqvs=T[tj%ȡ}mUGNoZa V13n0nܭkgωFe_Vgy! /CNU{1w]xJ6x=e6x=FtՅ)p|55O;ON܏ϳ[ Y>/l1vMeg! +`:żvkBKN_+?d1~{9W\1v1M9  ׊P-yd[|m}{WG_?]0%ؙxO%c@ؗku̎(ّЋ \}(BvCo9_ג#vtN]yq4ޏ[eS8vb>B*wSwRoDN!y? a?ϸ a¹l̓_瀾:g~CcW':eavK~8ŬK@!g= LJ3ot F9_#7]F Go Ǫ׶,ߛT~-4Xp.k@vüa~ipvF0 P2X?>eU(Fb#ևqKcFNg^ǻëK~iǻOmC.͕ǫw|mG pOcG j~Qk`+| v]3\|m]36q~1_K\}ʗ ^\1KFˉkcȗH? >5ݑNvHiWYwGJoZS͸kzŸՍ̌.0/-t 8#~i3gdxmVS?g4tvn/M:8W ]U#_쉽󵝚|3oa_?֙^XeH2!۲4s231WԐØ/ӢYx"x:n~qx-Y9f.冑VH7 druuܒ3 _[=znT-@7z-V'V㖷 %VMײ_¨_;ȇ;~-%=f참EVq聏VbxRv.9 0KOv_UD1j]WG3Έ{םє;|c1K2؋*k /e0KLM!9FF;ք g^tzqG KcRG{kžcH?e߁vFi^0r^&a{ax{` 3?uj9:)cA-G^Gϖ)2rS/q^Kƃ=,.b"yHϢ>nDP* F9kYO<ٷ)3zaml?]C^1=sW>\o#aR'o C]ǧHW1\OPWRO0-U|WNk35Fj 1Ws64{TJ2-R23f?d5G'pd?N K8ȗ1|5W†!z=)? B'R+ 6i{ nuzcOx+ܗ{MIϊyXt':ܗ b^+x}9|1fr'G/b\G\<Ӿց@kDzǬ9vKk?SG3w3ɛ1k~l?] RT_R>Si9wucRx9 gΎk/z)6c9dΎJ!O x:D.|5HQsBaAzN  3:irWUf~}]U~VkWz ~^a6ʅk{hrҕ{+sLK^b,Ob m .؋`cFa!Lyȑap$O|L%M#S#xO79_{hd S,,^8Dyc^Vs?tu#yܮa~$\eR $ˁϩ0F]y9z`W'_/LR^/{j_#=م"yylp! #`JoĔ赕\~0&A;!׆1˯ֽe֡ArA;^5԰ mnF2$/7mN8Q_˼w~`~ĸͫtێfg1ҁݻ嫎s? 0*w~-|mјbNYQ[e =dbaV9EDV9E~yƒak_l&]?M^xV~wm[>'*q`ı[mqXiC,w^ЯCu]X9rn59=&ywK'; a#s/Xq~`։*al=ЋÑƈ1ۑ|]ݑK'c.VKs Zf mWbe`E! KuOs6a}3Xî8ǜ]>kWѝםsT44T#ݤ 2#I-e0*.ћ34.ћ34BXѷ24Bޜ}ٹ0 @JN0bGm.hy?$5aA=XkѸ'^=y\c<FQbqW]No赑(s+c _8z.aGYvkzQGnz91aTe!+_l7Yx*1@;_-x IK8grk}`[v/kQ*s,T capb^Ks#d1ۆ^mp 'j|ʯdL6oy?.0X/+IG caL?Ĩy-sW~-Ȝ-!-mOO^}Ǚ9Uo9+a}{8:C^ȼ3&nsC_SzO;Bg?:91bӘMګ:{zYK+$w 8ZsB&]쵓2e!ٹ8@J|}ug Lz+/B(3b6g]׵U83j⻯>0VRdkE~mo1_s≼)xelCF%ϗC&Vn~&_"UB+'r6Л_3uiʸU1|1W~x=ºW޷u1ozr<ݝ##k0~{-ub,e!-x>!L/ܷCLZ[u2J-XЉR28.!#1 x w͘_C kư'4K{?rZ1ڕclurz%X+)T_#<,wZˣ䂓a""'c~K0zs`EH;š*ZNE:8WhNljЧ>Fo~k+ZC9| b6kś/kw_j& c=1['FxDg ?. f}mgԾrf^>ĘSOLqF}m|Y+{+9g'=3¼|1OVH,}_\9#KWlLk"|zH훤9koo;}m;S㋳3aaBI.nabDQ}~>C G ̐S˗rr! 9i\8◆g:2"k~3_EOrג[jrs>sTzgaq"G=Ivfx)^r}kOrDs]ETϺ&?u܇>ƞowdrW^5_tw @tw2;9_1Nqy'OI ƃ|a$ݖAoxS3=zssm/wݖa=¯}+&s+ϯuZ_gn;@Mw]Yy׊}wC&uF'BZrtJW&FW?g+0nWN _mnw66P5[=B{{#߆k1(FV1x#Z%/ ~:=<jνmcW1R<} ˡ&g!C-I)T1#&7_7wrc4m;τвgSax-#sݎ%Qog^V>󊏶Bm` @$]^>2Sxca/Z#wE _R̄/<>s.y?>F mi H}m|ǯ F\0xZWеS! CheUaw|}1볽N{{'P}N,=<$P ^_KO<qⵜ'ٷr8x2Mc$m38;a~)vc ΈU**:,kJЫmƝ(<25;),9XMNo{`ɼ|F#5hTq4*Fsy˕'O7JJ nT2M qww8nIaivHWCŗގwNA5=`ԅOa{^`sOxtSF3~W! 8[^].XҾ{sd @وD;9g9色XƾU~4Vݘ1$aqۇMN~B  hypsWv||`rW͹_[*ٕ0ð/A-M= 0U[lNJR=}V9H_מtЯ^$c10O!Oo<9oWydnZ?f2VI"%ߡx?{J#=l"B03fwj9k-cӮ8 >Q+cGN陟Lm-{z'VU9xl" ϼ偣M8ߵ51My&j ;W̙gjskbaua*3߳_Ӽd#\#ks8䨝>_ήa ]mR-mSGvmԒ;CВ9k;xw̞>%Sx>![Ќa~;_;;:H +\_묡N\>SԐG}q.= \;/8w[G"F1}t|ht!ᜐhq&}}h>CPy˟) /z9~鋞mwV+k;cYiI6^kp_p;Y8ğÙҽd, 26WFqF kζY%\ O` ]9 KKsɽe=VrCe"$>zƷ96ȳQj}&ؽZ,%/W%>7ԧ{qR@kwtUxG [# S9[m_Xo4З;WrObkI|Ȧ\L|N=K_XkvQ|0}`ע"eg/Eʴ@dAYK"%|९Z}>>=.\pLuQ DPtB/M^ l=z/܃C{/?*{A9;kqK DCչEX*1>KۍxDC?f%~ۚù^{CYl݈GӱoT 2r$;d<^csko^ DC^[!hC C{.^l]/Rf'CZpYXRfe7k>xܵbdv\me\q0{ 1,+sB݅N\뽷J,~tZ2#S!'kuoW, V'|tt<]uwixo6l=|moG'WJ,꜆/e&zmgVvv ";W'kAoz4U)ߵnQ'9emvcQ,\ vׅpC6ʯFV,hҹNf+ 9YGžY=9ΉFa/d}_,ާi48^t~ X fnTo,%IbW`&5i=zzEAl9ԦOn.ku1}d}fsV]Om=֬^ !3ƤndӄOkJ _KΧZCh6RǧK`ۅ>H~_}ާҴ̕7Y_kVW {^mV撅ڏYG9c>`9+^JQ#"O*h!dE8&83߫1 ÒmVŻFdk,ߵln2vol޻IMp\rMQk9_e6ΛO/Zx>;و7xZ5f_<~*:ڨX']pMrFNjW.zw_CٹF 0tN_F\=] H( ~ML'K?kݮԳ/{m2SsZs=WB7:h1*{y~>@ab`m˨Cޅs4}d16z>c ᫍ _:ߙh7-~UQ9YAmV6C8Gǚ};cO]BL赓=;Ts\>*6r^\GB ]h›-kgZyyig Y=Рrv7W}:'OS>V(MnNp}:U~kF5ǧnxԋg:hy2_~_IC+Woǧk>d pA %x]Ԟjc;3L8OתOP/f16S8\'aآ~_:_D:б9zjσL|o g%9"op0ib+VqwTzy& 81t~W鵣̝[9BPԙP5Szm$ D}13B-sDcյ]-9*e _cϏJUTMt܋ZuLco:=1{kt }'ڽ"F>n}'ӌ8Gy L|H gU1=a ^/޹]cdb[6d܅_k"G6|O(9FqۺfŹ3w[2*["uf*K3z;a^ $X~?]]d fC{*^{7/th}rYkfX):1ג#|*)'^kSu>c:*^+1sgwk.7 A<`:^mà0fۂ8X΍~}Vsj'#iV.YgϬ.V謜:QőgKN-y\hj )EvIhWU6y`RY{L{ _U;|C(o3w/9<׻4[cWYpf:vijuNµ[[` !1F۰rk<,j]QꙸצGk?ο=)Nfѥ9F>B$#.5bWrb"b]zZ(B ٞguY'oSg%Zy؇ Wys#ڳg^@?ȹ >Mf~޽ZZS_k7&\ 8vq=0g4 m)zkZ9g6/m/l_3տU\A |%FGL&U*{~P~f;dx5AbW 7r;qLzggv_mVhdk; _&zQYh(B;UGkT~OQNLiӨW}P2x>xrԾ8+KaWG^ } ,`b{ωsV}`"DG.|5Ә B;5e$ 7Q=NÐkJٽ:dC {E|`t3/ܵbk^*Oͼo v%s :89|l}ޝqo q}}E7e[N?|-ur"+3MvԝMLkxgnx~Q Y3] 8[ʾ7x+p7J62Skk.oSyku^Y,PΣ6I`{ך橬u%#B>@f{-'k[orpwyq d0%_\~~a|iAEKeOĪۊ?k w[ ϗj`.` _x/}ktuN*wzj=^%|<@"VzL7Gn'~ǿ p#a `lz&v"Cf3zmGߛ%`cvVPrYzWJ㻇2گrNײ_s&3gi& ܏9Qzmw\<[fז5~/V^iCv)뢟-;}&o僁ʹko;k>9>Swy .G9uEʕ/<=ZCvۙFxƒiiBN'מ5kLR[l3=wotFW8-kj+m+)낏0wHeϻ'"JZ(3܏}v.@Y3<] yU/`c]BAGr g}-= oMC|FϪZ|+Sy өGZ6-wkSൿ/~p?g?䌛SOגMoAwyHvXy0̸M纲I_Q27/$Oz'PYds-ӶS=Go7e!{L2ZfWF!0 k0^K -xVZzm1x,Ug8=G)q9FULΏλ'ՠw[ g@3gG@uvO~aY,#5Cf}*{3;,ْs\! xV}=&ɷb;=ڗs]pPfۃsmbVM540@dj~~-v^g9]':ZpDOpW&lR%g4~u4 `^W9=-u_Lw=^K7*Dc||]gV̦/$gߛAl(F95_{6w+`gQuer1 іdI4"zp`܀:|s=?;SڻPxwj+7ᑍ_dc@<6L9:wRdJ:= ~5M'3"n0r[9>,s> C8-'S{Ⱥk\NJV1<61@7 -עMc~{b`OWJo=@+Xzeo&흡Υ~+PyhPt"U:<>jQz7}?1z\7)zgg3nj[)Ϫ ynޮFCٹF @J bMT"b3%{moxϽ8sZwbr!kϼ]V;yg琿o:Cg=X?dρ/1V]xcϹ|p1CNzlI%r^Ikᒍxs VƷߦ 9y=M9E~u`s-AA+ںK>cL{EᦓeljO> ~mW@T3ʙ\ .ɺ:ÿfAu9q<-*/=6װ?y_+[K9wWxu/,8s2}΄ {~۲|{Ÿc-Z c'&^3Ha 15Vq1UxȓlD1+3/kžx.V;EoY[>+LC 9њ/Э(eqWp8|msϴ4ԘnLvu} 05 65#u4zF{;}h ˩sb[0/p}|S}̛a,nvjLY63R&6SO!Vf0rL^sIB% kW|{0X<}8kQ`5zm4_j,.?^t7^3<$ô%xN"WKU.8xrpډvzi?A DHT&9!1hloj k'~O>x͹ *<>r'bw8 a\DjS=~7ssւ(N3^l;g9C;_ƥ/ f)x)\x軗͈kw1fjw!mF/>?pDx aD G=o>n!o85/{5i&q!w4HrG7#s1-l&N| Z4dIZ~{TL{Är7F.UʯٷoצˍAv5_+#6,>箶19GھVF ~__js3rZLFFoU50r*SSB{CY׾g_^ DW ?XUm^ υ uO[bUxȍ3̣ [{67b&_:o8_g c1'{m~ڭǤsZxwп06:S{yo_[˷E']|[G7k[isrҫ3iNzF|U+ M;k㳂g)^ӌ<)!WjVTEUÃ=L" _Akꜵ}{]qط 7+o'ZX}׾2Xmfv¾=`ũYtW󏻎٧nQ/DOsD= JݿtUgʃsm0,7V* D;|2mw2fS^rEns4SZ:ٻ!Nvg>׾;a bW!`.@$HIE=^B5sr;o^ydKQ ZG)1M&t ,VCӮ=a=9oyV>WX]m^p8y>w?Cc;'03d=E^Izs` j9oQX @5f`q _lU򐵏ui7_#]s잆f?/q^u^&m'<{ar);N+\Z*yi9%~;vf{XE#ZxY+wS'٭wpo`iSx8od%V>~Lnӯģ \XiEɅ!G+Z9_ʠqMN hupv68 0R/[4m -~Nf} ukTLR}yH5G|+hڛj̝MmQpr6^mivSz f1? 1;zdWj9I?D^Ot~kNׁW]e*{>E;_t_ʼrIPmd*߱ny5VGѸSג1DNBu:BtمZ.ilCnx)1k ^o]f{tmhPk;NtĥgDW8v]8Ntaف.|O{Qv.60 ]ɶQ_H[?C.` Z ]k)=yF %[%9#|ʝG_X8ӦQ>&=d]>L\9 "0 5{!DP憡 <ג_cZgo%?>fy׎]?>߾ZOsnԽuGŘ=cȯ[7EC9s wo& QWk{Rɩ?:*^OHչgV>~:u_==x=[H/6.|mDp+D_屁ꓪ]Ks+f޶2;_e^;V6G6_K# 7=6tira c)Xv/ EMf{׺?6pa߱YkfB[B'&̲;!V|-=fu\>) goQ9psKoMOO~Kkk^MkB,]}炷 ΞfGcr^+f*W񵥃Ɯ]>9=fyk1䞟9k CF_cah}ߓH%=ͼs,᷊8kNOƮVڞCث̓Q D`|UQ³ۏQ/J߼ײ/iɜk-=zGX:*|6są)գ>4wۆjZZ4i~y(OcS_NZ 2u95Q\~QgrpOך!&o׆3-,d#~Gt虇502z=')^Koo,k-+wS3< J<|$OW&>^9'-Yz&{]kv^ xR%T!V&x0>C kGX3_K<[IhӘѽyngVx˜1LCkT赣xVgh.&3U/>h_v@l<ߘekbx^5G?1a{p&ݍ3<@''JHe !d7us6x%}'K?c,{ K+X䈀92XxȪ֜?5"1Oz,iӝ7yplwcL`XhW7p•7CwN6$shfppL)Ӆ$Co>'祮RZ w64"Va~Ok3%Y6Y/R]۽S@ǧ{286vK/ }=?b'EO[vr~~+x >ߙ_zn aewHE4$c?w].pτhVx ө _PZ46ݲfQ3g i9yZFhpގ%riY/p™=Eg |+EE=Zٛk!3'־H՘7TO# DESwU0- ZRߴe% ZyU0÷c9=xcs^ 27ޭI P/N,Z0qcrWip]7ywSE/ޡ(?,ytcl50,&+ #kuՉ^+qX]mx+fPv.6 0m)dl!| DSh#\*c^N_9 CNLCҨ 2|\Xv#v3\6(39A?͈x"z^}Jvcc5 -_'Ɍ^G8 *ګf 9?+]{9Z_>R|[⾇7t[UkWs@w_ ]yևmhEQukMrG1[<ݞ. s9g~J kfo<IS2~ע=E7Z]'ښVlrLDMasB_#hQ_լe-~_7aW"6pm6ϨhW@MJ^ _X`sۜR!Z,]ʸ*~ ߕ ޟYrFomʭZ4ĉoTZ}wZkVvR{ZjNm+˕Ǒ8|x|M<k`C6Rיp{ײty;.Cr Jt'MkׂI={нSyN ?+ rF\F81J'B++Kk=w|5$% |܂(Tj| |jО6!] rɯMan൅Q$s&|N }m t ު)Vqdϖr a_r$9r-zXX"ue"Ewxkњ׊A:%Y} mTªs|`v&ikמ&m2й낅-G xȹ [9bnzȲgqr7*-SsN03qPCtSCnerVɹ ?ȣ8 -Y_ԯo oysź[|a }NC FmRCSλOD>~ymLXbb=I; }߆㹩NY%dރs쵥7yC!->vtwAGZ_&,l%RmP^ǵk9/iyk uNEDo͸(;a_6_l曨>D!.0?<5@H_+$RJ{ʦɬdK)kljbOmoxm5F_<+/Oq?hqzepCx-Z|މ#4|W2:ב==:iGw!GWʗ̨"uPXmV{ a!֛o 8Jayx^_Ş9^ `7M=ahCZfiLϢO7VH_ ޱr<-[|叜=r -;es^Mf0FvND_z/fCws'S$>"ŸA -{O7&=93~XN0ZWwi0X<¿olQW6<,f~{Z̭ARF9swߣa:s~jQC)x;9`l(+tM[6K̉>&Ll>=w Ό Z1Χ7_%SCwg^U'h{-η#K[ΗѪk۝9AWpU[xe^r.Lzrme^s|2gV mCa^ZL*{5,4/\!q_Ǣ}5w_{O6ktP!npWii3Gݚ)6扆0V k^ٹͰTE=@u=o;psZr2j.[lLx !ͫ꘣9k_k6^a̶:~\0^pNS8 ?}lX_ Z4[=:q8g'Qd-nk{d }ʛy08UK$sC8n1[`޶!O }L~]+,Vhs>=q8cu丁)@2X%1rVUsy.)?r1p^P.v,7^~uiQC||hN˹⯥u{?eht^KWi"S)ע-x) M##עHuyw'u1|̫ùkT%;de!^{wt['8}NGvCqFLS/y^\83##|Gz~z̺,U2s&we C>|eg` _`*Z$Qt*B #0d#{C^}O=9$[z* .M=9xA '%Sx2V2l(OƬB7ΉW~px;} Vy0m)ʳ|\& tZa9s*G 9x{OVE'z&/%k 3|ݒg}h[e_>03Gbn\ =Eg$Q׶?~Xy]tޝ™ZAp}8Wӣ>فkJXZa*r4WH9=Ц';P˒[&2mE]);a ^)$XJu/Edl? 31S:\bt&KӘ&:Z:$m.'jwf3Qmz e¿ T9|?袃k$k-m3M^K35=/rNrWqɾb؋B]pNv79"}9xʒCYNzO B=ɽR^ %4Vɨ @z $_3Y~+t>L"o4Yb_^=xNՄ[aܶk ۬39nֳk1)|"GDƪ-,"!뵏YͽvIqv80 RGǐ=6uk;,}k>g z˹N*zl Ztzm6k6c&9;?Ӯ#ɇYӹ@5ޑ+R3_O~|hc:}Lxv?lDB]4w8u4z풦?gk|ی8Y|f[n60?ejB`Mtε otч(!٤C|LCיU=_㯝OԛxlEAFI'̈aQ̆6<>`Qoc.kɜy/N^nsaJJ_@Q?+ X"絜r)^뼎a^&uG9B%rI>?CiS1_B &unHEK|G`,&o(i9s0&y|0(ž'Zt0z۱_ZdF$Byvq'JUrNZMzH\E*꘯y,؛fڜ}l04 4lmNg/FWkfvt=jkSA%G9-.Gk}.Osx14¤ɾz7׾OJ& e-27WP'WІw#5jK_4VdZ 0I\k'gzG0+^gWqo\%gᏮI= ؾd*ydn%zA+ / ka? ]A9C0]MjOMҳza [7Au*^߶T/tIO$z(Lq쌠I_TsOY%`<{ kOq-h OM# ۵1Pe6bW/co$GKOex뇲sɡ@`_-jo^ ,e.N2Mγ2|' Fym8߇мzP8_W`:uY%JϪ9ڦ]؛/ֵOh^˽>O_`/x_[E5 }! ܕzsbZ 6m;6<ǀsڥruZTN&^ ӹxi|ڙAh'^CYE_;ON^ˡy-}9|lqܜxXp1h\d`Ğy-ڇ ѩC~F=nT0v '^M[9Zؤ-Ws v3sxe@+z/H-4U XA}_uh *{Ә ŋ'N yÄqhoAhkp}m×k}Ә]V;_Y^!羣cII!/9F:gI?&#9 L凌 g^h*_Vc1G mvi~x 쐍Cv c+?:W~4yifV< q%AJfcowoR~xK ^6΃+xVΌ9 ٹ%G0JYR܀ؖN_+xbϺҘ$ uKokנ17Pk?pX^<pJ.A~ zp+`:xx~ /Z5 W=akod5 [֞Z;"ڜw;-v(56 ϏJM8,/ XYPw֨%Nk~`mt,j}Hz7nnjktCj A4Cը'ć:+~ѣgC\W9vvmsGl63]; $zfLmTrtԝ*6/eg0/e&mÞ6yZ(~VޜZ>t'3˜Ck??fH66k&`RxNsݜgO! Oqʩ qz ~L,OM/2_M}:8=X{]Nݣ DpDĂ ;{2'pL1Ȱq1/Z@:y! _nI2)rsZՉGwuXwėF?+䝎V(a~h^#CZ' s[ʁCDY]xjWNrkX>&ą 8}'jKe%=^X3f}^ k-pB]3Pv笻;}i ^赝k^aYYoDm./՝ګaLCǝgY 0 Dd_7@4fzY ~#]_~:>xFU$zaY riMJԯNM^-[ԉ]7s73+kKI6 _˳k)KҪ!pC[| {֋^ts+ .vNfǞJ1Z<97.k=Zo[иXK>^M9NvG0͛;5}mnÃk.Bs ^ FS'.:``_k2K;!FL"yEÓתj~0'g~_9e֡p5Ϧs?8;/ IYAW"q/eM{D8_G }R~%Zȼp^*&9cr!eWLs+>|C_5zw%98 snpDKy/xܭf| W!|ks:J~b8\ԧxmUeϔsa+)(0&-|/ZF5r{t;;%.S#`ֻ 4WXrM~:fwXǂH݁?z^w#ƙ6b?aT=~ Gצ5I^mmń3{x׾GwZN_]%C>3N. S]rϪ^1v^avdx}sCN8K-5`K;kuBWޑvg8nVh|F^Yעu/|i7~4?ޯ{^xr|Gzm51{,کNV|틳sˑ! /H;TG\ajN›;ŞᰏejlǴV~_KUk6+/Qv.}koI @m_aP9 0.̮KawdQ敗Mz-y=HWDma7Q5Sgֺ ѷ赽fb1I-7`W,9oEwى(V5K6O~F27235 PnVG&`RZkYsXk92k"=&R^El kpIVԵKqmxgW(o-ڞ7 .F>ɿ-hl\ZUvXOp[="*hsOqBn7Uru_/_6&:S|I:kZ.C+e(1~;&45^|̛ ؚ3dFٽ56`FCLJNzVkQ#3Wlnnp&_[ɭ]p)r I/-ӌE~> 侧+eg /uKq(S8)d^*ks~#z+vvE_KNAz!qc>bib{!ڥmh/4#)hz|@\ (o˿rĜv?Y^xeH_t9pڳ`nrw=ss"_83/9B'RV{!F0)pWZ{!;|u \ g^ņoO/ݗz0o5Pnj~:75.}mFsyρC@ |GS]:{6t:Y>˘I#k;?6'B_ CnVoqY8w/25ƻm0 D[M7LdCH⟓_7+ElL9οPgӍsk'sF<#|jH/ z0HF_ ƚsA^+4'O SG g@>Ό;ϋZ4eYCC+_ gN<0g-r G/E2Kyy4:5X&] ^xu_;UOg?BuZû'@hdfGy-vYK>pjmWg+<>nQIo+/7m,omVpk_5rBo:_k-9":QcI4)PYM:Gg#!+QР{&.LVD۶w/ܛم*vC.f|'9s#~Z8^W*<<7#Xktt=.kWxksktY| wkү&s쿪Gvѕu}+{:N=/iVh𬉝mp}BE)=| BCvwŸՍ|{ #ܚ[ G,\š9|MV3ZuΡ#͜>a CZy\/[~EC㋄sZ9"sԚNN̕9o^)/:7:M9k='ӣwp7I L4w+4+ 9^XB kF6-_ki}|^۬ϊk?Ҕ9/9yЗҼT}պ($p% rd_.|D2}j Os)|mͥGԑя7LbS=Ξoٚ? bW€crF҅AZHmҥohl}ZowR*Suz¤W1ѝxۋNSfINaƃn5aMz&Fh(?.܂{kf5Js_9k?'ҩɯ}LqWT*m403ی[9{i!2{EXε8_ cd}յvg퀇9^8u}Y l sW&kvxI;kGu|){x}K|kMW+ck߄Hɣ4gXwIs̾sA (H5/@63V) V;f,@#lףj^Gk13av˼{sג[6x~0`f^?.>tsբY왻BZi~:ycO_-B`ZQ*v^z>9:VE–{OVM]x\ ^{\ J{ۿ,xQQ>0-{2A7ez!!F}s'kjwh>G~3Uۓs"ճ*}O&K9kwʁ|,z='*㿣\pok-v|1`.`:}dl'5@-9N͹?7cg!/ٲX;F(XD.<Z#=_2 毺'Sٟ/k㻀ݻ|,e`E( [+/2ׇZIz{5󯇏Tסb/m{?_C]/k6|o&ﭶfޱ~9;A 8p%fֲe?}yFu%O8c.vmv-!~-Gs\V!o3HLyШ_iuVI>'s of9 #9^=6J|D܇wC g-.vKf{?I;a^)!%_l wW 6H~B }|;x]ZNW>G$-:_ǿ=cnHȇsub[p#Pc<>:zǿ?UV^f3< Jۣަ3/Y g-`惇l,b&##suOmlwƢ/d!">Ѭ/m(׾Vn=:ce =CGkwWg.=nHU%ӸÆ^k-d->֠^+rXD6O ;3/ O/Ɲ83<*ZrǘɌl}_?u&+VIגgXYD竂}0m<`=W 7δZμOAcz-)p ^&aQK?Mb6ޢĸ3;fQv.6 0] 8'kUwHUc1v7亨pUJjC YӼcVΆrWRk7]i H~.pywNAoodfV$Y0on:¬}𐛽ene<)ڱ3+ޤop@c ښdRķϺo-ڋո(xmM*'Gg?a_{_ 'ou<ZsF*ǜ] 00N볶Z40'k L@E4!UFra ׺t=yVV;".~n10(%{D_u8 La HB䟘*e 'gtL~N_sxUj<Bk5H4[3ɛU|gǺhUv5̶£^@p YO*gˣަW~KCri7!V<#bwɿk_SHs<^Jʀ6*^g_KIGWUNK>0/0_s$>^tTjW؝na&kMOX hK{>OcR=ܠd;IFhE'*9^}s*s9~贎f_KR|v~ϐYr>,=ޯ.{7ggP +uذ @#3;Voby}sAENEvcP}13ty_9ܨe;T ϴ0 ۙ!'^4Y>g#:, L Wosv|vd:m]9gK赃9UZtS{_Nq f\S8Nr}~) s}=燳3ʭb5ʸˇ DIXX۳}i>Ye3r+a3o"Z1OZݽ^(k6v C^w/mU#ͼQ,=~{gXvH+8OX9-_뿯_P^׃wS@F_'_KMlY}G޷og>dC͏Dk]>F9sZ1O3 B0#NPD[_M׃zZ|:S[]pŝ8;yu., 4 w(59BhC f3$ IZyezjK ڎS(;A^$V3*R;{@l/ ݉kW`˹ C(}\mkے/zm9מPG~7}Ծmp^; QO>_ e&m ?37RpqCoZһI=ITB~}x-:>@kgVXۆBQQn)ڠdV 'Tl>Q~-oZ-@GpN9*]9ayիxmԼhدWhwj_sV^)ͩȯ]C?E~m/8Z}1/_k\I N](^xm.Z4rF[ a_b@a=T⃜'`1V]Ƀm<ć,|۝!% .٭+ Pܾ_G>+&}e:yOqE- AV$ё-sMsWWk^>+5_jxast9&Ճh"_JxVL>A4Q _.WE 4Soou_7_{e"qո^_{i j + rx>8&7)?p{kOnOGiM AĜhM3ZZorW|aw:ɿ|:O=fᅥSp_tͬ~DnwѹW{eV04"d}4nF1VLne'w&SwޗVu58k9x3V_0 li0ibaˠguYu'oκWYפVg0jݣ[UZ_oV>48"*_a/g ۘ7852:NZs̋vk/}Oa׾< ^VXe5OMDKt >J_No[2CvjڋyNT{qa,r;Gw֊ί0ݪ©K~臬 ?+  vR |Y ܊L<\ro,lhҹ/M3[,e}G<漣^{9Ÿ~{ /$+nt]`MYF_wc8ȯK# \tuivߋsaaJGrb=~ Ze!l_?VD|pØ9Mڹ) #gH k4%^#4A65SeG'Zscn>,qa$ｧ5y_ܾ ڐc_kgbvYx{uѵLˊ/94vS!Wsq̈{(f}&VY~O?2׬s'w]ιCn& ɧ%~m%~tnj&{9`u4Όn.rt6(?w:^​ d|-9i f:k{٢%fDgSt6Ib㍇&2gg0+!!b_Z՗j]Bc%=ѭ׬Q>u-wMQwx S<4ob^=C pjES=^&}y6sv#<ŞG\9m O")=]l]f|ʺ[~Or :r9S$ nvfEu٪4^& wU|rA>&LfCpD|(b~3w8Gٹ6@JƳpG(Y5 i ]8Z#2i_ p&_~ȃw{7RL`*ȹn"WwƝ8>܅3 l91?~}v\y]_+|WlNξk$yJLȯEYы*9ɾ9/kˉS-u-{r)3:q9g_k MSG }xRg[JrȾ+ȯ}_m֒_LPQ3e~xGk3_AMШZ0+"N`y%w~yG9ua2Z` ]v&.8S]?'\l,({RУ `s򑳪g7WֽBO'uN{SxTYhO+#fx=M!<6tĹA!k{Dl,XԿ̛N 4t0+y.k/O17:2:v Fk&jը}_׊]wpNݯC&3=5&9k`3+$/y_kֈ27eU}uG;|&wb1|POs$9qI|VGk FzR8!w7 oTbaU!9~ o^x=+'~C־;!S;utފ4j&ǛAY>"ޭfo ?95^G9Is׾Vʯ-HC G׺f/w9x^=Vft?[ CDo!R3S@}DZ5/~ȋ.k ˝}@v+~/)\ uԃN94<[ՃYNto%g3+X˽n;MXd_+Yu;z/LrBVt_}ZoA uk:x ^+YoGd JI>2ɓ> /`+ׂyBuk>ux΁3")bZpsOnp=l^AT赝޹ap0c|-޻j_6.|GV 7;tNo3zm fC6M3IDN:y&o&u]ZC_SƳx16aCX\p,ax&b+c= /:>=#u9mJK[θc.q;YWCy:ƻO6<_x 4M 9,aPu8=%~I60lI?F-uu7Z9xS{WK{gߦ_;AmhpB}+&Ǡ 1#²Ƶy)(#߉3ɯI>Gxi^/7cnɯ j|3ImKʢ^8t2זpzV—*)}+GIMYἯ /i'řCfK/z䇳s;hKX 7g}d<~ߏEISE/@6ܙ1¬ V996CSxw-s0>w0hWB4t0nu4CQCF; jrne•/qyCxi 肯3ù=w/;kӼPځd萇U,̈ryj+oYx'٤r A4!ތgΩQsk pLg6!OYOwW?zeQm'JO+cJorght0_hDGhxrY|kGG0{\oa "Rb-e=?Ϻoa3lک\kUr5}hD 2|nz~Bx~~_<Etf)y}398&| Z2- 3kSyCv:hZ]F4Σxt-'}M9!tb}Rmf]8J̇3 ]~E2|4::_G5x;]M-^ICeY:]jsps-;2`iɾCo+_M0kCtҁs ]Z#o;m,k7ؙ߱ _SGdu݇ 'ٹ0 @J6bLr*``\U5uVL`g6WtEO` $S/|~OR-=\m/bE'9@(u yNCKtrB_^މ0Up+]3Xzr{;s|4r-9}wٹ0AJ.8bMjykjN{b";_Q[c%Q!}XzάWtgfS,׵ D٘E_p97U5ׂ4kF<ɞ@/7_9 mu:G~QE?״ܯk;qGy7Bkm&Qg զrMvLxV?$Lލ1;eÈ JJ]C~5E~-ܻ9+W=쯕xڏ0U;?6ﱢCƣΘX׾>%ߋO|w 0a6c%q~|xq[JC?Y_[Y֪^ j N3̮ l2xF/>h_6Sr1a! e1Ȑ`E~@V|,u~8K7k3Zkv۳`|^xf^s!D ,Ā#k[9Ssd~mXfl4g&/ ۓ1rH0&ךg% <_Kfp>_76~m}s2~Rv. 0R-y5h7]VB`[]y[Z{~&AzzWE؏גg/k?[Ys童z/,zy85'0 S1*NH9ʯ!c;ZDŝ|}=]yOɌp]{cm>㹔 ΛXZ=8olx4[Eᬗk{tͦlz^|܂+:YL[q&ٷN{N<Puk"x9Es:3 rffqr]]8C4Pv.8 _sM=Ks,<]>avN-[/q׎!sWS=U0g:ͯ}ߞT4@[p|x 3W7W/a)1#} M~ƐC&>t}s7t=uWMfr.,3#0ΘՊErZ (]5y&o嗹W7ˏ W5x`幻FIo0MÄShO}jˍ{}0D ܳa]+h=׆\#a ܒƈo#34 K>h<#ݯfkW~Z8>>ne,b!S]Ayo<=Όyagyz9󐁾vGq}o^R~9sP?1SEWVg}V>^^&hԞ8>+CthEտy'3'|\vyOs4Ks:Wmo$ ᵩ9_e7JlκȰ/ {:^!w/`c`FMZFc'xUiqLޝwT] ~ )ST?Z9<:_{<Δ4#E|Ә%?dZ/ݽE31M瀣 !m'rS?NM&!g]zW7kn tZs{H%koRr~jZR65) Sf]Dƕa~ȑmyh^KHGw)3rEZ(^عg+Z>ů.?(Få|"Mfmޖ^{h:/xL}K}hyH~-3:_oD5{Qv80R16XOI~ J*j`]גuʳo'{WP +JУәMy<}0ҷE~^kf'kRs&3[Wd r|-ge$4Rt9w+Ae͕u9{\LVLz1vn 0lI AJ迱dLsc%kK{=C{&h3/m 9x!9MxlfۯNӒ-,iis!2'玌^?)2, *2Z#4wyLaLx#gIIM){d+L428{^k7ro7ggt0ЕP_RUQ wk3ǿ}d-| Or |a?^ً*}NU.Q ׎ݟXSẄ́,vLf=uZMmM3+P+gd[?ʼ܋9a"J{p}j=;tW%E8_1;~KĢ $(ѝλ[]+++X ^;r׮J_Dc`; 8G'o5d_~Of:=Mk7Z'V5yFFM~mV:y<YZZZ.2ymGZ涋9傾Cv-pKR ^; ^{I;^.B|T&@жqmUVsE9,~xL0rWCV֕2ޯo7=Gk+o~NN]E_{4r9<1YY9 ә=#4MG .46rݤCx-Ƚׇ>('3xutylv xTzifkɨt\^ _[s\d;_+{, ~4D[پsW>8)Nΰ|3ٙH @.s /6fx)T_ Q]뵔|ZWawcϿ]kы3\oU sQx IN:~{QG!PK9?`MUY˓^syySOTkc+bW1xw{^ksNT ,p3{^K&hkܵԾ1Jұ5_ r 49^j"8|5V{0[_ 4wSڊ`SÝ֝uPg*yעug|}S\_,)IpțSHgrw 3}|ׂYW>Gp-Ups? n Dqk>J;P>؞[^4+|cvny1;r|ߗg4:n9Kx vk$CL}tDW5>xG:Xx-E&[i4In19 _9[ע"Q~Z2#'u!}mO+_g/^a ivoOh\׺rN'Tc_X@K=vJmÿu;!Ed8ޤx3,l%|hr2Lx;VKV'i%9޾?ga glY ^+4R^4ٺo22ku<g2^KNF%ug#{GvN &y [Wk)^dYޑҏ~⸁#'ז_KO]X__e@c_Y3B_Pw *9v^Lൗx[uᕜ_EkޏpG27|kj^ Ol{0 kwl'p$:) {rF/ۃ-Ycr]yi/]൮MZnGNmsROD4Gs_?8;b^m2/ XJg}[鰧S,qOފpjYm]d2>{0?N-[yp=ޫ`- mT=cʳ~C ߕ}mN|ȶujw(1Rxl,yw;|mīMڋ]ӆ 9 k5')jAh_[`me[lY]急 wd6S)\hD\kkoR[gg0+Q0&WT] 4Iko|vx-8ҨrpkQ m/gC njw9zȥk-1ko{GR叜F]ߋ |)Kpbm (ojcV(2/1*'96^{?~XQ w5|BƼPuN"=W9#&]GJQr^!O&.GcCז;nT\X_w_?>VwMKAٹ 7 1JbM3rhS ʲa^:=_K:.fZ3/|'h`5u2Χn_|gY&ǃCG1 = e^ sjKVV%{O_Lsm搃GᯅUdؗ^[ @ï5lY KNYTK\(sizeE+"OFNlk'A[]<GVos%orv0o[y'LkɒT3nGډv2wUǵk }+$K{|>|_V?=\\̳:Y]-\ a`뿱=$ӈwMk$J]>!3KsZ M:^ۛfPCp,vdΡ{n{\^{ hA-ǐF#nO9+st=dyIo;H|c\~Q—v" _aj&+3(ɯ?F-]2!HyXF@$P~poMs>~!?k|hz^M@47\%zdO>pj6k%_ەP֭c93^;"3 2mھ{颧333XuSҤLY9gZg+(בS(4*B>P;&kC)2s9;kr:;gɥyN^!^\ipWq튷9E.J7^k}#cӡZ:Lƭ{zOVyCz 7P!?Ngݮ'[u'_!>I>&y4 g0 +#/E 2{m AȡXb/Ms<지œN]~,I翇)-}Gĸ Y>sS עK{ϑB*gCqD/a zR~-!O7LD>Z4 {9wd,A2fžvFORgx䇹[ު߯Y,x\n'}eg0/A6;Y9%$wg. g!c^yp3dC܏.V l5zͰ2eFt&O=gKTXR<Ŏ kWV&+жO~/|tܔ*{reN:.yϙyW_@5EC1o|3oko8y7Ak*ݍZ:An/]f)_ YںmW/1+k&3?i^ 7jV r^D smkK\?->Yg?Ȋ8FګVjߝgv=<3xȫ3webyU ?|Cf9}txSv8 0 %?6i-nLD+۱WX<{WL NQvk&SpL^٤xYʙf9ÒBSb NtDՒyu"(+er@ksܑ*9nvvZ宔3gC`0_xdlxMmԊ@9Awa6uyM?f<}[y|&2]p~̥oI/8LKӱ`_Upk' L995x'2'^{z) &gb Do{ﾦT5_SCk2cP9)8z-6| zQvn)0Rl7RaDWIQ~4 Vk:ѭlwk {7_c}_t[Q}i.wc|Qч.|,R5tQs޵ Κ^rr\GWF>|;\: sx0\}sv. @ݱsśHI/l0fc1sZU.p~)KxCZMoZO;I-sT?1~NR^ O~P2_:G: ^yfos L*:1/CίE#j/,J-g\Y;=sPeVM_[oʾp7#yd8EEμk ?3N{>{oН:s_x|{$xɭ頷-ځWw^@YK~|9k}t-B%u4~?[dIj&mkC.~ᑬ# E=  Xbkqt$"aǾ@B@nL4+9hd톿q8u<ք~v G ."N=̥hr/k'$W2g%7C{7ng*ΣsWd݋ /|&CkƢG}]3<>gxqNKGY$ɹ~-+0<䢞 ;eL|=7r^f>fѯen]mO2r \&|94݉ƯN\Jt[m<,VH q_!}ɯA*;:@% M5|C!sB/|8(dᾫ3/?sAN a򳵹N\ ,!d-Zߐ}|rZud]h)^Se3_?BZqF6f-r{?,óZ53ȦnQZm}}CjN>L8 {0˜5*k&;1גA<zVk 1"2mCWkKF+_kCGiFCFO>Mޣoj xf^.2gŬ7z @'Z:ܞ܂ݘe6<_>aZ{96s؝:-9IZ1;^_x;1iͼm}p0_9Я_n{eg0 +i!EkfZ=x~ x%$2;^1{Q?9DO'Y_QhwMwfR~cm }w<ۇZ (ka|ɦfj߮( xFkvQ6Os:# \_[]>s&ZJi9Q~w?Ωx_kS}wrѯ tM*LOaWj_l-Oeen( czߟޡoo@k2rRzmW˼N ҹI=2_U!7:2&Ʀ|ƾO9iiRy 98WG j|/Z5ƀ=Ծמ{ij^),UkS1_3S&kp2VY2b٭ʿۼ‘xV&CG!PTSOyK?!σ3J˔߄s{g-ZQםW^k7OEQz-Zy,Dxt{F3trr]9ul_9rƟD Ρ\<8;܆A ^] ^VMxQ;Hw>٢fWUkPl F/}u9\Sw̅ohmOp|-eNgMy= ~o~xmYpJkɇQvJ;1OUJ |ǀgWlCuB_>gX۩i!iX58{N4yGӨi)(ʺ2]ZurSz>C>[Wݝp C_ڮi֩൑dc9ZgB#1c8~?uμJgML4`sxCƞΪf3| }m[e`` k'mhgT3/9ʼ -aWJ*?_ l4\l N$RZS+0N$[M.erGkugE.BizVsaG׀YC^+NdHzb!.J89V06a׵d׷Y N`kQQW[F1_K7(&yH2o%R',76D zȫ_eg?#=ǧKshԏS{Ãb-R3TðDkѱʯ^e1Y/-[U+en{ƿC{'Ik|f%N`5ZNO~m'{ a|? b3Y}_gIĽ =B-̅܈'B|-ה)E~-yuF2#b\{m%-ȯmS` UĞng~ҕәO8 RD|W _1ۚIn$*!v~2bН0c.2ߧ|aW;;Wמhܡߘ\.}n+/PgRiYCO!?~Ŭ^Z9&/G|w) 0Q;R~dyD2J~Ȉ} D_+Q^ⵙCOi}m_7ZhE:s/%GbWhEϋ)5@(" 񼖳/h;y V1NMUDk+Gfu%hC!/t|CqZN++3/p`^Jo v LIHw5_ wD>9zr_CF@Go.|x pF"{t[Q/zG] NK_ut^|2f/qzm'͡|>wvv>~(;a5UGJ5Y)YFc1TWk{<hw&:T7}-sZ!:ӳfv#;"s4Fֺ̩bzz*-fʛ;ZmwkB^@Wyi'|h|Ƴ ?_s=gs"ixʝ DL>Qx-ůw?jW>ɀ?a+K6^bynQGg-8y9w=Y^+b:pc&4 ~CG-NLg%67v[|c k>ʚxcOdk}?*^&mQX{ZrE4_ptG-Y7i0+9`0b69Uv3o32#.[L>dUvrԫm[wpK }#qz!;vQ/Zxm*u!G֐Y%\gU+_r!ǂN!Xk8WPZ~d-/Nr=ѥq(kΥ Fn.;~>Pc|O_|b: HW?-p߮x&mQCV΅:)g_™_kA7 93<(YSSK%wOQh8$GWc;/FIgD/vJ$*?=0uN]Z/nW0 ?3,',\df:5' ck f?aD_~ءN7Vݽ2+_ٯnv OB­oc(g,]9>ܵ3:3ڮw=Q7>䌫ja*?ݯᬑo_ uJ>>൱=^ U*C_;MQ>13>w0à/.ԉkrc0w}t * tsW.9̵GcW [[cg]/NM|q̈́ vM?g{pvf 1mI${X>1lwNE2;o𵳄\vp? H㶞FP<&h ,z.ܝ9Ǽ4C<63g+C>k6C5.wroŽEMiÄT~-,h;~$nj"Cg1-ӴGjC<סxXb' _;k}=p捻_htgZ_`u#q,~O}"=-WOg=xҮ(q2v^g0]ZMg,L l FkR;9{+ʯmVM䛖p-'XCvy&\hj~e~QvF7 ]BR$@VI _k>nh_ ֱ[ظMcU ^sWh1FPOu5|1S>H;;kcn|6ԅhbHKFSvΣ !ksZ G|;wv|W ?d8iy)CWC3|) GVV˴}O-tQ̛L?vk:'~_;SJZF5^S%@w1rmnq=ΝUg3Ź_ɝo3 vWTq[ym״Ԙ_nEڙ6 @K#ǚլͦaAr9{Rg*٘z^|}C.CXkN,o26!vvңxnd;W]X_ ?j 5X=]/ }.W|OzFmhm~)N+ą]^<6rP7~MqSr| (fkCf/乒<[_]Zk#s'Fߝs9YsMtb+C&AX3Y9#7\~cmӯmY+)~pbAZE<7йѓ6CC,rXWoY |&j_[r0 dX;HȤb_kKFF+7zLVbD.U̙s;zd24~G.2Ⱦ-U3gN}N|nySԤ̶s'M3!L1z63S>jyFrv/7XkvroeVp2S3V>g.NuCHڂФwx%ng CLZ/^4 m.ky { ;p!_Gx$s%?&Y<0wɗfyci(_˸NkŐO/N2`-;~S^rܜ? w~yPv.@ kU6oVI^$ {ѯ kac8` T9^K >UCƫX8Б^[5]4b5G8"K'p^{<+ z-ۂ P]AW  ݏO kM(xb\rEI~CƞP^h1yxGs^o5d#z ZџI ?I N C{;N*r?[ D0ڴzƆ"*z;;\Em1}_X_6-UFã1/1[<¨:wd$ډ=͍Jr2d?dt㊾v*Gx9UIq.A}Qfkۜd KwTzC B_L73Lw}Dy KA׎Vh< гbd%h >?X}ɯ8?>);ۆa g"lɪC&o_ VpkB3x쇌gdW=^kWoY}4^{,/|ܒ4_k_B'Rl[J\-#$L4WŘ1}]/1\s};IcVy'}\XG.?8Ox֭3u-k >\zc:|D0C4Oaÿ'g/;)hP,c?dq@5 }bܷ=./Mk;d}ѽΜ< V;9[IG_ Y !GN:w, VC޽k ?ɯėK޾i}. UgSNμvDRmC-[{yO Xgr\kLҹG==&Mzr_qt~Kdؿ(;B Kol;Ora˟q쯥1nuݽ,OkǿWwgVh18{+e߿1{s*O$ |* 5tWt_ۼ;՜I} ΂ZΘEoB>f4C"n:ᯭ)Tgq97* jx'+`k ևvxW_{frm|jF^KZxL.|{;WEYwUsSC6C3-NkL )ڹ!N.Z:^_KfEC _ah}'AN!'v>xBoŚ3d,gQGb_;i&U:O l 2,OMr8;Q_;VhvE3;-pVc8ȹ'czCnQn5Z:y(X@1Xke?1@ ׎.l^ޮe2\-s}9g]| 7/кUfPx:x-nLz|tzʭQ>lGl5|>g5*+`>nohݬm~erх[u }+|_|5r6F]5E3h >&v'} ~߅[χ.|(rעF3qp*|LG_ ?gɹzO P2$v1hO_!NxJ~-]Fq_نVW~Exώ C+%_:,}!0J~32jn~Zzt;<0W3ῇg8m׆6g:D6g a,fNˍ{r'a <5ϵҗ\v>צxZXɜOתfL2,2406J!G-Q}JΏP~,qF(;[a2mX?R(@B")>q|> n ;L௭~4W;p&p`xk~D_;F/:.{&֋!v"mzɮI{7ܘû^1͵s&߉㓾g#Gg{o@ӓ(\Ћ"y|͸{Zv+v&̷'o8Τz͝\x3+;+^̏(GbWsU4@TþzU!Kf^Z{}kz* aX:ڮlL3,1a,174CEuf>1Uxʤy z_ .g}$gU-ג5kE~mAvFҌOTV#Kr;֍: ׾SI-m`. ˵iJxw;>uzs|/XmVmoGp)oqv0n ۲o,7wdL4 }=b9n, )m%X xqE~mړ7e16u˯%#ni <;JM|Qu܅k?T\$~c#Y!U,x ֧1+.{=S#'v߷Jov=ы;|S4<= |*~ȿ0B| Jxm^pj;wNAkO!Њ+kⱡq1%%O![}T{k?d~3 9G&3j6 ȯ ΄|?³pe}mel5fn*nۛ5?s͍&6b7v dyǿkOY+iU/Bht m(8+w9_;|="ןV!Ig$c<|Uyȝ۹.CY)9|j=M3G]hjC=9nv8?/` "Y)?_;`PKKŜڍ6]fk_;1R{Y|mf2ޏw语h|MhZF 1ܫ[8&wEYw7_;),t0Y]^{sbOyXΡ_8 cS동^{v*uvǬnbM|X>Ssdm;c(GϨMC zqq]]q#&C5{ 79HUe$$]4kW~yG=<|s ?);}qO~օڣݝ=G~#6vskgGOyPoϽ A8 1Ji 9Ү{ 6׬}W֫wBwL8`i~R&NgX6|,Me> +Uu'5);D}IǕsL"Yi[)o04V9>9ȡע9'_VgP^3_!|=ћ>[2mf&Wɕucn_Y=/Sm2?gU=Ryr5sm*6t:8ØVdK+?g//}7ug;ǦyycO+ky? kY T^u^ꀦS/o,߳`~+y.6>Cg~_ck뵽~;⇷`uY[_[Zubm:t?s*=]yN_{aB049"*ZRs[51o`kGQޝo[&W,^; bs6Z?`ly8kV}6E5^;1r^;!_ \^ޘ4M侹!kɋ> hxȍ{=ط||Ⱦ~[?A X-2-'AFy§,wOyTngr?3&^u^;{ +vn E!_BU'Jjz6Tjxȃ^pÿ ދY"k{j\uP<;&Ԉ7S57@R\vw؇a*>f>+8C̯E]^'pevGm;02?t+aN,R8! ,话x5MY -NsSm>T=:+bY~15Tz-[.gYz}/ e\/?]הFΨ+oiYR n01p5jISe X`zLܭ3_٨<ÿq0o'sZs<X&T'~jid({;k^pIk{Ҋ.ΰ5zͶ;E~G8zքuI!d{Nhd$x'˂;wdO73OO.~"| z+-FB_N!kL={sj6'_&!}P'%3y&*_}^/WocV{>MCi0ׂ ?kV|ezgdPN4Z0~F;k6gC/|*Ra箰ǵGdeg0C+abeis wgfZߓAF9u >!O:Txi35ל!a1W?KpʜxVJ{~b]{l@8}|;|HYiw) V^!`'j7g9g33_Σ ~W]n;|1vCZv r׶yU޵`DyOl'jxh)[Q]Uo4y ;9(lZ=:GǏMצ ,`T<}♈f,Z #w't'+sqaJb-1nb"ɻr O8W#aGrO }|ɚyzʝl`U/ qヴ8{ ]h|(r~W5Oz޵W~Mx`)|w}mK_KNy<$BWs_sC/*?+ja.㛖x';_tJڭ!&kdn78U^jYX#ֳ`Uڔ+8Lo ND)"Ys_/wg/C=|{ԛ) ܣ-01uzwN_C3UEk|Equu9b~?> n DCJdVBgP.=1XΛV~埓z8|j3t27k/\3k0dy7u-~2@5JN[k~V1k"K}bSs<뻶̠ ";07=[l?_KQsoZ2r2-kk!T9a[l"\=<+~8wNnT? \^+^}/AE.43]4lNɯůs$6Z7mԡo>'+|9n,r<0&C?_nL gGj.1 [m\+昳19^{)/=J)?g|c2|9C_KwL:׶qfQ(D|x9(i[g>XG7o2Z'^)^{/{d?ݴ]u~-sZgӦg)3ŸΞعF @JkG_ @S\#K}1,q3];!}-YSNO^;Xq {_~xQ3e.G xM5r#4y-(i.%|CVo(DڤfopZZ'Cd|}V;-|۹ 3,GK_ O42y;QE|z^1uY,S~|aٹ7<;û P.]gOtv \2[a| }mm-}2~W4C?jdW;˹ʤF_9>䫨,cgb іuƜ {H6ik,fKGWvdY|mAU_[`qf2/t 0r>SOU}g Ł)O9;}^+Z2#z3g5붿esG2/|tAF + sw^Yu|"NGItm_;Dr),ۢ pos{Z^_;(p'+xkf|ɟcɝƊֈ.sy1VK ti֥-4+5I '-_'M1Z l>4"kmsj\|m6Y3%sx.|:JUڻnNPc|_w9?);A~ |v2@x|t?"޳þ9)ax; 3{xa}[B~o\z Sc}SkWiZ{1spT1GGS/Q+L%N3ߪX)15>{*_{0{4S\y.xxMZyhx2{OW*VƼ;e@Ξ멜a4YpDVJ= rAd+=uV>:P*Z5O;i,ΞaYxka2amd b71#õ^\Ss>xXUZ7߄<۹?. ч&'i!f%8|W>eg#1/!t-t=|(K!? UW{ѿr~!]9wf=Vwve,=F˖aoܑżV6lyGtkn%p:ZXռ},=y[/yVx^Ji85xOᥕjb|(;B^`pjy4m"'_>UUƽҬ*?wp/>! Cl"0-ROO9CG+_ӳ%ө! Vdg|mӪ8UZx'UXs+*SV:|mwA|VTd&lndUk7~aq& Zo;aYd)%[{mre_JGD赥{\ECA^ odur'0SlƾQUco;װ\ؗ {zLQz?:EpKxr:N;/8XmNv9{j{!9|k˨m+); 0Vc5PvvI0R1M(opt}Ԇ|LqȒHEɋyҝt'`\&:c¡ [:kx:&u5 7̹{עxwڪe^MzO`jc#кV>^<9j6<2<4=0%]RbSGzD<ٿd}6aWյG'kÿ+q*~,(aS=b#*puË.x^e0؈1L œYu)EّrGyj}L6ftRbř! ]xעoV&J31to:4{|sv.G 0m2o,8M h˻D=}䜎5z-ğ?$ߝymz0~oW i錦I&qqW{~4s/&G_Gʯ`~=Gԗ|Okxi=W{5ܓymVyZn#5[ߴHe~g5>НNo}Ӓy-~yrXXkRS^mµ圣x w9U9{x(20mL27LP߇ψG/pnCF;7LGk^*s+*|k >d?oaWx!* s)s+"m-e=fG G*ż?G~BWn5'"wȿuq;Jtsx>r]a- g&o?dpw2zk/)8kJO tMzl2Zɛ(<ۡ/Y#=_{}p6/mwEe1&ѯ|o=ul Z9 D<+GZ\grRlWrO&9 z'סo_p>7K#񣠻U92W} ![vZG/k Ԏr7.6c'/:I8Ǔs`Ki9,^l6E2GW.##K}p~5+HxW`*uv|B2= W _Uμx2$ M; 24fO63er"~b3ݣU*DQ{,;6y^+S="7P=O{0ٿeH3]3Hr0 Mʦ5ͧT4Sz-l+Kt+Mv{ۮמcW﹇| _Ou(y<~\{u;ɿ^m&PSѿ3?>( vShivϭ\aZPt ~4gdk|\+|&Cmu+0̷ql=^wL-3A g<ӲFD%9;CꍲA|ߘòǧzv\'ZμyH|s /T=ژwNm&o ԬOзm𐓙ʌ>ҫN߶-NakŸI1|%B;C eMT,ZCٙ7 C1%^s&4Cp};a̒KhsLL 8Ǘƙ@5g҄z#'!%3=r=s L8~`%39;&}wumϣaRfRuH#;wgSW(_NSZt8_TklCNwWr'xa˸wǯ0{V%MM+e&/u^fo;lA-'kli~}ْk1C渭C& Հ#j8ȭGxaj_[NVpv37=^p j_Sxb{R॑- qOmς٣s`'G5NvxSvFI@ n-bΨG3E(ɾ\ѝ9ÁvXLf}%c9F{>&^tnɛגKSӯ^=~X2Q|w h4S^~m+`vKpW{m ;ï@sOGMWFx D_;ɛ|k-1보ɵ7kM͞cIҝ"ڛYKE|ZZT[O7I7L:_#ah Kǫ̌'Kbֳ__9IW\ q&{}G &`5&vI,j1_n#|Rv. @ ]IRLb 1@ Yþupsb^ w[9-x'krQJ}>'Wg3 x׎e0{Xfr-en_#yFͧk'g_7Z D@ I+9oWIedN=y_a j_ۘM9LNb em >X^k$|Wh\ 8|͛vr[wd9 ` ![VW ڍ/09 n2笏>|%PC״F{bBQo%K*=]ԃ, ՝. jO4^WIZ‚Gwg3Oc 1~8;AD0c@|g@xuoTU{]{/mZ<{'f+GQ_sࣘ+k=EsW0~+4}c9dPZ~ -_{/,l₯5֍9͕Z٦֒Ngn9g+.'8d G9yc<1<}=`Vdyن(t]kbrtyh(w!^y̵[s*챓eA*ݮZ9Q/2Yy?ҽ9+/|m?ge^)z{~g*NrOl = F9 Nꨫn, k}\l K*迱(k9 -\F'#{מQ,kr0*-~l̈ؤ Hlo2TW˅#F9ۿ`=i\t 7{,AԬ~-.~㯁4+%;y"3:e=N=H~kك۹2~mB{gEs2 {}h:4aև<-^GWޯԬU鉯|gϧľ2qQrBu%8 OKpOCn<Ј;ߣ'CŚYpz\[/tךǼ莆L--90 1F|`oM;|i1ghgTR;t KPk 夯vޡu p(7.Hv&[9"A14kCܹC=5ө0Udda/RF[Nke@?Y7|U:?Jܚy4[~[0c<s9::w[ rxuOԪ=y)&VC^>߷=JjozɞWZ|z9E.%g_=ZKA'&ks;DŽ?q&߈vNE~->g:}5 mng܇ZKWOcֱ\As WOpYxܘhMOn)Y#y/r]0~c8/m93S 0 -ɸܚZsyZrߕe?dsX Zk.(ZEەH\;8;a')X>$ p^!PrwYw{^;imgXYE1uN#vfCyx9 .uakgjw2oe3raMB+7tlok+Q-@+~m0'ΏM=z v`6[eV ~-ϯ twKzM8ژGeQL,=|ԫhMJvï-3 %=^KL"4'^f 5㯽;ʝ&f֨ɾA8P3jB/kݘMNޏ<< XkSصЃ#F9zm /+|(;A^`;Vjye" |-[1{W^oin0H x{%oDջ"VZqst0[}[4xei٧/zFYκ֯?0x` 6|(-< ƷO#4rGAѢu>//p pʊ|$Ow6A7Zk`^;Z wk׵oߒBvbo;D;2'|2wa_[ ȼ}hko/7oԵSPwf^˛+-`v9 )^fy+4ڞxVL0=_?} ~(;A ^) XʽR4,874‹w;ڀ70chk3p GDV M9罊9KxoK{'6+7]Ʃ}Sf|9|ν}ȸ<)<_"{a\ʯ=I42Jx'9?h(o &g_МLE01K Y*[OTm z|]>8p]=_k<;>0zOS+4C~\k^f}B^h\W2`G60RFwoA"i'y̅hmWuï=g%<]^&b[%=l \;L˔_M'tUZ/M#]3~/r1yC:p$׻ HklՖf5d1kٝ6Z}lj~\ Ęp~_nݏޏgqyJZG#'KQT% w2ŎDpB[9Ōhk&,3࡜Otq]9kÈA,> EWX+Pꢯ;r\Nx-ܻ6Rί=ܻ;^[5rlF.+{#px T̶wU52EGeuqK>"Wkle_7~ixVocI7CNRk鷊H9!׮d ?0vi"_t/Y g)dr䤵{Y׮(k3pO"`_k'A.Ck򢆾-kaAR鵏;2(4w|Ռɿ8;\a(n)/`W !@4qb_ɮ_ɓ.t2l|%$&\>ӹ4fk'֕YY4~ڡB|c@ג~Gν$koihXخb־=䬴}]=[g>drV|7:rdtGM~ ~Z3O:\9[3UN*9E߻6#vk؆ʷxqvf@ mit/o,}\@@,yLj¿lbO,= ~-p;WXAlN-?zf+׊~WE|0U V3+^:7|GeF}r~QAi~tOOnQVݣ M'9/f=}Cw= ZD!q$Sx<ԶߓQP7Z2+= zb}KLn-Z̕%9C1aQ3m'"͵ڀ k'8:}YRgQ}a+~^u_fb[htE+;bW3RR9"z~߳? 0}[؉KH&!!>E_K z?}k|g>#=E`/{\k=?Y=s{p %ss^fTfۙYy&X/|:ZkDnYvw}ms܋&7yH| nM'+]~ݿxM]Q2m}W̯u/4u^& se1ќf_ Gc3? aOd)\ߓveq'RZg7}1g FjW߉YV4h#_Mx43UYξ6:˽-"O &a?%AWJ q_H7Hl.KB]cV0^B7~C/?dz_ҺNh}!+řӆ`'vuc2㩔aW 6c>~ 7C4ag8{sQfxW߃QTh+UݙE%ߓ!lju^o(s&ol) ߹G[/xX[S1 _)sZ@F^gg;0nɨ!ǞOh2zF"ܣk'OHmh:\۝Wx3?<~}mvpyY^ȯЊEP%6]gg^;xiy(;#a pH#:ČkkQA v͜t tmJ1uWhNEak'&!;?hDj̲i&(g|ܳ ]'GߞʗZ{絺G]:_9zMU&^BO朚o;3w, 2 -SE|MgzDŽMl?ǂvKh% q{j9;o7gb]Ky-3+߇ž' wY;Y[UsMJb/1f2Yq?60w?g>ΪC%e ,عV 0p%{XGh$lK"/xYaoڶ:/-7Ø9w;Yskk~vA=㐿8~-)/C1q3oRzs^K^?vۂIӷ4b)Xp<<2\!SօW Lע[beз凜k(9TԖDӻC yk ѶԶpb\U{qbgޡ:9swRc~lDvS7an(oK_ 趧 '~iY |(Z2}kGpR9ƉE*MWk?'.!nCٯm|CٙH@Jdb]} ,d,ƞmk`짆F fm\ ׂ뭷~<[f#ݞ:Ty.cy)p !/j魌)u[d]~W_`8yGrX@A+7@ZDوxpC9~ώ)M?Y 'Gk-)/}8ҩˋz华0^;.|+g' 3,>0cf?-AW2IXHc{T*'9s1kJ'&s[K6c:zI~bkh[5OBǚp .P?45ځ.Fq u@MЀ.vFm/y-qE1?Q8fyV{$~ɭr4LP jxǻٲ=.-{ӗ[{y?fF|1mvЮ=g$Y8K\7X#F3œW[pr.X{Aӷqѓ6V!?dx'8ssAra0SMxN xR`KDBn83E!k7s+YU1m̓vOb׶DƇX?ówrfXcc >G,z|r} =f :q擻У^;|-9ew%c*uעխ9b_V*}+٧ k7uZ>K3!kGgtoi=;vBf]SgNzS>z{x޾#/Ή68 V3oEfx฀I_ տj8bŜ@p9ib  oCNcRrZB^ԫ%_Hύ{L\_ 5x,%PD O׈b)+qn⯍VQZ"yz| k^6W"]<ďseN;,NiN;S0q)0y/,ԚlE(k;wNӧ){ 7<ěy9(m#La;pӓ?S9LkV??jpB;aQWjN|ra;z4gyyryr40[p= ϵ9pt[iw<n_ x箬:坸F{FʅoN\x%oL֦'vM{E8?;:PWT.,ϋEti %쳓J8kf0կP)e _a5Ph*Mu7gkkEÃ3Krb蕌X|g]Ss/ޚPCns#^[ˌw9,pvIsdᯥe8^+qy-YW{yׅρj]3dQ'tV:8w_Ə`%4:-X+^z9>Zhl%;E+]F{b|6tМ i ,y牢ﺡU1n?MP,d^+=y٫%^ϙ9bc1[G!}/UׂJ)lPܯOymmk7Nk`ўᆤ۳8 ͍wYbŶa+ٔH/"pC~:Kբ:x%~ξ'uҩX_$5)]47:uqgnǫ;E3wĠޟpN]x[t3q'nZzJxM^S;}Z_sG | >koQxv]kUW;mv=4_^o{ean̟gS*R<>Z v{_yM}2>!?d(Z0vi^p{*'O[-7>d9_Kx|G;g\NdM3RO0v!}<OKF{|.8Hs^`k{R8;܈A^0kՄ7ii/vYbYs!`$qf9.2<Ms%75yw!^6ꝋ`~7u禫=\v>4"o53|0k]_Eg̫]}'nwȫ[ F|(k )Hwvu,%դ=GZr 3!-Jkp޵>Cu"gpڤpyLx+|9#=;̋$k8g)'4 7 mg-ڷ?w ({<8 :{_XХ5%Ȣ6A-Uq2ѷdMVND, ]>._s*uY]n Ik-߬J-OHA ؞s-9~3Y- Y+ٛakSkr:{ ,j̐'{>lyG9}1<@yڎ\)d86x[oTgVh)hΉ  2 ~ al-҅uZ@_[Vw>MK}-{O?'LVdbǵ[1"_ ͵s~I_KV|[3wg-s_Z.yҋsoc2 _׮-7&[MhEZu PRd (z8kD_f>z/A+bEjshպ h!ϟk1٤-Qm<&YW-lfb f0b_ V2Zۙb~yw+z6NajpV3&=(4Ve$ץ/ngrזM_8%Ј}mϗu>6 ~"5%WLmruy4IkΈë|Oh77y|+pKj_KF\#{(hrd-s e!}rj:֢e/JG~R*ւ׭wyd0أ߈.ٛ\n KvK5n"ts9i勞^a/9"6Klpa(|%/e͗]TZ~_ﾉWC1~}mJW. U;k#wsy.NOM-՜(Ǎe޾.'s>Ɣ1ړBtc!L|D6wi#WsFt'dow^χ![ Z4wgG[]l1OcN!<W:{4ąj1/CCFxm#nc_3j[  k;0ߜd~_dnPkfC G0>Ӝ6~b|1?ēwn.Yu&< 9W|]\c=2; H2.yگu-s ^m*6@KQOm>փtVw=zQG=x%ʷZcy5^@INdTz>''ɿ{gyd&Jx;Sp(/D{95/xr9Ryhr L?zɞ3Wk!6mϙ1|'j2=gk0@6s{4:/xȪ͹ c5' |Xͅͻ`͑4tw2$sGV-F{ ^p}uJz _K&{f;|8?+u;X !4ݫjOA.DW0GUn r D@su6,`}^ *{^t1/J}^5r3)c59OZp9Y#uxr\ʙ/L?dOS%gq_сy)nϦ;ݳM~uXzYZJ:[sSʳ.DZJ(9y̼%3il3kxz!;.>yO!{h . 垘dos.HVa!hݼ2:5yL"}Ϲ˕Lۉ/-7Ѩb:}-hV‡b8gwLqgQx-a0׶ o;V?92"os:pW=FPwr;g=ՙ_=|-p/^IBؐo}m]>J)pNNlrpׁAFG#w⇼_gjr̃Л;N}mm/7BW d/VݲN/`zᇼ/?!2gqY<@DC9Z;2gDGk_*O%G#%s^y'N-<ܝK~-| yΕ-rNnm~dViy ~-_n*ZjGD}溕"۪žr)GeZ%^{˚1 _o6wNx0!= %*ap D~m(>"-cd, E_:ٜZVhgRq(\u:ǧ?o?<˯ayxmO}>˕2~-(B&vwg\{?_ָ':7fפG'Ztm2ׇ ;xGopW0 z ^ZVZ\׎W@t<{iٷRfsɼgkXb1CYs䈮ɕ{pX2;%z| "]E@j.5m=: p0!ͥsw%V9n끓_NkΉ5n][w .CGDF]J&Cn,\`2߷P~Mk9"֭<>x"LΉ|o=O +W1C9'دGOCy6ncv&pO|N9ٹ8 1JJ~:{0wCda% P~%_ܫ懢㕛C6jgމmC1fKc*{19o`-nlE#'c(sjٯhꯅ˿it4;qxȽgk{&|kJeѮ59~-#{ӵl.G7tu |g'=2gt? ^7&<:}6 zLsW0˯ oҳe cWf:GaU|$<伐Uu㒑 < |m :,5?d sЙM:K&w]Y{qv0 \k S('1 ɤxQ<=?Dz:ς_sʫGM/,|}.kk-}|PW|mo_tGz+ EknvQ)|/v48t\9Lfu"k V>d M= ~mU[g]~\9kI<>\y?m36'cV赃)7'Nk''GDys^qp<yԛ]w~ vvZIj9{ Nt~&}_خ|IƬxWcF赗=Q A-7lI\sRNFЉ^r% 'c3}9ߕH؇3faN ߸o ~AL|#լj#Oo'Z#eh`B_I'c,ߜ o 9" ߯;u(07w眣WF`㭌c3`ayZ:2ߤYwgVp\⿽;CUtɊǺGE;:] ;ξCkѬޟ pUw0g.xE1=uDkO}VBh>|mg+b݉sݏҡ q:2зgSZZy`:sVefi yw Po 9H/v85˙׾ub! #+YX`Y|̎߄ ӓ!TV}!GMNJsᒺ=z<5,ug|ߙ(;a ^ dKUnrjqCxNlTcemCŌFg D4k9W(qG8FktYk3J+\u赲Q٣&ɹ|.ש'>SY "_³*^$뵽Лw|m0mf L)9[MDzjsSAx;<uŸ w5}` yd.!'=tyUJ"_sLX炇֗soh$!M} e/GOaGϑd__$,DNr: 2|s'1jIOuPR<"_ّ! DSAH8. P 3E^xinwp2-9O!CXYkh/=ƻ{bNa}yRty냾_ V[ ?§ꭽqO$k#F']dQ_;pGk\2?rΙÏ<$JP:M.W7}˭܁vv]y`_x~zkp_ʝjs'y|(V=^OgK^1iu|Iɏ̈0"A~tP߯ss?}[ۤ*wܱ)\=w话~oo4n_m0 D[HcX~4]`?lpZםI㝦}y4Gp vsX~wpr:d9x }]=3\|s_nl= oDS |/pMhvu3~Z4"Wu`ib^KO2ӘxG:? Y#$]YՊymY//1_dŋO<ўypf?v~-ϸ9ZN-xi O>95 Lq>89^䱪; !I9HONKy`h2pKhbv`k?:J׋9[[:,cO&9L_#>M4cM~? n Ddc؁_k޸JUz(gq߳Մ򌙼mcC2@' ~aitR^ '=/b%"iy&ggy4`V=-Ow;{yΙ筽&=āAT@!Y?s%ؐߓWֺr|h 5z>IMC#`d?&w!yȺmcJ:$<;qM=:^"Hf>;J/P'kiW#׶H{ CnsW’UhDDrȞ<-ɧy+;19_#k]dgg c\ۧf'nF-XG#??2so۵ХIb*gr0f7MNO/&5ޫǤAVT次v䉿Vz:>{}tiYӢ6iddNA~!ߴ^γ~q3Mz)]㄁hNוK6и g⥡v9grBH|uF}yGxУsڭ#?f2| t{Jk^YmG^CN틔18; a^ ~6v{-tLffj{MZfuW[;7Ϫ$z' I WwgVtd/32 {V UKpOeq>6O ~-,#m֙`?&yNmrjG7HsTy_ŧp] {4(PzNt+0VULk<#Ԑ/L=қpK6 <=g CuRUk̶FO*k՗'zauxs4dU)p>ҫ!U&8W[8;VHOM,a+َ? 4h|Ǫ_*g~9Z Kzi}W1x'V4*R;E,Mp&׈O WE+^y,=񯅶䝠SZw4cۼ{ J]k;"O r^xOfiO9VgJs:CD3'x/=QĶIk !N_?̏kLf=#hAbǶL=%d1FBoO?ŹWdQ$KW:OYlI`FX U_;pO-_KމБ}NKC~|>{=Ύ=ϐ{?x0(Zre=精9lՁ/G o^hkɧ1эY e~NWpF*k߮']IG[ZrA EvY<DŽ]$"ͺ; ]fc&-8=vwg_(=OKYvKt^paYl7yU' O0] zk7=|k/4P'[mk0W0"k~{~q/%׳rkf&pVr,z~0wP Y;A_aOn|Qv.@m ,X`ޜteg2Ggndg>s*g~ & ܷ_;Gh}RZυ>ǡ<>it|h҉Jtr/U8u9y39({m5{׌euz =y_9p)|T(~{mk$Kc@ô_KnAoq)#Ӳgc) s%⃉W|_SdߍxۏPڌ/CC.EPc;yR,_ >{65y.3_kv?6LX~cj]!YdF(ϐyC k z\a z%L_"o3 >5s;,SKC0 9n ϼ%s~)cXCm'Z /Yh}I{UZuy=z-O*$V׮宙Y25VaL7/voơ<ÚAm<"My σZ8,W2̿'c#^ܗ H;A_c6XiΠoy$8ؒS*~߈O]kvZ̛ 2 p>>|mp&g|&Gӫm' kkY{fXr@u8߾ D]xF徂^S#JЍbNsMx58obosFohAkN3C_忄|-Qh{5sν|FPxfo{~Ⱦ vY8qYXw ox\./;OX ^Scz0c2ẅ́\|m_ G4Lhc<}2Q܅}m+#qv 0%RhaȦ ءdZه Ͼy P gi f֔ ?eH^/tKܪ1{)#}D o,kJ^;v jГ:3aFc &RST;;SqE*c߾2`뵍캖V8?}zmx)a4OUW48wDWΡ!'?9^[ӻE,l;ڊ/ϡh;V*9Tmgφ&ȯG?y,Fʝ9w`Ȱq׭y9W!!JK|67 O6ɖaC:zmݾU#Ó_s()ϸ,ѿ}unWnnBI#iyOc^+۫}`9e9܆¾=>赭S;t/_{d |pNldIŽ,=s>Q D ŶR˛@Hl3N!#WxȇxQ۞^ 7cL80.eʳXVL\wqfZ E_ڭ7N0_[7- _)%{brޙ~^RNޣ?赉'cą|w1|JyGWQKkF ;,8 ⳨=H<$ tOgk.FFBw|-="p91zm&k/p5~IrC+oS$4i1O4*_Xh'U$'Sa|O1fn `0&)VqI ޫLӝJ=2׵ߏzݮ\+/ȁ,]u#ڃ v:w+GFPk K3pUgLG kq에is㞺_SNs!ڍK,ZxX# z&ymu>+cVY gn7K{4<ў=Uy-3Cr| Mڅ^18{7Vv vlZ"Yk/uۏIݎEd1 @Jp5I>Y|bff~jpqTZ{']1v-w?&˿zCkLɵ?ysZx:k.FMD]Z ezir 8&WnPۅHpzߣ djCfpWZbϰG42g"kO L4x:7$G3t9'eCiۯiZ)TgoCvf¯_8GEU}Տw{˅f&ڼ =r\fj|Tnj\ƝfinIbPݨb+G+/ʇ_h {\pazl@} sAZ;3GAI=+-9Ck9t*Uk ͽcsC.d lя WܳQbů͝O CM=x0\dc0 8û'kw|0I@['{6f 4V9_ h:> |y.B}g닲sat]CƄ^*S{߮C&7#.#7ghN]>>tbsh'yhCT<_>[%둌r#Zƒ | Z4 lH:+fpr\C|mW=/Av FRxNGg%?CQ?|a hډVƷ~DJ3'po}nS ߎWGNi99g?Yԋ7* 2 GZv|-Ӥo5 Y9 rɺωb6iԽ@g ![<9o~ǯl2Tlh|0wߨ`IC_ʯm2oٮ2mEBk v:Mۿ_Av ۧrZqaȼVz_ȶ)&\/Otht۔y䯽dׇLvgmXLIɐ5ѥ8t_-ėӟlms)oΨkVX ˂Y̷R obԉ=]W-wS_LSZ GL8`3hGԯۭᬽkgɓ6C~-,E%6kGka3!sׇ A_ FE\u-{tXyg: zi[zL'Ω}h,?=ρ-s뜖K򙄿|hAؕ%if4о׺~:x<˿8_=&\0f_%^d[4ӹ'J_{gtdrľ+sd/i*}>Z񚿭hwk͛]C^&gQIjT {r iU~ȹ{;E k5;دԜ^6@/7߅ϐu:zWWZgU}/Z|f|Y.f{){ߏ&yIll/Vj333௝Y]Rob9kg{['u h3t|mgf ,MZ9|;!G7n;ZCBks=-#%r*)Yq%)kћ"Sgܫ_3_b.Ds:gU1Nbl$G|S^\e0+pm o DY`©^I;~nhSp}m UQq8~nWgǟB =g1~LKlBKySu&]$XG9r?pfZq=ԪZeH04>!?d4BWN$lwgaPmߋ\-ة/ +@_&1;䇌fq|ԋ3mtpE+TC: Xp1xa+huq{d6 JLe6ma7&B7dkshxG춃{N2p kὋ] ŭ7z騢F =r of́yaVvwNvYܣog:D7ʬb?1BF!:7JGGœ}ȯ/?t Ozvx+?c/‡06WaS+g/gPZTW+p4 _U0;=dd{rXFܓ}vf 0 /*<܀b^($B!g=yᓣQd cfx-Xv0CxI,ٕq'" 'mr~wQ+HbΩ9zF4wc^{c<ȭ Z<@^Ao8o}قk-#-̗ 0; |H9Cک9|m}>:Vۣt,kgeo܏F~kGNe;d|'k&+""aysw|M tP 8mMA~}EkaGnhXFָu~(;ۈaȖRp#Pf|8L~p1dו4cZﾘuS3|Z܏&|m^U+ȝ_v.&F7ɯmzG2$UL ۚԜ!|xl$Bl Ms_!/ZPL׶8VEz;{-~1:)W ]m|321s;a$yLL¿pk N?ɈgMjJF[9dFJ52TZ9Sؗ4N:^ao8vyqk}Ѐ^Z2̕[ 6>[{-߿8; A_Imo^VǽQtJGK? P~~nqH,6JRⓋ&7050NZß#;Z^[VQT߂n6ev x39Wu/ ,N3ûq-x g A]|6^fwj>E!_k勦#ZtMI&V}\K&]Y Nig0+ 6SPEx7 =WwBX'O?]zydƼP׊2]jmJ6:~̠~۵cfNrY<>E2q35fȰJMoU&sCVjM繨ٛ;X=IJ;f3{0>GẠ2Zlz҂ 0 v7)=MNt#|1Q/n|:wo/OpFVl?~C>擱3ʍbHf0/֏7+m% Wqa- |:=^~Sy a hRng%p΅@&\zmp~ѯ`kE9HIRю7Jcs?紼Թ&B!Xy^ 4' 拟^Z pur=݊ޚobvA"_;)$v%YAgbÈ|-}t?%J{^{t zmEz8D*29B10'0DZdYپo{lg ։p_n<4}\'7ͭapPv.6 0ݥg')yF*jC[T4wZXl^C!lK)s<m4Fkl9Z}Κ@49rane^q+V_=L''oMR==:4U4iεmJ/G2Ӄ YV!2"H]y^s8Ykᑫ7yԜr`%Sž6[3O#i9 kk^g|ո &٣| {smCY9מŪΝPqbu;U+d3MgN^;V6W /FCYd39|zuluc.uN8ʊLc~:~ʲg$ld׊Ƿtް/kPv6 0\)/V$gDYȭ}r<W-VO?vpLss&4E_ why_yOHSX4sG#9o;I+O^MS),p6Z{Cḟ|DF/mȣy_C9?F>[M_YEBnT{7/ ؐNc~%iQ)&+b#^hrɯ% 9 /ymg ߂1+)<ӢSg?.~7Д@0SyuVДCNYg8Z͚Ps#ZrX&?sXRZaҋrǜʷt{rv.60])?!*B=XB|j}#9=6JٮoNc7<>p ff ޷ݛt|~\N[zNkS !c/C\kY=^=3U0S}mЛi^\58dؓoC"sНTz_W/UȑBg99}1wPj᧐6̮[ þvO#aw\n\<-E]S_ȯMlHߎHLގ{zOnwgR<}-\QnU-eևqࡷZtM/_fe@+I b[˴# Hl~_ ^trݤl{\72vגS4Ծo3_l5pJ{'sKsr.i/ox 993 gˢ5sZ.E24;|/Zr;wՓD^5wdO_2W>w>0 ]k9.܏|4tiVԙI1?B>kЋnp-|Ef<}%hܯ-A>n2 f5|=r;O-7ji%7̍i&Pj(M+dὦ|} tK#9Yx>7|PGY])7= p%a z%m)_ljdD*Й7U;M6\sx>_Sjtүh(^0n:οSϱcy`A,t|կS=wdakx0zʒɻMsү}xiN+^Z7p\C řoǵg1m+=ä_[qM6+ƍ߽\үmLЬ5$h~-ϑk,VW)WDxGx}ļYWv$,!O{)N.eL|\'XbWbGsU ,ԕ3o|L#{ zOh}1_umM$<əc|s퇲3maDrlRؘmʲH? rj32ݸ A#2Ნ^Fܳ{Y5x:^e>|kR;x:+]~I^Vc}w_O=׊,%Xa38lx7jk}{<9& ѕ1/&“Z8>'qcGv q~KaPD<К4∌f_fȃs;圏>d<ՊZB\E^;/5pvN:GNy~8;܆a~ɉ%[Z1h1&UdIȿ"Ghdə ^-#cb _5_s꜒_9%x k㵁>Js8ϸ~Rcƥ~ ;_isVpwvIDCHN^;G¡<9S%,ˉ/t3v*-kt;5k8[p}6L7kL hYE 6Wq1;Sj/;+f֫uE3^xŀS#h;{4j}"9n2p^G׎Ee0 }"Zig54Ľ+k;iP}< ;o7aYkeyoV\ȚQtMa]>&E[ンR t6W΢)ܹ?v:^ z1}[%9W/T~=+PI"?'Xw>b;Ċir¯6Yb5y>1Pעָ'_ sJ9NksGy2˘sG_i8+}~Ftmh|JglUYg[с=zk sN&`/PEK}D_p}27ɾU5hXùïE |Ovw/bfLmdc)ZtS=_{וԶAk/9m~me'NqsYuތ]_jL׎>t ܂|-ߪ)8B5h*ܗy9790֍PaM^ n C/ZRJs3Qt|.Χb'7K,Ih܍<,(a%|c0E~K GJIs !Xfxux |磛jmӣk,-gfuw])X}|l{LgGo>c=J_}brnvTgSⷩ 0VU=LMw&0@Wo'[ Ey=م(? I?_^_nb,]_9kS~`,tGN(\yܣ;OOWf ϑ';='':]?kv!oG2tA mqxwkmG7>*pҋ{n=ənJgh(ù [ |ȧg 88Gע+!k'^_dN;#;+Z goTnwѯm`OT}b ӄ98%{fLj?2~^aaFY{`b}T΋@| 󭾻uGxaѦ\}\?۪u&9k hMzҸ'=ow_aVIʱomtg2!~L|)WCV8<0~m3lԙlka+Mbp.P.q N8ͣ7x4u`L9=F0~VLkc1$Y8ysDWCޜOC:̳AϔRv0!Gk.@xk5#i!;}v/I9?kOk$@ HYti|L<Όwml7^[g^uR u+H-Jo ]àҨuv0ոsNolh,8qkJ&ٛZ^kƙ,wt`ޑU5rD~! ]?^ϢQ1i^HCqpdX礰ϸWߪ =$r4xPC~_ Ci! MGyٵRiJMFu !||=`ܑܭ4[%) trO&?av[]j?djZ2kg?ٿ7ھ1ºDJM0_(=y甖sCeJֹ;-qǬY[ "ւ=Z5f|m48zrK[᷍_F{jb짷ߑhj[̚ GnAE\Țy5o==/{K+o:'98o+â/7 %7fRp)G/\gt椕ϫf74[=gL 2=* 6'gz0 bQ ?,AոwsJ4Qv~0YsYt'xBM|HzhXYNYN}A1?:Lg~Gxmn<CgZV?V(әk׮O޶.rkrמ%/yyP9=Zn fw#C);a^)&vlRU eV:+xQk}] _kCOg8Ybê{{e*9]kK9!Ytx1;\.։J_/\la HcX~"r#+2]ٮdRiН^oռZ|'::iR^^uapv%>Aܝko[T9ƠwS(_\K8 |%x->ͧO6c}- 5qoc-|y.afrD_[b=?g&7sV6|a|NаdKg|\~ᧀ.]??fOgY >xh͘&ڛoǘE9ʯ-00櫁צ\ ~-2fC)6 7*s??GC@jt:ψAns|Ngs&/8̣˨} 0 D)VyFUi=?-6:ty9KhX\ -2g+,} C,NnQsZ_9ի?R2z[o 2v=WyG.g0+%1pj[HQ 4؞Yk-x ,Nk=/kޫ^+O ~NH_۪1wV]xOo=kp 9Sr?:^r%rx t/!5(w}퍯b̶^h~/OVqkwk ^3ak]]uYM̐o2shltzwDKi.CokC+=r. -cjqڱB_CK൉?&Rnc+.?{[~ӝ5=`YĜ훖{PoEhj*:+#f'>&ywruZ1tȁx?h /?-Y7δ%ߨ\3g:Ka  nY+\~i<vsy.3-FUt0ͤV5}һ!?dX#+^4dGPq_9Lu3Wh8UdH(AoGF r?z93ův^? r0CdX;%~R:(`2~gv'a-\9$*B6|t6:|B}^ׁGa‰|drn-[9{CIlC_(‡ܧTRtT>ԝ/ }^Nj{2Y$S44im|?:>dצ0EL,V%y|<Ԛ=\hBm]p:⬅/vIB;?[ Sw&2)u5@`u6}?EmvTew0^ =9f_>Fzmd4̪{Ca^w470B}?fiw/A-ǬM%%Cٝw~ΡC/ .Fi}87s4-;[smWps4ge+:J.ΏGsrmߝ^pFr##{m>_h_{6t0띸wU0f4^ٗ] cQSyߓ㶱?_;srdL:s9Ǿ$Eײ=9x'̳iL=R v5 SNϢ\)E/ّ pLsF`VO/s_xWOU[MAi|GY_H w>Sk}ds|(;A^ $ʦTHs-{F0˫_1ߺ+Lٓ'Գ_ZqC 64wAy}w_?!'Zk;d*F^s N;E~Ss?w ar9-"{`!_;IWv]L/a>FeX35KYL}{G 4yqfjwfeb0ѕ_(ωu(q>B_; N]EGڹ^&x絝xӬkKO=2frivu4B_{ؘʼn箬O-eev~Ms9'W>` ݗ#fƒUWѝ { ޵=3+ * ZSMb],_Cy`~_C>*0;ß܄żv1+\X=絝Q?>SpH>fo*`7Upy-gϭߛ3$kcCҼM''IB'6x2 k#99:)QW vg?=8;܆a^I %BS8,ҏ?Z</N.ݟ<^G_ xn3YY_y~)n3>P-H XmԚ=]zm54Ɯzd ͰW^xN&}kt&>NsϮ3 }z3c<86<䍧&;|_tQ';%kkC~Ni m.tEYC@<3챓܇c8xƪFO^yFsnRcIqUײGܯ]g>fVMw݌wh[|kZ_-VqؿpעTF ;ˡ+sNj}pv& P ]IkZc. t`,~{Z?AXt{X:d]=zQߧ?mZk=psOkBJ2_dyom >9"ݞnʾ>c=/,I6)>(B&OyiEoȿG^9٢lr AŎh; ~K;Y)8&ǔZhaLy䒁u_h1ڊN\>lWpi8@tsc4tDEpgyxOg2JrV]y/?D(AD_;&Z쌲a x%.M s<Јi62ox:V?zE8yMǫUd闞{ gOb~(٩r>{9pՅ@=NݣxYtru0Gks:=8rHgsFɿk -xC,@[y_1J:Nμ6ՊӜ?RZrbM19٨k~=|eEկB0VZ2xȋk /e9kql0 1CɼVy:Ey-[Os_ᬵޟmc׮ vޞ}ޭsGo&VLy.SX!Hk£^Gّ DS␄?Xk\R_w͉2Ύ^˺Y|溳S^f൱Y 8{4+$?v/)vGWr#9?dvνV 9Lpt9DŽ/~Ћ:^9ӎ9S+\O!:ʉC/_~9S k97?1Hkgwц3/XWnrל?(aWJ`̄_kDTH4߿wqJ?49^Es̀Ao)s9u9y_Y7KcU}_;/CY]3mx(s]^͵nV3s~>6`wq<Rʋ~艵2ҏyN73w-9t5Kط`kGK>4fC*2Ht>ќ=pFgfUN cg4);B^_4*&ٰ/#n~wԯ3KS&w>[̶^M݇1W'ܛ^SxF yA_aPsaB_!Yo~ Z~ or\+/5C4z+%{s5!?9'^ Gs\p+x% 'bԷcԾ@{_"!!՗MIEO_k^at~t3^{1~ڙ窵`vdL87 5/%WdM.ٙ iztfz$A0r?6z\h"PgU`F-ǻJSS3k,v- ? 4G=Ɏlσ.2\V2k8tw](ײ?ukf]EOsi*z.z~`ת}ȏqQoGWm?{Ze!WW}wC{E~8 1K!&Ǯ8j+w a1LCBE!aJC>6a $:_5V w_0Vx.\ {6x Rc?W]G>Gyp} 3hO;O3'x畜C2g x[zxEYY"ok쁙 =^[E9jh[Rv9%o5H~-TgsNsDNF'oNIp~l'>R,= s~wX<ƒd~ЮVoٮWзDFOҪZ=`үuy(+IN"g2/k9̾gkv0NXucJ@JBlξz9Nj 0m8"k|ξڄ%efK}_kghZvhaw|T?-[HWqۨ _K~_߫6f1?lGLfc<Y \y텟j-77)q! Rf?uFo{J Yv;=EG #sc y-gC\_Nrlo}ҽs:QzmdZ2O! 2ʂ}[oli03IVs | Zd1t }Z2ƃG;omf5f)9ί=d>=RVkLQt3S$7DO4edfj\Xtѫ5,saH~g}='5?Cq(y 8/wd7zpf=_L|z>Rw!;3pv.6 1 ] Hr9_H-HT1<O?n,}99 21BG|Mλv 4CO6#rd _hE'L k0Uح{𪺖eܛڄ@^-#oC~Ԝ oEkulY &R󮿧wp?FNsN85xdGߗZUI{ߵ9A2{(25;?cd*YV\NwCF(|ps%SNgU?T6]qivwy_~uggh(ks4yO7{QvF @ 5bpxiU.؎i\ɢ;sZҌxQMMWN1Nį-ZHnhڗduY2 g}TtF1ֵ2ѯ9{~c )o` d{-jYtn yp:RZ4gQzNw4>̺w8Z=3͑d`_)v.v:d_ {%WW/ۆ@:BAxպ ^(f]{`ȝwpQ΋*fDP_{jf<,cmQ$Ek&_kkչs~Q$|f't9Kv9۳wIs89'0kLx!3.pi]0;,޼הٵ^O쇎MZsSGc/ a_ER,Ӂ?(4,>n5'ȁ͐ƽa=ʂxϒO͔ w4zPaI|jZq1&Xs':6Zx0'3yc |-RLsSnb12, UwʐƸ_Ǫ3!t+4Qݝ[~=_!7JjΙyyi ZKUq).T/mS7?rfZX/A: ^{:-69 R4r-؃fd);;߻"#7z0M7V|㟞$aWq1Jc*?]OѻWf+{ +q gk0WJ⇼Xyua&]yiO7 \f u=z^Y{>vS)z1&?.3YsLztkK׎N'Y跻V!x|Ê#"G+102gJ|g(whal؄wKx/lo8`$8 $~ 5y*}-xm:h ){rT\xR=9+P?'&A=Q<*.ugv#.yNY-bM:jug 8ԔVW?\p#a z%_lvym+l/,sOWf:}mGP죉GJEoS/H ?:RC>ḄQNr p>޶|ugɯ]`;5}mcNי:ag-ڱ+;<B_%:,zVZgZMve4wr_NP2브*坠!nhVk&Igw^{ϹW硺S{r> ͵z}|:x7oK npjwëU(!o倏(GBWi&2.D`?+Ȋxx# slNr-dz<[&KpDȧgx8uJ rvYyyBqs^ptg-D:g79~On(sf'} _Uyyc+4wV;E;2ӫ;7cvf/sV~qg(0O|jx傇hҹY.m:_|G:"_Ws!FfL qt[~mmMm bÖ9{UfChft9>qiV?m0 wEI+P["o)o/,^Lhg6}TO ,s2p=1Iγ܇`|wzLk<1䋎N_iqVZKùeSlwBwZkgw^kjD*̨ k$Ńţk'm NoRaE&"k|b\Wd<_ˮ[5xZzm^[ZKxu1YzP·Zm^{Oʤ:\K7<xPhl5K;=㱡dI}땟FOkE^yt>I37)vc~/xmb_K_ߔ 0 DW"&).JZN;~+tދ/ feݯn+>է㼷C=_tn /R=4|ҕ9JpLλ~~9kϡwƙ/_䯍cxtyXZ)I7nxu =V]@ձ9s>9|-Lֺk3N)t,9^%KrʘmZDzCN2kkia;khw$v֭1=^Wp{v>߻2Zc,sZw<v)߱~Z u_-}KK}oD_7]ɯ!FCkJr.7Yk$lH6^~|•6YedKbD[ }nRZɣ盥//\JskN03<ǵm֝sٙ8 @%YHr |c`@\l{_;CS:練Aס9r{k0$;Tv,G,RwO<3ˑ\I^Gk}"?:xBc<.zyfK2N$ ~;QϵmhlqA#.9_!Kpy_읧 Z|mWJX4HmJuwN8Ncw!O쿟 ]"߄.2f2K#ډ⯕zR0!:.צCCoNY m5أ琛No9T&IU _{|a|\la i}HX 4z$r]0lxW c? q6:-^Q kѕ/{r>S^7*^mGk#Y[d\:wBol,x&gK#{^Ac0Cv \RO g?6^g#k}m:F[^[hXMY9u)BMgX׾k75G}qsGۨ9!O>g?'1xvzFo7<>[ʑBWn|q?/^]x;r]X(j[-V,-.lܑ7ⳝgK[83+kM&{S)L`F9u5|Pv&6 0 \ɒH/VORF;EWrџYͱqakEzyk !_kaO>]i\E_y奥PK31,oMVP'9ٽi9s \7;8 ~mъל`WYWW>P둟3\.sLiC?)_5{ߓIu#r~œA^=kJYUr}喳o'}Ljlm -s55v-=I;ܨfOKeSGï}ɡ<gh<_ktiվsǤA8ZXI., bVi&?V0qQ砫 ¶Re{~=Q:G nk=l׶A_NL9~$p2nrGkYdӷq\׼v}̺Le=k(;a~ɒmHz`o=hœ>y#'Pa-$jT;c(]s`WooghAǸ+6zm$Ǎl1wu;£䉲v88BOƲvSzX\}}5=tY)H c6e ᯭ~d̷,*>죓L(\Nf&cC l9{'a赜zl{L]9#/|xXωQi|rܢ+Ĺ;A;К: chh]k1AwJ?X;;>|?m<k *[W5|gg0 C+IDbMH;C J4588=*"+<{l׃yNMGZJ-ß<޸|JϡZ_MX{Z o3ȵWYxmC* NIkOnsr쁮:Y?ZG!p{p /C&)nx r72.3h3!9vJG$2g{}o[qkk'k󭮼4t{?Uꆾ ;.:Oʞ :HR5xdo/?h -Ѱ! : _kxZZjK&^[Xue~}Qv.80R0؄_lW&jvHl6yXƙmx$?>GI g\8൏.Ͻ5R: 褥Z~?1t8_CJzaZGs19!RX9Zkʯsyv_yWsF z@~] ǵjl|^NfvW\W9RZõ&w^nGɳ6g҂mua/w~'xV?kE;iA/eQ̯3,sI+DK>)^adg+}F'oHa,hɊѵk6"sD0@}7!9Fk%_s^;W=@k_^{^ܕ~]rbx$ӏ_lBGh㫅0.?‡,yr5QԸ0a8kXx>}[ע:szmuZwnte~gOC_Y}Ϗdbueb\q}`5?_7tyXtcF7M[h.ƿ3H%{N9uZxu$ǫozze|#k/SĖqkOUBZS{ xȋ$6o4g]S@Lfk'}s-[赚~:Գ2!GDN]|V ցi\$4W8&/_gfU,dNpVi݋Xo+pʜ]k!_ʗ?׮vV{;?8;m{ܤ :/?Biɋ61r~Ϊz-ti'mAAрZmkk:eY8sd}zyOyv?|k, I֚F+ߟֹ|'oג3AkafG@Ftڙ:>pz7j_5jukcn' ʾq6iKr:rjus:sͽ㏲3Zb?Y7cx(7Xk6G?NL5bڶr޵}X{!XO^ }mn#?k[-gNpΜMnx}՝8g4-W/өoj<`3.Y=iӨoOc_pWR飾]Y)OV.z21~;zFGH-x5/яy85μF.S`prk/hr Ұ8ҝVio{|4|MCX|bXxK<䙃IطIM$<1OzXEgmuUPɯm ki)dtr({ٹ6 @t%K(y;#HK lA_s-{mC9k_[0y9^+"wWcȯ|>wpñbw =|P A&B5gk ~0 Xk$STkZ{=7_}׾'Z!n ^mgZ|5^srhkK yc^ MZpgxm,t'}ɷ@{S =+2o}v7xmyP~iC%2xqώYUw]<=ukcsR6,l?{i'?d4.=ӨlҿOkS Zٹ @tv]w@jyW!WD~^+vs2=f- ]4N/^ , H*p]rh!>z_96,1EҜwr RZκ(|{1y'~;ahZ\2G$K(;ۊaCb~E P, z _R 2ttx|c_7͗V}U&{iqOjӤ <ū54Wc-mzjԽ_/ { 猼!}=*_2'chcc/CZ`np7\7 {Li nAJ_ȸﱟJ'<]h ,x9g_9R BmeP!9O"ĿpacfrOl/xwgῖGf.h㝓k#^ ymL' ?ㇲ3aa`Z} ^1PWebyƻ9?+;GS5܇fhMS fkKDM]8`l&Y#r ⼚y%}0Y3ݝp뵽먓={aqf?-`dE{T|1|;?uzly`BUYʌ%'jM|\nA{G9~9.U{1/d2gH:cT ۞|]z~;nN!>jArrg܇nS\[2xCgj_aɬk5NV2 ~^+|7zZ_nd6tW1' r|bv4=-n繨|ޕY?ۭ0D[2ޝo~Π)s@ {=OLܯ;@;,ڽWkᇂL>'߫s$V%hOGr1k- }v8sC]q˖ik5}shsyyO_əcvn1! V/d߮;]tn +Ƀ ˹`C̅ko5GO܉0Ry0x~g À ɽ|-ڻi. sk݋ԇgH"}*fsGﴠo.8;C[g#Zźw >W/mgg#! +-hyFQDNp\ݥޙBz/S}-UpSI>D~u?goƳ6^̓g6t.8n @|qkO\`:Scz+o?g}o~0a{'o;kL0tkg!9yoർM7H? NnLz& ^[etd^גQ߶J/&8:ƕU}.GPj3briJ=r/A൅?#+KY$˜Q'+MF{߅gVJxLpSczߜSsб2z {3Ja~lyʔv 0ae=Nq!k/2{4!$h_xLM|vnEѭ4/WfpHj4xi_+nԠ}{)9 ' i﫵+OO5rҗoR9? |I'ߵąU |9fǗٍPvmOط#ξ~udo,c-1d Lk9 U'OwѤ~LCX_@C&C"tINuᯝ1'J1`<(2`ə3b?|S]}Lr喼ʰ/c/cK]xX|IKuf _m0 DWDlXQzt>(.]Ңx?ʮ40&t?MMExMvKDlYC9o9RTڝwyi2|(5Cb pPkVCdm{6za:hˣ9kr( f6'}9gcM5ъ8g-Z6p9?p}9ej? lٓKi*Zrb?9U_k'~Wܨy_ N <]MЌ_ؽiF?f]3 3v"neaqE~m{/'sM衬pd2._әo~ȿOra zqQ|L/JlF*u9P4|&e8:#X %n |'/?PMm^YFA_{mGy95g,snSʔomhc'WO'ZWgXpWe,\E?ڹ.o@Q{M̏pD:^)`cT!ۯ-$j9*Z2̠LSJ<={ ?g9!Zyl)pE]] Y?d2?cNS-Xͨ7}aw`t7Η{sr ىc9%?Ziq }mI/Ǯz׶ p#a %8VjEU@t1k^#5oݷ+%I`vԫk2St$YRvۑax-^;2W$Nx 'g᷒'61@u ۘw(q2\mgYk[=Pve=kbpԫ?}Z8>hCǽz寭-蚍Mv۳Aiuw1C`7_ld ?=3bh^.wnA8ޭ_+Y83~P-HZ7co3q`/WP+X \8B7@$EK;^N%z48rao^y:^8feV; ZsyM .Ey孨tY9H{JV3um|o+6< u?!u9nќ&ws܇P`q?Ԝwb.}-m!Ox h }+o`u="nRZ+ը*,D~6%XYGx / TsO-Zmxi·Vy<*sY.̵.'Vu{Nƚׂ5] Sί&cooR>`;ig0+fۏ7R)V(l|틦W7 kITͱVw}ًd+[lGu62 O{sok~L$ڎXmf1!(8L8iٜ}ߟz0J/t"_+ QJ#"bSpׂ*'Mp5+Nok=,F#h0¯SL&5}׊ľO̓ob/{?!S0k8g <ݝk9V-;ܞS㻍^Er'o6k7}άLƘ^m=TR%zLYL~yk%y1Z(ϩQsx&z<eg! +/(D3,KC۵kF~_q^;vMfíIkeM g]:ϊG'ɤ3qx]%x}>thη~" u7IsPwH @pk[3&}M:lfcTWʾk8׮a י|\|LNr[K\{78Tǜ'.}}_>p _jN'/RL:U◛|mD`#z`<9S(xW`Wk- GZ>lt炇|f>ߵY!8k>ڜV# i~x?1X:̍^=}m2^כGrj[+e}-ǶoǠxIsȀ7]k~)f(k/:ٗ>%fv0NעYm<{rNi``G^ƻL> EepagΣlYr~ 3_k2ק9gwFw\a zIJŠHY4;VrdY-huO8q|CgNNPzmf#ш/ZǛ}ګN]n秮vG^|~ s;C~/쀇܂^>Pɻ4_[5ÿk9xyւF]6 dcSZt/k x_zmxV?8tMo{8HZ9CXu5xOk1o5T' GגŒX'1rpqɫa:wd^^F)1ޗ^{Q_#<:> کPoF^Xzmltͬu<=QuLfF[ABڶkÇ{©cCk=(;$A^ $_,ewYyX9WIE;~Rg7]-sJ@~7yɦv/h./jv[Yߴ1 ZX=1up. rȯp+Kl@Q>À0Cݜ!swۻ>*8|.⯅sڗ`;dnhd5zʷcf_ڏpVɻ,-RGC ׺Q˭k/R9d=96g7wt!kFCb}-kDŽҳ`fU9_ |f@X/Xʝp6ku9{OOMkahKZ{@kr G}Dah|m5;^bj4ԝgϴkĚw{?;fsįd!ǚZ_[ᜇ{i!NY7x҅^KnNYqүܬHчv4[) } zjE-^)lcmr'9ݝ>"_r⫕3<~sҗ6C_Z65Eb.;7Y#KtƂ@0,Rч $߁Ֆv܋_ێLS!:ָ{AGO_|?9mJ cwg>%Gk[p&9!x~6uYYS;Oo@ɦ.o>&G0ُK>/kXu8>RpW;MgZ*~OٯXe[ 29L50Im(*=EOgO7&GCS5[Ev^pPu۰ ]GᯝLvpɬi֧v; 2гZ~;ļ{?sWP~m, -׊Us~+ќgTn~tjLk*/ʒ\vYDlE9kg~!5Lv]HU;+^2٫ 493V3\ι{ZFE#'G!jG;מ`zԫk/>f /R=!2z+@g+,/̓3Qb蕠d_lj\A5B &~~}ȃ:yjIgX ڽQ'ku4ݧ*`yZΙ׮עt}pԧ܇ Q9g?ryDkpEiԶ_Oxͥ fb^_Z3kbR࿗Λ9Dgb^`E&떬UfUpFth$ϗxDvmt9]\Tז#sCwZ{{(Y&ݝ>_pb/D`^;jHGks63S{@7k&HOT&'L!?Ȱyx='Bٗf#X ?n0!kֳUPrJrwgG!G)?L ЎRlNO4H<{dC{Cw5X0ŕ!1s]F3(3|'zf"xs1b'R{:kܞZy G~]}nS+xG7k˔_~UdwO-<)MXyq+j<_kbM?Y)x3_PÇvx ~{㹇6 FcMV ÇF5yivIr+'cn]Gr_۹Gu04u_nek@fZ|Mnsx!FiEٹ%7 PtK2dcpvt__kᇼsv^u40|.~ |mf>oYɷ]VZ{wû}~d0 TisO8<є7m㵃^{yy0S<7 md`47|dϔx Viעm^n/9 G{pVk?гȯzW(oRsۋk;?g1FZZ2ys(NM^;=O~j硥pWj/yى>Q=w%3 zSY>IwVj^w8Bmی:&9r*}ELNtlW~Wѫxr6.酪}Gʅz-z(o`PS'z; MG ZLJ]<;'GW/r>!Sh4 sp+gxqvF70 ])%;+#(F4*RbP\lȑ s©YFC{j_e#'wڐ^K {塛ϵ)հgkiFwpy+ts"Y ȸ4{Z =ckߎᗿp눌9,ˉP~*2'}=2{9KsY+?ϨigcξU{;4{zm ֭bf Ž΋eÜ,SVO:EX䕟bQ-rN^ &{@|sQ ˳MĿ zR~3RǺyW'v)V$b!Ng+K 1r6(;a^7Ř}wjNMc1{ǸXuz픷,#!sUR熎ʯO ^F_.!Kh^˾:yሴ.]c\k2?ByjwTg 9K\+// NBp{/t<"^T5<7XH.(9NʹoU;Uk ==ηڶ$92R1G5JtZeBj.?;刭~j휵Bnߓw-r~a)&Z/Ds{#5K +F*ϐ ,6jžG!Gj?8;A^)/j_P <3o!y,R3 әܼע?7^0/5!I;A@'=VɅJYXf|}t-mà& .(]:٧Sh]3f EBv}PQpf2EzΘO圃^ 8[OShzY|-_2G/gk pSX`&3oss1,f=wy]X+n3wr' ˶^#Rh4 ekrxT׸ѤOqsgqWr9]9:[ݕe|4AkaGvݰ\wS}qv80 kU1:^?Z'i36Ki(Lg9|< 2 I&DU틳#7I{=LEV]  }Qq1Yp`sU9Υ[ Wa+?kVGZ>!-:fdhr~G 'p^k('N If#~>q4_~-|9Jr,t ^3>Sp5jfisk󀵉 =U{]1ECz-9,A_;AZru_,ܵ%.,ނ GÜ{≦vOwNc揲saJX&|5?z] {x.9NJ~m[w׎~ۃL`.7>cNiEW`؝iKW[d4<\y̍mw7 O=Ͻ4Ξ^К\unnϹܝW:a(fVZ<-ҿgڶo'rWKCޑ}v7)|a>Vγ̶i>^ՊOnpDJ8!.M\X8ny#kV&hΜ Vz=a=[$gfWc]y6&O\8SƷvN ¥fJf܅ =>i.*txZ5@x9;܆a ~JkQ׳ 4to9 X+kŕ))L ;ھ* nn={S7 l,u ?ǵvXP9qݘI=+ۼ};:k߲nO@-:g_1:=?[qjt6ܨGsW;Ɋ8 _ ڤd,dp5c 23^+:gOh<|m3kq3+n3E+k -yU9}ohZSCVpN۫?EawXuգ ?@ 7hM?眄s1=k_XO'_1,j%;F/Ɓ-)ǘyiJϰ,kUmFc1Tސ_4Lo^EiYZ'C6kP s>u?nz0'O֕6/8fLПþ`=ޱ.SCN;JVp8N'vbW&4'-9GKwj1\ Vtޥ ڑ_7>ٿڜ1wZzm'.a4:^1bbpD|mpUfBh](r!5@6kW~h g_> d5/z a+b5 |;p֢ΙՐ5n#Vk+:t=/Eٹ$9 1J@b**#v^QYZZp߷z26^S]scY@ͧ{'U%qzm*ڔ+;ߡTo3 !9>Y={ߜ7SXzm#AܑSX<:a=x#7,Ξy={t&zEZLNzjӠ:E:^1scN)~!^NPcI%c@7O2g49ثlrj';OfUչCAj@ÏŽviG%h1{;L[wu}yZh>d9gg1/l\9Խ~E ckgK'J;36ZΟkz\kl:z] 3tSY Jo-;ʻxdy;|́N ڻ(bV4~Kck`:Pvڳz d].1K;Zщڪ'7μmaX3R҉Jk媽e~3浍܇&^VZs'VNrMR௅q #"6k׮O9Qh(wڀɛxkysUAgztiGJq[q#"$}d&C\]a\]4Z:=zrw3gg0 +y-%Xd~jkew8! =൅Ơț;@gٻΒiZԺxI+ѫUw2 7}LrbLcE ]kK9!7W8+w8ѧ ?*xvЄ;5!zJ6k>ZX3tM%?mJZh Z6bHPlNX}hj+Z5)rcQOf5lz_1zъ'FgoQ}r;NtɳZ{JOԘ~;ܚakRԞ\ZCפ+Ϥ]\ٹ( 0.{Hd@ZsXL;Ll?**b>%,dkMs OsK_|9/撣ixɊ?t6fq SPf9{<V0 nIF}Fk{ZʺߜE Fl՗鵯;8bO};k^g>?zm<=DϨ|mroY|mpaZ:|0k?d>zf۽~q /N/xm:x01?pNK@k5s`[͌}9{z `k9wצ<#|Y D/֏7TP؞Z99q_S?Iu[&'&=Zݺ9l.l ?rӧ8Lv^;Ђ}F?!+9W '0 >yLxwa9欵J"||puN61=KYe%{&x4Nk'zw1M:]|wէGv7r6)Ћxsq$7,k-坐(l P+az&!vԖt9_[y^빹m/ԢOWa{LZ||u7nA= }e[)v!k8§Y]p(;t~L6\|s:6jd}ro3d 7$k BډZrB̨7Qƽ-ڋYćxGk5;Y=?d vyDzԫy45J>3GSk-WGk7V r>_ZCլLC)kwxٷTމ~coQ*69%\EW.AKTf=C87*t*ڀI> 'Wk֯;3(ym vw-2J; ԙt5Ma0DvFZ~ѯ}zE`WDC5^AǤ_ǹv1SC<6wLr|+Jז~Xԭo"gs}9+w+k.x r23?td^x֟5QX:FEGl::Cw/mW2w\~e٤ɼ6 |'z_ 2gS|Zz|hW[q\k^=>|s|Kcޕ]Yg(R߮eWc+gޖd==DVCK~-uԘMļv¡uhg'sE$1 0K!H 9((O dvIɀNLKH4kG%LzaWӸג,嬁_'YYOys슦_~ys26ɯkLU=݅_[a,ڍ>ZGO$x6}O<C64 'rw~mYrXZT_uN6!G*d&ZY%wך*Ikb^I4π/9KP/yoVua'L8_վrm2,CL0-Aߗ>^dH읐{U~{r#:wL8&z~XuEQ>q0 D[2-7$`cj}/!ҭϧ fgᷢG|dML+`!Rzdz}^d޻j^C#keL_(עlY}rZ_̺t|㽺>`&V:~Sn͚Z?gyS7Gm}eß8xlWֲv"mNk{fY%_F~~ٮm v/1kKdv#fm0-^kN, |wk;>UcH֏e:}#?z틲sAuQ/ grФ!? ZV\ _'ӹW/KYka^I?'ĞoU}*ϋYp+aqv3dg9ͽ򝀇,sjtYE^ ܊=_SIasVV!~\g2!9pҳymԅkqÁ( ;v.^8zux)#\\csvieBO[?bUމ?\ ohWZkܯ3,pjVݼG>@ ͩp]{t}që?>~(*sC" X֣1|/Z7%~"4;؋.'8;܈A^l_~V;gX? =2/|iU40j&WZݺULxfظOle?׶лO㕍|8t{hk"/c5y QKSЇv^7עs~&Ge׎ΐxk)(oQZ^ױ!:z#yy?n9_ZX~d+v %:o.i+Uw&o>-jSꑊUܕpԙJy4<nB'S}>Sv-|ŽO*X|j<t.:N̩ɺm8=mtYK^ e}_̥uMtݗtΛt#:C™DŽ}0<hx%|- 2}|"=46u_o\F5|'*]涟f?(;b^"J_F - DLٻ:&"Z_rbk_; =LbH0?_CźymMr_n}U3nNp'_R? \D}Ad\tV&gY8MѸ5_ϞUg7ĿgtHV9DŽG2ݕN}`kW)y1ϹP:Gײ37(_y|†˲}ϼ61H޽9W0&mԸq2bo{Q D4/ұ:`{o@/Ctע2&*-:!xE@-SYs,|'$"6/,82 N@>U9{oLޜSpG?fpvzrC.aSq;rLa`&c޽"3Х9^EBh;s0ꅊ:q\r_կw+)#Ek;gmi;[iVvaݵ-GDɑjFC_~- h^ d1s.|Gx3+31O$ZŞ0PkSιXҥ!lG뾊v,B_r ET0`sR紑f~.Pb_K0Syk^˾FrGY)k[m?KU:nنS639 mk'=EM77Y` V4e_sFޫG+rй'#%ע_zC܅ڷ~e`|t8si;8Fvxx1 }TrqF~mY|a^xF$ l/tJ3B0nDh@/͇Vu^ٗpYwMAEOr_7< =SJ~Gq J7pX_KeK#Vymi^c}ͼO {>p~mjC>'XޔA0$5a'peKF =Q&E{~G`myEkM$~N*kcf/Ma2NǧKNM3BkV&9S3d1<Ý:It`ʆQ $.Ck:p #Ƈ5ޭhMOkZ'߿֘` o =7/45ޑ}mԫJ{_ί!#CkaZ& [Oi+ϘzV^2?@צ]ğ)&uΰH|F! k(SHmڝrᑅm G=97egt0 Еlrm$ImY"ׂ))KkQs t~U rh)4ڔ>ꑳ|f^4zܚi=Wsnhoc6kuw'ز֚3їcѥu۬e+g&ʂS9__4G09koڧއ~킝2 ]XA S3 4?k&9i^KTï='s&uk^_2v\?oJC5@V;s!|؍:KZٞzu8y+k {އF 7gk} ᭆ_-uS\X6Rn#ڻ _{ԽM3p Z֜xa#{mSu*ߟ[ϔtks,u%SJpLi5Ӭ<>^m^ n᯽{G~fu;>eƤ8\_[v/A5|x)_;\_) Q|})ϪG3 P6(ijby=,V=9J>h|m^1*T j7Q!a]!72f_΂w_{?o|_k`iWZ2Ygi'mTLwa#a1xn>EZ^ac!g=C{tWU7|*|U-'|;ևy06+{|y gR Zfؙ>ik܅ !3/ˌCT.sfsRh譔:v䳺W~twltdW>񜅖u?R᯽a,֭i,5~rɬ,WW_{S^ uჳah_lchB 4 mֵ2o;;rhyFx 8 U9SxardLxQ8UǷ്=xjc6kqSW0p@/XyIs f-|arлõ]̵qt'ze0k5wu G|ºCJ#}]L-x夛=6f-|-9/|DWkܡZkŮc(2GN&cr;ք \y)Vy1YZ̵p \绽g44 _%4k9~j]8n|;Fms˜x g_BSmrˡZrn!!\a z%b=ʮ;v16JZsGQ%C_!+1ڮ0䒅*zs. c72Ln'rI8_SBˇ\{ur LU~GD5-_KF}ov %Mk:vKܯ dPav9yPg*wxņXȋijLž,2SV2u}19Ս>w9 4Anpr9Ň+]p! 03YkSsGͳOo;(pwy2gXWSCמ&Pj Mxk L1Sp{7W7ܚHL8gk>W #&>6cBeb0ѕ_JЊV@bݻ*\Z&y V1k.Y yUޫ-M 7k19u(i_SXyZ^g0Ux\$[Z>{c WΏ}&:{CCyfx/lkqe|F [=}/c1yfȝ<2k 8~cϏ"`Fˑ_{^Ozȯq~D#R]z 2JVM[0k|zud |ɘ9櫌eZ %ʕ{\k13ĵ.-H߆[=x&Ԃ97egv1 іHZg%N7aswaaԒ/\ݵ~l1 %vyޑ3Ӓ}m.[V-z&/}8xNx46qKL(fٜ3nthS2ṡ+\2wpLt.,kZ̗o] ^; tj< HV{wȣs}}|Ly9 aW4B0Еtjm4RS v]|CA|àNG?k'{~|w-sxʨО1h_k"00FB_L}[sF9)`PMX !\ɾ(;$a^)$_<:ڙ*)9~~R6&7}ыfܡeO76)Zp~Q{ )yg~ ޣ?Zy#ccXZ]@*}k# -Or>}מٷY #;Aٙ@@عolW r`{0 ]QO( ě4 \l'!y63lO_6Z~z0j.YԒ:ft*52 w_|{s?H+6n<ny;S|wc8GZ4,'0poښAR6O8ߵE 0 dˇlQ4M`9ī˻VmMv|ѕgH2]^~dƫ{ k#!OX]|L7gkgGCtC=STcF7T˙Wtμ07o m۹̛i~L<;K42B:"nyaldXXb(lhXwxxtk ƪK=`c8󢞓(M0i}կ}ROa]Ύty/7K^]ۏ%]5/=̃<;?_^8e{b1fs? bW ;<-28cْ~y4 澌h휡;f߉/L=rwL,V8[e,-kx~? F|IeAvmyvrt@9i>I[Ƙ A_]xwr|G-YīyBnMk;rhkG{ȳu-ٗtt9퉞RZWC`fD\`VW^狮S<^X]'m~~ZO՜$A_gLbW#CsɊ^?Z~004AmgJi/|-K_ 7xbhiCnwZ5q V=x9JX1UZ/pH;c S4_kNx2E s>zI\y+ ?pLVۙX3dA+sC B:.ssȌhk \^5֚k(ޥsgvgR5\3'M'VW =SM];zpG{0k9;zzT-9txfKOrV_[Qǧ c '#tVX_a-!ao, o8lFhWOaN.1_OXzm'7>霏av~b:J}7&Eyrnjg8 Nj{~2;?/~|WA`RsV.wL׊U?9f^w$ϰ;K7E5(2۵8g_؈/Wk+oO85Cു7q׾[+u't=JoysS˘aD~mDOൃΞ|'s $_!RaԕG6(VZӛ̢ќcQ(voΖ\1?X1?j`rj x h}a/_?aWs5Rʛ(N/l kX_fOKvs8-F<%}Z̳hwFwe&#y #7"q܃=1ñZZ3i08/F(bO<籪Vh);̗UƋꯂZC#[cqAOoo}&`')?dx \}:==᜚@gH>͋L+. p_3ܟ{ڍG/p5Z?w_Ǫ~³VD=p>f(kۗ1 *9 ]&|_&ùx|MmC9šk&4zCp1s/<ҝE !|}mR Ho6t؉Vŧ|:$g5I~킣\VprV|ZcZCkP9=O>-9BWCc_l8W #ֺ3#)gvi~_md:{ߋ\w-|.*+WiwFd';ƆצYrWhszmoSM:m#H+53pW^k[_Ww^s_;8qNtX}SC_dDsjy _K_0鿇0f7Ϋ>zmLp?:~&mV9(z+yQǫ(wk>a{Qn! C4/J[gJ!^ n3=ɾ&o=kojY)8׋|A$?jo'g̠fw BI#OG'/:U r1P_| {Sksу]H]hvɾmW iL?dU:4t({꯾\=>ϋ3gsq bh0bYirf|Q0 ^=ׁ֤Zy+$O 68ogO rC;>ǔyUE'~zb2Co5g2]3TfLT8%3@#Nrs0:.51{ױbr-/rf'2L , -@0DJDef&\㦭׶w/d"_KG,;:Yi_|0p 3JC~p;3l{}#AClU;f~͗o*.b;zRstEF+3¼ǫ%~& h:]Hs|}|_7:w-Ԫ|rv Z@{O~yc. E}SLV?+_{"8XYN{'x圅PF/h~-mќ֞~moc3eK=^KZ2䅙E_nMڣK[vm?<ۄyfnc5k]?7?Ӕ3E l2[bIaJ,aHГO8v~Sx_{nj쁧1_>"{hGvþ<3_QhOO^n kWeY/q8!gԐu:QžN2W]ٯ&=^{?Rlv X Ub;"vg.?yS>"wsm aJlk&@v+RO &Y6 B}]9e͙xT}̉|s>FMT赫w~|zm۝o<旡+ÿ?5dm|"`.'3[赼8w{ Z.&C|kZ5ShsZqD\2S&Ρ7ky(G8;pQܪxt_ <ޕEZ/> ^o vx}l\Eʀъߟsh˜U0|"6jOY3:>aЃMG߬!m yMwFYwexD4l[z$&Er$a z% ،DUHז?ڐcqGqCp}H&4M=ڼj[ݓQiaR61Mv.,},_ f: W_e:c !_d(|Qy 5R%ߜnjk"Co G'y~P;AFPLt 9}U{H]d~)A218y>en:~P2`Ay-|'We\Ks̍Vğ/ cZD~Tz~^ʘ~ۺ}U΍q}ᯍ4B}3_a!$Y|?%9bW f1k*ɢ L.FH78>| 隚zb-_Ht-g7?f9!٥EMߙve65ൣ8<η/x%P?=9h58kӯ>fuOk$~s}a >fn=P8ω} MY![ܓ_W]vk:>^}B^0h8pj44Bw٘0Vpȸŷo`K#fa /' "k_A gp ֩g]]r^;Czd6ggc1+%InxF]@%* ‰s0_!{ĸ'מ9Y4'gί.rt#r^7_`*|T~-;-}򭔽rOk;>^V~p4n;Zk _F搗!;x!g8ʀk񮝚{T)y9C-xkW2I2z'E>Ω%mvw Rѯ?a+Y~=-X[ :h#DH<~O0ۋQ=}^Mr^nsÜAQ\BrsZ'x }jz-oUڢo^k~kk3@>k/8kMQ:oEO&3wwLQ kCħp րCflŸ.hzk$$7m<ۮb§Oc4OlDai*rt[4"_;ӊ8 <{uXn=믁 #1#޷ζɡL'\#蚩"C#ړ$4r:}N^Jg{g ^LNWCxCײwo`y2%ӹ[&P9OעۼB_d…q6ytȼq ڱ󆮤L9/N} n׫ѵF˟f`&Qc>z)?%9(J  \ \k*?|_p_[Aos7_V'8r;xʴk`8ڕ9[$՘u⏳sˁ薐"ؘANu6@ I^ڜg׌\sѽaJ")žΠ=e}3R==!b=-`[& oe Kk5OzO#kOT}8説 ATf>E_yǃct2 k?1}ȘU=|-EM _[,gVʙprk O z"pL79ّk%lDܙukG + @J_9Vu^m/"@cyf?9+Ȑ qZ&Mk͢pK74y(׭55C/40D_[|QYZzgL|_;Iڔ>!aY ^c-EZx_ &}ryqt sܗke(MF7yS#~~Zൻy1YOd-g%ۢ߾mkɛxrCNt>S[ΞӸ*q04 ^;d od&~U#gmCR&Y 8nMYZ1wλGo5/{cxm'c5 񐝻{?a»0AI1UX R$WI?/]/՛rW}-1Wt0VH5mKe`V[?s!^P Gd;}G(\8'ל+8S9}yWߨզE:Lq*ȭ1WkOw*ʩKw+8߈"dqVyƷ=2~kwpVY Z̭&Xm9+p2}m;/_E&Bj ꜂5$pwZ'c4{9kQŜOz` / o9?&w¬FAz:gg@+bMۤ 7AVf&t('f/!hX^]7ݟLcoEW)awÝMzD൫~b6s7)C]ӆ =HmOpOm3DŽH>Uҧ6f"W7p~_L? |@;ZvD9X)fjC>+ڗF7f+Ob7ZXNmЍ [3k/k<_KJfkק){㋳3aahIzf:%@( (mŲ?=5ޏ3Wn qq4~8oM擗w 1]x-8>?VgtKPsZ$/9zl _[0CKZfT~^aŲ~X{LO5v~^ǥy%/l^ckwzVMxN şpŌCkyjN[c_CsiYQ'"=Zf 22fRW cKV~:e+ ~U&y3JCK]q8;A^X+4&u z>k@[x"ϰ2 - 9UCEʷE+3bq]\پV69›גAeכIW$ q{_;BשJkWsjզY ^rO]Zi-xݲZ e(czAFLsw=3a͆RvW"`{/`uhn`UM'ʈo ɿ^yG3mNv&CI*)< //9 jGs}=מ_F-_ x ~k*OFcK9x[ wc[k&?C4o Km:' Lla(R/J C6q{m¿>Z <y,z~q<]*4W9^=3YC1-ƿhί=qe WkvʽC ;nA9m?AsI2\Tk<ÓהҪV?jQC9U@uU|!Ur<=!XguPGϼ?-KOgB;"ڣ*ZkҙaQϑ8B<'T>3Eҍ+\&-{ZyWx|`Qޜ9|xɫ׺W僧Bh]]օ}c4I2=s ϱ\Ayʚk a)^}2 T饵h/=8CyqvnI ݒEX~v;%bCZ ] wү%zTIǫ|iLkJ/@ٹQ]lv>|M-8"p;Wyrkl:[5v鸆1=si}'=Ik`~TzzB9@+Oa}ګў(}RWCl*e],YE/z'Ϲ*ץK܇gg0+႓pc&sxm: 0kR=ɟjwٷK13"B7yk+58x\]1%g]W_ Xbn ~m]oSX)jg{2v.H0RS _̎e^ C} SG^[euLw^^;k6#&T<{4 R%ƙQ3a;:~ .4yd[b,ڿ•6Ь L˺ԣ~N/\Zx(@GaZׂ$!Ɉk5wd0Cſ>1Wǔ9q(w}-g5'|_eRxkf򍌸#xmk{mdB_+:OtWZiKxjIS6R w/Sxm&j[ʹB_/iO ļ&'i0 B+jlsZ!jl/%σye+~^+諝~&9zbE3f -ӸIaGjt|OWrDZcfEFU40Aj(FC mx0k{&sX;Y6{-,dW%gUTVxvևi: ݽ\oYӏ99E4Z[o2 d{Y2ٙX0J/%ϣa$¿@d9`VyZфQ̌?99}ierr;>W+SSXo}(dS;#^6gRПSء*(Jp];ѫS|Gk}>7,Mp'FICfWCS'v2ced?Qbض6_{~*uH`ȂѸ]Jגt۾gƯ =s:8"\EH4]3F~<9;{Y'ڍ %k/%wLb0s^j"/kF}gxZz.9}GtCڹ@ @J_l>{g(\b-\!ү+1`*,s \}_GޯXk,~D5ci;|Nrj :!b5a :/ mX!Åxjl?ZAkF{ }ӗ׆u}at2 oKEu \6۬;Y\kw\} +,~5pa{Ja6QsV ȑmˬbD6&:<2-;;Ŝ|05JMd|}s4^"M@P7 %M~hQWr5֑*V[Xs, IuQ+V|5!=78>򇲳Kb _6I<1hWv%^[;H \&4[a cܜV/Koj~]\gZ=2{jlfT#+Z5r>1J\=~)&k[_t9A-ɯukc>b~$ mXL:&>^cdqB=y _Y zlQgk s{ -?8Åuϱš8C 5>p;29f5wsyd |-p'i,%y{"{؏^W5Ӕ עEF[I[~Gw=qү=o|+ɟܵ9,c]ą¦$|}-\ąoT.y~cboViH }^|kq\ %e,x kKk(aGQWCsXK܏![%@/aC6ͯʽ$raz!0myF* jQIC¢~(5;K${ޖmk3*/DZG{\E}''n2bAc|9UPK[8_k'y}</M -r_3_UxQ/`1_ {Wc. |QRqb #, yX9?&]f Vks} JЯ5G1oNp9Δ%gnhZx~4#^gmT 9P|qV_+=+F[WXqkX 1@K )Xg:579kո{tgsډ;xa+,G-1!kq^rk fx;cZ617$iɧPGF3O:N0#Z>4GjgYtnvOǣ{|ۙ^|LG٪<~| Ԛ4|或ҨqҸ}e_c`{iĆhQp&iq>o )2ͦbjN⫥>C5络'9n'zط}ECy 11KwGǒI*dP .jg,?4 S>&|UG͹CyȟC^`  }+ѸyG+&Rc"ȿcW|*h6 \24;ߣC4hszG')_[BȅH%Z {73acU5=U=N{*cJkY6ed=%Jx%V<5ss]3묙_q.7QpKo^k 2zGîSlY,I,砷y{d\k^7 6'R_Kmڍ*|Gsx 'mZξE%1žxF)8Gy>gaD5?CB:R8+jxοY'ZkOXoujd!k y]byX.3-6JXbL_Ud=&fm,%=_guqaf.uC-9G]g +p-'f݊ &dXcÌm9cW>;9py)Cosh9™۹?jΪ9=wwbS>q3bi0ՉnU_ʴ^v!_zjHx-޿-ht7C{-CV{G=%(Xrop`xmkRr irWe5g$]^3YuN6B7r|/P*8. ݨFEp^zd'd6S'*.p} >Sgv({:Rw3d侳_|2Dǿ{W$|uڵmus~(;\aޅg'ŞJfE@ԚPY{ZO8_ŹG197Eؤũ}\ :Y猁A⹞wtFep;w # xFee$kf)ꚙNkb<_baY,%슝&xzrz`=iٜy{懢Zx1_/w͹.=2+^sK=6~n3k& #{$m,ۃ޻exBZxC4ֺφbNk'8;\A^=#4_jNX!/q&x~_ݷ3-hc9iZtNYnRѭՂ|N{wޑrxaa8Ӡ&i|y!O'[?^[ԇ,MrC^+,k~[=H(Pk;V?ه4h^y9X:M# uZS+zgmbV ?ӷO:eWHٗ2rsg-G"_+ W8;`4m&<Jͭjճև=5Ĭ;R}Ԣ!q-J5=SW=u~Jyc+Kk;j-3cS~:KZ.׍!r1])j0IIĿq +ghsZv)7 xWkU.Wjwn/ ?Gxr$az% _l?pDD%UXuyɏ{\P~$u0=cwCR6M 8Umxy] q-+wO>c~-U&OY4qX%@_=X%e&r?..Vȏ,M5UJZlp} =ᾶWu]}`zR9-xgw֨sG_`_xO?jrj߆RkSIXz)Vٞɞ᱔闩{U iVpN|F]9khF@^sȯEY_˚)XȧXЍBoz*{-ɸy`۵K/\AG-["{70-f Ώη7wiW/ g 8[}0G?C΂Nѿvhe0 -c#QА;2 >~-ûZЯύ7wnĵN47կo`8 rt]5[rvcj~D#N#5.Z /g|d֤Nⲻ'UpF/+`KKItۋkx։Kc (hՍCspL /VQcW,L8npr՞Xf-~ߗ2,t4m:3eX7VK<޶1[\ sv&I 3zT%/yDzua襭C 9}=몛{"ZW/}Lj=N K~2MeEgeYi#B}OoC n5=bk[.m946=dA =^#2~-o4y4Krӄz Z%坴(֦ 籆o>djbi>GZe6br̸ju+ՂV]w8_X9'X}ga|وw\_1*W{* 4>B3aʀM3+dES8 CkҼW_+_2eΏS; /v3џj=Okk~=ZUXT4da)Ԏix ں^~ V}K,,|ћ[Mt^?8{w]rճ^nkubqIknh7*~º}n~ `=c:Lܯ-xFκ)CO9+Gۙx+ !gjϕրeWoG7&VhDou5M3_Tk}:wv.9 KOZUf:j;VwYPLbl\M-؅Zi\;#WO-q74-)ع w|C启o5U_19:$q|duhZXBPWCnkqoB>u=u~wב<* ٶ]>1Uu3}' US62#'-j1_Kr-GqK+c펜`YطsfaطJ<(&|Vi!S yy 췢vkqT9 7pZ~N+}M$\sAUEoB_*c%\6U NsMEV-u[ ys==u9.r_kUӺ4V0s9O6'>[-3Q<.~QW~42όLOd#^#Z| hM7*yiɗ6W(:̱vMhѯj=#W[u퇺tJ̚ a¹r`Vrliw"^9~<DŽVN3򛌑*y<9.Y/xtcZ%6f])W3 g/}qv.8 0 /j/H: D0ıGiҿH/ׅ5ZEZE75Sw6ιc SxSO|..*c1[.؊N {t΃_n_& ovM;yGxF^&7-/~.lmϽeC/:s\ϙ?U|$ 0'v?`Ӵ1֦+s4.hſG$9)q 6Tu1<g ږϡ7z2o0x6јqw;KE00J@ۤ6 iO!XS~:i<ȋ<s|_k8ϧ3F=ӿvC? Ev taCwGk>^gѱLv^tMޗz<@[`qMtCudxׂ(V{jŢ^˚vU&V>>jkK1KMt' ]yW=x=Kp(/y:X1կ룃EܟVweVn}L1س3gǒo瘰A  ?zp 2h0X$soӯOlO'_[Fy{Tvݵ>,j/k;Zl̹9>#s Զ=6W qƯMk1b Y:><:^\C"ǟo_eRrh)FԿ3ݯ<' =r_;h2zi'pn_8 66o4b+LI7r5snH,XSoPk; ~b4b ig1/s&L'YS]D8`,Za2t4,NMmm+q,Vyv X|-KXe9IU-U~ԅ9_kh_qGv~ϢkcYzDz3s/&Wצ(Xy {laهv5@&6hS^{7 \N 2=ڷ/cv+NMngP!ﵸh]:ͿEz0wQqUok?+/Vpwk7>/Ķb+bX~ " '>dE];re%@vr<++D'_VWqp}0,oKFsj~bI_[ϖ;2AKaVVPNF]|G>ŒMʶ~՚yG9dw k-_~&[ek"gkx)9 bV)Y%ZK+ ts/tQ\E)rr99^p'5=pxg~ ?dC_ޒzH~zvK[hB?5~+'bdE=nϭ!uׅA/#`M5N,Jrڽy'.VgΏ~ṻ|!VbS}#X{qG1ǹd#BuW(qUnΕޝK.^}%=ףxuA6X5ٙ7Qs-Ivr}+ans}8;a^ITTX<=h"?c K/SY~puՕk>cveېџ(ͼ20ЯZ٫VuViU~X)JKlUGWCr͹;q|Qj̓|/Ɇ= k͓a Ӱ׎z^5|w8SsYmCj`Iv-օs 66jGkVd{a3 z"w ϴb_8POx''5BAk+90<{G`sin[k|R_ثɿ-_V5gYb=sa#.;k9y6J^Ex{̹KX)ǻn_VvoLuoWzպ赕y9fx)kknK{>X))@DzO.d%kv:Xs䋱xu+6j}4~3%'i1+V \93QlyXq\ N+ڀG=YY,3'|awoOaAKF1~|R~>&i,庉 `arגeJ:bsqCfQuDsK9?_~ϡJns`KɉߐqUx͕&k}kLvKyYkT~ v[F~Ҧ[X@S/}ueQi/A_" cuZqę?pc)m^;c}z^z߫{i=ʒ.wCQ v kZ6=}ȝs:xYp*=i$1GIO_"u؅#yVݩ}Ly`9A͔_W̐{3ڔYԃwz5kޗ:w G8s_WiAK&ߣ% kz|8;B^Ұh#WT2#0=x8"ẉX.7Q96m4ˬ2Uͯ&iUg*VK#}mr/DK2 [~0w|2U/zz %eJ#V<.ziT `%f}Gx 3oܪU kc_E?X$8xO8xi/ěAXf3yic;{^R9M1Xm%|H=Q+xbc~_q zL=8H^,9{!Zm&a^V"Jl AJ;钘4t@(E)VDvVX/eG/s-XwYgiるo,u\}&w{*.1[|.qE#VM0'ASG.4o' 򯅆Ѭ 'MZu"7*Ts^qN@?[#=)XkZTxzzfz6+hV(s,ƿɿW]y~AtcL+M/̵<${9^KU^ %aW_}ui1`JPŨD.4_աǭ4tQuo2xT3:7e{-ΫY4_ŵsT\g[췦SaMG9ImWښqv9rĜ'EJ oAwC/sus֪w4 C / uۯ\WV%ֺc>OԷ'.Y,}'0# ^2<ٸsbg[gx7Msk1y-/>~qv9 0KimMf,!Dcz`mcgr1`uS^Y/9Gv>מ.)Olac4-7sug3j֯Eʏw[:J:ua5yPL44>징jLEu{"{8u'cżǤ=Kkx{ ,;LuX.VItP74fk }Ǽ ߗ\#ٯIW_K]TnwV]g\nkWXo{XxY84[c|-jZ ^Q CT pm3]_QfCvb+ދZ}zl^ca&\{8~3='g;\kͷ2ce%,Kqy|xjU8QrrZV122=-94X#&>RV_^keP菆sGK5eRgEaudג#O}ͮZι#2ϧ_^&J=_ALZyë&ӺyjLЉ'w|ǡ~ikn.?CȊ.^2dŒqeB'/,zm^b(#(3sX>w:E=fWX0:Z޷ zsX~]zNu탯UېEC W[|',Q>| YmkkEmk[M 2f>j]Qm5Tu|mwאy2ֆlehvR譱/=2/ ITY pm`9G?0FM`NB+Yr`}X4m{<);B(ni*rh}rhɷvs9ߌ}.Ώq&_ l w#ЭDO`^yw%c?ܛZd։> 7ݪC~?3ȱ ';탞Th`'mŐ3Ĭ_#瘇?nW;m}6֎ƫZy>Ben";߹hx:,ø ?H 0J%ir>2b^B+Lc':k/՜#-_C 9׍Nᒞ-]k{!CBwBj~[ѧ_C5N4X~ɾ6f0wg䝋w tV]$i3仏):NȯP-*kU s\rJsZ>FtdSANq/#&zƜS`o֎Sla=E5\'X!{|ܵ{YXWu͹Nn/gg +&Ʉ_~YMĎ~vO9[5[XyuRnCr\_;b1skma_;httv{hpBC {3~Ңt_KoձY9cS3Bc^pCZ# xX(OeCއlz-YmCot>2^՝s7ծ^6=lkѤ>=Ӥ_#:ovs=dɮhw֘_ԏa)?'?cm:-,AO]9[w8w!Xd4VMy1 0t%ReŒ8Y&mJ ai!~՝磟Êb8#׮EZ) Rٯd|'F=&s-9tOG:D7-_| &:pMt9C8E=:=ZH3Cq!90+5Uuցc0_7r(MjߔN͢3;5@z6Jڶ/7`s/k`~k}]<+~ f)O6kʉ=Wnag n=`}8;a~i?I6Ai~:X'M_kZK[=gjX?1N'~koO\ .Ǫ{]'?ug=\*}8'g  ںί*Y]|h׾soB_`ɋr~jky ~i3 A7e ־>=X?]|mu$X!_޷g+y^Z zd{Z.^!AG=E:.1Wbn=/tF螥ʙ߳˿{'ig /!31: b \Xu^b><{k9kaEKVos_Z~W){k35*^W) wO^Y9z̫_9$0݇UX bZ(ЙYǿSa1r,w U1MWcRg*L3ĪV`u;1/'/2v,s'|{xkkHizb4zE_Sq5v<.}_-FJm;k#x(證OcY`%ǭW`Qu:{/\/#|"z̆^vke~ɈO!c^md/f-WB7P$[y` ˹|8;A^,_zMP{qlkA,9ӚֻGV/׷p[(kfX\F־^3;xjdž 9V:Ӭ`0Y*4edb>IڐMnf[FW9*`8a@{*eUcIUg#ܨs_s/XrṎ=v_}UItg/gȞ9/Ӌ,OkO#]׎yLe|aZAnNז'951މ~-3c|rvF90  ~ȻZ!m/*aZЧYabF|_spy wZd@{Z=/)|3pKGQkߟpW=pWmay dT>'] uf:u'.{*uB[֋^0 kwu1OG63tAڢW }89?ХM_=R.A^]A R l; vrԂ(RI;G91mZ)ku`QO>#k_K+dރyϧa{uޘIXyy÷cqs+J;Z#ɝ(Xaz505ƭla7Fttwbt p@weT zi[/;r.5xQ/< B .n#^Evr_=Y+ZZE y ׮] ~j~EZAj$/aWӪ>7$MHjc@6}<}YM^V\!r#kS. kq^kɟ8ܘ6Czt߱ hc^Fٶ߽E׻nS.XH\QIUԵ4kʸyi!ى_;-X;Gs=fϡ؀M IxLjZ-,V'On7TÊXS̩aj{szXꈐy O띓^kGڹ0@t%~kQt ߖ-_E~NY^I{ΖP:=555 X/^8#kXЋ4pw;k _v_So^e=7s:.;:pk}NDK7B9<hWעyChD}_yCf>`{ON`(skmo_?!a1ig +!XR^i@DEfXiC\9ўZrej%#~:fyע%}Zm޿8;A p_UVI[/Adx{{,^Ʊ6m3͖;𵚦j8"gkw+^ `!'RV->MSϣ'_âܭ0V,_,zɄOc`g8ݥS̹+|Ut _{]y˝uDuA!7t>4 #kK (47zcPky?d.,t}.N[i-}]olXº\s^2sOU pWGUW%оZ 6iP_{%5:1;Uhÿwx߅Eu`|Vc j ˟H"5hZ֣X͋%^~q~r9vqԣpѝ7VX׹ {xeuͮX=仱 Pzw\ka aSspܘ? b#|HYρa=[)4qIc6_ TwN?y5VYucrw'^_'~Ha%6h&>`5'⾴/_-}<}MZz"Wˈ{j$_cf zUkb=A~uTc?=VF~:Z*fx?8Sþ.Z²|{]Zh~LN^/W[b]kFSZ+a݆^2^h MF/f%,xFN׍;&kHC˥fk'3a'X {C)x7^B3t7{q%^Y De7(Pn/0, i)_\(b*=RRZlqŸKޛ-זyoc[V^Xb-j:zQ`#UB^<>G׊E柖Z\Zpk-|m>Z*fMjz ^/Gm|QkY.Viero-niODc,cjQ9})S3iOx ki~:!>w pA(z%B ؒ>65~*V|kT껡Uo1 dSzty\?bF]AO{x gljz1vrҨ*U(?mO >wG~O`mvbƾx|Eu'ky yZ 5PJ|kg.nzCv8FͰ Fkג'7b~+LB@3iᯅËD_K& .4a>_ r0 DdtCۀ3e h#i߮Cg2< MYJ_+,l74RIJ=:< 駑 >}UQR'ock 9F$aGΠ~65`|Wjtmx1xCV,iu7ڮOӲ/.AN6E_;t `Ylǹgy켇D+y~O!rҕ[BgXےZZ+b 9a1׾p{Ntp%2}22ؑ)}퇙yD_;oy,O(mH_[( HxݛK~hw ~8;a$gŮ6Fl4r $⮛v+8=Ⱦs++1q={}'v0Ӳq̖xa:wuGJ/ pVXCn!縴6]q# ٯ3I9G8&zZꁅBOs#ϫM5S=,sO}kٯUVUXي3x~_XLz 6iw$JVn[Xc;O<ּ.|\.'^Xu:.{\GGvBϪ?sbf'rm?bI'*=ԯUivˠM ; @J&/$~}`ۖxa©s_5j4.#a.$ =֌_hek;t~9֖cGëO3w[bɥh }d _FNzcl 25w̏![zqtb 6Ny++\̸6Ff?sӊwx,ck,.l^ԸćLV/=^ki\Ѹ<S%Ԕ-׹5g>a;D-[c=g|m9 NU^A_z~2>ópH{7m+}Cz_ 0 WRgZyZ]J;2v9X%Nbuk2w 4Mr*ьggR:uw_jA> '5TsJ(Gi=,}]j1< K;+UmobaI_;e:ϫ3į}$a?C|-5,&-ߥ6(W Jޣ8;;d[X[K}N^ٸ.ı?9*ڔ|x!*JWԷϕ瀯;Vڍsn)[5S9_׋sKb" o:R7pCy:L󿂬6LgVT9۞V&Z0k0+cyDn6q_{b5C>{cf4G"oZI"1zL2F}BVX4[&tcпjK/|?'YЊE>Ct<}կ:+q]W.ʧogкעllԈ$e6kˬ5&; @J({QM ,lyZ>,&(&†7_8&!eF=cp>yH'&=Ux1vͽ =cQVuj|>>vW{V˿ p~] [ULgkݴ8[ [crn$cjz5뽚} lR6Vgy^i`LCBGܲvGiˮU|D|^۴/CbkW[fv9:~J~>@ί{W۩}ME)Ιh7m[ψN`e_tNM9'Wk=?zgNGNEf.<q/=dqLڶl~eKuN/?6r߽lye&0ek\mA^u{v.80  _lG+vO ؎[X p\xѵV;|fjU|߱^+biRju_;?^qG?{o63i..0:|FKʯγ|:=]3YY@?Y:k[IWuV@jr<ߪ|`~fh_KU?4k\Gy2\{XupwxV1оa=hŻ:瓎>ͺgM1Lϟ~Zp_C:,|hN9F5n|:iGgn%a!}tf ? zՊƊG$BNv57ֱW kݵw}z,G !PJϪX͖M%F@A~R,k19R^`1!K?+B?=@f)+@?r)V]hu0cqn30737b>17Ǒ}}WF㬲Os5`sZgihF\yƹ=g 8ްDXޣ| =f54ŀORyRZ[V":Ciu =zڗ=tR,aVC5٬Gg-{`?ZuzC9=~I;#aiOОB0ò<' ߷^VVY51V|bi:~*?kyأϔhHKC\qj4ZungT2q᩷5XXGL7 !^NuR>2_Z/4!ˏB:Uw9׮VM2y_5c01pVp?Y74V}!WNMsC_-kyL1?~[y2C#^MLF_K9G[qM0 0Kk($&m˹S XiB) ~CJaE{^>_uoyykk7| }M>ו{X~`<䡼 @L Zsfi $4f6wƒyk9c̋1JX]pWRL0_ޛ/Ko;q:GyUϑ:MK׮\ȫ!_XĄ{=&6erkZ k;a^bPwNTSc o~$S<{ݖ-~0i%,Ѫ_ё9[ k0 F| nAc;ig!3-_lYܙT/Z4g{| gR6׊KyN9%U7,ӲXcD-+XLbQלP~ݹ.{5`hZ!ʣy.^;'Nʈ5Rg[#-N;zȍ|ON9BVZm̝ Vִ*2,鈔XcÂ{ k;S.TI?"+rV#T79 ,xix\F0o,|?{kǸHv eĜ&>  c*~헴sAa5ݚ_ D!~عUCLk"Cֽj7oZKGпX13,u$x! : _k5} +8CG57gE#ow--*3ƗrEo>Lujkn{u4w8s Rl1`4/' _k,aSKoŠ:ǤޣSX:i4e]3J<2c]vK`Io7 <&&ΐZz}-Co'Ud!_˽ }1qm2 ~NGjGRYE/O82,]Y[4uQwwء{yu⍏EŒE?k3Sc, s8Wb5SV76{hl#ڋǺr DMA}u{l1rq}/++̪W V=,)WWVk|sv%H KUlYI:2H/VڤQGZ~:c5Z{_+;x2%g)>y4'I}k KKXρ΃teK}Z,k/>p^ 8"5,~EphlYV;4=ã$?!C/ºG9v ,s59/a9M\~?ag k4[lD{v=Vr-ェKu}ѿNM⮈,O,+aa_ >9wSX0+ㇴsAb _3ZM[H/tLL#˥Y7n,m/+rh7׆C.ݨA "ą< W',xP5W9޷"$7X#Iڹ0 @Jļ_MgQH^`d( ]O,d*'V?4K=ڛ1S];,R{OT(<+k>uOsXgՆlej&(&ʩqݎEqm\sޓ,;,9Zy[U HOx Y,oY8ku\YÙM!Q_)6ӱb,תזNfWv4bu4co6n^Y'᫙O!V[v. 0R1x!XIG`׬gПثg39=Qd9zPZOFFKvpEvk}nݢ'#W/<"'qfTZE<Uw"F_'k:&*6fX*]8_sN?`qE$Wc? ?ŊqOR“1fxyXי<@~6gc\Ϭ ?ClzceO$|ZXp}g߁^mu,73X=>jDf;~;6뛴saJa*AHt'C1;ʪB`' 116F^!jlp1kc@5io{44Ir/kkG_&45԰7a0OӇ,Fޭf+C-|zi9&굒_lq\Ģ~NQ1N%~AO}MЌ5=G٨IOu+5|E/Bwt/x͂'ΙR}=eΗU< לX@U{jxY{~u+ٹA@%h݌[NKl *$3+>ΗE_%j+5k{j lrfՠ^ lb?:4^V/7 ?d(qO8f/E3F6rlWrM q xײ9<[Gw憆%tXʿUXG|GYI\A>K1|&Zi~.6Ekə_V gcO_I/Mh|_K=UuN1VXvAt#ZX/ =ڤ>Rojz[xg)^R;R/hSkINCڹ&1@JAXC>-I/dMW]z+x!Nc `g&a9c Ҿո7ָc=^<}mb/j}qt澩=cuk:Zrzs_Ăߛ/FZ%}f_{yn䋸8O+AU 1{D7WTzk).vRV:{!Zq{! 5Â`fQYjXV |6Io;ig1/ nR6m`ӀX!lNк_k{l XxKYVgo5~w٤5Ϣ|ҳv8zfٝs"}MWVVg\*\,Ӎz oMuns> Nb1/[ߘ∙e]p1%Uג[u=E|o,!uԈkWV{jgVv\{ Z;eZM<.V?0KV֕Ų#fPvV0*P7nI dfCl]s~軟iQ~,X1o,sB9~ &k{oh{W#u4~ȵs֡sǡ ;_[5Y5=ƿVE}G-Ҍpү9- s mNGε ,ԯybX;^"1t-_,V 5L3bmCګ}κeqqb`dw~06VkFͷ*䵺L˚fx~.i/u8NXΣid3 ՠIgZ;Δ|>N,uMy巇/80ojv-ٹ 1@JjIhv؏ `"]?a6kN18?Λq9ּ]7b3.eq 3-j1{R,pWvD?j>p._:rԧׂe4V9܈hsZ"7)'OvHHI'+qH #7YoQ}5i^Z>V9%fޑ^@*Zڇׂe};~m<5Y,C.u٣R먉Y_kOW-o/顋tDNGљBV0=W|c)bxgg0 +ʼn LRǪ0`$ě--[;{ j }@_.WYG7J dvpOz -+vn0'}apa䎄}@+BCW1LM>վι04Io _ď~iι:}R-ב5G7q6ñnśg[}ĭ/>?Ntn]Ȍwa㵱'b\4/xCIe!!f>lvFVƾ,tD݋o\yl7$@-07ʖX&ubCҗmQOa`A|)?|^%aWjUD.gcjBU^4 ܚֺc Ad GZC2bSF&;vѿ~ܺb_-6<;L2XaξWG 4*U/oc=S_ u^גռ8HOx9;9{}je׊WTϵe CM\Z Gkӏ_qLG3ȝd^kmO쮫2+VX#rW Bͯ]i&'词̅׾9;a 'JJV;5{=U%,kG׸o +b赽ķ^'O9k#|XJe| KNZSJ!z?R\v㸙# <1(*y^9n}m%_K5a)Qs<:aYu=x:$| ?>:s{| )+xrLV3,w_,W*?^ tK[T(';Y;9L&F\V;o+t~!tֺW1vά4j܆Zf%׋z_A W$`g+e!&*frX7N%]ژpf K|),c8rfҒD֙]J1_Z'2<}`O,ݷZ'rXE.ʔzNLL=w5ֹck.m"I'n\2Sfc KZݶyX+aѮXC }'զ;Z묿w8y׆4W}_Ugrѥ+Kԙ".m Vp6Nkޜ]Q pIkɂqkkyb][,uzQglyXWK_j*_9Ӆ8#qGpRCvC]ŝY:g,˵i}yFU`k!Sp+q̖i_"[ *!mŪ_y"s\^kj̺CbcФ9!.k2ֵ濘A*\jnoHP,x5xLu=gZ'iX7/'嚡y;LuO>l͜/zөw߮:4bzIOPܟky%|bwb;1q }G{jpurYpvFI 0(rCy \`L}Z#*ķr.j'}>cq|Xg|FkkiӱR^ax^XZ\_ksoCdĜA]N)C5eo.'2{o*ڣ1]XCZ=.QY!-'èFOVcdu,恵3:V*}iX̉¿6kbM|9ð',9~;s;3~6[=6Tw,հe~b EWһXTTs-cen=V֋3a `K^`o,?yH8! qxg<`eM+;eXSGd 8Ck'ߣbrt.6r2}}acQ?d+l9,:㩚7>R c,VhE*mU]SQ~`\65be\ⰮCVuxB_*&C7Y͉B:EcDUϺVIc[^oYb,'Jm ]uM9s,1ewLk^ EC֬٣A/JS"e}̱yYz\= aUCż*xcDÿ s,uյnڸCKt\ui鿘֟:˲۵2*WYkpv=g][vB|C?Y㒛#,[5Ҡn= }9)jCY6gk GXیWÚW֤,E\YVjBs5j? [Xř;xٽgi\ja}'fvYkH]:"u_+V/-Q~/ * ݨXǼ9[7~OU >~igBOT}NnXM=R.VY mm-|9k;.|vWc glI< ?X,<ԦawF>#>S]N3E}9-_7Ml eUFfkF:wrksC󮥿2k-+GcF @KqcwRɘ\o,pWVGoQ=kA}kS~$}O_XJmB~CX{}N~hE4Vx3x̯ fPΪ+kM }kd+ke%sL&xu/Ϝ=[ak/XC) Mlz7\`܇__D{+ʚ"}l4/!/Ώ~YcC^`eAa߳j߮"yIM/2 yܓ!N@CVV`KZݫ/k2jVE膆%Cr% B>{G/-?o5M#z+ڪL擺7(h 9s=x/Q_up`?X\QoJ~G ]9wG^W'tdyXmde8f~f֨ ~~v6 0ܥl XSRCHqSKg^7jD%}ᇜOjaWQc;WvP3a&2]X p׊M#K,4 &q&>eV! :dʱ˪k;.J;M3|3xڈP;+soz_^Œťaq-~|Dl&L8̞\?dx_3O9C}<_m^ȫqZ]˹S(C\,{aͤ7gg`1Bѕ*,%->L{׀ h>w(-և8̣.wЖڅnTno>s67Vr舌oYvgҏN?Jr 4/C5\Nku߻252}rBmgC)bYfaokl%W]uU@]ka+,Vյe4pǾuQcq =⿶0rY椷x(uDF}|8yMM_r,kajjUqv.6 0]XVyH=N%+{k{<1cuDRu0GD/yɜ}|^>LN#6m,o|Ӎ~NV~-5Lѷ~VpNy3X{?Xb_[\<βfŨk׎HwDYڇLcҼf=zkklL,k{KV|$N }^fͯmI!I?xkT~t7 ?dѻ%]y>sv<,rŪM{$h|d^$ۢk9u1pGkVQE_q}rvvI k/S)3 ` >rZV`Cz ̋fCе>iko Kr4.y-Vì孳cDM=!@2Ki!nwmc^? o~)xU«?\xW#Q3ҷ^Y _47Go5 v-m3a=§@m|4[ⱋOTj3K'{+G9bN˴!C#BRqv:;Ғxm[}a֘7 ]75JD&|'ig0B+QX?eJ'Esd"Yc=X~^~@k8֡w~4kM1qz]v]\q.s]}E} kuន3+z z65yOKt!^bqGbr=I3|m|-kEoK_cEŒ{sεFӚmڅnTXv=y3:28.T[b\ia|gE2s6SR7igv0^RAGpu I]ߤoÛx . X;^`9.JozuZ+q_q9Y떻_Np7 k7>W紿ikQ s<1Yi) v:2Scw7*W +ɣAG,z^YoB:=Ͳcbs6x#}Mԫk:z ,x Zk.|i5fzkϱŸpوq-L_˜ +JqNڹ J@y_Lcit 5V֘LGVuڈ5{힇g)s.=ϘD5Lu*>vjO~VX;o^.νŜ"+kWߣն},;xcV>V>N(s"zȢF+Zicef}>1?dMN"J5=5<5GP _.rŞ )[s<(Fdd{\,!3쿅ٹH @%K7{$ iɀA8 專AO}X6F y,fpN,YkO_n|__b۬y Ym',S­kۮv 4ykQM/Mg ޯ= /_+'\{E׻sZ9 !.k#{j}r(*w7r먆^mN=hՕs>KV[Y >cy+mtDnUz(<-jM]>מZGmD?  D5J_71e@) {x&Y:T#~膎]Hy_1jVmx$6i_ògckǕ4ިVδ9_[v)>1,tș"0PX:Ǖ7CqCGt __>pv𚳈fﵣLŃ\Ue*>`-ھP@W|O,!COa_;F.3S=ZXYSbJWVm2N8bQYb}\)+ ޱ&!ք#zhlB S9mٱC>돷nhQ'{Cs귾͜ Msgڗ/=A/G6 9X^Y174o t\ekȁ }<}x'Y:W"̒ A z%rOv$ B"[Yr׶Ƭϳ/c+<S} hVŹ+ kLMI kdcqOvуT*`Zb+ ziԡDlXS0ޭ:yt|빯R}ҽX }߂wI՝p,4I~^Y5og dz` u]9Q&#n^AsBW,s'17d9VIƕeX[YX.9hC G 0K 4:w~@lgͳ y,}Cv=k 8߇m,YWKiBO^x[EWz[ys. -Wt(k>],>'c;?cӒ˳#{$,[<'WD'vƬǬ}MM?מ#X^%鸑$/OrMpO|k3gRCy;F,eƢtVī6}v9YPtj\uэ S"WvW}'N'q%cKH!:+b Ⱦ?ڒKs1CWJнc}qv.80smfߨ]c$tǢ.cX}cZ =!̿5ˎ:I_[ P-X e.jur*Vw|ͭ6i6U߮[HNݶ_ۙog/RG,PV&KX9ENbfB/tòa1,|QfעY|ymW0yuebvS}kGzNX(aw /]'Z o deςo{L~j_fŬe_9>{ԅ3{3BC2½HB3УkGғs{-1cĒM\^xź4ż^jk|>nst}~ _Ma9#]=.ԬJ}m "1M,Y'Q\=G7wmf5z\..Xq Pد]3& 51ޤ  DEMvuhڅ/(fyl.VK%Kk~W0vV׶قoFX5pgj,9_[ޮ+>d#-.V>n@&ŵgי|-|kU5LVjFX ?=쳋{hd }νoVYK+O!=nIw֋Ї `>w (.4{Α;iϣ;. }7Cڹ 0Jb > XJ'5q-hi'1WNz}Mj#>x:q[qoЗ>1p:+~?7׌Μt}ixRZ4`u=(_y1k; i9qI{,eŅaUӧmC&_K{YXmXqkJ[cYC]1V5$Ok霅!_'#o:Uh߯ه)5={>xXc淯zV1B,>M&;o =:|Fo thKm,ImжY%׺it1,kU+}WG2,kcxF֑Md\ VQ<+9:cQ,_V?bAR<;kjj1|\uT10gA@S]aa[S,s:XFo{}ΰ0_9Cu<|ǥZBp}zР*GѦKcSZI3w^ ,=䋸ǵB9~Kڹ%+ 0tKI֝Pe/I%3_[9&6Os^V9bڷXX_;JW?rrky9,w&hMj \Q9rQ5 }̪|4=I }z`1o.^Z}'EvYwתF^XԵv4R^ qz'ذNk^5{s艶mdx^;aϽ_=x'^m?q5y!ߎfsm Yk^alHx-;Zv>ʖeg0+B?NR !?ׂUǜ ~XzօwsMl7p"qPiNrok~폜:,]  eUu]}|Ųu]XFrfW|צY1"g-٠F~V|Ś}M Ƽ+1==yM'~+jjtbƺ+CFOxkײ.1K9kָqDiּ^9Zm*Sв S͡n!3apNkߐk9M~xή a}ѕ̝9} v$} yfsF8VYy oJ |^=EyKaVg VF 9RբP,c/@_+,Er} ,AnQN{y0ЦL~_G'SSX9ݳ( 4ηgŲp/r> \s u9ҏ/k 8>ao9!,1i{NlxG kV}; _{|3;hJOl?v5= BE=12z?bޑ^- 6}ZeI'G ތkosh)sīZ=๋SceS^9FH&9+6|hheGCW^3G{Y:?SJ_?/硿G +5r2tGh4ڌزtKf87:_;:c3jӁy!CqXiR~q9텶YNkd9ɯיkիZ}4 zfknteS/k8;,A^ `77@_E&ƛtX/'VO F =a;BZ+\4`W7Q^Gqwfnpw7~Y~̯M;?P~giCksv{ߣY3xCcUQ ,,g]ġWƜ"-W\ۺ8R3bO2}Ov'/x +<G &\95P.ĢS9%!?df &jat=}Mjgɵ=Wk}+1ba+X%Sdy;;: qo P;>)g Gne4WDecO  c[%Vk9a>CO_bmH_N8LBLbK}ݓ_x֨u? i9ɿulȽZՕziޯ!sJb4ib%]Vj~,ZsZ< {C>Y?M9mpVXS}KIJ_J#JoW5nUZbzYhiC3~ܟO-G#eX3LS &:vOR:9>IASQmv x`(a(<&x,9!OX!lzYCV*{xRUjOn!,QDO/!^k{AdxGבOX~>eQ~יzcbA_k0JQ}^89xQ1pz"x9gPƟ-NC?YXBsTЕ{?ݑ WLR͞hjOhZ!,no|x *ڂ~iQ/ig0B+aU_lKVn iX{SfjwmQuhEQPV{wQӉe=oվ0;0)>>vkлVo6[9u_#= OU_+X3>Z]cqzΚN1Otmei6mT {^|/a\k<;j!ȥ1\&*=ĺVVW1B'UV֛pʲ߬Wf,;}X{t39wt0Rչ3֋3@RC۝\oI1xg}˦@]mcPcn-Mi0FGzu bcwRvX'?=I%OA:KF ;+lW#>je-p{\f%N=Vvk&&GVQQ-d%-ڟkeQFxcc߷E]ODYkbk6W5{afWͰ)Ȇ}Dhz,IU[>k]66oeqqi~[i襕=Z<=J:jdfjf "Z!n=JX/roE$,r ӰؿM5f߯RP|g/K3H&`AO>fKqӅKsj_ίIߗr |kp>,ٕ0°_lz Vrj8!_Z.|NX׮ԩq%K7>簨rVCn][I,1srшi-Pזi^|/-ZRyXN yjyp1Jq#q_u3ֶaK#sSk=x sOGژ_Qnc}Zt|m!qҰ!PZwd鲉E9tҰ`[ !-r9xy =WjDk؂nx/ϳYd0;oW7bǜ_-<4<9  d'.vtF7E}`cTYدb\QkzgWr1Z > ~D cӀ%,ǒvF_ǵ]G:.C.SMa-.Yj7NcQG6ְ:i z"~o~wwU'XYmm֕⼓QN+h`+Ֆ9_^ֽ_9.S_ ܉#Ӊ; |!ą5CC\|f;{#{ZkЎ|ƙA/SM9[?U?j QMAg8,Av"dhItkIGgkYC<b԰ρՀ>u|9Ӡ_-ְ5y*X16pM=)+pWs#w(Xc~ȃu=̷E֗uoQρ<͠`ٳF} vwdG=w1ܛӰϱǞEk;\ NjzELi̔[e(Yx|O(}+{9VV! M½|{I;A^I "bK~%8}aJ5{,KLk%NiŢO:k}G^ >Ī:y|YyIufHJ*85]|Z.yuWe,1%?:ZV|hE+revE"G?$/ى=&}Y"qv{O?oo%|۞{~r*2kϾ'_ ?K֭mi/}`g9+_>k5û®/s~DŽ[ YlKkVZ+%֨sΛig +IzӖ _;Db]>g>kڅÄJhee^9_-t),[ 6tY +t~] -ѳ%k\S_V%୆ 1߄h%kMO~i1gk;cQU#ZvkdGk5~W~?&5&^Omjh[9),r A z%-ͶΘj_^R 9,v kQc0+@YA}-Xc.\X2Պ(5㦞^* :|k*1}VXFY=/}r[OtxH=C2V6\{?\~3+L\ b6 ߣ"ikBސ c!{y)Ѐ)IJ%fzb1bÿj ։ cI V[ǒ'^?x`*B}-yz:GfԊ zAtQeA_ cmG6؉ pwVѕiu#{=( Z̷M8O]ky-f:-k UhbhbZkyFǿ kԭu!V*uk]9Wcɂ~t}u $m֕93)X]25u'+y҉b-]t$k]C6u svgkG&Q! |w`wρ EC(kO +ݳֽ 4}vH #u&=ܨu,ni-Y+NkW3J~h_ݻ1+]M C_rq5Ug&OKu벫(_\\&`^{rҘyS(=dos~tO ~m%OS3e(]%1* ^댏ZMYzȁכ3@BB1g1k@.sm\KNWn»[F3uW,ׁOM!t zRݪ9Z~gz/ӨzSqW{`5e<^rPy_Y3kPX|5DZ'ຨ0sYǺ.WצŜ(%Rofrt1?_kpsC,imz2^4euڞ@6c%Ubč*&do1l7[G!K&}rUݜqEcX \=/7?#ϋ0HO'p._+\=9Y>~agzl#?-zeyna܄& 505gR| ~_د]`ZXʘo } ~fHLӔoovM{5g+_ȾG5xg^`!6ƫ#as^{|:Jz1X7bө+1KE5V x)sոi;#=&F=JF u}}ێ\7jwxsJ5>XҮa~iT-rphKX,%6NucMz-sgZ ibz@ 9%um֕¼xF:F1Mym۷^;XD?; >n=ދ3_²/[ou5>UzRr4%HiG.¼_?ޜ  CT> ͠ xPVĉY |]+}ZmdMa8{U$ 5Q|;z9\Yhtk,1_-XŻÇ%q+) s}@]KeuV..! y]NBq_uV5ivC~K/*zs! pA %M\L-LhgnU*~xV{gU8 Q%'"Ux4צ/O a^3dk}L/•mA)YraSӻS~/Ӱ=}vk/T]e#iوd~Y \x$>ϰ)+w+Īwؾ_0oV)'SteZ*vW:4RV&kK/փ3a]vN/%w%R~><'̳Zhs\}>k Pc;8eJ{7o$>amxb|i}UX<VXcY1s;N c,Y~Y;b~a~9b^{ z-X4;9;ppE\M%6<^E)1y&K79m ru7'v1dz&&pøm~H\1tYr4Bƍ|q[n`'k>o==-i{`_h!Х,ꜞ4=E.\'kDx;rwR6eA ~a)b,!_ {`_t5Uy-sdj\wĿ6=-܍_ˮQ}_Y D2X~Dj H(mFƥ&|{EV+ltK!˓%{ ɝ uixɳf)K, X_k:1,}M fnl_?\j5nVH*O?,~s6.'L5 N,gϔї3!;<7d [=SGc-lhCӫRյRNݹR7E$l!ֱP-N=+b/k+teיo;{,o_DIwj,>1L!K;DNKBHj-xXnB9בo~- ajW¹UFWW`~m7p;sV=g`x~i)5sT6cZK/Zu-c¸We|OCG9 uqfG̀E7qk757Tf='P/tOo|f~G;0x@ q_UG;sgWvC1VG?k=FP X>.X:!CNn?*XSwOӯXzQ 9kUWb.+z}m? Z#ad-^͆6!QGKk뚭>GKXoԦ {M~}_Њ^JCwxh{:;ń:V`%JXثt[f(=b7JomWe|#VVy౱aVCc B61o ^yO6qZbm1%{[{OmJ;'js(aؕ|lbDh$tkz5ק _vKaɅh|ns晲F|}} „wj ܰW5,2x;}jzy8sOHk^{ BOMa zƗfcz!v2rV9^t[xePz-{ nS|{%ǭ؇_>z1u>yUܨ:Vyb}UM}|-#;k+_h֤`|䂇SGЏsaaxbs5.`pb{pޯgg8Qמ)(Y2~Z.P]sH ׽5ߨ$?|d|jbwe623BoE]RXbl]̥q:kZaU4S@~aZOaߘb8+|M|aXhk,CƧX795'~׽MrXeoG==p_S]r%_Xe?bN4E~ma)9;$A^?xՉdi!xS&VWE씠0ۂ#sXX6jga<+;f 7/V/!˴N!}J.V1JvۢpK qYi.AZk|Հk3fU4{*ת_̍v"\csns5ք%ڵkEZ;&K;"gt/,șb½6[UĪ`՝U(X7y_MX8V2F~f&X}_CS9F63,Bi'k? tz KZgMM&jhAX#o9rFON=.3?>0g A_[>@1lU+MUX =Z~U:ִ6;{" XdemsϴZcm,| g7#Jqpe߃5YGA7+r^/a!ܐu6hXi~.gQְ^^㎹etZ v9/ڻ<[|:v@a߃wYO{y0 |-۫J6V ~^t|BWcr ugmx~ZBgD)sj>kXi <^  D:]LS,+w~m7}hVƧ^訛@UM95|uע} vȜ_#F^˼pu.,V1rw4/s4C/ jX?+pVxvwtf̒3ԣ{ GŲO z-g۽<,Ї:X2{ou!VZ,)[{a3]Js^[3IM꘨H3҅Şh\m^cj M˖Ua RyriؿBvCڹ@@JH/3fQ3x)okҷ·vڗeܝ{ $VZXkxNg3n7><#]۬y#>o<^i؇\<!oצ갔ӎ(⃦. {X+whhJ}O9>!27s.L591&ەsM]ua_gl^Z(jM#c%ܯt,Ě9n>S\رf5t=bLXOX;va!)5ob>=-kN8@pv.60 ]@?Dsu,JhcX\XvBxC^;yrЏʌg?tzzng QjNQ$]Ȁ};NAEȷ'f1' Y3Pk_kE[:joɿ0KuZd~C>q;3Q/3Tt\%g!*qL]!Ī+m8.ѩC?d)睄XЭ.1V}r o`]nw,1ѷS ٵQ P[{{59G`Jwb*k+w;%/{_XZ7*_zfٯUHn u-r󐕰3"wnޞY c ;%SrhnuAG$=M/rSāU1b'RYr7p:z[%A =MЃQ ї}.sރUݨa2`yt1FVy G0 PJ"/diom.R+|Bm}3g ^{޹BWO{-4}zjskjnWPXu+nY9֠_f91kfKFujVʗ}̲j0&",q,٥)VYax5Ns-O*Eї8vB"BXz=!n Xc ,u06Y}x`ėF֜Wg--U~HaRJ?iYHZ" ؾƚuN?dx(teѝ~`Ͼo,s؏foq. 9:Uoj[ΡdrΜ~OSm['+7yfD {C={G=w.۞&ec"W¼Ď[3jj&OXތGg*s?V5 5hQ9qVמֻOBQK%Y)$G']w֔oUcޯ .[LbE|ZJ,q|;=-UO2 Y9ϩ+a3 /v"מ-`P^Ks NQX)`G؇Ǻ{*Mĵ(^yyj@xc>[[^k!jʜMPVlQtݦoKbx= #zڂ8|'mk:+lqtl䢻6}wb\GSTe}&ZP_W[t:8j#:]Ա$ iox:\V^1c>u99atXvt|\g1szqtźv%8 Kl63 EJq8Cis>XuWPT/~i$s8`Ga)ℾ_KP!?/K;>i/jt -\Yrt<*Nck&@gߜ#Vqg{ sXIx,^]\==z:g(Q7"X1{/UC^\_k߆L_,b XzD\yLs?] [_r܁ZV@$־ |-!ԥB NS,0@4T!"_xҽa]aZz8oY75^Q V2uk86 J~ _~o^`{c,aA;P77%rvEzt gEۃu.垯￨'XODHXi: ֵ?P漻W G=.9(1sO%_1c:~{jZuZ3Ab\kg*TBL>ˇX굕1u!^)xX0yXZ_[VѕRlŦXsW]G4|k5vMBܮz،SӺ=s{f-QbZḪ|̛N7M.ff`( ϛ9m!F3Bȟ@}GoW=vk\ѴO-dw !V~`EB]|?⽇UX{}X##_~z&">;2[.,hΡ,υSoRX磮4VC9xc2c6.{fLjׂs6ew),@50.ZzZFC輸Ϲ,O!e!Y2rJ*Ώrp~k ;^kXgdVJa>i329O`%~Vq{T6xUbW_탴sI;NU\B>Hہn=Z}.ZKw2'N_|t εo}\*ޱEkXCC6Vn="_[ڕV8'g+k-NH3K 7kF?X0 ڄ=ycf~;}GkW+.k/,F\אuXJVreZ̦*W8?.~Ըb=C]ľ|q"[Ic|KqR諈99X9_\&Ֆ$}v>Q D~l15{RwGɗ0qGxreXcY%gЮdID.S ݣr119'Փ#,^f7ko5¯xF]S{c^9|KDk2iGXc*nGkxEOG=fR~"auxGt{/Ŀc":kdՍu\{?vtṝa5 /հ:kY\1K8kK)kYj,ԕ;hŐ]k[h ƇsabEU=MlȄ~d?o kaW?&L1=[\@?9MqC.ҏXeџC@BsV^k|-Hk$Y}b;j5} )vmW|Ikg.^++5gO;Yͯ."v9zLFs} o:ί;>Xcbu1(tUS,V~wv˵]iV )b#K_˲}_ky)Pkj㩤X l A0z%K'yl4v7jp`թD|O@RRv~a3[X޿0yNL~E=dg1z)=GJ<'Ēkba<5cU!?T'6&1|7!=6{O,XXz\iNQzQY,O>Ge~t`ie}w4Wh,3zz3qv =g#yi{=}h 2,ڱ}M۞8kP#? W4quqs{̪4}FoYPꋴ3aJY~4̐C/X"^67J\,[Aۏ,eh%Ka<@cpʛfU&zȪc+_%7KwV, 󘨇2zv՞Yi,:\\!. Y{/Zgu.#,fҬr`5mKwVͦ[=nS{ظs\4 >"^vކ^s;Ϥvv4-\3ƅ}+* jI`YSPÈT}pjUY810=ޜQ DTb٭k"*0x|n׺޸ab<WJ|\ybVyK\>c+.4*:֋b`2o[{?^)88*gaލoT 4?j3-SDtyٻh'UF=i:@`'?qtCX /k\j 9Ub _~"_i'FoXs{1NMdҿe=7ڻܶib ѕ`J yJEmA!8v|g!'rjІ N\\US{kcQ3v>{|֐]qyVʳC'-b2}tkxs85шG =4ޮqϽxX+ϙy&©;BqsW|ēkv ~gQ5V[R~`E:cV>aiubmWZMT.eq%'^hGX\_kתxHQ{S = ~-qo|w '@@%PT쿱܌9.fx][G]a,cRY/*6+j{>N/6IwTބ".C_[3afEC_ izX޺e\4@lF:|NfV=;WQJcqծglӎ̐ﴝ_7WhR9ĺ!IoaejXPW7igD1+#/~Twc7J͛%,1Go;XyJB=GqG*Sƾy}EYCJ_Xqmb1FK\,sWˊ#C\x#s>_R ,Yz>G+=X2!ׅϖUGV#.;+^,²oBX\9b콬8R6Xid5­.̞z4GǕ'r>*:=Ǡ,Gܯ] @qQ:\pA zi14V/Ԓ]&^l99vXYXޛo'KS^9kH偵y,)!*k B3j;jZO8qq=9J_>'|*>COFP~yI?K6ыPZ^\JZb`7댘{dΈ=?ښXЭɴWXkYsgNdrz'V1lQpcz_Bky%V{Ue\|-Y"ENbMfз\p A z%[_̍Xk TeaYVرQU!r!c{r&vHy/b,%{ZE'0_[hŽ)㒡@3.B|1({GPNaqY&$Ds};+P縂<ބO]!j02Gͮ]D΄Z}kgŲk#cqFUw!n,'s f9ο3~Fp>7"yu?a͚9B籹BW]zA8 Aڙ%A@JMs͇CL%ZDl ˙98dz cDcްbﱧtf&;k\OCF=d-V\:dFWI;-9/{0&{͕FA;>ȯP,XĢP'`UgjUMcWYfg%g]9O4EWD ?h1K7c^'~]0[) 6/^cdqo,VXi,s+(V|Ͻ {?\\w5wDX=,V5?=+_۸y.7љC_( ht }Ζy:9_px ԅrl;љ= 'Z}vQX8^%h?Ybwݵ.3;lC)l,=ǯ7:m`7ZUs1go̲}-Ym11Y2, R>z-btUnjFa>la,{̩#7!oi%Vh:iEG>F\#{Z2@bfjȺУA]94nxOhv~_c:Y&(^{X3vao3g}^~âO|H;$A^I :]kol,1nwײڕ\)jѣgЮ[ʰ^BZ^[ E dgITu& Fe!O4AËoX6gߐxi]}|Z=y:ZG_Ej,8 GbDDuIHi;w^ ,u҈I?fei2+6G1w V91FGQda 3T}Js3sk棌{RۈlUpOroX]3n{t9[b}흌xs;>SbF c`oB-Gs B(^W5XSHh'߈=eל3O9Xz5N9kԭ;t뵗꘥W04h+Opv:Y5}^;="K}>b.l:Y|_sތ=zhy+P~† &No,k;+ҜBb@=>} kg?Œ^\Nhw|fɹ&yLf?ib0]:AUwT.RDg4ۃ8 k>ސ䯭o־WP/b+Bf!VYo,7{"R~O= jcfDZ J{8,{+S՗VPKOsm[2rrLCƏll$&`]Z7b >/ثC|Fbqž|ջZ{tw?9@M> /;k,q1ezX赙^X[ >&YI5+XU+4VaE⼇ɟQ CDY ۴[#2_OB>yK~+j׫*ѮI FcAM.1[xf.nпvjKc6Y9r')/lJ\k.᷿:*k+܏ r>VqNȝ,x﫼GK)辺_y* :F=du3i+1mlC,GGL}.N ZG,)w-뭠chײ4F!#+fqo k;ޤk `QH]&^_Ð, hc{h±t3?RrϲzkNI)Apq3DXmc90O'Ȓ+DX4 qR&VAψymEگR,;,qmriR? ^[=jX7 K" k ŕ:M,[s7rM&GۨMڹP @tK!8ک%"0Bc֧kkf>175ׂ?VY1Pd>\f$-ph"0bz=˭KG V9~B7̺וPWNjrqB}-_zyY`qB& k./)CC?d|CT{}U,ycbyoݕ b!&ߣ[%1īfeXqf ]Ne[я3K5\W?0)t6wUMXjz2aqՉ%u9#U\ށqVkxuSgYr\yFޝΉ}~mzk Czڂ s2B,}>}5}! z({gZaQXݾO0z˸fCI,)PW`MEyz2| O[F|svZU;VoR2_] k4Aډ+Hb a (X;$ddaԕ$<_|6 (w*~'!,c"|<A̡9,=u{!Ɖǂ{'cz]οWjjЯO;ѭ*S?D, ` tƜX>x %eCdTuΜ KKa),FUmGb~Ｔ^5,1s9{jVK9j8s7Jm;.=bʕZ O}'Oc6Fkbɣ{ȣnA _3EA @%cGt9`vV|Z ZLZ0;E$fwZsqwB/x_&FTX/ήb} K5K % la=JT=ܗ=r6{AGέ}^r29y\]qXesgR\:Su.jSXuvqC:Tᬂ_[YGDòQ r4jX+kcaa'Ux(Zȯ]`%y9`:eiy5ۼrs7-|My|˧o܏caIqpvn90h ysXZ Cjc9;+~ 7RϠjjK| K=eL+P0x}M,父:J(pgPE1+.kylE{}B? 3>CC@菦fWquIp*R,[=ٸ#.>=Z3,2_}MYonC:xCsS_D -og޷56Xti1Ž%,]`u_˜SZW`urܻJE06< Y -mBrfd4oxuW3ZW ~86p`d0G}' \9(a!OB/Gos +NIFd̮ܡ}t wE}a-t 5#_X#2YǚxI[% A %%*4w6dRvk;wNPgə Bus ӄ8kǢȉ- *#X|~u v[Sh7O$~IZk'*o;#6zdQ5uȝ9 =dYf62O诽b-_!sXe#eHXE^fru|-?#olL e4oTB>HE˿0x=?:/?;+%f!s*ʕw(O|Zo~BWV bK4`^*jCfeԡB1K,..j02a庩Zta,WJ[$#U$R].V2>|)&}F(Yu7^U&ɢC63a<{)c޳{Խ(!ֵ+j¯Vst1uገ=B,?_}~:yCqaѯ)sC=cgL~GZt0P7sv8@ ˁz]>0)-]}f-W¥+zXVF.C&k]uY!IJRN:3Tqe^bi^&.3 i_żPXKk}T*ϬQY`Xht.} E}K}`=GV%}$ ̈Y eJ,xY=Z *S]Λys UXsIǂb}ooŊ FyYJ]Ycza]pvv9 >?bk:b>}Aӭ? |boҲ}dg.V`e%/hUB{]7Ϣ|-u z-s?byȍ^˚SjULX$ksa`c{Fv%&y9*Fj+8/+EّQV~ϖyor1=Hܴ4]Zh{э- f=u6z-ݡ?Xkuƈw4ϻEϏHׂ%8CfvF90Zh_lܙƺ ($$yXsY=՘ =C)!_Ok&-V̜rQ[{kg9oYL UY-<盼J I>T+ﶵ p{>&k\+BKiek yyB\?'ίUsX46}a;z35Śkp#W>/ig0 /86C$8-s kam kQ\\fwGX["S&@W IWeb)d]Mr׫O]g.S(l#P2FZt=`gZt)5>LUSVCv,XFWŹ'Q|N.u%Y~mXFymXc⋺ʱduecį=תFY2r,cΡ>C}vF9 RQjM6Θ4ׯJ+au%z|EzkUQޤW1Vs s?c9\C9%K3ONmr D0d}wl.Ν5|uiJv}oG!F,K_\C!0mθ_ & {/vĽI܅8a!;?B#mSه āCw%Wl8g Oew IJZ< yڇsaJ1_RHOͥoc+Mt$VY :϶*/9V0uX3D{b'"lY >k V ]'JZee%/NE3[dQxS(:ܨgX>p1_l[|Ȳ +PHbUA9 w$ v͵\րOEPgSMU^ q%VXX0jVE RsZ_+~:e%y;np 9IUޡb}<^-[.{tuyUlu֥bXjf=upgC1¿&y蒵Յc!~{{U+~0d[?v]\P |`Ƙ]Нd.+:@2,!{2"d {SW+";;{:ODXdس1S?d5/soY8m4Wu+ɒyd+|v}pJ#/:kغfEF߰ʯ\2!VrA%?VgWY`or}ZMX.8AV3, ? "7 r "7 r "7 r "7 r "7ܠG0 iL us#7 Fn0r`#7 FnAtwZADnADnAonp~M 0 ;X޼Q Fn0r`#7 Fn0rKq%7 r "7 r "7FnADnA=7ۡ 0JoVZJ,o1 Fn0r`#7 Fn0r "7 r "7ܠR5r`#7 Fn0r` TX 7 r "7 r "7X̓FnADnA\RRcPN@lQ75:F` F` F` fH)EQ7uBE(UYEViEWyEXEYEZE[E\#m{1` p1(2(Ë2(2(2(#2(C2(c2Ǩ0@S'[sᛯoSuC7lnխUVZuǪ;Vݱ;  ؒe{wpdH̠Zlbf3&f61Mlbf3: 0Wgp)2DfMd6DfaX}6l"&2l"&2l"Mlbf3&f61Mlbf{đn4@ `]#@vܪ3~Md6DfMd6DfMd6DfMd6DfMd61Mlbf3&f61Mlbg4;aF+Ol&@|ܮ3l"&2l"&2l"&2l"&2l"&2&f61Mlbf3>6qٹ 07i M.En6D+߹DfMd6D+DfMd6DfMd6DfMd6Ddc#aM9w/ˣlb`&>?B& S.M]4uiԕ+SצM]1ucԍۦnmꎩ;ijM<,oIݢ7q-z7%Nj r+6bTWKnԥKSL]2umԵS7nLݘ7?rSeꖩ[nm궩o"G7q}'Խ11 ANQ8/umnbb76umSWL]2umԵ;cԍS7kMDMDMDM[x!0 1QE@&n"&n"&n"&n"&n"&n"&&f71Mnbw4;(  )wIg~77l"&2l"&2l"&2l"&2יMd6Dflbs&2lbN6uzݘṂMlbiC"$ߜ^DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMlbf3&ivp0l(/"fot]fMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMĘM&CC 1_3g~e~fMd63dsՙMd6DfMd6DfMd6DfMd6DfMd6Dl"&2XM~6fB Ĵ>0DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7Dvc71X`K@Hsn~T]fMd6DfMtw&^VDfMd6DfMd6DfMd6DfMd6DfMd6&|W7I"b|O, `~S_ޖ/M,7ԅ S.L]4uiԕ+SצM]6uSwLݘ1ucԭ[S}٩!}XO sv/z//Iݢ7-z/rS.L]4uiԕ+SWL]6um궩ۦn1ucԍ;ϛ E,sRݺ8G~.%<,'uox[yYNm妎Ml7 SGeKS.M]2ueg]6umԍS71u4;$a&E@YYfNe6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df}8`&*`߾vDfMd6DfMd6DfMd6DfMd6DfMtq/&:ļ:&2l"&zM @)yѢ6@:pwMĘMDw崺&ͯ崺չy&2&2l"&2l"&2l"&2l">6fB0 Ĩhc ٹMDvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DMOlM!ץ^sۺ϶nLݘ1u]SGD&6rRwؼ,'urS.L]0uiԥ+SWL]6um^4;vi/vݵ]7vuc׭]vufMd6DfMd6DfMd6DfMd6DfMd6DfuM|1 00PS(Lտlbf3&f61MlbfMd6DfMd6DxVg6DfMd6QlufMd6D6qIc;+| ]{v&f61Mlbf;#&2l"&2l"&2lM?rl"&2l"&2lMln& R0bւp|#ՙMlbf3&f6/8~f&f6DfMd6DfMd6DfMd6DfMd6Do6qn6@[Bz7[)`F%ՙMd6DfMd6Dfo"&2l"}M|YPN6q<&N-Սnluc[e[?6jF0krl}c nD=}0uaԥKSL]2ueԵkSwM5uMĢmbmyZNmn61mSiԝOKPT - /0.M]2ueו;cꮩ6um6rRh|[Nme S.L6uG J҂@>S7nLݘcꎩ;kꮩ[SnMݚ=D&7Mdo"{ٛD&7Mdo"{4;&bᏭ*޼ufMd6DfMd6DfMd6DfMd6Df3&f61Mlbf3&]]g4;$fس(+uufMd6DfMd6DfMd6DfMd6DfMlbf3&f61Mlbf3>6H!` bT{hUiB+n"&n"&n"&n"&n"&f71Mnbv&f71M&ivH 1UϿgCPV:&2l"&2l"&2l"&2l"&2lbf3&f61Mlbf3~6Hc"` aJ͛]g6DfMd6DfMd6DfMd6DfMd6DfMd61Mlbf3&f61# a ٺolt( &n"&n"&n"&n"&n"&nbv&f71Mnbv#NT Fl"&2l"&2l"&2l"&2l"&2l"&C61|[d&&{G6@=k7_nԅ S.M]4ueԕkSצM]m궩ۦcꎩS7nL^&^^Eoi9[&^f'E0=H0ͷ-7uaԅKS.M]2ueԵkSצnm궩S7nLݘcꎩ7ыrRM<,oK 0 DAL˟X" =y&ykMsSWbmnꆩniꦩ6qqenٯ[nmMDMDMDMh4;(ik1On6DfMd6DfMd6DfMd6DfMd6DfMd6Dfl|vDf3&f61KA #Obٲr.&2l"&2l"&2l"&2l"&2l"&2l"&2&f61lfD@(}ggອN79UDfMd6DfMd6cՙMUUg6DfMd6DfVDfMd6D6q>vTݚMGAswSO fMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMdDfMd61Mk4; uOVA~n7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7&F7q1 CAK$0(`9:e6DfMd6DfMd6Ѧ,n3l"&2l"&2l"&2l"&2~c%ݎibjeĞw8޲rc9.&2l"~6q2l"&2l"&2l"&2l"&2l"&2l"&f4@)E7]\1MCob/&^&^.L]0uiԥ+SWL]6umԍS7nMݚ5ukꮩM| ! E<Tpg ȽM\NmorRh<-7uMLn궩 S.L]4uiԕ+SWM]6umNÑ:m/Lg~@`Le?1AW<M<-I]7};/M]4uiԕ+SWM]6ucԍSL2uo{M\?rSw}}/ivH0LT(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2t;&a *??AVĘMD?T]fMd6DfMd6DfMd6DfMd6DfMd6DfMd6DkխUw#ݎibG ~9ټMĘMd6DfMd6DfMd6&6&2l"&2l"&2l"&2lΪ3f0Ĩъ!!qMnbvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DMvL @K!tȇ?2"~?&~c61fMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D{#ݎaab;M6ŭuѪsYZg6DfMd6DfMd6Dl"&2l"&2l"&2l"&2&t;@ 8T/L`YhЉSlbf&f61Md6DfMd6DfMd6D3l"&2l"&2l"&zivߺ4;8a Rl_cq )`AE&bm"&bm"&bm"&އe%1vuc׭]vukufMd6DfMd6DfMd6Qv]vDfMd6DfMd6Df=A00Pmz#%Ϲ&f61Mlbf3&2l"&2l"Mh7ѧl"&2l"&2l"&4;` ʉ7]*ϭMx}ܪ3&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6Df6n5D-i;n3&f61Mlbf3&2l"&2l"&2l"7ѡ$&2l"&zK1 cgN`:rMlbf3&f61Mlbf3l"&2l"&2Ⱦl"&2l"&2lGAuW6 U >sMlbM̾Mlbf3&f61Md6DfMd6DfMd6DfMd6DfMd6&)wl0 @p-~ҥc;WZg61Mlbf3&f61Mlbf3l"&2l"&2l"&D'd7qkDf6f7@VB# <@~gnיMd6DfMd6DfMd6DfMD6E6q<&N~[RN6qe]7vuc׍]e}M PG<50lO`+րmH,beD.#v.ZD3 ؿ> #"B%"""""""**J(******&&&FLMMMMM]v#ja_,,9]TEXDX䋰JUUUv*DDD؉a'NݏG0 47v'd,0)HaIaIaIaIaIaIaIaIau#u]G:ZCާ M f0 0l `/k9$YGyG%}?r#?#kF JQ"@TT;&aG7 ?eA@$]25€H"< H"L B5r"h "x 򁮝ͨ5""$ bj4 05ƟؤQ0~`Fi F^0`d#4eRHKnADnADn,ڦDnA<Ct_ >,kX$`e X(@nA(5r "7 r "7 r'ADnAG 0JnAtl "7 r "7 r vuRkDnADnA=[5r "7 rv>)wL0 A Sn?1O0wi~隶Fn0rW`#7 Fn0rZG 7 r "7 r "7m r "7wG0 㴌?`Y kDnXFnADnAVĐ502D_̐u,4d!K DnAkDnAG ulW YZ#7 riADnADnA^}ADnADnAƐADnк#mTAbN5} r zBJ_#7 r "7 r "75o)zKn0r`#7 Fn5r`N:;K5m r "77oADnADnAcikDnAY"V)Lv hkV*T ,iwh 0)w03|5r "7ܠS j r "7 r "7ܠc,ADnADnA~5r "7h#mT-/^ffzM_#7 r z-E_#7 r "7 r "7賐(eFn0r`#7 FnDzy5r;&a y SOkj r "7 r "7 r "7 r "7!(FnADnADn,FnA ;&a SB KOy_kU-sLntcŎvlcr "7 r j "7 r "7 r zqDnK1 CV7}ADnADnADnADnA#7 Fn0r`#7 Fn0rnHa_ "2ADnADnADnADnADnADnADnAf%0\տ)D@e5r "7 r "7 r "7 r "7 r "7 r "7 r "7 r "7w#hw6%@? z 7 z 7 z 7 z 7 z 7 Fo0z`7 Fo0z]oHcaŸL _>5FnADnADnADnADnADnADnADnAnp!Xo ADnADnADnADnADnADnADnA`1 0YԿI||yjz r "7 r "7 r "7 r "7 r "7 Fn0r`#7 Fn 4;aF+T[kDnADnADnADnADnADnADnADnG0 `d5r "7 r "7 r "7 r "7 r "7 r "7 r "7 r "7hs#͎i 'V/U2l|ADnADnADnADnADn Fn0r`#7 Fn_7xA 0]ol _yjz r "7 r "7 r "7 r "7 r "7 r "7 r "7 r HC"a E@YYޚ^#7 r "7 r "7 r "7 r "7 r "7 r "7 r "7 r78@`JyiwQkDnADnADnADnADnA͇-am1|cbbbbbbbbbjjjjjjjjjjffffffffffꎩ;-K1#3+Jpԝ;SwLׂx١@ð.%L?;SwLݙ:{7{7{7{7M<`}WB>ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DflbICBW Md7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMivL 0 \)UywnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd61Mlbf;#;x De|e|,?ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6ѳK@q`c˚ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM# a yml( n7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7&f7G U>ʰݺ3a|Y-?ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6D6qICaPevDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM6q1 0QV 6l]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D8P)gxwHMh7݄vMh7݄vMh7݄vMh7݄vMh7݄vMh7݄vMh7݄vMh7݄vMivL M||rl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"6q! 0S`,2sl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&6q1 0U6 ke:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&đf40Tk0DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7ѻ#͎ `¿iX#/CnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;6eъ_*aav&f61&2l"&2l"&2l"&2l"&2l"&2l"&2lk4;` Ҧa>]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DM4;&a*_OvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7D&4;&zƖwnיMlbf3&2l"&2l"&2l"&2l"&2l"&2l"&zđf0 dտF@YY&&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2loG0gӰT_ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&F@_YtD 8nbv&f71MnbvMd7DvMd7DvMd7DvMd7DvMd7DvMd7w4;`f ʦa>]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DM4;$af0rl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&Z8BǿjE[~]g61Mlbf3&f61Md6DfMd6DfMd6DfMd6DfMd6DfmHcBοM~C xn"&n"&n"&n"&n"&n"&n"&n"&hđf0 t4ǗWnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6`G@ \/Z$vD&j6QMlf5D&j6QMlbdoˇec].v]ubŮM0 6/__rSwL]L]L]L]L]L]L]L]L]L]L]M]M]M]M]M]M]M]M]M]MLLLLLLLLLϛ١ ðeX.cbbbbbbbbbjjjjjjjjjjffffffffffꎩ;&.ivL01 bo!7ugԝ;SwLLLLLLLLLLMdo"{ٛD&7Mdo"{ٛD&&ivH0LS;=ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"MivL!LB#-ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&4;$ ޿n"&n"&n"&n"&n"&f71Mnbv&f71Mnbx1 0OW 6sl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"F8awv6eeܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"MivL 0ß[)Uy5&2l"&2l"&2l"&2l"&2l"&f61Mlbf3&f6_x! P׿+vMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7D&4;&& jƖgnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6lGA mPrl"&2l"&2l"&2l"&2l"&2l"&2&f61Mlbf#͎i@ځeX T}c]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;a dk[2 ]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfivL VolvD_,&f61&2l"&2l"&2l"&2l"&2l"&2l"&2l&t;ȥ2U2baܪ3~Md6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM-ivL L’ +vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df61 @(% ЌM61&ƶmbhXmok|}C1IS+Jpԝ;Sw..........nnnnnnnM<al1|M1u1u1u1u1u1u1u1u1u1u1u5u5u5u5u5u5u5u5u5u5u3u3u3u3u3u3u3u3u3u3uM\aOl&@|ܮ]7nvufיMd6DfMd6DfMd6DfMd6DfMd6DfMd6D/8a7wp>ee]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMivL!LB#-{nיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;$_ӡ(+?&f61Mlbf3&f61&2l"&2l"&2l"&2l"&2l"&ivL!B#-snיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;$aE@YYfnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DoG1 V ouf3&f61Mlbf3&f6DfMd6DfMd6DfMd6DfMd6DWx! 0Ql(ʲrl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&z8B({G[ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2lMivH 1LտGCPVOnיMlbf3&f61Mlbf3&f61&2l"&2l"&2l"&2lG@3m`c˖ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM# `mcPVufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6ѳ#͎ [o+&2l"&2l"&2l"&2l"&2&f61Mlbf3&f61lf0 TտӃ(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2đf0 T4Ǘ%&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2cGA *h/y0rl"&2l"&2l"&2l"&2l"&2lbf3&f61Mlbf3رG0siӰF_ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2lMivH1UKݳ(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2đfD0\UC/:&2l"&2l"&2l"&2l"&2l"&2&f61Mlbfđf b n?:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&:61 0Yw6 K:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&:mb!00Y=0vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df3&f61]x1 0W0@*`߾~|-rl"&2l"&2l"&2l"&2l"&2l"&2l"&đf0 lտF@YY~nיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DcG@7V `c3&2l"&2l"&2l"&2l"&2l"&2l"&2l"Mlbo8``Qc@ 2?ˇeܮ3l"&2l"&2l"&2l"&2l"&2l"&2赉C0ӅcӰT_ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&F {i$?V\ivDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMĒf@0}ӆ?`h6cy-˗rSSSSSSSSSSSWSWSWSWSWSWSWSWSWSWS7nLś8ٱ @ðl} PNԝ;SwLݙ7Hc a. bo%7ugԝ&ivH0LS;=ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"MivL LM||yvDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM6q! 0Mo`,rl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&6q1 0M̿8,*`߾slb&l"&2l"&2l"&2l"&2l"&2l"&2l"&2gK0 T",ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Ѱ#͎` y¿Z}ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM4đf@<]{{6eeܮ3&f61Md6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&ivL!LB#-ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&4;$a&E@YY>&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2liG1 V ot:Mlbf3&f6DfMd6DfMd6DfMd6DfMd6DfMd6Df}# `m'CPV:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2hđfD0L_[->:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&mHC` a <\nיMlbf3&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6Df}lf4 T,,>^]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D`#͎i` j:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2hđf40 P5$ȗϟܮ3&f61Mlbf3&f61&2l"&2l"&2l"&2l"&8b'PV:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2hđf4 \_,,>]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Dd#͎ :;+llܮ3&f61Mlbf3&f61MlbfMd6DfMd6DfMd6DfMd6Dx!Xo vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM4;` 4nB &nB &nB &nB &nB &nB &nB &nB &pnb1 0YԿI||ysl"&2l"&2l"&2l"&2l"Mlbf3&f61Mlbf3Ď4;` udCأ4n"&n"&n"&n"&n"&n"&n"&n"&z71A_$>ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"IcAR&a0uvMd7DvMd7DvMd7DvMd7DvMd7Dv&f71Mnbvޛ8`X(0_ۓufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Αf rѿ#\,7:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&61@@ o ЬVg6&2l"&2l"&2l"&2l"&2l"&";ėO/˧k{Ic` bPnv:z/7u5u5u5u5u5u5u5u5u5u5u3u3u3u3u3u3u3u3u3u3uoHc" a,f7Opο;SwL&ivL @ SO+Jpԝ;SwLݙ:{7{7{77Hc`atlR1|cܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&Zx1 0M77 K*ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMtHC` az <|rl"&2l"&2l"&2l"&2l"&2l"&2l"&2&f6G pWB_a|Y-?ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df% `yq'CPVufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6đf4 < ް@}:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&hK  il uu,/˷vDfMd6DfMd6DfMd6DfMd6DfMd6DfMtl'͎` ¿Z}e:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&đf0 Dտ(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2mHc"azlls.&2l"&2l"&2l"&2l"&2l"&2l"&2l"&zđf0 Lտã(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2mHc"azllrl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"6q!R5,wwslb&l"&2l"&2l"&2l"&2l"&2l"&2l"&2lcK0SkӰF_ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2lMivH0LU[;=ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"MivL !L_Z5|#-?]g61MlbfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMtG@ sU҆w,ʲrl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&z6q1 0W6 ke:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&zđf6@öYKe ,̟ܮ3&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D&ivL LMR||sl"&2l"&2l"&2l"&2l"&2l"&2l"&2l">ivH0LV;;`esl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&z6q1 0YeЋ6slbf3&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6Df=mHCa_#,ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6ѷ#͎i¿iX*onיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6k# ٺ76PVuf3&f61Mlbf3&f6DfMd6DfMd6DfMd6DfMd6Df}6Hcaol ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMtHCa#,/&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2l#ΉQ7b pNk]g6DfMd6DfMd6DfMd6DdF6cnaiemck]7vuc׍]7vݺM|ٱ @ð} PNԝ;Sw..........nnnnnnnnM<a$&)7u1u1u1u1u1u1u1u1u1u1u5u5u5u5u5u5u5u5u5u5u3u3u3u3u3u3u3u3u3u3uoHC# a5̄31rSwLݙ3ugԝ;S7S7S7S7S7S7S7S7S7Sgo"{ٛD&7Mdo"{ٛD&7ߛx1 0M77 kufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMđf0 4տӃ(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2hđf@4qU7r:&2l"&2l"&2l"&2l"&2lbf3&f61Mlbf3ؗM<awz0eey]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Dfm8B'G[]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DMivH 1SϿGCPV:&2l"&2l"&2l"&2l"&2l"&2&f61Mlbf3&ivL!LB#-ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&4;$a& E@YY>&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2leG1 V ot:&2l"&2l"&2l"&2l"&2l"&2l"Mlbf3~mfD0MW6T8~X~-&2l"&2l"&2l"&2l"&2l"&2l"&2l"6Hc"azllyvDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df6q!00S=FE@YY.&2l"&2l"&2l"&2l"&2l"&2l"&2l"Mlbf#͎ +; Tԝ;SSSSSSS6HC" a ׿3$ufͮ]7nvufMd6DfMd6DfMd6DfMd6DfMd6DfMt6HcaonT_%&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2豉f40 0?I:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2mHcaFag:Mlbf3&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6&4;$aD@YYFnיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DoG@q`c˞ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM# y6t(:Mlbf3&f61Mlbf3&2l"&2l"&2l"&2l"&:x1 0QV 6̹]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DO8avt8ee]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMivL 0 [)UyonיMd6DfMd6DfMd6DfMd6DfMlbf3&f61Mlbf3&vG0 3UΆ",+&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2l#͎` ¿Z}e:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&zđf@L[|4eevDfMd6DfMd6DfMd6DfMd6DfMd61Mlbf3&f61Mlbg4;& jƖ-&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2oG0 SUN",;&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2lgGASV `cWnיMd6DfMd6DfMd6DfMd6DfMd6DfMd61Mlbf3&f6M<avz0ee]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df}8A+K5vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df}lHC` a[߬2_nיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMlbf3&f6c4;& '3.yvDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;$& YevDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMmHc"axʪllvDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMlbf3&4;$X OyϗcXvDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df=6qIcal ufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMtHCaNbx pwufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM\X``'`7./|Z,,-ߖ:&2l"&2l"&2l"&2l"&2l"&2&.ivH0LW;`vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM46q1 0]76 K:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&mbٱ G'Z un]&Nk|Z,7u1u1u1u1u1u1u1u1u1u1u5u5u5u5u5u5u5u5u5u5u&͎JCOi_nbbbbbbbjjjjjjjjjjffffffffffԝ;S&ivl00lb_HԱ77ugԝ;Sw..........nnnnnnM<`XK#,N]7vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DXb77gPVufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Ѳ#͎ `i¿iX#/ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l&4;$_胱(+:Mlbf3l"&2l"&2l"&2l"&2l"&2l"&2l"6Hca/n#&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2h# `yqcPVufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Ѷ#͎qs+ 7ov&f61MlbfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D6HCaPsl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&6q1 0QV 6sl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"F8bmcφ",uf3&f61Mlbf3l"&2l"&2l"&2l"&2l"&2lM<B)kG[]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DMivH0Tk;:|nיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D&4;&bF*O*޼uf3&f61Mlbf3&2l"&2l"&2l"&2l"&2lox! 0Uot(]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Dfm8B*[G[~]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DMivH 1Lտ#PV:Mlbf3&f61Mlbf3&2l"&2l"&2l"&2l"&#͎i¿YXR||rl"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&F0 c& @ȗϟufMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Ѳ#͎i`J3I/?]g6DfMd6DfMd6DfMd6DfMd61Mlbf3&f61Mlbf3đfD0dտ <|nיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6D&4;`& faI:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&"ivL !L_Y_A`cvDfMd6DfMd6DfMd6DfMd6DfMd61Mlbf3&f61Mlbx!ZO vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM4;` ?4nB &nB &nB &nB &nB &nB &nB &nB &pnb1 0[ԿI||ysl"&2l"&2l"&2l"&2l"&2l"Mlbf3&f61MHB\/6=J#&n"&n"&n"&n"&n"&n"&n"&nw#` տIxeeY]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Dfݓf,GЯ_:&2l"&2l"&2l"&2l"&2l"&2l">˧mC*  [/ۺغغغغغغغغغغںںںںںںںںںںٺٺٺٺٺٺٺٺٺK!3g/,cbbbbbbbbb_WSWSWSWSWSWSWSWSWSWS7S7S7S7S7S7S7S7S7S7Sw&ivL1@K䤗l' 7q&ٛ8{4;)÷)T2LZ,יMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6чM,ivL0Lӂo<o_ܮ3h:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&4; t7%(AMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd71}nHc"ABWX^@lʳ|XY>-_o:&2l"&2l"&2l"&2l"&2l"&2lk4;` faIrl"&2l"&2l"&2l"&2l"&2l"&2l"&2l".ivH0S;8ܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"&4;a )!ʵnB &nB &nB &nB &nB &nB &nB &nB 8avr:eeٹ]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMivL!LB#-snיMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6&4;$φBnonיMDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM,iv @L٦kBMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7Dߛ8avv6eeY]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMivL 0T̟Z)UygnיMlbf3l"&2l"&2l"&2l"&2l"&2l"&2l"6HCaPevDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfM6qف 1W®A&n7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvMd7DvoHC` a>slbf3&f61&2l"&2l"&2l"&2l"&2l"&2l"M<A+K52vDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df=lHCa_XevDfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMmH`bVfc|pMnbv&f71Md7DvMd7DvMd7DvMd7DvMd7DvMd7&ivH1LV;ݳ(+:&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2đf0 d4Ǘ!&2l"&2l"&2l"&2l"&2l"&2l"&2l"&2eGA d/y0rlbf3&f61Mlbf3DfMd6DfMd6DfMd6DfMd6DfMd6ѵG0ʟl nB &nB &nB &nB &nB &nB &nB &nB M4;$af0ʲ]g6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6DfMd6Df=8BǿjE[޹]g61Mlbf3&f61Mlbf3l"&2l"&2l"&2l"&2iG0 U?eeܮ3l"&2l"&2l"&2l"&2l"&2l"&2l"&2l"Miv @+1 NnB &nB &nB &nB &nB &nB &nB &nB &71@ `XK,o!%UΜufMd6DfMd6DfMd6DfMd6Ddm_?/O/ooY/)uP 0 ӵC ߡC ++++++++++A0 0RM2B{w_______AAAEEEEEEEEEECCCCCCCC{4;&bFde1;wߡCaG?#aG?}B&zED[?B(#?B#?B#?B#?B#?B#?B#?ivP1LS`MD_?BhGGGGGGGt{a%;CD??zGGGGG?1 c;nD <=W[/=GGGGGGGsO0 4faY=G#?B#?B#?B#?B#?B#?B#?vL0Ҕ6/Uc?B#?B#?B#?B#?B#?B#?1]O 1 Я_`_GGGGGGQIca_"*o_??GGGGGGGva<baY=G#?B#?B#?B#?B#?B#?B#?vL0Ҥ?0~ #GGGGGGG7a)haY=G#?B#?B#?B#?B#?B#?B#?vL0CDk=G#?B#?B#?B#?B#?B#?B#?Z'ݎiqrZA@۬C1?B#?B#?B#?B#?B#?B#?B'ݎiZe} ?BGGGGGGG! 1K#XED@ٳ\q?B#?B#?B#?B#?B#?B#?B#F0 4m _>?1 cC?B#?B#?B#?B#?B#?B'ݎi`ZA@|Vq?B#?B#?B#?B#?B#?B#?B#F s_"*o_??GGGGGGG:vL 0 S#+McC?1 cC?GGGGG1 0J{gV/Uc?B#?B#?B#?B#?B#?B#?Bn40 8#+*??GGGGGGGH b:o~?1 cC?1 cC?B#?B#?B#?Bt;aFjYA@|Vq?B#?B#?B#?B#?B#?B#?B#G +CDk=G#?B#?B#?B#?B#?B#?B#?Z'ݎQj7?!ټ{#GGGG?1 cC?t;ai 峊{#GGGGGGG7aIS+*??GGGGGGGHBo0ߤ?BGGGGGa`ivL0LӶ+/_?_______ПߣGJ1 !gVMg_________AEEEEEEEEEECCCCCCCCCC>ivL@@'c'u _________qHs"`a|YA7o~_o=GGGGGG4f40 0E@@|C?B#?B#?B#?B#?B#?B#?BICawwC?B#?B#?B#?B#?B#?B#?B'ݎi`Q2 峊{/?GGGGGGGHcav_"*o_??GGGGGGG:vL0SggG#?B#?B#?B#?B#?B#?B#?Bo1 0N4峊{c?B#?B#?B#?B#?B#?B#?Bݓn40 @EYA@|Vq?B#?B#?B#?B#?B#?B#?B#G0 4)+*??GGGGGGGHca6/UcC?1 cGGGGGݓn4L Q|p?B#?B#?B#?B#?B#?B#?B#IcaigG#?B#?B#?B#?B#?B#?B#?BoA @1MXND7PcC?1 cC?GGGGG1 0K?BGGGGGGG#ݎQj?!ټ{#GGGG?1 cC?t;ai 峊{#GGGGGGG7a)w ׀{#GGGGGGGN1 ԩdByG#?B#?B#?B#?B#?B# cC?n40 @X#+*}GGGGGGGtt;aFiYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1Tu' mVp?B#?B#?B#?B#?B#?B#?B?f@Dq7?GCCCCCCCCCC_/ B߹A0 0NKRB{W_________ߡC>)uP 0 //////CIc` aҡ' [6c 7#?B#?B#?B#?B#?B#?B#?zHcaBe}=GGGGGGGG{O CDW??Z#?B#?B#?B#?B#?B#?B#?yaͿ+/ ;cC?1 #?B#?B#?B#?B#?B#?t;a)S+*??GGGGGGGHcarL㏬ _>?BGGGGGGG#ݎaj<d!ټ{c?1 cC?B#?B#?B#?B#?Bwt;aFiR4 峊{#GGGGGGG7adaY=G#?B#?B#?B#?B#?B#?B#?vL0 6/UcC?1 cC?1 cGGG1 0S !5C#GGGGGGGn40 HE#+*??GGGGGGGHc` bZŸڃ0lY=G#?B#?B#?B#?BcC?1 cCG0 4-gG#?B#?B#?B#?B#?B#?B#?Bo1 0RƟYA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 'm _>?BGGGGG cC?ۓn40 @M@@~V_{?B#?B#?B#?B#?B#?B#?B#t;aFiWƟYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1Tug mVp?B#?B#?B#?B#?B#?B#?B?f0DmP+CD`=GGGGGG4Icag} ?BGGGGGGGIca'V/Uc?B#?B#?B#?B#?B#?B#?Bn40 (M 峊{/?GGGGGGGHcavLᏬ _>?BGGGGGGG#ݎi`ڑ'V/Uc?B#?B#?B#?B#?B#?B#?Bn4@ 8ur=vcC?GGGGGGG1 0T 峊{#GGGGGGGt?a%7 ׀{#GGGGGGGN 1C9QQ?GmX 7sH"a6_أ;wA 0U+/WߡCWWWWWWWWWW777777?BGGGGGGG#ݎiQ jfG#?B#?B#?B#?B#?B#?B# civL0LV2DD@~~_`GGGGGGt;@j ׀{#GGGGGGGt;a*ƟXA@|Vq?B#?B#?B#?B#?B#?B#?B#F04i/_?B#?B#?B#?B#?B#?B#?Bn4ivL!L""-GGGGGGG4;(p0&"/4#?B#?B#?B#?B#?B#?B#?=ivL0!" G=#?B#?B#?B#?B#?BcC?1Ic"b+CD-W?B#?B#?B#?B#?B#?B#?B'ݎi`Q?0~C#GGGGGGGt;aFiJs*??GGGGGGGCǮ'͎ aW/؇`_/{#?B#?B#?B#?B#?B#?B1 0QK/ G#?B#?B#?B#?B#?B#?B#?Bh;vL0 T?0~C#GGGGGGGt;aFi[A@|VqoG#?B#?B#?B#?B#?B#?B#?vL0?0~C#GGGGGGGt;@fj!5C#GGGGGGGn4@ 8U mVp cGGGGGGGn4T-2DT߾c?B#?B#?B#?B#?B#?B#?Bvo""Y?BGGGGGGG#ݎi`q6/UcC?1 cGGGGGݓn40 Hm _>?BGGGGGGG#ݎiZ G#?B#?B#?B#?B#?B#?B#?Bht;&bKd ? C?1 cC#?B#?B#?B#?B#}a=S3+*??GGGGGGGHcadgG#?B#?B#?B#?B#?B#?B#?BoA @1MVD7PcC?1 cC?1 cGGGG0 #5MᏬ _>?BGGGGGGG#ݎib!5C#GGGGGGGnD@ (ß؃lt=G#?B#?B#?B#?BcC?1 cCG0 4 baY=G#?B#?B#?B#?B#?B#?B#?vL0Ԥ)gG#?B#?B#?B#?B#?B#?B#?BoA !AK$xoRq?B#?B#?B#?B#?B#?0x~aac?4;&`i藯///////____________#Q3+3/////////{4;& B hȺH////////EEEEEEEEECCCCCCCCC?a90 0L㏬ 7a?/7C#?B#?B#?B#?B#?B#?IcaIm _>cGGGGGG!LW@bXaGGGGGGn40 (MnaYŽG#?B#?B#?B#?B#?B#?B#?Bo1 0O;/ G#?B#?B#?B#?B#?B#?B#?Bht;a)3 峊{#GGGGGGG7aFhaY=1cGGGGGGIcaI㏬ _>?BGGGGGGG#ݎi`QkgG#?B#?B#?B#?B#?B#?B#?Bo1 0Nkc*? C?1?B#?B#?B#?B#?B#?BIcak} ?BGGGGGGG1 0R4 峊{#GGGGGGG7 e'"_(? C?1 cC#?B#?B#?B#?B#}a*??GGGGGGG9+~?BGGGGGGG#ݎiahf? cC?1 cCGGGGn4L ׀{#GGGGGGGN0 c?0~C#GGGGGGGݏt;&bF]d ??GGGGGC?1 cC;aiR3+*??GGGGGGGHcaH"*o_??GGGGGGGQ;vL 0R:=Mc?B#?B#?B#?B#?B#?1 cCG0 cᏬ _??aGGGGGGG5a} daY=G#?B#?B#?B#?B#?B#?B#?vL @RŸ؃0lY=G#?B#?B#?B#?B#?B#?BcCG Կ1DD@n~a?o=GGGGGGn4\̿1DT߾c?B#?B#?B#?B#?B#?B#?B1 0[̿1DT߾c?B#?B#?B#?B#?B#?B#?Bv`b}?xf^?>~cأY)uP 0Ӓ?tWWWWWWWWW7777777777w߽OJ1 #5== +++ooooooooooߡC}btt=Ȗ C#?B#?B#?B#?B#?B#?B#?`_"*`߾bGGGGGGޓf4 ,Q{#C#?B#?B#?B#?B#?B#?B#n4;&a|ol""/CC?GGGGGGՓn40 8EjaY=G#?B#?B#?B#?B#?B#?B#?vL0SigG#?B#?B#?B#?B#?B#?B#?Bo100L珬  7]p c?1 cCGGGGGn40 (MƟZA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 <㏬ _>?BGGGGGGG#ݎi`a峊{c?1 cC?1 #?B#?B#?B#?t;@fj4DT߾c?B#?B#?B#?B#?B#?B#?BvaHdaY=G#?B#?B#?B#?B#?B#?B#?vL @R+]S{6+?BGGGG cC?1 cHca?0~C#GGGGGGGt;aFj3+*??GGGGGGGHca gG#?B#?B#?B#?B#?B# cC?v{aI#*aGGGGGGGܓn40 (3+*??GGGGGGGHc` bd ??GGGGGGGC?` e~`/a?B#?B#?B#?B#?B#?B#f?vL0 G#?B#?B#?B#?B#?B#?B#?Bh;vL0 V6 峊{#GGGGGGG7aI{YA@|VqoG#?B#?B#?B#?B#?B#?B#?vL0ӎ)gG#?B#?B#?B#?B#?B#?B#?Bo1 0R;2 峊{#GGGGGGG7U?an{c?B#?B#?B#?B#?B#?B#?Bt;ajŸXA@|Vq?B#?B#?B#?B#?B#?B#?B#G ;Q|p?B#?B#?B#?B#?B#?B#?B#I*a R(ox6`p(Gq(}~_?ؿo?__________ߠA3:(A k= +++ooooooooooߡCnOJ S5r;w_____AAAAAEEEEEEEEEECCCCCC˓f40 0[17o߰a7oGGGGG=ivL0#5DT}C?B#?B#?B#?B#?B#?B#?B'͎i@i !+G-GGGGGGG=GGGGGG4Icai} ?BGGGGGGGIca"mgG#?B#?B#?B#?B#?B#?B#?BoA 1KVBqoG#?B#?B#?B#?B#?B#?B#?vL0KCDk=G#?B#?B#?B#?B#?B#?B#?j'ݎi`"?0~C#GGGGGGGt;aiGß@@|Vq cGGGGGGGt{a)㏬ _>?BGGGGGGG#ݎi`Q?0~C#GGGGGGGt;aiO@@|Vq c?1GGGGGGwO0 #IᏬ _>?BGGGGGGG#ݎi" G#?B#?B#?B#?B#?B#?B#?Bt;ai_ß@@|Vq c?1 cCGGGGGt{o""Y?BGGGGGGG#ݎi`qڵ'V/Uc?B#?B#?B#?B#?B#?B#?BnEA -pc/`C#GGGdO/7/{7H` a@@~VG;_______________'ajG6أC ++++++++++100JO  .q7wߡC;wG?#aG?QfD04ѫm/"؂=GGGGGGGHa l""=G?B#?B#?B#?B#?B#?B#?Bۓf ,""_`?B#?B#?B#?B#?B#?1 cCعt;&a 2DDor~?q#?B#?B#?B#?B#?B#?B#?{a)3+*??GGGGGGGHca?0~C#GGGGGG1z`e~}b?B#?B#?B#?B#?B#?B#O Q|p?B#?B#?B#?B#?B#?B#?B#􏶓n40 @+*??GGGGGGGHca&-g_?B#?B#?B#?B#?B#?B#?Bn40 8MC+*??GGGGGGGHca"*o_??GGGGGGG:vL @S{ f?GGGGGGG>vL0L+CDk=G#?B#?B#?B#?B#?B#?B#?j'`Yy0*"ʞ{#GGGGGGG7aI haY=1cC?GGGGGG=vL0 峊{#GGGGGGG7aQ|p?B#?B#?B#?B#?B#?B#?B#Ic"` aYA@6oC1 cC?1?B#?B#?B#?B#?B'ݎi`Q3?0~C#GGGGGGGt;aiOYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1tplED@ =1cC?1 cC?GGGG1 0R 峊{#GGGGGGGt?a,_"*o_??GGGGGGG:vL 0R9=Mc?B#?B#?B#?B#?1 cC?1w1 0NӞ'V/Uc?B#?B#?B#?B#?B#?B#?Bn40 HMŸXA@|Vq?B#?B#?B#?B#?B#?B#?B#F0sO旟q?B#?B#?B#?B#?B#??_of 4m;2= ++++++++++}100J<f!tWWWWWWWWWW7777777777wfDA-~7v"ZYoooooooooa84;'ɗ~x&`GGGGGG>ivL0 S4 g??:#?B#?B#?B#?B#?B#?B#?ڞ4;$ _ pw7??#?B#?B#?B#?B#?B#?B#?}a)ϭ _>B#GGGGGGGt;@i!5C#GGGGGGGn40 8E{ƟXA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 Hm _>?1 #?B#?B#?B#?B#?B#?B#?=vL0 T4igG#?B#?B#?B#?B#?B#?B#?B~1 0Jr?0~C#GGGGGGGt;ai laY=1cC?GGGGGG=vL0o G#?B#?B#?B#?B#?B#?B#?Bht;aF*YA@|Vq?B#?B#?B#?B#?B#?B#?B#F1tЁDD@ =1cC?1 cGGGGѻO 3Q|p?B#?B#?B#?B#?B#?B#?B#Ib""C#GGGGGGGt;b Rs=vcC?1 cC?1 cGGGG 3E_"*o_??GGGGGGG:vL0U6 峊{#GGGGGGGt?avq3{͛.?BGGGG cC?1 cHcaIϬ _>?BGGGGGGG#ݎi"g} ?BGGGGGGG100JG  7]p?B#?B#?B#?B#?B#?B?1 cvL0 Ԏ?0|b؇=GGGGGGGHca-gG#?B#?B#?B#?B#?B#?B#?Bo1 01JU bfG#?B#?B#?B#?B#?B#?B# civN0LSݺ`?_GGGGGGњO sE2Q|p?B#?B#?B#?B#?B#?B#?B#􏶓n4tͿ1P|p?B#?B#?B#?B#?B#?B#?B#4`b ?1,u {~a?أ5?)uP 0Ӓ?tWWWWWWWWW7777777777w߽OJ1 #5== +++ooooooooooߡC}btt=Ȗ C#?B#?B#?B#?B#?B#?B#?`_"*`߾bGGGGGGޓf4 ,Q{#C#?B#?B#?B#?B#?B#?B#n4;&a|ol""/CC?GGGGGGՓn40 8EjaY=G#?B#?B#?B#?B#?B#?B#?vL0SigG#?B#?B#?B#?B#?B#?B#?Bo100L珬  7]p c?1 cCGGGGGn40 (MƟZA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 <㏬ _>?BGGGGGGG#ݎi`a峊{c?1 cC?1 #?B#?B#?B#?t;@fj4DT߾c?B#?B#?B#?B#?B#?B#?BvaHdaY=G#?B#?B#?B#?B#?B#?B#?vL @R+]S{6+?BGGGG cC?1 cHca?0~C#GGGGGGGt;aFj3+*??GGGGGGGHca gG#?B#?B#?B#?B#?B# cC?v{aI#*aGGGGGGGܓn40 (3+*??GGGGGGGHc` bd ??GGGGGGGC?` e~`/a?B#?B#?B#?B#?B#?B#f?vL0 G#?B#?B#?B#?B#?B#?B#?Bh;vL0 V6 峊{#GGGGGGG7aI{YA@|VqoG#?B#?B#?B#?B#?B#?B#?vL0ӎ)gG#?B#?B#?B#?B#?B#?B#?Bo1 0R;2 峊{#GGGGGGG7U?an{c?B#?B#?B#?B#?B#?B#?Bt;ajŸXA@|Vq?B#?B#?B#?B#?B#?B#?B#G ;Q|p?B#?B#?B#?B#?B#?B#?B#I*a R(ox6`p(Gq(\}o/{7o!`yDD@b+++++++;wߡۓRE0T l""\G;_______________1 0LVE}{ﰿ 7o߰ GGGGGuO Ho o_?Bh??B#?B#?B#?B#?B#?B#?BIcaFBe}=GGGGGGGG7O1 _珬 7a c cC?1 cCGGGGIcaigG#?B#?B#?B#?B#?B#?B#?B~1 0Ny6 峊{#GGGGGGGt?aA@6oC#GGGG1 cC?1#ݎi`qZ[A@|Vq?B#?B#?B#?B#?B#?B#?B#F0 IϬ _>?BGGGGGGG#ݎiQtV6+?BGGGGG cC?wt;aj6bGGGGGGG41 0J;"?0~C#GGGGGGGt;b F.=vc?B#?B#?B#?B#?B#?B#?11 0Q[~aGGGGGG~a_"*o_??GGGGGGGvaHbaY=G#?B#?B#?B#?B#?B#?B#?vP@`pUDwP[?B#?B#?B#?B#?B#?B#?B#F 1Q|p?B#?B#?B#?B#?B#?B#?B#IcaHO _>?BGGGGGGG#ݎi`qg6/UcC?GGGGGGGݞt;aj#+*??GGGGGGGHcaEO _>?BGGGGGGG#ݎi`qG6/UcC?1 cGGGGGݓn40 HmR#+*??GGGGGGGHca+CDk=G#?B#?B#?B#?B#?B#?B#?j'ݎi`a'6/UcC?1 cC?GGGGGݞt;$a fid({+??GGGGGGGHcav-gG#?B#?B#?B#?B#?B#?B#?BoI@AK̲xH_FcC#GGGd' {7H` a@@~VG;_______________'ajG6أC ++++++++++100JO  .q7wߡC;wG?#aG?QfD04ѫm/"؂=GGGGGGGHa l""=G?B#?B#?B#?B#?B#?B#?Bۓf ,""_`?B#?B#?B#?B#?B#?1 cCعt;&a 2DDor~?q#?B#?B#?B#?B#?B#?B#?{a)3+*??GGGGGGGHca?0~C#GGGGGG1z`e~}b?B#?B#?B#?B#?B#?B#O Q|p?B#?B#?B#?B#?B#?B#?B#􏶓n40 @+*??GGGGGGGHca&-g_?B#?B#?B#?B#?B#?B#?Bn40 8MC+*??GGGGGGGHca"*o_??GGGGGGG:vL @S{ f?GGGGGGG>vL0L+CDk=G#?B#?B#?B#?B#?B#?B#?j'`Yy0*"ʞ{#GGGGGGG7aI haY=1cC?GGGGGG=vL0 峊{#GGGGGGG7aQ|p?B#?B#?B#?B#?B#?B#?B#Ic"` aYA@6oC1 cC?1?B#?B#?B#?B#?B'ݎi`Q3?0~C#GGGGGGGt;aiOYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1tplED@ =1cC?1 cC?GGGG1 0R 峊{#GGGGGGGt?a,_"*o_??GGGGGGG:vL 0R9=Mc?B#?B#?B#?B#?1 cC?1w1 0NӞ'V/Uc?B#?B#?B#?B#?B#?B#?Bn40 HMŸXA@|Vq?B#?B#?B#?B#?B#?B#?B#F0sO旟q?B#?B#?B#?B#?B#?0~c4;&`i藯///////____________#Q3+3/////////{4;& B hȺH////////EEEEEEEEECCCCCCCCC?a90 0L㏬ 7a?/7C#?B#?B#?B#?B#?B#?IcaIm _>cGGGGGG!LW@bXaGGGGGGn40 (MnaYŽG#?B#?B#?B#?B#?B#?B#?Bo1 0O;/ G#?B#?B#?B#?B#?B#?B#?Bht;a)3 峊{#GGGGGGG7'޿Cp90C1?B#?B#?B#?B#?B#?B#?By1 0PѤGV/Uc?B#?B#?B#?B#?B#?B#?Bn40 (M5 峊{#GGGGGGG7a5 g? cCGGGGGGt1 0Sÿ5DT߾c?B#?B#?B#?B#?B#?B#?BuahdaY=G#?B#?B#?B#?B#?B#?B#?vP@LAֿ/? cC?1GGGGG>vL0[CDk=G#?B#?B#?B#?B#?B#?B#?j'J`y̿{#GGGGGGG7J mVp c?1 cC?1GGGGvL0i} ?BGGGGGGG1 0V#+*??GGGGGGGHc"` aA@6oC#GGGG1 cC?1#ݎi`q&?0~C#GGGGGGGt;@fd!5C#GGGGGGGnD@ (uكlt=G#?B#?B#?B#?B#?BcC?11 0P; c?GGGGGGG]#ݎi`QڷGV/Uc?B#?B#?B#?B#?B#?B#?Bn4@ (U.=vc?B#?B#?B#?B#?B#?B#?19 0QOCDt`GGGGGGk>vL0CDk=G#?B#?B#?B#?B#?B#?B#?N CDk=G#?B#?B#?B#?B#?B#?B#?j'͎ QݧM#k97mƞe}7/= ++++++++++RE0 8-ICOg_________EEEEEEEEECCCCCCCCCCA 00RSOl ?+أ;w'͎i aJJǟ؃0lٌ=7o??B#?B#?B#?B#?B#?B#?B#͎i@iZ !+G GGGGGGG=ivL0{Ho o_?Bh??B#?B#?B#?B#?B#?B#?BIca7&"=11 cGGGGGQ=vL0SV/Uc?B#?B#?B#?B#?B#?B#?Bn40 8YA@|Vq?B#?B#?B#?B#?B#?B#?B#F1 xy By? cC?1GGGGG>vL0ҤhgG#?B#?B#?B#?B#?B#?B#?Bo1 0N3 峊{#GGGGGGG7am _>?1 cC?1 cC?B#?B#?B#?BIcaKCDk=G#?B#?B#?B#?B#?B#?B#?j'ݎi`GV/Uc?B#?B#?B#?B#?B#?B#?Bn4@ (҅?an{#GGGG?1 cC?t;aiZS+*??GGGGGGGHca?0~C#GGGGGGGt;aFiO@@|Vq?B#?B#?B#?B#?B#?B?1 c'ݎi`?0|b?GGGGGGG=vL0Ү?0~C#GGGGGGGt;b FpA@۬C#GGGGGG1#͎ aڠW/b{#?B#?B#?B#?B#?B#?Bhn4\1Q|p?B#?B#?B#?B#?B#?B#?B#􏶓n40 `eO _>?BGGGGGGG#ݎi`Q'g_?B#?B#?B#?B#?B#?B#?Bn40 8YA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 ##O _>?BGGGGGGG#ݎiqP{6+?1 #?B#?B#?B#?B#?B#?B#?zHca&-gG#?B#?B#?B#?B#?B#?B#?B~1 0Ko G#?B#?B#?B#?B#?B#?B#?Bt;b(h,-ƨos QQ?Gmؗ~c`ba I"a6_أ;wA 0U+/WߡCWWWWWWWWWW777777?BGGGGGGG#ݎiQ jfG#?B#?B#?B#?B#?B#?B# civL0LV2DD@~~_`GGGGGGt;@j ׀{#GGGGGGGt;a*ƟXA@|Vq?B#?B#?B#?B#?B#?B#?B#F04i/_?B#?B#?B#?B#?B#?B#?Bn4ivL!L""-GGGGGGG4;(p0&"/4#?B#?B#?B#?B#?B#?B#?=ivL0!" G=#?B#?B#?B#?B#?BcC?1Ic"b+CD-W?B#?B#?B#?B#?B#?B#?B'ݎi`Q?0~C#GGGGGGGt;aFiJs*??GGGGGGGCǮ'͎ aW/؇`_/{#?B#?B#?B#?B#?B#?B1 0QK/ G#?B#?B#?B#?B#?B#?B#?Bh;vL0 T?0~C#GGGGGGGt;aFi[A@|VqoG#?B#?B#?B#?B#?B#?B#?vL0?0~C#GGGGGGGt;@fj!5C#GGGGGGGn4@ 8U mVp cGGGGGGGn4T-2DT߾c?B#?B#?B#?B#?B#?B#?Bvo""Y?BGGGGGGG#ݎi`q6/UcC?1 cGGGGGݓn40 Hm _>?BGGGGGGG#ݎiZ G#?B#?B#?B#?B#?B#?B#?Bht;&bKd ? C?1 cC#?B#?B#?B#?B#}a=S3+*??GGGGGGGHcadgG#?B#?B#?B#?B#?B#?B#?BoA @1MVD7PcC?1 cC?1 cGGGG0 #5MᏬ _>?BGGGGGGG#ݎib!5C#GGGGGGGnD@ (ß؃lt=G#?B#?B#?B#?BcC?1 cCG0 4 baY=G#?B#?B#?B#?B#?B#?B#?vL0Ԥ)gG#?B#?B#?B#?B#?B#?B#?BoA AK@ozXo'?BGGGGG|' 1 0M ?BGGGGGGG#ݎi`qZ@@|Vq c?1GGGGGGwO 35[CDk=G#?B#?B#?B#?B#?B#?B#?Z'ݎi`GV/Uc?B#?B#?B#?B#?B#?B#?Bn%A 4t`+;Bq c?1 cCGGGGGn4,̿5DT߾c?B#?B#?B#?B#?B#?B#?Bv+~?BGGGGGGG#ݎiahf? cC?1 cCGGGGn4L ׀{#GGGGGGGN0 c?0~C#GGGGGGGݏt;&bF]d ??GGGGGC?1 cC;aiR3+*??GGGGGGGHcax>c?BGGGGGGd100JG  7]p?B#?B#?B#?B#?B#?B?1 cvL0 Ԏ?0|b؇=GGGGGGGHca-gG#?B#?B#?B#?B#?B#?B#?Bo1 01JU bfG#?B#?B#?B#?B#?B#?B# civN0LSݺ`?_GGGGGGњO sE2Q|p?B#?B#?B#?B#?B#?B#?B#􏶓n4l1Q|p?B#?B#?B#?B#?B#?B#?B#Ica armRM'g`_ͺA0 0NKRB{W_________ߡC>)uP 0 //////CIc` aҡ' [6c 7#?B#?B#?B#?B#?B#?B#?zHcaBe}=GGGGGGGG{O CDW??Z#?B#?B#?B#?B#?B#?B#?yAͿ>` c cCGGGGGGTO0 mgG#?B#?B#?B#?B#?B#?B#?Bo1 0N9GV/Uc?B#?B#?B#?B#?B#?B#?BnD@ 05^?lt=1cC?1 cGGGGѻO0 4)jaY=G#?B#?B#?B#?B#?B#?B#?vL0?0~C#GGGGGGGt;aijc*? C?1 cC?1?B#?B#?B#?BzaQ|p?B#?B#?B#?B#?B#?B#?B#Ica"mgG#?B#?B#?B#?B#?B#?B#?B~1 01JtOA@۬C#GGGG1 cC?1#ݎi`q 峊{#GGGGGGG7aEϬ _>?BGGGGGGG#ݎi`Qړ6/Uc?B#?B#?B#?B#?B#?1 cCIca&el _?/=GGGGGGGsO0 +Ϭ _>?BGGGGGGG#ݎiQ:\3{6+?BGGGGGG c{Hc@a6(!" b؇C#?B#?B#?B#?B#?B#?1 0W̿3DT߾c?B#?B#?B#?B#?B#?B#?B1 0X+*??GGGGGGGHca& daYŽG#?B#?B#?B#?B#?B#?B#?Bo1 0N;GV/Uc?B#?B#?B#?B#?B#?B#?Bn40 H+*??GGGGGGGHc` b:T9d ? C#?B#?B#?B#?B#?B#?B#?aI baY=G#?B#?B#?B#?B#?B#?B#?vL0CDk=G#?B#?B#?B#?B#?B#?B#?j' Z"KĿa=Q?z~_?ؿo?__________ߠA3:(A k= +++ooooooooooߡCnOJ S5r;w_____AAAAAEEEEEEEEEECCCCCC˓f40 0[17o߰a7oGGGGG=ivL0#5DT}C?B#?B#?B#?B#?B#?B#?B'͎i@i !+G-GGGGGGG=GGGGGG4Icai} ?BGGGGGGGIca"mgG#?B#?B#?B#?B#?B#?B#?BoA 1KVBqoG#?B#?B#?B#?B#?B#?B#?vL0KCDk=G#?B#?B#?B#?B#?B#?B#?j'ݎi`"?0~C#GGGGGGGt;aiGß@@|Vq cGGGGGGGt{a)㏬ _>?BGGGGGGG#ݎi`Q?0~C#GGGGGGGt;aiO@@|Vq c?1GGGGGGwO0 #IᏬ _>?BGGGGGGG#ݎi" G#?B#?B#?B#?B#?B#?B#?Bt;ai_ß@@|Vq c?1 cCGGGGGt{o""Y?BGGGGGGG#ݎi`qڵ'V/Uc?B#?B#?B#?B#?B#?B#?Bn'EA-1rcR@?BGGG ~a op쏔:bj g{wߡCAAAA }Ra&d!=;w///////O1 Toy BoooooooooC;wߡC#aG?#>ivL!L""-GGGGGGG4;(p0&"/4#?B#?B#?B#?B#?B#?B#?=ivL0!" G=#?B#?B#?B#?B#?BcC?1Ic"b+CD-W?B#?B#?B#?B#?B#?B#?B'ݎi`Q?0~C#GGGGGGGt;A mP?1 cC?B#?B#?B#?B#?B#?B'ݎi`ZA@|Vq?B#?B#?B#?B#?B#?B#?B#F s_"*o_??GGGGGGG:vL 0 S#+McC?1 cC?GGGGG1 0J{gV/Uc?B#?B#?B#?B#?B#?B#?Bn40 8#+*??GGGGGGGH b:o~?1 cC?1 cC?B#?B#?B#?Bt;aFjYA@|Vq?B#?B#?B#?B#?B#?B#?B#G +CDk=G#?B#?B#?B#?B#?B#?B#?Z'ݎQj7?!ټ{#GGGG?1 cC?t;ai 峊{#GGGGGGG7aIS+*??GGGGGGGHBo0ߤ?BGGGGGa`ivL0LӶ+/_?_______ПߣGJ1 !gVMg_________AEEEEEEEEEECCCCCCCCCC>ivL@@'c'u _________qHs"`a|YA7o~_o=GGGGGG4f40 0E@@|C?B#?B#?B#?B#?B#?B#?BICawwC?B#?B#?B#?B#?B#?B#?B'ݎi`Q2 峊{/?GGGGGGGHcav_"*o_??GGGGGGG:vL0SggG#?B#?B#?B#?B#?B#?B#?Bo1 0N4峊{c?B#?B#?B#?B#?B#?B#?Bݓn40 @EYA@|Vq?B#?B#?B#?B#?B#?B#?B#G0 4)+*??GGGGGGGHca6/UcC?1 cGGGGGݓn4L Q|p?B#?B#?B#?B#?B#?B#?B#IcaigG#?B#?B#?B#?B#?B#?B#?BoA @1MXND7PcC?1 cC?GGGGG1 0K?BGGGGGGG#ݎQj?!ټ{#GGGG?1 cC?t;ai 峊{#GGGGGGG7a)w ׀{#GGGGGGGN1 ԩdByG#?B#?B#?B#?B#?B# cC?n40 @X#+*}GGGGGGGtt;aFiYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1Tu' mVp?B#?B#?B#?B#?B#?B#?B?f@Dq7?GCCCCCCCCCC_/ B߹A0 0NKRB{W_________ߡC>)uP 0 //////CIc` aҡ' [6c 7#?B#?B#?B#?B#?B#?B#?zHcaBe}=GGGGGGGG{O CDW??Z#?B#?B#?B#?B#?B#?B#?yaͿ+/ ;cC?1 #?B#?B#?B#?B#?B#?t;a)S+*??GGGGGGGHcarL㏬ _>?BGGGGGGG#ݎaj<d!ټ{c?1 cC?B#?B#?B#?B#?Bwt;aFiR4 峊{#GGGGGGG7adaY=G#?B#?B#?B#?B#?B#?B#?vL0 6/UcC?1 cC?1 cGGG1 0S !5C#GGGGGGGn40 HE#+*??GGGGGGGHc` bZŸڃ0lY=G#?B#?B#?B#?BcC?1 cCG0 4-gG#?B#?B#?B#?B#?B#?B#?Bo1 0RƟYA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 'm _>?BGGGGG cC?ۓn40 @M@@~V_{?B#?B#?B#?B#?B#?B#?B#t;aFiWƟYA@|Vq?B#?B#?B#?B#?B#?B#?B#F1Tug mVp?B#?B#?B#?B#?B#?B#?B?f0DmP+CD`=GGGGGG4Icag} ?BGGGGGGGIca'V/Uc?B#?B#?B#?B#?B#?B#?Bn40 (M 峊{/?GGGGGGGHcavLᏬ _>?BGGGGGGG#ݎi`ڑ'V/Uc?B#?B#?B#?B#?B#?B#?Bn4@ 8ur=vcC?GGGGGGG1 0T 峊{#GGGGGGGt?a%7 ׀{#GGGGGGGN 1C9QQ?GmX 7sH"a6_أ;wA 0U+/WߡCWWWWWWWWWW777777?BGGGGGGG#ݎiQ jfG#?B#?B#?B#?B#?B#?B# civL0LV2DD@~~_`GGGGGGt;@j ׀{#GGGGGGGt;a*ƟXA@|Vq?B#?B#?B#?B#?B#?B#?B#F04i/_?B#?B#?B#?B#?B#?B#?Bn4ivL!L""-GGGGGGG4;(p0&"/4#?B#?B#?B#?B#?B#?B#?=ivL0!" G=#?B#?B#?B#?B#?BcC?1Ic"b+CD-W?B#?B#?B#?B#?B#?B#?B'ݎi`Q?0~C#GGGGGGGt;aFiJs*??GGGGGGGCǮ'͎ aW/؇`_/{#?B#?B#?B#?B#?B#?B1 0QK/ G#?B#?B#?B#?B#?B#?B#?Bh;vL0 T?0~C#GGGGGGGt;aFi[A@|VqoG#?B#?B#?B#?B#?B#?B#?vL0?0~C#GGGGGGGt;@fj!5C#GGGGGGGn4@ 8U mVp cGGGGGGGn4T-2DT߾c?B#?B#?B#?B#?B#?B#?Bvo""Y?BGGGGGGG#ݎi`q6/UcC?1 cGGGGGݓn40 Hm _>?BGGGGGGG#ݎiZ G#?B#?B#?B#?B#?B#?B#?Bht;&bKd ? C?1 cC#?B#?B#?B#?B#}a=S3+*??GGGGGGGHcadgG#?B#?B#?B#?B#?B#?B#?BoA @1MVD7PcC?1 cC?1 cGGGG0 #5MᏬ _>?BGGGGGGG#ݎib!5C#GGGGGGGnD@ (ß؃lt=G#?B#?B#?B#?BcC?1 cCG0 4 baY=G#?B#?B#?B#?B#?B#?B#?vL0Ԥ)gG#?B#?B#?B#?B#?B#?B#?BoA !AK$xoRq?B#?B#?B#?B#?B#?0x~aac?4;&`i藯///////____________#Q3+3/////////{4;& B hȺH////////EEEEEEEEECCCCCCCCC?a90 0L㏬ 7a?/7C#?B#?B#?B#?B#?B#?IcaIm _>cGGGGGG!LW@bXaGGGGGGn40 (MnaYŽG#?B#?B#?B#?B#?B#?B#?Bo1 0O;/ G#?B#?B#?B#?B#?B#?B#?Bht;a)3 峊{#GGGGGGG7aFhaY=1cGGGGGGIcaI㏬ _>?BGGGGGGG#ݎi`QkgG#?B#?B#?B#?B#?B#?B#?Bo1 0Nkc*? C?1?B#?B#?B#?B#?B#?BIcak} ?BGGGGGGG1 0R4 峊{#GGGGGGG7 e'"_(? C?1 cC#?B#?B#?B#?B#}a*??GGGGGGG9+~?BGGGGGGG#ݎiahf? cC?1 cCGGGGn4L ׀{#GGGGGGGN0 c?0~C#GGGGGGGݏt;&bF]d ??GGGGGC?1 cC;aiR3+*??GGGGGGGHcaH"*o_??GGGGGGGQ;vL 0R:=Mc?B#?B#?B#?B#?B#?1 cCG0 cᏬ _??aGGGGGGG5a} daY=G#?B#?B#?B#?B#?B#?B#?vL @RŸ؃0lY=G#?B#?B#?B#?B#?B#?BcCG Կ1DD@n~a?o=GGGGGGn4\̿1DT߾c?B#?B#?B#?B#?B#?B#?B1 0[̿1DT߾c?B#?B#?B#?B#?B#?B#?Bv`b}?xf^?>~cأY)uP 0Ӓ?tWWWWWWWWW7777777777w߽OJ1 #5== +++ooooooooooߡC}btt=Ȗ C#?B#?B#?B#?B#?B#?B#?`_"*`߾bGGGGGGޓf4 ,Q{#C#?B#?B#?B#?B#?B#?B#n4;&a|ol""/CC?GGGGGGՓn40 8EjaY=G#?B#?B#?B#?B#?B#?B#?vL0SigG#?B#?B#?B#?B#?B#?B#?Bo100L珬  7]p c?1 cCGGGGGn40 (MƟZA@|Vq?B#?B#?B#?B#?B#?B#?B#F0 <㏬ _>?BGGGGGGG#ݎi`a峊{c?1 cC?1 #?B#?B#?B#?t;@fj4DT߾c?B#?B#?B#?B#?B#?B#?BvaHdaY=G#?B#?B#?B#?B#?B#?B#?vL @R+]S{6+?BGGGG cC?1 cHca?0~C#GGGGGGGt;aFj3+*??GGGGGGGHca gG#?B#?B#?B#?B#?B# cC?v{aI#*aGGGGGGGܓn40 (3+*??GGGGGGGHc` bd ??GGGGGGGC?` e~`/a?B#?B#?B#?B#?B#?B#f?vL0 G#?B#?B#?B#?B#?B#?B#?Bh;vL0 V6 峊{#GGGGGGG7aI{YA@|VqoG#?B#?B#?B#?B#?B#?B#?vL0ӎ)gG#?B#?B#?B#?B#?B#?B#?Bo1 0R;2 峊{#GGGGGGG7U?an{c?B#?B#?B#?B#?B#?B#?Bt;ajŸXA@|Vq?B#?B#?B#?B#?B#?B#?B#G ;Q|p?B#?B#?B#?B#?B#?B#?B#I*a R(ox6`p(Gq(}~_?ؿo?__________ߠA3:(A k= +++ooooooooooߡCnOJ S5r;w_____AAAAAEEEEEEEEEECCCCCC˓f40 0[17o߰a7oGGGGG=ivL0#5DT}C?B#?B#?B#?B#?B#?B#?B'͎i@i !+G-GGGGGGG=GGGGGG4E~ RÔS ?L)0pÔS ?L)0pÔxL|r~NNjrIf~DF?%?713ą eϝYdemo/documented/bcs/common.txt000066400000000000000000000045421412460263600167420ustar00rootroot00000000000000This demo illustrates how to: * Use meshes with boundary indicators * Solve the Poisson equation with Dirichlet boundary values The solution for :math:`u` in this demo will look as follows: .. image:: ../demo_bcs.png :scale: 75 % Equation and the problem definition ----------------------------------- We will use the Poisson equation as a model problem when we demonstrate how to set boundary conditions for an imported mesh that includes boundary indicators. The Poisson equation is the canonical elliptic partial differential equation. For a domain :math:`\Omega \subset \mathbb{R}^3` with boundary :math:`\partial \Omega = \cup_{i = 0}^3 \Gamma_{D, i}`, the Poisson equation with particular boundary conditions reads: .. math:: - \nabla^{2} u &= f \quad {\rm in} \ \Omega, \\ u &= u_0 \quad {\rm on} \ \Gamma_{D, 0}, \\ u &= u_1 \quad {\rm on} \ \Gamma_{D, 1}, \\ u &= u_2 \quad {\rm on} \ \Gamma_{D, 2}, \\ u &= u_3 \quad {\rm on} \ \Gamma_{D, 3}. \\ Here, :math:`f` is some given input data and :math:`u_0`, :math:`u_1`, :math:`u_2` and :math:`u_3` are the prescribed values of :math:`u` at the boundaries. The variational form of the Poisson equation reads: find :math:`u \in V` such that .. math:: a(u, v) = L(v) \quad \forall \ v \in V, where :math:`V` is a suitable function space and .. math:: a(u, v) &= \int_{\Omega} \nabla u \cdot \nabla v \, {\rm d} x, \\ L(v) &= \int_{\Omega} f v \, {\rm d} x. The expression :math:`a(u, v)` is the bilinear form and :math:`L(v)` is the linear form. It is assumed that all functions in :math:`V` satisfy the Dirichlet boundary conditions. In this demo we shall consider the domain :math:`\Omega` to be a model of blood vessels with an aneurysm. It has one inlet vessel and two outlet vessels. We define noslip boundary conditions on the walls of the vessels and aneurysm, that is :math:`u = u_0 = 0.0`. We let :math:`u = u_1 = 1.0` be the Dirichlet condition on the inlet, the outlets will have the prescribed values :math:`u = u_2 = 2.0` and :math:`u = u_3 = 3.0`. In summary, we have: * :math:`u = u_0 = 0.0 \text{ on } \Gamma_{D, 0}` (noslip boundary) * :math:`u = u_1 = 1.0 \text{ on } \Gamma_{D, 1}` (inlet) * :math:`u = u_2 = 2.0 \text{ on } \Gamma_{D, 2}` (outlet 1) * :math:`u = u_3 = 3.0 \text{ on } \Gamma_{D, 3}` (outlet 2) * :math:`f = 0.0` (source term) demo/documented/bcs/cpp/000077500000000000000000000000001412460263600154665ustar00rootroot00000000000000demo/documented/bcs/cpp/Poisson.ufl000066400000000000000000000020551412460263600176320ustar00rootroot00000000000000# Copyright (C) 2008 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2008-05-23 # Last changed: 2011-03-09 # # The bilinear form a(u, v) and linear form L(v) for # Poisson's equation. # # Compile these forms with FFC: ffc -l dolfin Poisson.ufl element = FiniteElement("Lagrange", tetrahedron, 1) v = TestFunction(element) u = TrialFunction(element) f = Coefficient(element) a = dot(grad(u), grad(v))*dx L = f*v*dx demo/documented/bcs/cpp/documentation.rst000066400000000000000000000003201412460263600210640ustar00rootroot00000000000000.. Documentation for the bcs demo from DOLFIN. .. _demo_pde_bcs_cpp_documentation: There is as yet no documentation for the C++ version of this demo. Please consider contributing the missing documentation. demo/documented/bcs/cpp/main.cpp000066400000000000000000000041151412460263600171170ustar00rootroot00000000000000// Copyright (C) 2008 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2008-05-23 // Last changed: 2012-07-05 // // This demo illustrates how to set boundary conditions for meshes // that include boundary indicators. The mesh used in this demo was // generated with VMTK (http://www.vmtk.org/). #include #include "Poisson.h" using namespace dolfin; int main() { // Create mesh and finite element auto mesh = std::make_shared("../aneurysm.xml.gz"); // Define variational problem auto f = std::make_shared(0.0); auto V = std::make_shared(mesh); Poisson::BilinearForm a(V, V); Poisson::LinearForm L(V); L.f = f; // Define boundary condition values auto u0 = std::make_shared(0.0); auto u1 = std::make_shared(1.0); auto u2 = std::make_shared(2.0); auto u3 = std::make_shared(3.0); // Define boundary conditions DirichletBC bc0(V, u0, 0); DirichletBC bc1(V, u1, 1); DirichletBC bc2(V, u2, 2); DirichletBC bc3(V, u3, 3); std::vector bcs{{&bc0, &bc1, &bc2, &bc3}}; // Set PETSc MUMPS paramter (this is required to prevent a memory // error in some cases when using MUMPS LU solver). #ifdef HAS_PETSC PETScOptions::set("mat_mumps_icntl_14", 40.0); #endif // Compute solution Function u(V); solve(a == L, u, bcs); // Write solution to file File file("u.pvd"); file << u; return 0; } demo/documented/bcs/demo_bcs.png000066400000000000000000001725441412460263600172020ustar00rootroot00000000000000PNG  IHDR IDATxyW}7UӳiX%riFm9dÇxlއx[Ӄ,HĉJH _cG=#[ec Y֮Y{Y4t|?g\]U]]m̷{Zh }DDDDDDD0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK0- DDDDDD$0ђLDDDDDDK7@DDD4oڷcx7~o 0-_/vj{azd}鯾O|vW򿯸t5`"""jy_~ht-c &"Z}GCǧ=rG7jvh`"cU|w &+JcBb&Oܵߟ+hI2HDDDԒ6}ٶ3t5R ˜ytI=n=EwHDD͆-DDDzCVV.[{W:Nwg: 0"p  &"Z MDDD-fUw +Lu;q3]r)#UՁ7@Qx͝^RV[Ѱr)R)yt+ۡ7@Qkx ;')ctgƼLX}u^&"& 0n = ̺vP-R6t}/k_혷['"LDDDn`۷A;LZٖ-ڕBCLTIb;4Im..|BBj!4B* ũn`&"ZdMDDDh`ATӯ/ٶ\h|iݹlu`"""j:'w6l3 jB˅RTh/KBVs'vϣ[o5`"""j.';|mŪJ-˓r![2l_i-ڿh`"""j"5@[ïk!`utv.8tHӅ6V^qvݾrpL̍ڿGr<0QKc&""ߩ_`\i{˷V{DGJ1*vmD N'9'Qc&""k]e0RiUc4 aԮ4H[$)ѓZGo:g\~ }-uO" ƅ$DLΆY[XHӑA5 Vf$^HwR 8>~d`&"jEBӯ<J,렎 P kZg ҌFh!-"XXJHuXG'sKD1T=U3ytR*CUj#k6J/kGY[V)wi+钓.v2< 0PwPT+Dt^WFU)š<_n8V$d]wNyED1&*:x8etRp 6LõK+K6\-K;Lle9RHG2*ѢVt%7]t2ERB1/9HQ3zaA3 #27XwζU,xmQ "۷?KD1$WM9mpGfGpё1FvY9=Y Mj1*~u_)9em,GYΔT$r2^ 깅A~˧I@$)'O*C'4@6SPO0}o/42- DD-*St2p NJHmȶ=唕itHJz({j 5?+eZ42 ,'6ߕkC)P~=aV"p{0XOBBd!WAOBj/t9Kg ""ZD+ QKpQn)N eؖˮە-ЖtBh0amL5J#Ѳp\e3e7SVE'St2EFur !?ƫ> ҆u.h+Zkү}co. #p۷{E[ "Ee c鶌 n7l[ҶdyʱmmL5lH Y+hm(-F Pۮe붲)Ng݊JK~W楰.vR"¿vՄA޽'e!p~ y}W1/RLD҅rٲUS.=1kǔ! 0R+2#-8:YrptV(uMU'-q9N+w=cc4O] ucwy+Erq/!'~vS2ܦ?f3LD\^lݝ2 eؖcU2!\S*!}+1Xt6 @JP5 /UҀXV fr%RȵP٢ zn)@뎆=Y-:5 }4fɋt~2`"Է"KȢX6,9SҶd"ce RB"( "2Vz0joY+tCXڷoE[`4d7٪hbm2Db I`*@!Q_l{&"ZZuƫlf;rJZrnJSJG_ ۆmF}b\-v.M4Y|/{{K`#01GA+#EFcpelp$}Gu'"Ŏ BX&`u\.NJ7NZFF}C)!Wڎ*ٺv rswqmmP[HtƐ~3yA;Zݸsjj͌a>ho-DD.+WɌJn{Ihbd~Rm@\c^jcʿ߈nI,ZlCIZxId p~HAxzGz/-1 += \%2gh@{397αn8 b7?Y ko}5?@v4]\{ } ԈۿQS>x]5uVi.Ov>?ZDb7&kBdcʿޡjtү"J8z->ADDT%^U_nDAr֣ү-aYyZYL j;k`6ihpV߀.~41jǯ/RDDu5V3g u\bm_`5R;^_ bKv_ rypH%w:~ֶFcУPÐ υXw@߆ ~VZO WAtFV>lB.[ KY>5-E!$-mAs5OoݣT*z26 PGVAOBauKӾA""ZZ\?담qк\9Td` & CZwѪQΨ?`N '"@{PvoFBDDh"&zmm=d0R:ZO"_M-(wӵ?o{90'WMu3B[Ga۷O3DD1-^ #boOu91a;E%_Q Zd*krG`= )6-mX#"jY' 5* 04VMANz" 7]uto\5}9wO`LoB)_|8UM@U>DFз0t9rGz`n21-:8D6(yUyI= Jpm"Ҏ:0GXoI59ˠ~pt$aB|#!:Jnd'|&"Ya&"jI/[چW;'A-#,.FWP@A_2o>-0o3ZDPJd[}j(Wʿ _""#""jMBsVrx'PnxATO@ 爞|7OM&Za }tR~{F}㗂S}^;gZXTVU@ܼDlX=Bw] F`t-Эho; 0ttge# !Z`yd>}53f闈N0QkE 8AHpΩ/׷+T"F5_O zԄT_M#0 &vFWՂ}U v5FuSĥ_?_m5LDԒCA 0 5dl!7T-V)DRMe‚6;"z,qXjbon?Ae 2Ř OCIt'\uOpm5LDԚ*+ <˯ IDATFf W$7BD gSq_ m'96`CX@:;ԇ3Б9ܟoIhZVMjEN%Y78FT z"~@X}2Cq^/տb"uϕ[}n0K mѡ„V~闈N=`"֓]KCVsHi?q`T'~ ~:xe@XCu x\--#H)̋Fj'Bۡ \3XOBOWj& ] I~{z83/#`"A _%b<Xs=Ytup& -s#Qmbe @.*%"e^mCMb" a/Bk=뿵i^h6Z`}.WC/@b`Jd7N l@.9 #X֭]Y9tRݎh?ѷn:wH?nffY'a+bI z47:6kz l},?BdWFxd O˿I:;KDD0Q+,0 v.PQN&Uu a_jDY?-_O,ʿЀ her3ʄ:' WG`hm#_"":EB͞YCujf3 X8+y6 l}l3D&A@ctE" ҟ_ T)PG!πX"u˙~ae, ϞTXuc2cgU_ڄ6^asP `6,tT3u7=}ŸhM WVA׽>uc˷0Q]ddi|W8qM"8eD˿i~="0U͙i4xQuDtWY^v^# (_"":Z?;0(~=g2Um؂hz1/zD*y膰fJ]@-NK,݀یEDDtZ\=?&]oT+=]05ѿi`|\"R@,^CvA'F_]WRv,tps>w,^hNZ$2@ ʥ„\ ]W螾 @,rf)z7M@UXO%Q"r #:~1"t97MFN0QFgD0av]#ЅVѠ-J45ɟ:ӡ2p ?EDtR  ә~tc&"jAX@TB΀0F R~aIof{tD˿$'Nsi%HC: čV CC1𓰶_#P}1LDԊB.ʆ.$ZG꽵 9*E<}t ʿ=#Vr5 7LtU}0_<(˶oo1O#xF~uBG`˨ K#[)!D:YI @4~z'p0dУp_,CDD4Z<_S :ZmօЃpu8Zd!s}:)D[mle$ z"3Γpf= g\N?`"$: ]JAtl7 -ͺ E_OƫhTtx2~7 i1%qO u:IS*wS`"38c bpB5zN'})\_jJwx$ubuݹ`XtFTo ) *7m3}'DDD*v\57Y; @vA,X3ҹiROsW9TnNWӫŭKPǠצ hC(Cm.(g!V0beQ) D[=(B'WE簠̛y7pOzgȌ,eتop5XӺ zre_[~ha1-w? 66=H)XːO.`Ǘ p_? oFhqR[nPVyjꕹHAD; '"GA :z߲r}""LD)j8‚HCv[X?S@"~Q$-HSa hRA@ajm9\dv@zQ3`&"j5r9<0jsm'. KZOC dROFw-^ zgC^ӟw?rw_[fN`"|UKE`V&a@ l`ܗ~X+u7Lu'>VMKDDM@D Y^`f(uu#~8١LR$ޭ9үǟQ|Y~/$r~DD<Zḧ_DOAGGdmQZh4rw/J΍o)XzvoPf_""j6LD2 "S]S \~ΆS >I1A'q4r37cDJUУ22g\ = = =U~EHCd6\4BDDt0Г b3mУ[8ǁ3/͆i~3'kk&8Y%@<C G0"h"Y&#WBpfN VZ *Q?xDv:8q: ٰ*-VuVY)o1ᢧZ%kIѱ$OWcP,Qb >(X-{ @N Gō&I)~7RV \ID79P_m}:==c+qt1Z쭜f2r~Eϋց°0gn; =U}Q~KU(B4pD[8˿DDԴX&"j-?CjhiCqe^?pf h wbBXpG'/tIA]5Qjep@KDDM`"V#Гj[W武_]Jsŧjӯ: 0/h75?S`BdS].OOAKDD͌^nXu*58k:ZaXtE{_[6h4*H^^M}ħ߲~s>6&nll~#Gtttwyz׻~w~ .8xĉ~vС'Nq֭{_ꫯNR u5j*Bk=YDD6z;D; "WC`ҏǺP" H{^ >'uyod|3 ߈_J,Uj?;!yp]?PcOy,{SԱc1DTorRH̉-[|K_y/_iӦӾ^ΈZG] ",_Ƨ @PG" ^Mued+?/۽ L{&^BE/h@"BR @}Ѣrw^wu@\޼yu]7_E~.? 8qħ>m/i5'`"V1.3GXh'~e -WHd46+ "3n-K =󽡎8MtVODσ>xM7y===[n޻w??5m۶_ɿ޽{7nXIk֬K/455/رo<쳽暑p5jZl&"j%"u9䙐 VmB@Lx=ѧ:}<&Pq?۩PD{n'7}j H(+ WdWuAWHCl詄+!(=ǟM)v=BD]ts=ଳڹs>arrmtuuXnq+J˿?>7pÖ-[ަ6o|w*=æiQ3cu3&*E|at|:}1+s M"HAPlo#~۽r+"p}y-[j/l6WWgu?Pɫ{ؼ m֭w}08WfLD2@ :XX'D*'=0&uVWJ`]}Quxsn0G6.뮻.~?<ײm_|OooT߫Qc&"j!&Pf}$ulGO eWr\Ho ˂G 4?t-Po%aw?Yz闈<;w6.-\rSO|G"yϺW\ >)59`"18D]V MU{TMiy |~sX]<:@Ejw%>p;p~=F5q8nUjpk_Zo˜s388m=io鐜xSt5jr]Hզ_ 엋H)@֥_ÒD_g|.oNB @+)ӛ1^)c@; ph]LD(of>\q ά^˪~ƞ|Iocz3Ϝ-?I{Lvf&"j-6`zzHC/=ԍEDGk, 'w!uNȯLmC$Tu(୪UG_hL{hq3 Lάt>^z/WmsΙ+]0QKc8h/X= `#"'%mWcv2tby8ʨ-~K4 `P&4>P܍/p<~:cp_ M7=̟|: ˗/+V0W&LD2?=o =P7Cdi4+ގY:Y`m˴_ g918߯>="Zm|9_8WH6j>W&IZqP;f.AfH<$˿R۽\Ӡ.DLhQ&ZM ~գ ГLD37>>Ouk|rQ3'f2+ըɱLD2C?u%r3Y.HHQ[L?W߅!RH$`j=SХP|X :&]p wFhiX,ݻw݅t_*7q2`Uhkը91LQ K@Odgߤ : Kgv4,o`*Z%x%`@C =+<Vo$+KOODy뮚Bo}[W^y[ZQRUlΊ꺡/[O+_Y]#-08<+XԐcү$>]@߭O}!Jkm6 0QkFhyJ\:K-[W$@&&އLYn60*@7Bȏu=LtCyD% !m~`;qU- wEDW\qĉǏ?~|߾}޽{>'ҩ%:Fio`"֔8I3=gVyd>6W;󡶞kºO. V/'EcvfCзݻwݻw_veޞz_-A DD-B!LtuA5{ i4D"8Xӿ5] .M0wAs}[=_]+YAdL⨨Jׅ>N~FDs~KIlbuJ DD!noj a``  `TK~q뺦8z鼥S. h\[ōkeõ D ~]gDt2/>vC=CK 0Q -BՆxt9R ?jQW6}lLk5W7sl c7@,cM9_":i^z5\m=1юJsF /K<<+\'D۞;#~' 3z: \wus=w2יmu߱5'`"VPSwf{L;N@nxL_ijJDк 5^φ%AD4O^xOp o^&"jB.&pD_x/ϰMKBp_͊ 4\O̩Vgf'jF]A^CC;ʭ:De#XjX}~-[xwu }_m:th/ձ?16a&"j/[zϽbE.0Jty5`kx^rd䇞g᩹U,M[n% ?S滪m@D;$y.C @H)~ogakqΚ5k;_-<<+VTn59Zg!R`Sw؆.@vJ@rugMu_yzKuN3[=? H .W¸rUp<H?@> `ߕ=}WSzۧߕ<mИqvmHiho@oX^şY|g"wV{ޙ<|gE/ݻwػw f={x}kOըɱFND D'PvBeODpfBҴ? 09}^?û3C?6ʕ+aGam_r57B& 9 "u>7oyh,VD%@V1Ԥ*zz &XWno?뇨6~W~e/ZylWQ/St5jr DD-«VOGBAFW GO@d+Yt}7 WZk= '>F>˵GܖE7[% K:e Bp{t23h0@o~1KD ^{6[ IDATOO###s=UW]5꫽~ _w~FME?WOFM3PS_^/J8+E7j ]Cv6Oڳ/mKC/) d Vüe0/\5M!W2pݼ_ EkCsHm4J")W 3 Ҁ} Pju}k%#Q(/N{>裏hooߝt? /099~vR +.St5jr DDC :j炎VEipաi,~>@Xb|Tiw~&X viJy_k` knWwlsĥ_O}-V׏OAHC&D" u:05t嗿[n+|C~Qnn뮯}kΝ;\=W&LD%: ].BoGHEnj j?V'CNy`?l:D0Ó{SM m |3Ka:ڈ :Cd`==Ϭo5M3Ggqq"Zb{k׿^9l׮]W^y}7|_Cooz۟'nwk֬'?yJFL~kQSx;9ZeA)/A ^Nq@R(j_@VSuO @q.M6D]Fs,xaۯ?ª,6< ؀PnhZۿJ]r%Gs9gjjj{]wT*#\y .(|R`_x]Zv>__?VZ5<<|>ww{fCCC_B^mZNS``" >R0"YAXuCτ'2jXӹdP]0/lcRx1X$ްi3(qPc?tS߆74:tkz7SqXX^sB 7C}7 cG5__toV.M^@Ù*y7ֽ3 é2!_@@5u&VGWԖ}}֙W+]}6a1P T5s?n@?> #Q ºB jgvA,l8t0W2v(h~U^ww36PXg]m]`pQStrkww6amoSj>-p`AAXAXISgNA>rҷdI`O&rwٹo\v{Qu'85juX}t#o#EީR #Ex6Y}ssw ūH' ^Ft_p~$?  AX+^Dq>p\7}O9 ޯ#z0y355.7Ip&@ZAQP/N rkDmHs^y/0ꒁ}\yp aF1K^qٿ囿}WlF ̑tO '~G}n~+}~-@`AUk+ Pj>YpIAԏc5jg9L&Q_mCkۿ,a:ddZ5V.%؆Jk{V~ m=R[Gt3% Z'$ bm5n  X-V\':ݶk'o,-TMM-\rYp7mLu?pDN~j4>[:ܕnۨ쭽ٹ[+ӀfD5NK}J/xmpf>m+\  vD jf d1NƯs[Q쪼RN{1'R]{#lHXdQ!,;w k5-O+eqb3aU4pptL}p/k? T-%mV'QЕ@FƄPux D F3͘E{V'}Kl[sLg>|}c7zqU "BS]"WfSu@^p+,&fau T3~}V/7y?['f~ؿ ºD Ɯ,ا _T=*D0ɻ8ڿ U˖_.Zj`;jtt+ZPMwAS7!eoLpƾkdڞ9Ch`y8׀Ao`'ѕVA"AV7f:NS/t}\?s ֘M SK{!ʐ+8p9CFQtU?xdz>gK[KMF3/&B?buo`{w'WAXAX ZOB#b?!6Ti_}i;S~ko@{a U;rר^k/oql`9]*UOTR00cA/#zS10mTݽ2`½cfuOtOߙE  kZ$̓]YuTg(_Sxߵ7dyOJD ƫiVV +Y"X5 _P:e|dJ_Au 6kx̣ &y<,fSjG#@eePw!.X=V~?\{jaGuU‰qf?;7^5YWw9\ԈqrPkyv+*VL{jWj'_Rv[Y~P@7XAXmaXa-_X$-6t [%pGb;Զe &Fk%ؚC(j3j,*3~\jZj䮟fn[ / r1~Gcnؿ †A ªfv.I0ۀjCj>yo-?aG}(j5Db)a &]亳ZssQ2.s7ծ|<_bAa!XauD{j;O-3ZM}އ68~#UsPa^Am+̾ Mx۟X ODVogH *wV8pv{QEWۻۙ꣭?6JAa-"XauB񖠺p jqF L畹ӽdCU)-bq[Mu jt\5j3ͮ.OO|uY  D zLgdB>YUg j~"3'C2Kݸˑ?x!Ib j2ޘC3ip~TBWf1'ov1'(9_Aam!XaS-'(LM}_}}2; SgJ7K@UӃsRXELm}*~=-`[F&Ͼ,99KA`AUOpjt:FD۰ĵUTٹ;6ؚM}6PQg } J{"XbWTQSbi<7ilweq@hkJ_07$ ,z9j`=~ =ncL&f,'zMujF2ŪY6A5϶(X(T2bws&'Dg2 гsr5S{ 4~Υ9ˊ?6f_X7O$XaYAXI|#j]AY6(T0r/3wM*Nj xʭ`RCjj.M3+jYL.@m46QMCQ㨱!D6Aʪim+ lAX(hj*vK`K:ڷ]k1: fNR1;w@5 R& DIlyVpU+՜^w:P1˰\qJtB,>V ؊9j$ eR9)lX<#pQ뭩W= ! qAq{0˘"[$@&f}^^uo.0؅R- ծ/yX dJ9j$oU͉|9ܨyQIT ` )-4COgAau"Xau;{[* V[cNbm! J} \fLM25vҗ~!jB>&YH>Qq8_ºJٹ~eJb)^m8M2f!S繈>l\eU~2g+ lD fG2 r} #zKK_\5|nvjs*& C3%%RPZ? IbͰ|xvB}PKPA1SK!y+Z  QD _7(3d&e>N/~ٹuhuZ[JU?O`jLn6*{ +8]RK}?OkI]j34@^W9{gO` f,1i{$ Vtaώ)xvK>]ah5i۽FP^)CMNEMBuBW9&t*dpM ;2y;&4e&pN=~`eט5oVg/ԥg>u L="AV7 ꅠ''a:D,/U .{W\Zjey=\saϕdj05Q=M5Y%Gzk6d{5%:MP#ɬ 4p5׷+$v28.+~o[gxAa`$w n̢8Q ^I\ 3_( oN(4׿hi$+xxVZl 5cPпnň$TlLK^Y_{FQЩr7 o Axjj(aA{K ނ ~,I5|50=&kj4z)ǪFYKIWRk}&6WfVa:TJ߄Dqݪi33DsvX%(yqDzA=:5uZ  ID ^ZSΧ2L 1˘WA 59LߒS+K@lX6_BPi먱`Y9&͐,dO_ ~U#`]zAUM   `zOۭj R&ϵsN} @mP87 VNBSZ.KO]爯~8$r٪9;wӦpU<`?,rawd%z0/$ AȻAH jBqfBL4XppQ_`olni_3ѠWOfVih;OaX{kw`squhe콱s_g%3nIʌw?":7eկb RKAxAX+=28+~&GJ5BF&jCR?{VƐ]UN& 59s &$Z$.~7>7X  \`AAXAX$KeV}яIq4 ibǞ ^RUۜ 6 3"R=1+T-a/+/%<+@] AN0j  _D vV *ظQ̱2ͩW u RnjS>IA,,_**<;2ݡ iÏ nWuШ:j5C}+ IDATSL1La+9ٜsV+  V*T+Aa %Gv` 2%d_yj Ldҙ{Ɖn^sL=[:G.V<)0=y\0'gg`AAXAX l4E\=5PV ֏'5d-X,ӷ;l7@mBccwP<}2m?s)?>ЏVFCfaj+Z  D v^ b˷Z= ZS)(+]T}XFDnCAWH\8}ߒoI07t}}B;Cs. :F89Hr~cG[SlMju :CE ^iuЇvx{C'Ak᪱BEwWto~m LJ޶ӌߒI Ml-̓N)""01];t2 l1E-Tib,SK,BUW~cX >-mUJH!ˬ$:~BݡgEKA8 k5~>-ؒ1fFJ̘Bڂj=j7;‰c{Mq;YID&aYl #A=Voڅ*jEd}pnDM`\UH8^ fy lYߛ]0Eia`ϐHl%``B!}5}ޤBpAAHhA99iCss<1k*@ˋ:5w?A-8m5n}t]B$۠$0%x[ӨSͼAZ~&7bJ Aٶ3$La%xQ`;9:%_%w:YF?/Lvw=}~ ,fhM]Қd+8S2-DKGBkcbkbQ t"-DkA<]366m]*%KÞK#c_vGTk5Sc֔xo=?N9svEkG o JAXcӿ3&aO;BӮ<~pT9aNyr pѾU~lܡM4KjVUW_k]\QB3˗[W0JB߄ׁha :% W֢o"9 k 2fgڀJ 5J2%,`2Thqކ6 ݊WE4i3QfƔ윷/7Ǿk?n CK~yiٳV=0-  d,z 渓@s&pa](Qj'PxKBz}i084w8JAGs +Q*ѴQG.rzgD:&BW!q'{ź CFb B k%DeqzΟiڮ@^tF)*5p6gx: M&{X428sz"fqQV,0K|ԫǝ ϧR!feΜ5gGD?1W_AA#Xa}sRa|yve~Vs -\'e;^tt*>yU"rEyD ǟOT򼠒fs:/YbkœgD~6Tbȓ5K/@& ΊpM E czoi` J O]sLU6mLLA.aN *[3jYĴ1QYq&8ֽ1 q7FILM]MPQ5ffSJ81>} OH  ,hM]B]vǽ㑕|سds7 ¹8LBH99YQ 'M\Bc:t p.,`*tN؏,֥l'߱pQ vEszwvV5Og E ڣv2V>ԠVV|&PAǺnvM;A1'0K##+[$I%n\vN'JxZ~rU=CV*)J?CR%loX5~8_лw'Q9  l` czoỊaW}lW*A;[2@AM@ݝxTk/WaFL^M63K`%(d"TPfYsEEt"gX.mBR\2&=˨_y!ȸ;1}A)8 kT*/s_cT UC5J/?Bw_PsA׾]vT(ȥ蒀ml%PvP%UjчGƴUxA&Y X~zwd>aDёA!F ڣ5uIk ObtFƔk2V IlM 'R2uG0D\n)~+7&O5ܳ(' erƑ7~}d A,&+ٯA,Q}pj/ۿVvs&hVŞIIV]=EAA+a\fW?K-'ڿ?`kn!L@AI  T"Xa}<ƯYBP#I{ilAmSRN[\TjXtEAhoä1cccfr`Oɩ_Bo=K9bn<~V~`K@hov{f#Aa"XaMbWeJ?f7r281} 4%om|'s8ol5׭,\؟oe]% ảG*9~ahV $ :8=^Y/ɚyL7+A"Xa2m#S|Jdp ̄y78}ةx4e8գ2=0mYr~GIc8x s Wssz+&,cic0cfqfC]ojRL: ž)9 @I  A Z52cA Ol~=T\Xݚε;2i0j FfKpe]]eri99 m5N`NLc߮sc7g/-!@xFa=N[]hŔ[|&o"}>@A?Xa }쭇v4y DfaHtnJkp7}?>{qå:,`Q#Y[ߠ.B&,- idHq>#{A~TX9!j3D [:09Q~}3{cZ Ʀ[>,CX =FkU_tڹ%StnWP{5;w[eF6LkTg ec]|WivJo ]ɳ-YLk+uQj٤KI5Y8m"z8G~A-OHa Ӛ<&MD\ 0Ѕ? e\*tN0LʝX"̢Iqy(蒤_mxQ~nA}Okg`4&Umfw U/jKW%1}3{= AX#vSf7F$vns {Ψ_5oUvxݕ\w%׃GEW,mX J/1ǡ7jg+F_S0a$ޟ˶oS z;8U|RH, C#Xam3}D{;,BEҩo'78-?Llj^(EA4_&(sZr9f)S4dZ(j5KW'G]tXxVE+e}%nJpD AX۴.n~ijo 85O[%НKf I|hO(b\Yt ͽl GE8t .е݌ReRUW--']?fkwG QIeUE{o2 ܽ_AAX"A<[EʈL\4ip M}A5QMШ+E4XF9jrK]aiCP{5s@5p]C" ̒h5TpuCJ>ٙO`A'!ǙYv6g#̇ DB3$Ue  H$A=eG>`-b5u N~ j+aec.֏{fK1]DF0d"Mt6j|¦mKoL]l !A0RrX6 ЇTc/=罳w as/[40^v&&&~b F' D ZS^mT% e&7c@p4lB?E}_GݹL's*:5#e+RVm)3]S1j>^E.7!\wBlΩ22g~?%>:Ё 4m{ nR??~VMd{;AHG ALK^Qѷ/NQ/CE6 B~;./qh y{4I^Xyƨ9 mS+V@&NLObAARAX'.i["|!4mp\ +6` w7Cm,A6Qc_~ 7 66 :a \f e+K-B9WaQa?O5UAv_Jlsqs ס&(j/ ؆~  =˟5ǁ̣~`g~XXy  T Xa0=om-.ViOmh~]g'ڌ:ic^Dm NZW}"Q{KQ#ΤL,/7eqAUf`f 0V!10h d73* |1肱xc.Me.ۣ{;M;A % .Ĝ$5aޢingѻ4h<{Fp6D'i)q' MԘ&UH͛QVUJZ"a:%&p2Eլ^ՇlzrSjYN c7.o  8QA2$Xa]1Jq]9D/ RTKP4;[|?O+'MOs.$kp=6C#LӢQY1n>t_trޘ=i䊮iCUO"a ط㕘%zߜAXt:}sw<۷o?[W\qe)}^. Ym|&(S3, y.swQ%jkIƛNO߶; 5 n ܡts@M[bgK8PJVl-YY0L*o k-Aʍ<q?K툣lfs%W"+y~\&AXc>я^uU=X՘W׿~u^;袋^{W?{'* H dz{C̄Cw $I,},IcKPXlO~Vʯ Մ/B1 \.S}9k_VJ%m&;"#D&F_AV9o}[׾믿Y~|V3"A'Wy K DmGmO;&)Ewٍc&QR!gT3VMDF̨xOYe9^VuKSܔXs?vZaf\Ы]@R{9٠hiG /'}wa5v//}8/|~wx^?@XH z1;w'KfڏTnSLfNEƠ zYnN5v'դYP@eOPЏfRᚷCb5SvZ9Ӟj+j˗ڏ&F3Xnۥ ={\wuySR,~[կ~jr%Td虫~b+%rwy^8oɪvo6K/{z婞cN=ԃ~i,E@$Za=Ӛz̞w?SER GPc4H6p7 <$| @Ԧ~V[و>o?~) .W em!7}es/5AxnF@*Xax 7@[n[WExX^xaa#Xa3ݭLG͏ewsQi0:ٶi`_<^=0UClc^BmY\ۡR]ӮP5 __ゟco)5^topF6Kp[}h7VAXc>W\q+_ʁڵ+?Ϯ "+XasMv>;w'i:Mg4:Em0LZ9:wZPЫy7oP*S4ڠK:H goͮ?*{m Oj=T6NHښOt-.~>E<7w|d j[O<o-oٟ?o^=MJ@ܹSO-ʑ>,!sܯ?XYK sK NolCs3bdX(HE$"4 1%[zzn0K*:ވ 6\ϞX'm5jjzðqU㘎 V9< [dM.o}k‰ o}[k^3l . ߾|^~Z  A.s%1A]h՘4܁azf Y{BV^t\*R[QC7`1o(j4{g$Q^p1:=䒁ۿ0b;Bĉ4fǎlo$9ᢉv0 oӡwNӀt? Iq S>*kSjS S9Lil>ӃJt}ۢY^o>fK_j,Wq2p'8azaa E۷o߾s|>ol߾}\nߎEc$Za1a S=P=@B³-:jzѿMQNF'(+B(RS5{S4&_{yk}i}ڙ4NŴQq t2> 6'acNo*}>T5u_A}{;#صk*.#G|cC=Y^x//o J k 3{?sh0P6nz(U —M𼴏9A5ˮŐ!H6AvE=W gRA[Y̶uS-ZUC/h_-9j^uMYrAuŧ>x_g?v;κu0_$Zac13{ߏ9FPSl6lpKM:*(BHMTu!ákiȱE82VYIDԫN{plW Je^s&_<~A |߽5~$?S>?w]QUV-"A6{?7Hӗ15m-\`A ˕Hb@[^q\` yW򪂸` /@m-sKK튤V؈+]yZk .KVE}8K/>v.,,<㳳{6oK?)!$Za#2߿Y4P9N5fsOº:8!= uS{p@D~QvNx)D y_U2z&E_8MaaO?}+_R"޾} 7S?SɞN;mjjCл>OU'Qك,AqяR{_w5'8J%N?0~P h`:N:'w=ua)輻3&p/|^~r7 tHt;n/[SʏAXw|?x`Z%}'H?C?4;;{g﮼ʏ~O,}gff5 K9<;w;t 8=a"hED+肭[$>rMTC?f{d帟p;@$ڷ(h@EJ'?.W>wnE^]N}0Qڟ)?>Oo~s;a\ԯ ??Ї>o_tE'j܍###]tё#Gn>ϜAO??>ZǏ-oy.4;/^!G*cA9 š¦ B)A!.eOՅ3URc. eOy2qee,Fq1_v^ˮWE_ӱ>q8yp_A6gw3~_|뭷vivA>~N:LDx>6ØBXoW-LM1P_A67xۧvڗ}zR_|>), 0fs$Mog} ǡ~6@J*&rlr;28*:cDDQIwӶ78̩GŁNK5F+?| &85uYxkKKaq7moN'''//^}o|K_z'# 0mg;(! <ǽwc_9ڜ9ל@ñͥ0=Pj{d6o9t0 P=Dp PPr4ұV9>M-w7R4}AX|_ոW /p\tƽ\/<, Xə~slGvs3awKt ;e a0'lQ _!.ѷH}s4s4vPͫߴ/TE.}3_Zɧw7ݢ~A8|_X _x#EJO=st YG`A!e73wlXw; e<[,!s!܅~31 A!eem(8XZه*#iq8ٜ,s=ዳ] _z= gA6Ww#B޼y?dzmzXE a!XAȐj`pA!n񿡚Nz4<޿j}}ڹTiDtjNf-(b`M]` y7FU?(=.~[_:}~A _ůگBtӦM^׮΋.--]xYGbA:Gm۶=%?,;A+ӥvfWqx/h[7WھOFy;_7+/r9,7mkk+JO<OKIj_P?{ ~_תKﶵu]ՙV:ɜŢqӉH}wc)Aa٧T~Hb"$7)}N_dXs\uբR$`ReUyRW[<<):N䆫׍lc>s+W+nkkB /7|{lg9o{,,-`@K>{zn0֨-Ҵ4)Mɤe2yU JMV띌%o0G\I_ɬoy6F[Ǔ}r*Svwϗ }guWB͇?a;?8śN/wYbf/c}S$8ע#sϿ y[m$eE'H䤔*O>QN(n2Y#ixϊ\Id.Rl\\hVwU$^Uۢ)RpiX!#zd.Hҿ?gPB}+_\. .8k\n>'>[nE1{y[:{:G}o?]p.w'} ɸ<=߉ y]mbZ*82Z#IS$ImqA6؛R-ٚlJnRn``7-w$:[//U {Dp$I Y? `Uv6peatll5y?m۶j<337/y ωeK~7dIJSۥߠ/$I.PܘܘL4)=ۂʑYZĵ=tEUWRyo-Ny2Jrm HLyӯ$]??|+_QIv}衇38#7.bIg}wῬ+{_zK'b> wKLR/+? 6aH&RjߘtZdG~kg="M˕'*}\ע+YhMG# `* 'rVyd Iz[nD~}Go~~+nRJOҷ?Mͺa`_bU?ZN)[ jwfZ?ʒ<ِ~fײx%/=}}sI?+|.~??_~UW]599){Vz]{_Td,A 8fڕs=uHd U;B;_,7&7,*=(;De7SkRu误"U&&䎪ܘ\RM~kz\7^ G&uف[w$Jr?W]uU.kկ~{7/ 4pMm `ʣA5y)%e%ɤmAnI!tIAKdoCˍweR*?,M+@ϵ;v$۠pN﮿F~{XܻwPgg֭[7=y[Zz]7wC܍$'oR/.}O,dS/hҵ6100eښG]V*ү\?-))#7lS9 }ow\D\ξޯTޖf<F|k_Ppl$d}ucZ񔜚d`[ʒUy_|߲n~*?'^I7}X@2ȴ1Յ=܀܄6G.`kV;B)iٻaTާԩz#nFnL:DY܈*7VEA XωI }N9An)/I^R{QCrc <%On:y4U M,MI3zrj:1Aكr6tɤxd_d2B~"b0v]aI܈ZiiZN)+{Dd:eIRuK"99+MKF]RU l>_+Ʈ4#MZؤ2xDv }o^{FX\" X0 .I)y/="wT$wT归Ur6Z$sF&#{PދȴK$l"_?N6,\vopJ };% ;vX Rpې-$܍$'Cs/IR)Ir#67|;Zf$y.[';mkKwg- IDATnRnȟCw]Q;{?!KxNt,Bsz?}^ދziMt>!&md_>+7*I yt,7s3rGf ΒDub>P|۟K LN*RU46IRjܨ܈h MZ}u{34E3 ;(yHd`7)ӦiirCa-fx6kdLNLw8垕rs }o: ,_`ɲs(!ك2]2:)uZX&2`, K+UIn2 I'ܔ$^)lI^䤜ƃ4[M'n巪V*96Wnv:Цo! lIpv^1êVWʴZsN&6òG'h׬J, fGo1IT`6!Ò{$oS~`$s;MV&/m~(ce 8RQ&-.oۂQ(^{QQĕ}JJ?\+p^/wTh#%{HfM_z29ܤL^NSu6,I*J)Iv@R[{=,g`Uo"Rr2y|C{AW)Iryzyg*}zdZq`U(4nǒpJ}}nftI`=#'S 8vVކrUgMHgHt(yTyRLAjt- *|)Ȯ))YX52e:n:Y`qip(2kk+ZD91R_ oR/2kq=7<`!N ?hґĻAކ0 ˍJ`lpSFy#Wr 4E,B-Hɍ3B[iB*ۧx6yy/Y{+ v}揃"IKQbI*2p]7[oY;+(A)+YʍHRvھaA`?WT%-ӯXӢ V7,BٲwJP*Zv}חVƦ2yܨL` XZQ Ry\^$N1yr_+]+e%%NIyiF7 Xm 7!o$I Id0tG3$فp++Ճ&w,S|CX$$k6y字UWJVT^o}}w~(yl,w`"*?Tۮ<);TFZu \ס)'@0`yRJ&p \7`8&eeb !X7/[e`piV&#?$o~* XdeګXehg.oL{uFjcp^Rq--Yˍ뒺dʍE`ɲFRMtLL&VCHtRvծK*MH؏Y[ᾳ22RFKL E`ˍx]RE؏(%RF?d`*0`de6o9'7ʾN/7Uѹ$)3z`#Iaiۂ YFemr _4d`D/zw V0`qLHXlȍ60٬l:e]i,XIų3HuW[?V*˅ŇLZR  H}u[iJf7_- T0`vyUY+j"UjZ9+dhgÓZX sK=ke$InJ °= F_NLVzMA*Y%1XElщ& t]܈Z/0<,7&e6H ㄫܠLWnfܴ4-99,KI0FR[LF&2qWlUOVJA,.7 6sQev6N\]Ed Xtn*6mزE} f";9+ }oim-H`ܯ$d҄Lgs MX"pòF˺o +M䥔P%*,E&<.M22rr*FJIdlfQ L'zYx.`3[#١M &ʿ))\$#7^;X*<0 !ǕzE鐛2)>MSFL:HQS$`aI: %0`Ql`Ik]}&O`{MG0t/) $XU7U^!' n6Dm$IZz`3yy$xdg[Q] 쎆[ ]'tJYa)-&X;* "p|f{YXvSÆM|@0`ѹ)G<s 77%&Mˬ O<|· V$_)Qy= ck6TRrRJ&+65QOƍdYgn/~O$L$i:gttmVi_>nP"J 4`xrmPt 22226Y#ebWӯiw?xR?X.JٰZI.Irr22a'87~ %i\JׇjE ;_#ӡ&MMNH2?MFi)%UNJ@,]uGF[MCaIձ` q=Gf=aIIRZJ WWZI2YM;Bxv _&-( I^V:BK \K~:%I2f ,n!!y=Rܰ$QM9%W+-&`:s"PJRwΒU$p^ZL^R|}:6ZX{aDIp2=Rth  FBo5_(|>_ol|%6^^܄II~/DnLHo+k"-W2rєt8aI0RFF)L?Zt5?#vV-vItw>0 !~2"pu4@d,UܔL^jҴb/OvG$:9tk+u)82V0$zarRd+[n:҇9&9/;I)%i}iI^\`T(p΁ dc; MyRZ&ۤol=Y{ /K^Ŷ^!$o6ߜQ".o}[;B{Ҍ$+&WlH`@bLN*KRAʁP<70 5u{$&"u㸣rGkGMLd˕j1q+ʿ D$s[FZ: t%. (oLWȍ7d7D:T'v`% b܈4!oMr\q \Y ؍Ljo,kt $fkڤdP_MGKK[)'d%$f,Sf@"Ƃ3J$Ʉ)~鉥__]G&W+ˬir>Og#/MdR/w-W. 6HS͎q^#;$79$!)Us2] Xpwu{6mںu^. .fs_% nqe孓"1X=Tg$?fd:%whaÆ M9z3V ;믿~;/^xy5x㍹\+-[lٲsٵkݻ/Zk{饗s=4j*@BL^ayerSr l|otU'HÝ<`~^ιjxǎgq]K_ңmղnڶm_.X,~G} H$jvR%xmUjW,-`9xÇ۷EJҭo򓟜%V?oڵkzz HYyɇETf,JZ vG[_y|S?<ԧ>aIw}5]1 t %7·_ Z }o9;,A6mڼy]x׻1ϳ:;;/ү~]r% \Nhu#_{R6ϓz4苴nݺc:&p XonaԬMJJ=+sr>`Yڷo_L};'?O?SOI:So~e]tE|uut̋qH\i퐼ZJEn]YTCJ*l 4`N}M7?[~ᇿz꩷z%\bLiff9I/i:%e[yXd6=`IfYw|;Jeڎ29VD$Ai L'I*g7Hxn8,- oǎwqǾ}ǟbxWwvvG6\ ]1J쥺I]MObdo&/Go0`pE+ׯַuW]{W^y]w%;| vίW;0 A))%;f`=W17_{XN|br,y7 HܡCO^vZXܺukӖ[l+O_|/޽.r^s 4 QQm22-%#7Os򪓚6Kʆ mo{͛VחNqM7ݴX% HFa+$I)cLv~ݔT WHrM^lJ=<,-tK/Ovisr_W~۸뮻m۶ӉH ɤƥLLLso>$VwݩTНgE]TzСy^m||qK{z2a/ed&*ni)q}u,N_m'eaNNi)/]y$UT#7"u `Lf1Eu-|SFRJaҲ쑠Uz@y`ѝ,UW]5999/| MӯS[ͮnu>%b˒dz?ϖt$E ʵMLnyivvp]&'7) 6RIL +__uU\UW{7soOz$4.qh2V׫0S~-O*O>%I\q `Xyȉ<'+$`?JrelIKq| ^HA ү7iyKCoo]vud2o醝VS<ɽ36Nab [b  HLaI;`9+ [)%dt[2=ODh@fkkʒ'yi 4CRZH$X%rIp+%`vh;$EofAnYz΁ H;n4 Yy9?>w\p\A~ Ӳ}n2×s@"57 ,Jא~U'6$IZ c/kT'-:.EjxWd:Lwl}D,Ot$ddF3rFT[ ^GLgp; 2{1L8U%ܕɵUfY`=$LZNRv][`@rL܀L[ IR GU66_ ؤ# 젤Z̬XNGX]1kêlJJզ29Igz'f7}* Xl95wՍ Hˆں"ʓrnRIdO+ɬR,\Q Ėws 4 Yyف`td?Jrra8x9y,Y|CHYyQk%"V/Krppb‘ݤ̺_|Q$%?JPFNHv .yRqǝ H\E#xݘXhuY#+Ub])d@$X U HLa6I2k孯<kd<(SFǟt E$tHek[MW9R9֫%5<).NLH7:e:.P̲̯r4 IIRJnjanY s c:IȬlP6R~Tv&;wՍ HLq2 h)tG4Tzc712U HFH4-i2o*RjYK=`!c:Ty"ddb X31x{>33XX 7&oddRw]di aM؅6[--` LW*"7! GH l(7_o* wF??v|b!>KiB|CH+ˤ%~`#*\MGN+'|(*:$tFWNK`#Q,45ad2ɜL~vѿMߴVw, J j^U>i2aYThW9"[SNC, 3?8&*nʬGlWyŲ`b,@2-I*E3;'c c7#0]T S_;(]Aj @;"U"^'*aY8NUI# ~X]Ɏ4DYRD5A\| %ʿFt,* ]+g{ΉU=dJI${ XyT>[XT 7ؔi 7?:`_A}xw0 A.n4&]u5YjBKx>ݪ D$s$[lM1 mdq=HaYAZ2.d=r`@"nTfMCc#7#m079/V&aɤ3e Hmx"rбMȴ{#Sg!ɓtnDүY 1OދNrCh@\K+I6>vDN4#W?dW=\'n<0[߱Mշq1vXnzL,6c&ofEh@f/d]}+r#Z:nBfm=IUVvH<,IVIr^ wsHPZܴTE;I)iʼn%LFn"fLN6'{(6#tf]u,9 $~#&ʮ{" E`I9\,E#RJJզ.?,.&X}dyct ed2RF |QxXRd+IHMnt֕J$XvUNw59ddeV#~);4XMdU{AOMۦde`In\dC/--U_V0 q>YiU'Ǫqy&o4):}bxw #0 1}}KJ"$>{馤 \i$;3y&V:&$$+I rl}̈́|#M[pJ FG,gR OtJڼ>R/,JLX="ù "lv2i)B H+e H?sEn@fkiS+K}A*rrc- Aꖤpm%qA:M!l ǔëULӯT_%+})!dڥ0MԷ6HNIJKiHeI\E.b_I)S0`#eKi)'7ۅf`7YI\)뎄d:CZ+&'geH6VI*ů0S&\A V 0 in\CƖuS-ח= C$3tK # GTlF&+]$L ˿= 92'@a:T _KeiZ' VS2LJN ,sv*?wՍ 0 Q&n$7?\ 7? y8vͬZX׎v ү?P`@ ;_)>S5%Ir"9z)Xi,<o I@-ƊpgCbjtIiaI2&80 QAZf7%f`uKx29\~=ÒJ&jt`@܄I%)` 3g>&( +dn,'KB[nP&-H)١Y7*73+kŒsG{2 }| +.ʓIK29|CCr7#"U;?I^_p.? ,I H܄L٬ioqJIN2VӯO>Ž}@]w;xMnW. WYA9 $YIFnPfK 65`$I%i78MnRn8HcL8OCXccc7x㗿R)8pM?O$fooooooΤ~!:}6KْN_%r674$6~ W2A%1I2]r3 /}Kհ|}ommm7tӶm.rIboG>r|{g̿c=>9Wر㘮/Ah@ }oR'7]=2*7vln V5Wdpaݸɷ(JzO~rWӟk׮x[nuW4msÇ۷o?7Z.U H^!,ɍKO&6ssG*Xo騔 ǒYpVl,~!4=Ʈos=U; $4<ܤl/A BCJ@[9 5r%j)MK"pRƔ6o `󰍱Ϝxyǜ磑朵kskU7D .K7J5 x!͖H#뭥|T+W捥KvttLpTgg^y䑽rfCq۶m4M-[6Z%<9s=31 Y5-/go+߫"荬?ѿHkMv~vwַۃ`h<ɭp}Ni y.:G9Xr7}Aޑ!b`F[w:p%Z)xo.}oF4~oE5^ ,;,oK|N~~}Ws0In Rp0x [y [Axۡ!?ȶ TʫH#~dZ'P~ޘ={n; {Cezk>?Oֳw'/0 a#"CEl?Yu;7]2#H`bZWW=wޞ7zzzxVZs͚5yڰa-Y裏9s̙3K/}o>434|1"\;" p.xmLƎ;ƬY&5uOr\0FϡK@|>nZjժU˗/_`߾dɒ$a JT7 {{ KZa~;#(GD\'@[[ۤ75tzg~_Tc G16]v\pWT*c /! /Áf6JU/"i!yxhFtF2#MCOh`OΜ9K_؝VsrO5klݺ7^lYggm |:% @c[i|iDify~sE+ՁtFܽ=9}o|/yƌctβlh롇z'/,\}ܹ-۟};/vb͇ghtDDT߉H#?GlѕڦIZj+EWE4G2#a}:C"T*-[lׯ={Λ7?'quםwyGy䴞x\*4E0"ZS2PzGR+Eu] Oe˖;3o_|Ń; #/~3F;%IS$MDRkGEvP{tp`f@{｛6՞s{\\ W_}CKK`^|k'gIA rxN2oDlֈ%4"I9Hdze"v= oT*~SO=㏟ؖ;EDħ>EEDZ}G&{ԋ @CX|FQ}gw:J4 | KIwD!y{")XxŊ{(L/FR#{w{IdW}wow|x~Η[B`dhNOg?zjXfw0 @X \eࡩ8eHfE'1˗\[xT*퍣z뭷 Tߌ$( UbjeM?psZ IsX`ƶm#E7 6܋npcYf]~͜93o .wA؍}ho/|ܷ)#t_r?𧑔nSGDTdD0z=3F=sS;kš;w;ʸ5dWՈ(1!mmm}}}jD<ӓ k׮s|*JQIDAT"ߍ-4EI[Tߎ=";cuӁ]##߽K7ih+L7F\j V .3ٸq=ܓ?ϛ7o:꨼1Ŝ'?0"~KCw荈aU幷e.GyQ%N~3FDDoOgP${lx'5GqĴu.B,>eA$-5ލzEn+Xt9H:"CHC`4k=`!O= 7ܐ-[6Zĭ ,;S K~|wǎsED[[׿ ´h$Y֎ȶԖ%oX Dߑw:p_l)W]WW=@|K_ WkgĞYygqFkΝկ~uO__y晼}W3Nggwܑ}ݓN:iݬ]owS |+h+㴳n#o#ihta"i7zOeZ۴iq/Λ7K/]d|lܸ^{O>q7g&Iϔs=Gk׶Omvۧ8/N;w͛}G?`+jo\hٓ^uh +3H}p:?ҮZYx-<Kmʋtg#"f}OO _Wr۬Y/_>&W^O|"oߘ*V#O~rWn۶mܞ_z 2->G`O@@/:>bk-V^9H#b{D U(G4G4E4EGG=>r?1QNZ#/ّŐ}yX[n9tիWyvmyӾ/Z+lii… _r-cߨal*4(GD2df$p:d疈!U Lu]T |fk$QyV.^xP0}}}=/of[[ܹsϟ9\tEtPq|֭뮻W^q\rg>ISA^q 4ݿ/)/"S4E:3""ڇ\@ 8҃xp-Y'nyWN!-43oD:ow~{47By;!u$-e:[@dE^$푴G6GĮ_DiKp[p-lCD$-IS_cOh,FDT^H#շ-}7ޤ5kI:R7"iOw$M}V= I< ŧ|"JQɋ3kw>W7E##vD2#Ұě;4jDt\ёmIo񟞾 DO<*43""=ЛHݳȪY$ÿv t (َQwo"hη-/DDTߌFT"݈hdٖ!'IR*'-iڼ#iޑo\t{>xjڲךeE:/y$*Z)8_:+"hyD֜$r5iyGTxNh*4E>fI[_dD2cv'FW"wD2kigSii[O:437I GԼ#iM7nΪ4bsY),4"lR[#"vlM;Ǝmi۶t_^ ThDit,msS_$)ϊdFDuFڔKI[5Og=iHxp5)(ͬ\osڶ.mI{IoSzqȪ[rhLTY)/G=/~dۣ4#)gQ$JI2ЮDڐJ)oDs_M=iִcKڹ5QƟ^t.KAm߹+ܗU=<&J9Y=ijoRߤT{J)䙹UYMim['ؒU\wR ɲ{sl{kV>4m=(rY5>i{\ idJ)ˑ',MʟM۶rG=S:ΓдzB}tqY .~1z %Qn)IRzygDR=u@CQ+ݫ B< O&>F'}- @! @! @!}}ǣ @! @! @! @!`/ߍ'dIϠѹB(B(B( l4`_UJ>Fh A` A` A` >~n* @! @! @!}YEs0>!K}_(B(B(B >! 4<`Pu8\ A` A` A` >8\ A` A` A` >jR3ht0>! 4<@P0 P0 P0`$`lذ~umذ?>/jnnne 6HIEԖ-[n}{}}}={7e˖܋:Qr`ϠN&Sի>whѢ?~C.S^``YfoUK!s??3gλ+Dof0:w};bto?qkww]w ``͛oG__~ߝȨ믿o_}.SKT%SC1{kvttLdԖ-[9wy'"_eɒ%u`00Emmmyc۶maÆY߃e ԋ LQGGGؼyIzރe ԋ Lܹs+27n]]]=h]@~yc͚5jժp.S^``=ؼOj?78.S^``:물裏_~nO3<N8!믟[o7"N<)Ѐ``4k=`!O= 7ܐ-[6bčʀ}н7PeYʲs<I\}7xc{{=뮫*Ν;w͚5$਽}н4 M6wq/ry.%K|pƍ_{{wp'|3~н1 _.\jlfZ|g=Fqtڧ@ 0͛bŊ[nҥKW^=-qzZ)SM__c=voƛo6ws9]tA`[(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(B(M׀qIENDB`demo/documented/bcs/python/000077500000000000000000000000001412460263600162255ustar00rootroot00000000000000demo/documented/bcs/python/demo_bcs.py000066400000000000000000000043621412460263600203570ustar00rootroot00000000000000"""This demo illustrates how to set boundary conditions for meshes that include boundary indicators. The mesh used in this demo was generated with VMTK (http://www.vmtk.org/).""" # Copyright (C) 2008-2012 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Martin Alnaes 2012 # # First added: 2008-05-23 # Last changed: 2012-10-16 # Begin demo import matplotlib.pyplot as plt from dolfin import * # Create mesh and define function space mesh = Mesh("../aneurysm.xml.gz") V = FunctionSpace(mesh, "CG", 1) # Define variational problem u = TrialFunction(V) v = TestFunction(V) f = Constant(0.0) a = dot(grad(u), grad(v))*dx L = f*v*dx # Define boundary condition values u0 = Constant(0.0) u1 = Constant(1.0) u2 = Constant(2.0) u3 = Constant(3.0) if has_pybind11(): markers = MeshFunction("size_t", mesh, mesh.topology().dim()-1, 9999) for (f, v) in mesh.domains().markers(mesh.topology().dim()-1).items(): markers[f] = v # Define boundary conditions bc0 = DirichletBC(V, u0, markers, 0) bc1 = DirichletBC(V, u1, markers, 1) bc2 = DirichletBC(V, u2, markers, 2) bc3 = DirichletBC(V, u3, markers, 3) else: # Define boundary conditions bc0 = DirichletBC(V, u0, 0) bc1 = DirichletBC(V, u1, 1) bc2 = DirichletBC(V, u2, 2) bc3 = DirichletBC(V, u3, 3) # Set PETSc MUMPS paramter (this is required to prevent a memory error # in some cases when using MUMPS LU solver). if has_petsc(): PETScOptions.set("mat_mumps_icntl_14", 40.0) # Compute solution u = Function(V) solve(a == L, u, [bc0, bc1, bc2, bc3]) # Write solution to file File("u.pvd") << u # Plot solution plot(u) plt.show() demo/documented/bcs/python/documentation.rst000066400000000000000000000066471412460263600216450ustar00rootroot00000000000000.. Documentation for the bcs demo from DOLFIN. .. _demo_pde_bcs_documentation: Set boundary conditions for meshes that include boundary indicators =================================================================== This demo is implemented in a single python file, :download:`demo_bcs.py`, which contains both the variational form and the solver. .. include:: ../common.txt Implementation -------------- This description goes through the implementation (in :download:`demo_bcs.py`) of a solver for the above described Poisson equation and how to set boundary conditions for a mesh that includes boundary indicators. First, the :py:mod:`dolfin` module is imported: .. code-block:: python from dolfin import * Then, we import the mesh and create a finite element function space :math:`V` relative to this mesh. In this case we create a :py:class:`FunctionSpace` ``V`` consisting of continuous piecewise linear polynomials. .. code-block:: python # Create mesh and define function space mesh = Mesh("../aneurysm.xml.gz") V = FunctionSpace(mesh, "CG", 1) Now, we define the trial function u and the test function v, both living in the function space ``V``. We also define our variational problem, a and L. u and v are defined using the classes :py:class:`TrialFunction ` and :py:class:`TestFunction`, respetively, on the :py:class:`FunctionSpace` ``V``. The source :math:`f` may be defined as a :py:class:`Constant `. The bilinear and linear forms, ``a`` and ``L`` respectively, are defined using UFL operators. Thus, the definition of the variational problem reads: .. code-block:: python # Define variational problem u = TrialFunction(V) v = TestFunction(V) f = Constant(0.0) a = dot(grad(u), grad(v))*dx L = f*v*dx Before we can solve the problem we must specify the boundary conditions. We begin with specifying the values of the boundary conditions as :py:class:`Constant `s. Then we use the class :py:class:`DirichletBC ` to define the Dirichlet boundary conditions: .. code-block:: python # Define boundary condition values u0 = Constant(0.0) u1 = Constant(1.0) u2 = Constant(2.0) u3 = Constant(3.0) # Define boundary conditions bc0 = DirichletBC(V, u0, 0) bc1 = DirichletBC(V, u1, 1) bc2 = DirichletBC(V, u2, 2) bc3 = DirichletBC(V, u3, 3) :py:class:`DirichletBC ` takes three arguments, the first one is our function space ``V``, the next is the boundary condition value and the third is the subdomain indicator which is information stored in the mesh. At this point we are ready to create a :py:class:`Function ` ``u`` to store the solution and call the solve function with the arguments ``a == L``, ``u``, ``[bc0, bc1, bc2, bc3]``, as follows: .. code-block:: python # Compute solution u = Function(V) solve(a == L, u, [bc0, bc1, bc2, bc3]) When we have solved the problem, we save the solution to file and plot it. .. code-block:: python # Write solution to file File("u.pvd") << u # Plot solution plot(u, interactive=True) Complete code ------------- .. literalinclude:: demo_bcs.py :start-after: # Begin demo demo/documented/biharmonic/000077500000000000000000000000001412460263600162505ustar00rootroot00000000000000demo/documented/biharmonic/biharmonic_u.png000066400000000000000000001056111412460263600214210ustar00rootroot00000000000000PNG  IHDR4:wsRGBbKGD pHYs  tIME 88 IDATxYǑ%vN}y U@$ mHd_ԣd2L36/c6Ŧ56Lb7b͵Vu{ėE6 pGZ⫼y~q?Nǧ,p" zS|, cǧ!~3rņrc H$R?rHp x>^˵Â+ȣG;?Go`tf7[HHkH2 w{ O<<<} ǥ1Ox _G -?q$p x;nn_ơ"5@嚄)Z TGxzK[HDp# |8,آhuGyw'ď; x8xx] 7Np\M_#س\R \'< C>~6~KOa㩏Ou|< 78ri3EFĖCс=e>ZRxo! ./ތ+:o~6~orŁ\Xm),-+@ kru# ,X"s`YځrƯB  m_H!=cjg/;nR*88V, roZB'Ia1 Rj!` o'<<<>~/޹ ܸk-Āߨa 0!)tHD,Z1@_G:߉nnp:eXU,@ !BAPL$D"WI +u=\߈np<`źbY,\},V 0B)VBD)0$H,@f^zB0A=ܼ V) 1! 5ٿ!(D`",A8Kk=.zxY޾Vo+"ȋbo4@ yߔ(,\ $ s'bGG />:.\xY>{ [+ŀPt Z2iJ"Qy?{O#$KfS£ [_i<{nx([DeeA\K;PDPV, Ԕ?^? H*!AH$2PbnR<&ܹo[17?j|.lE ^ZF@rGL6%wJ*A" X`\ ݽo)?qp 7^/?8[U"‚Ϻ4P@;HzkPUDԤPy3ܤ>#AĄ$, [k\^wu_PrYUh"s8<@b9䏾gI_C(h `n*Š%/>x8򄯽饀./y8`]lh?iSKNrA j*8䂠} r0)Vwѫ $ Zք5O'ܾ-/Cp |;>{X`@PPP?%LDHP1}106 ԿG(D)7 BBXIedˇ|sAxKX Aߚ)PQbi @F.]̏\[QD>꫊W]77kyxipyeX5u P#ĞPv?k'tP_D!I=fA"(`,u@. HV#CܻWxzqCa?2r"-z?PT.hH;h(aXF~(.L`APC a$5G\^ͯﺥcǧ-n%MV-  |Ɔ !uHXG adPI?\=Q(6$ ˊ˵N8>ĭ;?+\xͯKl<ƜDX[0?ϸ#J9=F NQX眳<+^r^x|X\m& GN>8VbfpqP$VTDVYW(.J0I4AHx y~!~ϝp Wl`l/= !7RH?Do `, D:@anz)QkiJy X !)4,45*y(H˼FN)0&RD),{dPvCjSiY]0oY6n.]:!V0@b݁l".guOfPJ::?PKS jes@#(L r-qz\ROhxycer#Ъ Fد٧=P}{D ?ԙ4q)F058dd ㊸a;p7'3<>q^ĵV ϼQ'e v"i*u_Q`AR@#Ru@S$@6)2,5kU n"xEq{"YAaյ[>:EB^=@y/ڦU1`{NY$` i#ޱ<50nX8\Ù#k +3ݿ `*l D1A;k%1ir )ԏ yA }"@"\ $ O% XVM#.xzc'"^|5j8*= jIsg׸@l2t=)VHذ)8_p `@c- µk,ׇrK8I{xȘ}*W%`ou;m#P]cuݖu{Z+@4T\ @D4伟*jYG4$)r58|8t{K<%~p,P .-`zGM ꀤ( V(g 5T!A fvW*SBGiU#$#cZ5PuO<'l f.M ;T% (b@N!PewJ 32+u@b$}A&MȥCHuDm5õqz%|vۿzBOq/x81n+``ԁ3C~҂p-] 7m7u WHC@>K@,ՇRk) VN x|ŦLJ_g ª TygRݛj_Lj(,6I*Q0ӸY+;=St@\ !2r/5<" Ksjgf% &< ’kDlRQ1jp?[&DpS:\#<*KfG}K3}[&Gt JjQ.tP;-ר₤J z{D4}RJ_] I@zh(aAXWnGy檀cSWvb/1=}F]EH: "v<֊C}N;u@6'HD+2 LyxXBl'|<H)/)3y1{{[Gq!?`;ߺ*TM.s;P\!`!PhSlA]T v!O hvIBm,0"t;)E5 qP&Rk5m2<ʒK4g{ K.h{8.e[ iSO DPj HDPHP;D)I(e[V I5U¸Jx-? /<<"c&7p!r)kqt4: JK|=iFf2Y^` Q{" H@JCkP)Ԧe9E$Mi:(ea .\ीcǓ/u)x)7St|!dh<{JYz`)RN,S8@u7BE!Mj"qeȸz qcXu"d6"ƾpÉ,7PzDjøuw9܍q_]$uh 3v- 끯|g4<—rಕఔN$t mz +TmMAV!dg"\AP8܉ Q].ր'2?U*45ʤYX$DU>/3/ȥ9CPQ ҄ԯgR~ܘļDAdF)q-I7"nSӇPq<ʚ" 0@S Q^?z<!ʓ_N;s%"@tICuR٩NDB4RG1n\O|u/<x#@:v.DPn "U :p>3TE@b@}Gef$S"@,D8(bmV (q8^ xxqǽ/E. d XY :ꇙ3~=b|=CiU!Hh~R F@5t J 7 OduN B BZ2{\^7:c{a`VvN_o ԟXN( B{E= sc$6SI/l2^d"JRjR_Y(!AY@p奀cen"W6"热^ m8,4(kf )"Y9Y{3 Dt@X^ =4@FIc0',\T:&@,M Q0n.xsz8x| ҷ7_ aEX86):]~oI?w7HF.@=b n\0| ZLgQF0P@ۋ)H[2N*X$/91vˑe)X] ]BU ualBo5 N=Dy\oV)jȎ_˂ypAR#r\D3J۸ase?AxWa- `.[o[;f*(Zta&¤u}X:ךGuh6>H;zug!(Shʺ ʰuF<>8 %A(-At癔``pQ ļW;>ި,4#D$5ҝB ` !a 0M ^ xxQǽ/m%Ö`{u] il&Db ~ǁ) MZA% VT5 gu.o_ȷ$ʰ"׼:#.N!U G59 EVa}W * vs!Ft2M镾j&fje^EtDS:1㣌aSu@! IDATSTr%V5X&4l Av"#0p}A>h.HaѶ> ':BȹB4E8!yO=p 77_Y h@0fp}8VqA9þZKh뢑@;hpݢD"c7 . (:Zv :@m''`*p˩]x--dYff sU/t (!U \lJi` B(}!A-c"WAar/p 0W^^ ƕDBwX%UPC@px"HYCvXl&{%@A&ItA[t/)+* zP"‚\ z)!VY恜Ymt.( ZBa~}`*zNNzҳ=aeH f'CPH)bP؊\,kX.>=<>?6:&aVsA97'H1.-?O,w?"p:7K~x&`Z$j5md/*29(! }z8x|(qwNp`hRpQيk@u30 95 sB|thU./T(= V6("p.P{f0Q7Ny8x|h^&Vg?;c;W{7jz t- ^ꧥ9e5ԋ({#a3o~]/<<>ՋKM&\vB@}"@Ĺz@XM~ 2@!d t(EO T d T1YU!o] 2k'hW`q`USHI;jp1~ # jBP4XL]fNK-Vt|QeGpAxK_\%lZA XWpAe7^t/3j4$x5XKw3",@jK9Iv`TBEGl`,}xA楀c\ 1d"(ݶ.AzoE@tyc&h(C  ¦Ev (ZPP~2,R@Z#p;?zn=<>!j?h!h#9b Z$}) m>Kh}xRYzH;>QjVͶI@S2*z)6,|R`P&%h=<>K%L@_$X{o1\hf|{H'lEٟ0_(P Aof̎7A,_BQsbUP[B S J@녴'*>`XHPSpgj@T0 w<Ĵ5ITj|$% :8 i.k[˟__cotxim3Y `$B 5]Zeȵ=.H嘧dH-2ZboҠ c* "2tKB` >ʸd*qmA\co (pALoąJ0@*SأQ(§]RleFkP]`(B+ъѝFƤwt.ȴ #>M4BvWZ `a/ϼp -"BP[B[;PNAHoGbEwiQVE,2bT1oEI_MCMI){6"h &豲*w7QȺ0. y<%+(;#{g7.Rkɨ gIv V}-)q(`CmoHK5TiP! KAKX,f.!?y1O2ĭH s`FL`T'x["Jn+yBP: @ClMA _z.Z\q)z@k%rf= -elj$ŭ7.O/\րXrR7OP2̅=<~!\@W (AɺځtO;أgjH;IHg{E YҤMH٪  p+({:zv $fv@hF nq1R;"Q d-o0 l#z~qRL+ U4R9`D(b+KdtގcvV`O(v1Y0D9 V"^2O;_qC4ȞBfaaZBazl .u`0 pqTd}kϝ/rE&q5 #43BS4̟RPJ: p?R1/.blpCv#9rP{-۩4v뀖ɩ@mhS`$/ڠ dodf:]/n2>00~cÙ+Ì`)dR1׎_q|2C,DlSUl &v[sP>JIabsA`5 4> MxFV ΋e>s__U м]^CHf)x bo31+t7cs{'jNίAHb{D&A2|њ$U\z_^SBaB+6`z4뎠&>̾CtB0񫚛'e,;D'=}A5Fz/0GІPzd.l  lnkĭ:MP- `83ϙ˜nea\](P2ùR{jCYvƆmP_<<ظ.1C8͹x86P@dKEВ5YTbM#D;HW?8Wֱaf8BE^ $w ņc J0o뺄VT5K9Tnrꭷ祀cǹ"FVKh($dQg(`x9;^ ,jr)qDj}`L#?&'PN3{d"f؉ =?lb`XCWc5pE@lb_\7UT=ekѩxzVUޫJ(92jC ccc`>Ш˯CajefXV6BU(:bxNEiᖉPPFە3}Mﰟ{4Yd6 u0HRV/\-5f[D`!y* ?QSj`،ړ̰c_ux G]H'L@&!ykDMݶ `g>`GcR3VL@+H 3ds= >6d`d̛$PE ;U@D@hS\g߼ckZہL`v=ShI m^)[['f_yrPR;U !Q[?=g;HRݺ7;1iff=K3&Q9;/J.QTRV"H'tE?g9s16BJ!'E= zZH>;ԢR`v9[ LQ穪,,3+G 3ϼW^ 8xx/\C+;w|?mןTqt%Z `h4*219vR偞;޴pejaX0`zNcc5Uⅿ=y&(ͻbmvjM߅Lh=VU NߙtjNQw{ʽvF ؙ"[EtXGES!"FM^>Kd"Vf/+"8O{-RaC=pֻhNCi2|š?lW]kx&Q=F.*Ž;ɑLk8ܻ;8x|zc}X"" o ZfXLeo,8 miOzӼjE4MD-L{hzWY* *[hdoc9e#aLX%bT c1<> X"ɪP>u@50,;[z'4n G$-nh -y҇*0‚3Zr{a'F.ʳ}i tLU~ŒAKNm65A"@0Okf*QP.CEcy:yLjR3.PkL$_e&ĀaOkī[MQͅ=Ŗ<4̟M?P'd*}Ƹ$КĕaMUL&@­h1ь c2M >wRkhsB)ФЬۮP15Lx@D x{?<>]={ux&bdDHtjM0B y_2N}]zG2@ OaÀ`,g`Ȩ2t -5Vtk CKicǧeV.U E@5;ktȶx2bWtGU{cgE&fJ+3;K)1K A-:)tuxx!)g&0N).!Lb, zP& A?(<>EKMg*c/PFϳl; Dg34+ɠ>L_v Cq~N4H *ulKhgzOu;l e>iL";@\A,ƅ"<>Eqܽ  TEwV1@RU^㑿Q=yI !`' D;Ns7 LŁ4EAPa@ &쟋|8ߪK5lXיijP+(F \=8x|낥%v*B46 Aڲ$NT=`TJ>;AIPveҪI*dCm HcFy@6econ*@wL/c'?/>>wĈA5" KqfkY{Z $ )5-qe SB q ,?R=*;ӭ j[&' 4gMMОn(T*qF dVg`$i).,M PD #͢HF1sy$~yWdXb: +=^"U<@3ڀzӤԙ5u`6Z-&h:*jL\V nsmm! H c'T 6}ZH5Du" aK ǃ:<>qe1 1]WA&d'T߈9fۡZieAs8=@Ԗ 㡒 AHTPGrfA5Ь do!슱kH9e`]Ust8f$KQp-q}z) .NLR@%@ɺ*Pj'CU![5 ʹ@zi"0E9^ ޓ:p,:X8l @2F&XO f9%¨I(A BAꥀc'7-D |jVVcTTH@h4DOP h.~h"9,T ԈN$? ``cl@ 5͹~5;3{ߺu:m}A(}A$ָܹgnIpu %"Į{*cmjEL응mQ tM`%Ev0IZHf#H,>[-d2 $LuY+ fr~0͗;Da $n, P$,_)P"h] ; Ƿ6DRi3SP 8W75"@tEXQ.dd;Ǝ =63%锟h JjdC$=QqI[>& ː5*V0G `[[w'zq D/,w辠YCB+Tc ABZjPso}N@1R@W07h `2-lRQ cFH0}A`yL}mb$@Pu F^^1WX"HaD ҦhlpqkfѬV95.يr 1Yqp>{Ɨ0)^ ״9f.Ț\[4mY2ibFMdC8Af8"wH{EU"~ ;:x|b{~{12!H1  uGrg9wҹsA웻RY&~犀I nO/l0BfH,ѝES=_:@b%#:U QMP\+y +mUd Dƴ>q ' ce$: Z[s :AN[ǃj]1&q0IvLVE9.0k 3iA}}2\J nq%'c<+tPV 01ݔOB 2.E (]Q+%uIÃN ʫ ,wHPD|Q/d^B:daʫ<јiùui$'5A?0cð c2U="ReF(.WK?[Vd(?2@j,%đJ`4O~5"v|r`O兤'whĀŏ4,Q" IDATsܤ嚚d8' l!\yT ϋ%,>/ q V`>PHkK'B ! ĵN-;'5leڶtNStK·3`H;۔N4jzm-T~} 6jX YXL>ҽBI) ̣<^x)޹#u, Oj@U^O\](&qFA+f|8a -w+}IwZ@euƷnkQF(blrYPG[wP?ƀmU\Qp;+1)/N,+c)}(, `a8E C\ h#)4E+b!g1`u?Lh!:H5+$L0DUMjsf?*6A r3~⥀cs3%" , ك-=A62 -H0/}>+F .4D9ڌ~b m PwI6?I%T)a1LInDMʕ q꫆<"[B"*zjpi׬@fpE)d 5ikd2j09(;ӳTje*bfB, jU Jzn!Fe2VF3P*VR@#=" n3}ӿWcSۊ .e@UT (T`^0>:A35\0or{ue 7#j | 7%)In=jF5\D0W W^ $`dH*4A/~.޺YtPJRpʶ^3QgJh[6'}vNjq}LeAK#aJ`0(!2=;L@@H.B"H2 ,7Q P M*åIqw>wהcU\ؒ1@Cm!2E61/=i謩L> ܩǃwԭ,V?mMs_*<PO >~yܹ]N1TIP;D #&N49nH.^ 8x<]EwQ\X`I675sA@\ @D( `t; T9"#t8TEٿ TS9LnexvzCdf'ہnÂ|g<"pB"Blɺ-!hy-jpj$zlanjٞ)B'f"t_!Y7r`p5(ifB^3#6 ?Ewb0\&HKW{x.JKb _>^h,kuYFjPQ:aK6av UFҼJ" 3H@qGϒAjp{ʴGIt5 ȘUq/Ԙ' tP+ٿC¬ H_ ovחc_l +ݡ\gi$v,)j 2'lٟCkȬ%^@&% s=;A>qEZ23(І  ؤj@uZh`%@7e%aOs ;TsHjpK{W&5|h3 A]R}>η6E$ts¢߼%ұ6kh_Vz!ĺeL: *VbY>]CV£~~F/ 0"n׿39x]( 14M=S qjҪY $MH kU}/ k?`04a 1w_nO \?AP ! Ň'/( I4sR|f'Ū( UX`OAUA`Fĸ}?2Hƚ` tF(?F1:+ 3/Lq@[ۨI;7 8ךcǓpuqCX%)AXus,dQ Vq+UXBen˯Ry|ugP;Ƴbh_Tcf0sA&l[?Ϩjtҩ+Ãra:hvٱ-B"aA<ƫ׮>Q'خW" Y l؞3,Dֱ/CCϿ$Li)E,R`Pm>O6Ѳ7 0n*F1N1,'`Փ#0u ԥĚw'0ح8Ɔ9 YEr!MB4Rw) dSJ'Jč -mMu Qչ67$=ác$'xana stP4!~; $,BUh9vI H o|_zOD-CVЊHTj(>JUtͧPn] =ذ [[E9ɼ4}hdW5_юsx.Rha$}UFV 0R촁a7%hW \ p|!7s /oPb"xΒ;Ɋt/fNW,+ibꋔ f>@=kKt'a爠A*i9_P| 򾥀? 5 lcPeǨ UbRb4/Qo\Kn\1I(p9FD2Oa`7.u@m^ee<s.ug@m)Oڴ-Z5_TI[}zKh,(ՆӠ+:05 leQ =q4w :B\vBto0 ZS) =!e $^/^! |aC\ Je 7!W0ݱR-ۃ?) yH;=4P 7-cCeUJ qJ}Al:; W2I$w sU[1F3 aEA3x| q#[Rp&`J@nokMY^|hmN^NСcGH VնU/gAH4#:vh@[J` i }p{0wj>wTvx$nO:[@ H[_'lj0  a@RAhJNgn4[_B춢,hI%%ݓMZ Eް@[*"4cԳ%멟B?Nj*Oa9cRFߩAx+e8q/9x˼[܁Z`ZXR (SXYHTzn&5T2hGWHs\{Nal)3.=fPNr;_M~_m\h%>q-€^|C4 ڌo Z[#etzCdf3Ah U˲-)Ok72A}߈Y*}5DD9 K} Rw/ b_͂TUɵ .1>/XLsaYf+B;` UE3JFFwS]zEhݨ[JS;6)cV$f)81yC<}[TdhH0Hz,Ւs S cu1L|_UWZn(2w),C!I@s@髡 V 4P9;' ٿo'#]`}LEqL=쫵g^^#7j#xJ,XRf?L[Pf? \KTV0 /w4<>"+H}όcLJX'pEX9-U u87>%̽ hdC'S&`aJ VcVZ% {D/B[i_eW C# n=ZZFUYN=$T) Y! ok!Rz_ЯpL"S_P E9:BS 6 cT};&#$s5626j ȮOhS`KQPBR~:,_MC7tf7n|O kJUTZ!@@ pfؾwoQJ ǂ%)A@*.>i+"˳9EsL$b{B[hg3aʾ{&z(ˍa* >TB IqH1B2O9U@ sAٿJR-y$ /[.+T)x,E@A hg,?6פ6T#wNrpSw;xO}r=GETsa/}D_ f`<_Ms~fWPco0Fx!/oRײco'UPυUTCa)Fg^R`J#ic'AGm(@څNg|5^Xu屉AHd)ꉾ{5(?i,!dF?NPwl./8[. C\ƒ~'__Ԏvp<\ w 8y*‘P1`Uq J .@%4Ea`ԡ&ځ9\A)0&4e)]r6hvITìTɦz t7 Do"!|:02/M[I$ @XG#A A ﵿc}Klp)(-+P %)L9`M.vxGP$G>æ"@^.oEpwE:QclWĀူ냸nz,M4 2]k|CUB@ B\^CCC~ 1s8T !'zQ -ﴄFt2u4B;!̶2;y X990835'TD|Vj@wZcB3*0~O(v-oJĻrH;2a^+HC~ ?1c©3r[G%  hFY6S  X̢A `;h0fOhVA=s+YڃW j52A[:<%} u1s=lٛ3B$5t`z׺cT\~Wr;$oE@jMA/nf1b^}wUCMM/ jha1:**#(;1K80M # 6@Q@{{<'Ͻ@̌ׯoue/1X&`J(hH0F'( HtJ`{ oH/Á 9~p=j i"(ކ(_!UA2aE>\D }b,PqzRH ,7ĵ, ӹc^~JqO(.Ww0, st ml]Ȇ:zeO^zRngn`G"P>/%3$(Aa2"ϏdO2f4c"T2:=cY0>&"T6 "-`yb>EC4)HޟCft ٗ0LW7@^ $A h"`bdy%e|.C.4"JP? A*SoçF `"8N:cŕ|:X,+P.p2%\?L mߤ!N6(jKX*7 O70LcF7A pY0l:PQZg" IDATVBG/ - " RDPZ@a1\T *.C$Et臯9!@FP0ba􃀀F x ;eX j+Pl$c<ft4n]p\'`޿ s! j}%|%Q*eyD_j2(Q^<*Yc"(#Wm*h FK}@Y''8Vy( ee!BPL*A!ro%0,.`  8b *J×ZЂ1"8 o*ן CQدI!l>=xx@@rq% E﵋`}RA~Qe \n>&"PMcKn`aFsHXF$(cYTh6X( F U BHdp.F)| b2K.  蝕qADh.( J  <JVІ,,r^)#ǁVק g0Ewb:jQnL2я?hE[Ԉ t&Dkܙe,@K*Dc HRB@ D叞e(@a(PdD<4DnJJ@dth4SDģaYM0b@pЇdSX978Z:PRKr_ ( #XGy !0-z;c|8 z.|/1#TP(2d?AcmhL0/ Q s$`p%vhY B`$ q@9%RipVuXun?|)ܦ7N4sJtd19,* -R%"6T.( P,&! P@|pDRܳ3X~!;$a8"RH,S *}XAǧr6+ fck([ h`$6Xpi"CP T7B]:5 GJ/>xjKD<'HDY˪N8#аQTh2Έtc Pt. /ffa0 k#92E*W#,EA>K00W _à "z!,k Ce-SMpLM H)T&5x/C*`?H\P5 * 4 (5ăkn`b`F kaA: 2G ˇ`T¸@[6ǣG`s2o*la<,BY`ǯO\RB'HZoBK~`-]<3%PĖk`8t(U"$0"矜%'c'kn`1l7 8 ATB2$4O#エu/a9#tc*hX,4idY<zL&;PXQ>%_Cy$$ ,%GD%>IKPXC  ]N|xjkhMfDHV JFMaˁx_XrnVyӜ ((' <7$[s8r.Jo7TTך<ݥBE++,D .( ¡6caYe0 k3(?+&nb h2 ܽǣwiP5[N"E="8sA=BePJ?C  8}O$%~x$^:P,2s H4r *Vĵ@~_lH@ga A" z :r*Td)Ktb Fx` *83_J $2Dzʊ 8)sru,hT $@ț!.#Tp0, c p]p3e, u V *X8<@M@^KJI3*D 6-J-PDŽv' ysN*lPl}".0&q2_1^gz"@.457 0KpGs(X@H`^Y & l.B+p[aYAx$ ΄RPm2¹S+NuEHL); |XxgP DL:.dPydW,?t0o230 0A়8谯郶&,ܗ%#Ԇ#,veM@إ#FއoMOL(QO+*Y+3ɌPnϳľx4 +Z$T1Xy y B1 j`V7@#,v^Xڪd((U7RB}!J R4CPT6bݧ&d S* (;0jq}AܭQ'Z1}@.mMP49Q[40 0Fln$4@^Y >$IaY&iDWL4p3(6TNe;!´ndCߙ :8p8`OHa6#Z }4 ! 00T Jz5dPΗa#-K@KY3A)QZ >TR&>* CvSmfi<6"v2bP (fIuzv6YӔW;7ҖZ 4,ͧ#12cHI :TGLpA-W? o!WdEJH}60 0K+p4(bGy /Y W!  *RH!GbR(r `0 ‚ *j ]-dI?<ȗ}(Bk atl{$hʠBmc5?~_t 5xW`7j=]T9:cY5 EbL#(l@F(u@<1||8Nԟۗ0,7YQanA@ W#lp"H ) ߵQHUjj;zL,IK)g:ϋ cu<&1RT@ :HFE(l.N1{$ˁ,R `}Pa`#Akp$7Zr@ 8,a H@I~Mw,ޱ+AVEv|rZ!bTuLQE:S% *( 0J@|(zZ Hh*\+T %cP(&jWc7 0n%1`J9 - !|<(w^r'XVYpJV1@U 3"QJ)cr BEIMV^B ??\l#r?Ԓ: HVKHexffpcZeڀ#0 D`Հ@ xKc g/,@8HD ,6 t}ФaY|S[J1wGERg~XB xL'~`AaYçAPO1:A Y@A!p^ Z@HMrJVD E´7C(Z] XހCtP ld CA9ZaAa0 lNe>mn,-C?B1U9x &Xhf{\H?.1rR.H PSEx"ܼE( L o/#9 ]*ú@8Z}Xa23e5< yA?敠|Ly9)Yu1?5YؚcH)!QNZ`bi´d~UM,'K^?Wn~\v??;}W=ofbjy'a``&〶t S!d>y}1>))2xN1{ֆ,M =,?a O%^T#v0dҨr\M.VT _kpq#- if]20 0{9Ce4DJ6fwϧ(TuI18E$ LH`O"3|@`ti3}ַ}9$5iAhNYEmjymiI _B$^e@3a0ݫO2>33 0{*"p9"- 0 *fͨϘxNͯ [I, hb))y@ }}f{O}Ⱦ flpp*Xi48)6Q9?9M?D ǽw2>I EZJ -Nnb.vߜ SݘPt6CBɔf\_v &;A%9W t<#n]sIȜ1lz+qL3.*BcWЅ bMU1yQPqFo" ̪!hP}\% ^%:jRq( *$0P5*Q3daL@ds@N ?haً^{J?.jݣ [ О/bH)`DO @ T7׀rFI!R5OTx: D%~op:WE ,03 0{ CߪLX+&Ji(%@S/$|h`6/7b ^:]`D! AvxXOA4$}BApjYgQ$XGcuL^M@_0@VRFw 'Kw+ $#jΥ 9xoN@Qf-@&sZ`slٿx2S1rbs!x`%SG&l.|>VWo{r0}q<#ߛ]Hff/#vK2ȠC" _h׉a/2Ǿ('$?!Cg)%yZ? ,e6{YYo\M@ߴFO0jB9~{y[2===66vgwEnx)}cߠ}[.vo4nw=σ７&Z=ߑ-Uqz~ (轤P{q}߯3߼ys}{9&s oܸQ~}mۈx衇v:D<IZ&5kJ?qڵ9'|2?ᦛnjZx5޽{׮]r"oEnx)V,fw#~qݏ"bE5k֝?{oo!7ۭ|Э|Э[/nnn_vs__]nvfVȭ[q[qf { IDATMM}Mমu_qM~M~MM|ލ΍֍_.îfDDGy$=s<"tI^ϜF:@ߎSSSٟfÆ ?pD׿ND;wDDY\\}Y&M6!E"я~9sO;K?ψGċ.vo\q)6_L7A{":yUtsvspsu?wVV8;݌ M2M~M^ pҍ}ƍ}@X.rD|[ZD:,D|+_OhΩ6usE]v';Gı1~R&5kJ^쿏?8?gϞ=W޲e" }Cđ[KqY[n=~ߚfn!?__ٟٟ{܊r3f1 MM}M]yz:gw"Pןn݊333<9뜺n󣣣͛?߿O~xk_E{/}ќrJfMVo쿟gMoz<'|r۽K{ަM2H|>O-[l/.snxxN8Kq鷫z{W/e?z2TTph``h h ` `-q~B8%UZW=yO?O}jʕ+/gy##oUVmݺ[nַnݺ;w@xEzO?餓l+y|஻z;߹w۷_-WG=aG <^x$!FpgբKyaa .@/| ι?tgݻw7?9uN9iv뭷moy׻ޕ>!|F0mٲn:iXC{챈xgd'p v7nܸqyV^}M7+qO<-r"ŜD={ up+~f~fq3;nn.7OnmnV7}7n[nnnoun+nnn*7~K7i7͍]>废tݏP3]xᅈxԮ~Dz3|AD\n] ]k ^{\pgGu0"qD|9v :c͚?fEZǎNرz_bf]w}k_CO?EO77#7}MoqSuSvSY nZ7q7?nr7~w'\]gbRV렃*Rjw900?'8S/빉kM9xr? 'W^y%v{Y 7LD{+Qq3n+|}e###EUʟd߾}xaG7l؀W]u-rxyye~j͚5Ngll=g7u&M~M^&&&ڍ_?>cc8 ~ {~Z祥WՈxתOg>_(zSN >s|SN@wYg ߾}{#8wޝsR͂+z/wID|X93sαn/`1}VܲeKJrooɿu_u_rӍލ}c7ppt끶YCz`?NsG_vezN97|QG 6\z"^g+ ͅXb9*[.cff {??5>fffL0|N߰0`@ Lj+1b=COK'kq0qs &O<ۇ+'%N֞ĥN֎~'{';7Lygɭɭgtgg?-{Wa0hfffYp.gŠIENDB`demo/documented/biharmonic/cpp/000077500000000000000000000000001412460263600170325ustar00rootroot00000000000000demo/documented/biharmonic/cpp/Biharmonic.ufl.rst000066400000000000000000000030471412460263600224300ustar00rootroot00000000000000UFL input for the Biharmonic equation ===================================== The finite element space is defined:: element = FiniteElement("Lagrange", triangle, 2) On the space ``element``, trial and test functions, and the source term are defined:: # Trial and test functions u = TrialFunction(element) v = TestFunction(element) f = Coefficient(element) Next, the outward unit normal to cell boundaries and a measure of the cell size are defined. The average size of cells sharing a facet will be used (``h_avg``). The UFL syntax ``('+')`` and ``('-')`` restricts a function to the ``('+')`` and ``('-')`` sides of a facet, respectively. The penalty parameter ``alpha`` is made a :cpp:class:`Constant` so that it can be changed in the program without regenerating the code. :: # Normal component, mesh size and right-hand side n = FacetNormal(triangle) h = CellDiameter(triangle) h_avg = (h('+') + h('-'))/2 # Parameters alpha = Coefficient(FiniteElement("Real", triangle, 0)) Finally the bilinear and linear forms are defined. Integrals over internal facets are indicated by ``*dS``. :: # Bilinear form a = inner(div(grad(u)), div(grad(v)))*dx \ - inner(avg(div(grad(u))), jump(grad(v), n))*dS \ - inner(jump(grad(u), n), avg(div(grad(v))))*dS \ + alpha/h_avg*inner(jump(grad(u), n), jump(grad(v),n))*dS # Linear form L = f*v*dx Before the form file can be used in the C++ program, it must be compiled using FFC by running (on the command-line): .. code-block:: sh ffc -l dolfin Biharmonic.ufl demo/documented/biharmonic/cpp/main.cpp.rst000066400000000000000000000143521412460263600212760ustar00rootroot00000000000000Biharmonic equation (C++) ========================= This demo illustrates how to: * Solve a linear partial differential equation * Use a discontinuous Galerkin method * Solve a fourth-order differential equation The solution for :math:`u` in this demo will look as follows: .. image:: ../biharmonic_u.png :scale: 75 % Equation and problem definition ------------------------------- The biharmonic equation is a fourth-order elliptic equation. On the domain :math:`\Omega \subset \mathbb{R}^{d}`, :math:`1 \le d \le 3`, it reads .. math:: \nabla^{4} u = f \quad {\rm in} \ \Omega, where :math:`\nabla^{4} \equiv \nabla^{2} \nabla^{2}` is the biharmonic operator and :math:`f` is a prescribed source term. To formulate a complete boundary value problem, the biharmonic equation must be complemented by suitable boundary conditions. Multiplying the biharmonic equation by a test function and integrating by parts twice leads to a problem second-order derivatives, which would requires :math:`H^{2}` conforming (roughly :math:`C^{1}` continuous) basis functions. To solve the biharmonic equation using Lagrange finite element basis functions, the biharmonic equation can be split into two second-order equations (see the Mixed Poisson demo for a mixed method for the Poisson equation), or a variational formulation can be constructed that imposes weak continuity of normal derivatives between finite element cells. The demo uses a discontinuous Galerkin approach to impose continuity of the normal derivative weakly. Consider a triangulation :math:`\mathcal{T}` of the domain :math:`\Omega`, where the set of interior facets is denoted by :math:`\mathcal{E}_h^{\rm int}`. Functions evaluated on opposite sides of a facet are indicated by the subscripts ':math:`+`' and ':math:`-`'. Using the standard continuous Lagrange finite element space .. math:: V = \left\{v \in H^{1}_{0}(\Omega)\,:\, v \in P_{k}(K) \ \forall \ K \in \mathcal{T} \right\} and considering the boundary conditions .. math:: u &= 0 \quad {\rm on} \ \partial\Omega \\ \nabla^{2} u &= 0 \quad {\rm on} \ \partial\Omega a weak formulation of the biharmonic problem reads: find :math:`u \in V` such that .. math:: a(u,v)=L(v) \quad \forall \ v \in V, where the bilinear form is .. math:: a(u, v) = \sum_{K \in \mathcal{T}} \int_{K} \nabla^{2} u \nabla^{2} v \, {\rm d}x \ +\sum_{E \in \mathcal{E}_h^{\rm int}}\left(\int_{E} \frac{\alpha}{h_E} [\!\![ \nabla u ]\!\!] [\!\![ \nabla v ]\!\!] \, {\rm d}s - \int_{E} \left<\nabla^{2} u \right>[\!\![ \nabla v ]\!\!] \, {\rm d}s - \int_{E} [\!\![ \nabla u ]\!\!] \left<\nabla^{2} v \right> \, {\rm d}s\right) and the linear form is .. math:: L(v) = \int_{\Omega} fv \, {\rm d}x Furthermore, :math:`\left< u \right> = \frac{1}{2} (u_{+} + u_{-})`, :math:`[\!\![ w ]\!\!] = w_{+} \cdot n_{+} + w_{-} \cdot n_{-}`, :math:`\alpha \ge 0` is a penalty parameter and :math:`h_E` is a measure of the cell size. The input parameters for this demo are defined as follows: * :math:`\Omega = [0,1] \times [0,1]` (a unit square) * :math:`\alpha = 8.0` (penalty parameter) * :math:`f = 4.0 \pi^4\sin(\pi x)\sin(\pi y)` (source term) Implementation -------------- The implementation is split in two files, a form file containing the definition of the variational forms expressed in UFL and the solver which is implemented in a C++ file. Running this demo requires the files: :download:`main.cpp`, :download:`Biharmonic.ufl` and :download:`CMakeLists.txt`. UFL form file ^^^^^^^^^^^^^ The UFL file is implemented in :download:`Biharmonic.ufl`, and the explanation of the UFL file can be found at :doc:`here `. C++ program ^^^^^^^^^^^ The DOLFIN interface and the code generated from the UFL input is included, and the DOLFIN namespace is used: .. code-block:: cpp #include #include "Biharmonic.h" using namespace dolfin; A class ``Source`` is defined for the function :math:`f`, with the function ``Expression::eval`` overloaded: .. code-block:: cpp // Source term class Source : public Expression { public: void eval(Array& values, const Array& x) const { values[0] = 4.0*std::pow(DOLFIN_PI, 4)* std::sin(DOLFIN_PI*x[0])*std::sin(DOLFIN_PI*x[1]); } }; A boundary subdomain is defined, which in this case is the entire boundary: .. code-block:: cpp // Sub domain for Dirichlet boundary condition class DirichletBoundary : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return on_boundary; } }; The main part of the program is begun, and a mesh is created with 32 vertices in each direction: .. code-block:: cpp int main() { // Make mesh ghosted for evaluation of DG terms parameters["ghost_mode"] = "shared_facet"; // Create mesh auto mesh = std::make_shared(32, 32); The source function, a function for the cell size and the penalty term are declared: .. code-block:: cpp // Create functions auto f = std::make_shared(); auto alpha = std::make_shared(8.0); A function space object, which is defined in the generated code, is created: .. code-block:: cpp // Create function space auto V = std::make_shared(mesh); The Dirichlet boundary condition on :math:`u` is constructed by defining a :cpp:class:`Constant` which is equal to zero, defining the boundary (``DirichletBoundary``), and using these, together with ``V``, to create ``bc``: .. code-block:: cpp // Define boundary condition auto u0 = std::make_shared(0.0); auto boundary = std::make_shared(); DirichletBC bc(V, u0, boundary); Using the function space ``V``, the bilinear and linear forms are created, and function are attached: .. code-block:: cpp // Define variational problem Biharmonic::BilinearForm a(V, V); Biharmonic::LinearForm L(V); a.alpha = alpha; L.f = f; A :cpp:class:`Function` is created to hold the solution and the problem is solved: .. code-block:: cpp // Compute solution Function u(V); solve(a == L, u, bc); The solution is then written to a file in VTK format: .. code-block:: cpp // Save solution in VTK format File file("biharmonic.pvd"); file << u; return 0; } demo/documented/built-in-meshes/000077500000000000000000000000001412460263600171425ustar00rootroot00000000000000demo/documented/built-in-meshes/common.txt000066400000000000000000000007661412460263600212040ustar00rootroot00000000000000This demo illustrates: * How to define some of the different built-in meshes in DOLFIN Problem definition ------------------ The demo focuses on the built-in meshes. We will look at the following meshes: * :py:class:`UnitIntervalMesh ` * :py:class:`UnitSquareMesh ` * :py:class:`RectangleMesh ` * :py:class:`UnitCubeMesh ` * :py:class:`BoxMesh ` demo/documented/built-in-meshes/cpp/000077500000000000000000000000001412460263600177245ustar00rootroot00000000000000demo/documented/built-in-meshes/cpp/main.cpp.rst000066400000000000000000000030221412460263600221600ustar00rootroot00000000000000Built-in meshes =============== This demo illustrates: * How to define some of the different built-in meshes in DOLFIN * Writing meshes to the XDMF format for viewing in Paraview. Implementation -------------- Running this demo requires the files: :download:`main.cpp` and :download:`CMakeLists.txt`. Under construction .. code-block:: cpp #include using namespace dolfin; int main() { if (dolfin::MPI::size(MPI_COMM_WORLD) == 1) { UnitIntervalMesh interval(10); XDMFFile("interval.xdmf").write(interval); } UnitSquareMesh square_default(10, 10); XDMFFile("square_default.xdmf").write(square_default); UnitSquareMesh square_left(10, 10, "left"); XDMFFile("square_left.xdmf").write(square_left); UnitSquareMesh square_crossed(10, 10, "crossed"); XDMFFile("square_crossed.xdmf").write(square_crossed); UnitSquareMesh square_right_left(10, 10, "right/left"); XDMFFile("square_right_left.xdmf").write(square_right_left); RectangleMesh rectangle_default(Point(0.0, 0.0), Point(10.0, 4.0), 10, 10); XDMFFile("rectangle_default.xdmf").write(rectangle_default); RectangleMesh rectangle_right_left(Point(-3.0, 2.0), Point(7.0, 6.0), 10, 10, "right/left"); XDMFFile("rectangle_right_left.xdmf").write(rectangle_right_left); UnitCubeMesh cube(10, 10, 10); XDMFFile("cube.xdmf").write(cube); BoxMesh box(Point(0.0, 0.0, 0.0), Point(10.0, 4.0, 2.0), 10, 10, 10); XDMFFile("box.xdmf").write(box); return 0; } demo/documented/cahn-hilliard/000077500000000000000000000000001412460263600166345ustar00rootroot00000000000000demo/documented/cahn-hilliard/cahn-hilliard_c.png000066400000000000000000002656511412460263600223620ustar00rootroot00000000000000PNG  IHDRXW IDATxweUBNЁܒir (*Ɵqq0τsg01DDsn2 {ٿ?9jY)w_q]{* } H$"LHHHHHD00!!!!aZ#aBBBB´F"„iD 5&$$$$Lk$"LHHHHHD00!!!!aZ#aBBBB´F"„iD 5&$$$$Lk$"LHHHHHD00!!!!aZ#aBBBB´F"„iD 5&L/|?[HD0fNC"„邗c|9I&$$ 0aZwdm) NL\ !aoȌ`oq࠰Q%$$ yIЁM„D O@"yXE%( a 8"[2 OUN81P&"LHH QM ?#d3%[cF&C [d<'慚eR*}S+LHHHDAz>7=@ h1bAnc(!E#bpSz;^UD Qh†VvYC,#B=ie43t[cRA1*hw,7df*D 99„ ,in}` =y>WKG()?JR8%;/&$<搈0aCB) qMY(,[e94s9 _;GKu.ЧU,2+~i=R: oO\B"„ Ή8;X唫T ;,a*vVkBP#E?MdS yq+B"„ R(Np•w`A@ޥ(-N),.T)=zEC׋8f#i oCHf b ,ٻ1?S)NPpA@KHYO~cnp-|vd0!#!(0BY%G+ i6 5?KXaso6z?eOzl2&ᐓv^ Px%M@;$\H0aCO竹嶻̙f(g0g%C*VD_~yˣ]7e$˸w kz1Qi R)P ]ƵP;o;k[Vz[ҳ?g_>[9t J7߹.}Lx")„ .'|緼x)򒬕ùs9Tuu1QZO 8oD /a†?> wY7^'~ V_@Аe49b8zګWV.Gd1Ɔi1 )A(RڹLt|_b5t ዋjWFVk>/pe+>o/0z-}ETTXN}_?e0rfp~`2~u5b/H„&cpm_? Nĉ >2ܢdRx~R CCp,0,TpK#}K2YS \XbO6'^j Qe%|#o&=ƻt &ztJH\x9g ww/W.]o{n^Q$SLxx8:}. f3k# nn'5$v1<_~ Y fP8Uzz%,C<4 _9#fH0&i2E|6ډ>/{ўѯOv"^ {6f͜<B,2|V3գ+> J±`)s ^{yX@Y-.΁+)\ _;]Ϟpѭkk%Wt-)upcQ(=X%_K?<gZ8"_[SI"LtSoBզ7%|_- sw3g^ka3}~?,@EQ$hY2N3&FX0vN+xAR:NK GC)5{JiS񮷘:%7Sʧ>Rn[avN+#?(xA"„%n d98cK_q'f S>Xwczkhߒ z6:v-}1*1HÐEz ҡ:z]%_1a>AKsaL(JgE4D0'R$TCi۲bF+nAϢ%HO]%f`⤄3aĝSQ/jU'HԯmĦcLMЈ?yϯOBzG*&w 5nLaDKn^IO)Cu5B^&MXhѳ+A!b>ysA38} G)b(]̕AzFO}02:e>#,Vؔfr.sFh7jh!SZQTS?.d3 hZ9͌Mgƃ${~qVv͝"]#f2l;FY5#լbpAV=a~; ˖~x1.ڳX *lo7P0$h1܄z~?{7 ǿ+x OHKazĊf!>EKd12JښnYV}ϫ@0ݦwbL̔W+%ġUg de"?N7+񴏹^ΓNnE9ɦ(BҒɲu 2]4CnDž uc_k>(}dʋkթg,GvY̖?ʌ6C rCV=|NNHYCbl#w]uAe> vWӭ|£kaDVQTu*PAK0 QFQH%i=`RI}9g^sgna4zVTgZ]Ч {o.) "z7H]'2^z6z` o5\}?Kq JǾlGT 98VFy42>+Mok2!34AɴgS_d&YWmAi?Mޒta߄D k>-H'!K4X}(#W ۶L]Ja!С!h!b:VOmCrU]TAeʼrE#}^i7xy/5 \LhO 7 `Q tշUzvQr"Oi8` "3?X!0:$|?Ehd42͜fV:3bc\\`(rmWpO6!I|b>FCRi4a!^˩p_Vz)Q҅N˛>~v5{t )3Rm(]Ix7" *E%*iA4@t[CJ&;B ʋtf YgBsc0f^C}CGIn("-#Cb-{l^zT-:߲zPŮˑn -ݒN%ʨ7PD5*ꭑ.AĞ`fo8LP~fS}3?^Dn3,g`tRVRXM3sy_S|yt-ḣ .BiC[Jˊ  c# .7jàb |!a\ okP>z[ H?~rjvXv8BZ &1.ݲ\/_'t -p %}?MFZ\`u+6R7QB}[!K8SyBZFZ`O=GpQr9dn\Ą &D)JV4jhMi(T)1d94jIihih74ޞV`.v3[! 3nXx@!i5h4bp6#-i53qzXuj-ꢋk ?Q7dI;eۍ8CeR$+ kuynȳ`h1?JJ}gk,X([d9YCfQ᭔eILROCl1_x@7( Gw5{oxt<#oB/dMx))y9"B|<٧W/ߧXKiiލb1?pMa 3!fnn~g>P+uI&;tZpyq?8zQ Md5׾gekgtAR 2\nP!tRS~+o!|QhXp27cVC> ֡.H^IYPg$ zqi-VZI'_i ǝnF3c_:]0QeɌVTy&f2QK_ l"LMj}2vr*MٖF=cD0uW'_& ~rۃYxwVw]Z&+`„dp-(U_P1d಩N>LYaGK +"V;b 6#ȣPNJa y~?:Y{ܳ_xVw8r(ݠ0}'Mql/sᪧe$<E:Ɋjޕ{z_j3H- \rW=X=_ |B!uKeLb['m0MEMW/D ǿ\xTgf;X`\ɂ"x 1TAJJe#'vƳ@+W O]mqŝ-07ޣWϸ_w\)j7تZ+b,\dA--7/gLF ߹P>+}kxپLCfz}t)g,2;ςۈAb qk_+]} R)5%L$"Lx4QqRŨF擇35.2;-3[lid&'BF揧l# NI_u!"&c [9E*Lˉn^tN2Pu\סSNwG;>@9:T.E)3cғ_dA.WsۃܵW'^9Z?a: \.Qz%$đՖxg 6k軆~3X4mr{8 5j~x_#U䀟s\i8 I\xcȊ@dZ!W;Ҋ򰥡'D59hvBOX2f^c#EGV ƗQI5S@b]pC)ݭ. }tXGa,WQC] P *k𓔾A;Gz 'wμ`EX^}RTBqE ޗ26_!$Utj#6VOރSuu5nxiXTUqvx+E93X9KߖjnobQ´A"„G|kd6ai+Kv`E_Pc>y6&crA$l),XՈsFJqUTDݠ.Zqae~UrEQ^r { qCS~w#[H VAMU)xqFqUN:P}nBayӥ[0k&cì_UDm-aU}ؐÓZ5R1 Q?Tۢ"ŔauQONX1rEE>C7ԕl;.dn2D%a aߊ>yH# KĺAo`>©\(n13P1LѱA+šb 75 G08Ks{X02L[!V[C K9fޜ~IOQA`MnJ)QoKT/,/8`X\X-] YFSF0QFP䋴;fl2&sɳ>{^f IN?$Eq'‘gh( fp#\ ~Nfi[-SQ[a_=<|v4rrzIJ& z7ȔpQ(q}hjz-žۣOy:&uM=Eu䆑&˪M.FhT*!z^izA3/g,jxI2saF~yU=q <Рqpp2RjTEq?u*CENh5i5ŢSނuj+'B@ _{ݑB2Òy2YC4ni1{- Nx´B"„G2Ԥݠ`QvZ=tFyp5#*z[ BasFd9 77/((ةO+Ujjq5Xuk2JsJ GF5yݓN#3n-{oW G/*()bK/&&Xx73ZU_'%^gsr挄p<)C9#Mw;be&rr]x0>°07+aUp2mKwo8ҨC>7|,pR҈v23B@%Av)͜_ߺ7>IVLQ9]HiD V@!",'!-tr_W/>eTDkQev[kA6EшnEЪF#TAdYQ㓊n1 R]ЩT'ET(+E]wݠw &ْ>)+4}p8bqaT\1t8ZIڠ'K~7`%`|~iRƗ6H(nɾ[˙1ާm o!iAG5XA95RՂ1꙯r|]ϓjH3[݂$bp>5. rrlu{fc:|TwBac؁iD ?DU3 &Ly7YLy4t!ڻS2!==! Jz% u8lW3QU^x>חE˽w ^VC27ꆟ0JZ*`Y;TO:*;~bcpv(wm+f h'A//X؜!Zq(f82F`rLpVTiUzg&o4UYGNO% 174}$F&x6-StxRY!o e ʪ&)9KJ3W&zxƮ§Oַ? .OA00"MŠ Y&BGY8-wa4H܄@/D,}!I jR<)5A,H_Y .➽Q`l;g m)l&F(Jx)NɅFXjЌ1Ɛ7fԫ{QVgUH/[:ʍq E]7 XkքdɃok1aSa Nu;le5"&XQCCUP,ꣅ0B\ʶKy,2x;B{Lb(ŏi$w.Է<]PP);vwg42T8]URpZ a#S)+ffsv_~pmld&} !/##V w"XI)D8bdLP 3MR3̿ygyxQG¥nA{'39.{X@"„GVFrl+xڎI:qk:yDpPZ: JVR. U*. Kec[jm97is|^mOyF3ՠUeJXӡbL^wFƐ\ƛSd)[Ρtl ^ٟlmgt9\-FG/w*E?QgViB.K-Y\=K$^ IDATGXҳg p قTtjuT*XuD:E3Mz WsCÄXK*`a BUҳ9 0L%4Űv!F \-fb=?<β:}νU]=L " 8!*h44j$!*W㐨E02ʠ$"34]]Us^{}m4y_G:[Z,hM^A lA@c]ŵ<#EH_4Aٹ/t%iy''mB%#d?n~y1*T M1`󂈚0 =}3/׷^q{m Ǜ:^V5xgFXd^# |yAEU~ ] s/G7R|`C u0}JeY!5mh66zQѦ`ۮz=n^ 0ޡ[+\Y9Ə,%DD)p)81\ (Jpc%Sҁ2P8\@P 5"NPn^Ccw; Tpr:Exq-KdNe`/Otߺ. YD+.{RuVK`'e+&ƌ?sw>CeܼZ\09Z::ԛem{/u0৤3mx|+ngdC(cţO5oG]m [Th'G)8_\_3_0L~aAC:REgHל }skYm|N0kb:غh(xR~h@:X e<=ϣ<4e2'JĀhϛiR+U7Ƌ-#ag4ntPfn {oϊ-Cj#SăEUrƟbc~kZ d07)DN:B^p ׏\Juer YKi+/H#_0Z#| mW,~X'P(Wީ'^!^W6P0n"{p8WjR0BΔIEQҟ!5 ( ­߮?R)Cғʶ sx)@5}fes毈?R E G9lλ>ED'VW vK.-w?wxx(hrk6I{ٯ.fVm5Tw +gK~˗-y7yq*KmBU#m\J@Q[it^$=vNPeϒ OqJ}`&,XAǵ^ApYz^yx׏*O5bhf@0(kt8"0{:[&nYK,JWٸ*0]fN Ŋf_MJhB0uAO/j*}ϬgG8[1S3뙭e&2g[L# xa?hf{H^m_6|JgP oi,*QǎKe,ziO6!ؚw makECKFk%y lλu%Wg+O3з1&ҩ-N^"# J5 |_N:Ju8i2 X0IO)H*@R'rlF([#F8Z:v4[r$V,[sO耙(NsPtz`y!}de:  쬏mV;Id>4EʹKsR8).T-Npv)!%ֈ͡T^M vnҺ9[ OGRk 3ͺ[18ƥx@ɚpf6_q7{aGg Wq֍D ):DuƂ3{@jxUAfքұNkAc$04֋8o.l$A#;HʔWULr\kHü '&Rҩ ߩ' >?= [b$xa6 b"2Yks$wc%(g\W/B3^)cA5b6^C[!s((Rhg{Ĝqi2DEg MÈ.Gccac4x&oVey־ 'NQ;<*>lHI&BRt4cCۓAe4 ]IO/NJ^x[7 t:z(!#AŀK8"o"_8;tt7~̼14v |lBK9'@ *>[ř_k5Z5*o|C3ț;rCܳGg Yi`jL/M6b[[Q6Cs+S#3>K,{3|49='FhUJo7BN)J|Y_t Й60UoH}+uMJ %"*-gU˨}K>;c9d>>u旾Sz=x6v:X&?@jDLk:C?Ы%X{1ˬYocrKvFݪåed4|5^5xpvԕTJN70&ʡ uB|eF{_~MS# sw #$I3a=T2Ts6C?KqbFV -{99J'{N9bwI`b-͙B}h`. ;5p;m#UVy^Ջz Kv[Cɾ;O|_U8PAx)ǦYZ)VH0=x]tvM`e!&W/[ֲ$q)PI/FJ'hVܨծ wC;6umUz9" ƙGXutC fґf2 ?r̼-QVb¬ج6E!|j͠>I,2elלCc~rmzwTUW._ω{6K5Vq4**WVCTYN0vVHmX\7+KO({o {>f+6Yaz@*Ӕ^}l.JF\;,AAENQPak=U^LM^ǘU`/ vJ[ mI!C~,oyԞCw?9VξNgBJʤ ybl/ F r VP:OX.ZZYkJP:%?C.qGqQ0 S\ "In!MDa8ʼnF -C!))ZNgh.JI)A#UdGzv\җ%dh%B E!Fx 촔b>eIQ eO3wyvO}#uByձ"\-APdûʾΨkKnvg/Ҏ(Y4v qlP>T ދtYD6wﰪ8M2S1]i?h?hk|{*Eaz''1o)8L06bݹvf#?I\R(;vͧed4VE-`:Ee ]du0S`Lj ߺNȴz{:ib_98h%2j蠤XZ%DWI*k {Og\ۊQ~Wi[5l4>ƶDHE8GɺF@8ZՊ uKJfE.EHݠ).ݒ}Tk11S=˜KQ[Dª?f_Y㌕i^M"HmaPBfb W<.ա."5!CR`F mF:rs. !Lt q{uk}:]+NW7C[ IYvꕲLt+-RRSO((8>c5/!~q M .в5x"qK%1f(h0 (J 9KR@NxnW/|71&O= l[ Bp@M79 tJ]hDZ-F3=/\K;/>B>yzX?߻B a@5RwY6^́;йyZBg^NavG~O(O~u!8>}}EKŷDDL-^'l.cm@B5wگA A*9B+aOEX]l/G+門mTw6|Zpu"QJ%Lj$J[ i1mjUTL\Tͷ Zi& QGt}<}}8AwF=^@D,t8Cwa s$FEV(Fa*ղݖKׯ<8]~r&;D7>e5p)t qCX&BvHHfZxpN>P8k/*Tk!NHI>kidMMځtuHnώO\u4/`1` eK&i Q5%nQz:6VsϠt>W~JC1Bq8!dL7Dl $׌/!FŶଚqs(ZlS0RXe5/]z?1JXi#k*OU (:NDzcqjs^ 3ٌ` _WAtx fe:U;ehh)eWM,WB$ט5ZKo6ef,0~lL4#EE!ԞSPU: (;F ȄЈIE+DMxs]O4 >j S4Q>ZM\We됕_&b3e*3bO5¹HQP*r jyWS}6uWЇ4m:~:l/gqQs(ĶU <0Ec5R!Ht&R(buZYR6 (9j]:qC XN( :ɛ_"TZ1!Cnl~{.b0FIH'y!靐9UhO_# (  wEEq*>)3ܲ~ࢍ\@f 9lW5cxCjQתl *ui#`C/s?n'WgE&(mR?}yD5}N"4 CpA lͺ´?9TNTTހHǧFK{Op0;Lx;xwq&)ӛ&LZXmؚFe˗N/;Ʀp0*׺Ƙ?f ^((pdQg;;@ j(p. J@/AA7b '=]}>2K9G?"ɇ qH C Mp(J@oXvԘ؋FEWfZksw=,[`{gl2-o-^W~®)R/x޸؍FjҴ#y][*>(Y2&]6ڍT_P;/[/S`bL;믤 קP{j9(8)TcʶUF):V*`Gk? ."f,m*"6;С"w#e$[M2._J~)6N$'bdɻq+iȿuYx׬ΡPDmD,0F5M|u$A]06`GɠAm䯦f-mv݋\s7x37ףVJҽO "vXT ߾*ETPs*8Guv{%/ Кi=^# +֋NQ:Ic}* ԛNIS2kR`;*OYPhSB`P33`IB ԠRՄ!p*bSׅn:ux^]lŦEǬD|$P% a/?A@'WP\'3-Ƹdi _dIdQCE昲ڸ٣aȐ284ɨȧ|/OVDqK4Nplw~sb.ֈ3}:lP|6k ߧ*23`8ÝPC葻ˋ+yӐmCİPT P,hia$Tl} O:7']QPq.A!7w/8GH*ԆɏW')Zx( jܺ "zkP IDATؚ>OJ)E˗+jTR0QK䂒*lS<|Sf5{19UILNh l!IO1"MpqM쏟!gub &Th$ YYrDL->Я@_x]9 zp-ɹMիUA8!xƻ{G_?~P+WtJ\@:N6dT ;o_}*?+ՉOХn-Y$g?=7ZKQ t ^+I&zazHj#TOs8㣠_lr}XxTÙZ}*Έ6ROpz4񏦩$'F ##,*oDR),E?2y6Qa,eZN8.yMȒn[:ThX{aVxh5;Hc=w?S}^֮tI%#%%ڞN~nuHL/2y]D-bY*GndSQtUqNOzO{!zqR(o7) EaBnT"XlBh"iX|D QtW ~+$.[%؃msE;DuRF̐{3oݰ}C4jiBzrU'{tN `bnHKL'xμRNiLM JRjKRNJ ؆snfFf~MB18nQ(((vfC> p wl 2 ;`S,^hzB&KGLIq{ʲ,[Xk0Bqwh%Ԟ~m-ů <{lڍԁe9Cjo?PY3UVie<>S3VS/_OۙCgQi`CM,x>Yso?=[B`":wثԫE|W\~Ol"Et2CmV/x4EFPg 8G{"IF@8GSyZB¤WnSRb_a,rLr8a0Bth@D@:[rM@ )揙&"(eI7cf1ڥgNek̫fUϐo 2!^ 9FQ4XE i;|7gBjGJl]-Ic"19k'ÐF~bfN5g%;(XVRn~PstBvf'w*o_ P8bzSf*z55|8R|Ve=XQL`cg13_6ix=33`?Nא?]>@ז{4W"Tʲ%WB9  #dpMY-&)E[v%Bc{w>c1 ψaNdCg ~2 ]x *Oە}6,ϡu"B ̕Wis (S#j +C<ˢbrfNaq}eKq!rAk:cJ# 3*Dݬ# iG 8tO^gQ܈lmyW` ĪA*A"p-"fy8S+Ш3M:UY߶\{/"|Fat5B'~gfF;L4=bK)EPړX0X55)eۋzQ%啠^\ -@ԡ٫%V5-"٩_ :ł^>( 5)kH4Q\Ev^\5xVxB*HX3D=੮yS pNLuKIm?7^v{WlpŝFQZ{Y&CDn{OwŨA8wֈ)Q\}3dŦ#?_B*Q%ߜ;rZ^.ykؖAMm BhS .=EX#m#Xym-R*t` $aK2iu(eW^zOYG$,koQ:*^+>:VpOUU!DQ&FɃJ 8SJKS7ZlLӦp5Tp|{cd춌?woD*FG@#SQ\fW֧(ӹQo>jU6sWd*$VH3B@ch,cWOhEWpȼrϓ+[¦>OU f;yUR)jS#25mc 4IDlSVMo;IX[*SqJ 5Ne(/:@ЦͬɁ&׮#D=/uBY*LQբ?Q;%Y8ʂnaq`F Ԁ*[-`i> &&^TO#8ʼn@9ӿ_[# ˎQovKP'u`m9{s`NI\t!i[@դd$O7L擸1 쿓iZO iR$Hvj,*[܀W7t1\6BW8g(_e:jBv&'@yl:M@| ]щSJc4݂Rp.N)qt|I`fSqAHO hQXZ i,FUu=ϕ[)zNԙ}B82Q`@p3yz e! ꛏO~|"|b=n`8eA7%*_O) QwOA0#lp.}P Z*X]ukFChb!kЯ{z5nVL`XPG&҅V['+Fo]wksI#*PI!`zQy,mtC-V/0 )Ƹ(eI=ߨx==Φ3jHL}> %# i>FH2F C4V:Czb5 a!yDsPퟨB "Y2/ Ap 3=NppԁSv>zׯx X{^A)d,[wrRt:p83"AA8jD-:-nq UzzzX-MB[NB't0oI, KPj-8yjg 2(S5(`v&;m簷9 ܢ*\uiS'lmx,u"io`{k~g.7!yҐVm~+4fH};'͹x;[ "9:Uu+Yg qGh/F KP="4Pcl~q~uvu){`o6`^krE+4#fZ&BItPZgiњkswb@i#sԎ|5E8ԁ^E{ caPڵxZXCDG Z( BFBr9j6זw7E@+B⏴IRhDL8d3ULTżZAL^kmQk$1 Zwū kmN9՜}$##jJcᒛKoG;'O{1_S2©g 9CU@ 3t;tJz<1[3[Kz zf=3 JJ杳9 l% NyۨFIF@8wWg}"*쵝J"]0=H4)Ej`H[J# P;aR%맙M.v㪠1ƼX[*^9{t΢Gε7mij"xo?m3e?zz$F۞N;zJLTk[yjMro~ɤ?ExUh)DZ"{T}'QUzlmA3353vrVfkTx%YB 0 ""Y# +oĚx.r5OדUOm: "@D }+͠%ca ,yֹ=EB BUeu3R(⛧ϧ--?TE` ig\l^hHF&'6a`QkIX! DKȍ42p8>M0:‹',_̛q;hhA|J_3xk.IKǠW1bBzH4Hq^KzR]Uhj(8t5tF ¹F@8wED#RǗ/ ˾LLbcr34>hhAM%7s=@W=c7$kJ6LP L!h`f# @~Svm~Zzl13`E {ބmm%^13XBT.EdF{Qp8aeϒy,g~K~C0ak?ӆKKn қkP߯o\)ߞ?cWʦSA( >h x~|~XX_4> y L&vU4?$ *mO7J7?;G 1m7wfvpNT"g_ccA]>=jo3:C*NHր K1C]Ta =Pepڛ[r9_Sm b7vv[gwhU?m!qNE ?L~ۊp]|bC"VMh_3*hحmwk\bEr>!gá=X^pcgW  *m̞[q6{+u+䍇1zn{Po{±iA37*kTcuԷs(hyC2QiQ#PPpQpNQitN/Cfl,d%n)5.2¸COfV+kbJ(ԑ Kʱ{ȷ.,AbM.H"p9 `1C} ; '[k3BriJ)F. `HbMQ+GU>rVnIYPR:1!@#GZQ4ljn9X-M$fn3. s Oߍ^[+wӷ.>XaDWxi!\@pЀP6 h\z 4i}*Ң]12i]LD-p45 FRQu1˚ N3ZO46jY%63Beծ kq—./,O(L)9J0[ӯ(f܄$Vï̀e(qg &>]{$EJa}Kz@(JJCclM}<3Oۉ^EExp#n`ek7|PZYœex/gH)Q)z{ y!dA(#F8R'A# j-1գ[))YAM1R(#* *i؃TjH"O!+Mf^`G'*e&)h AG) ^$V-Uj罧袅f{7a2PYbOieB\q U;NIVf[W3M#>ܬ, MÔP9_P_HٕgDJG~q2g{5[-`mQV IDATR޺)Py,_†>\(FslM sU/*hKV USʈ8})޵֝6Yz{&iޕ5kQ]_L?=i0 FNX53E$Y~0x^}tpJцZ~dnVxQ?'gc'JGq\UG;>ēgM@jpѦuBx|#BY43r; V,aeZAYP0ѱT80&LE Цl1Cӕ5Y&(Vs9?N_7xΚ@L&gwvGuѹFpܜST>m+lDnA@Q̟MLh+E+O#;J'YloF6& >\)X–A"PX\M3OGJ 5hj57,ώ}}a-IRE:tI0k6>R|m |ޑg,YӡA2oN||`|his(߇}  n0M#B>gX۲SؼJ;?npXdT[,GbDC9:^=o-"vVv>ur_u)n/[@b&mpέ#+9(*8uc8` [Nd'c8&/S^)g jԲ.10/C1ɢ0\&z$/8tԁN,6N<@^&Fp6r0_l=v3|t" L Xo}OH0,>5r^A /9TS4%Co;W6I5bub'<}Rfi/B3 *RK_&XnI(@,I<R3x祕^񲻥M vyi8qz*3qΕ e‡@zg.6Ju=Zsa\_ sz*;.at fҦpOūѢ#G RZE 4M! %vrL&B!Ŭ\Ƽu{@q /BG(W*I3_ӯ)eR|DssKJ u\Ӕ;'Ƅ8'HOOS6(XQ |OhI)"&J*: L20&Au..TdTMuߥSI%D6``(D$|BAHABjI}H}sSל1Ɯk`k_kߧy͞v=$w>G}L5are)fGbP3ß%zKFM)O?կMXV8f\e n$l\܀5=Lrl\ӾwNLʜet0_ok~}u뚺␍"΁{mO^|t}4>˜nQS( #$*R=K lI0jE¨)5ZM~h^ھ V%Gbf]k fՋW!&ZJD՝ ,Vv= K=n Эbawu]$iLjyrU'/ӷ~ZEe4ᘅ7iKoz̬ #|/Y0~ q<3)V\v@$&>}/Q h\* Jt!Ff>Sd0MnW4G#}0g_$3a"FeF,+0<5ԉ>w<N}c3~ }97fqlqʾJE>lYϕ2Iz$k#mE0Bk?On-oNeȱGj[n1>!~Eץ{˰rAJ*P漑$1y\{WjCJ^HVZoI%M5QCsOD~ݶr翵/KWPJkgIwHF\\$QIn袏5J"ǯyeR*%)KlN,Y=ƍ?dx|}-JoJEČΧGN-V17`P36iդȾPOQT 5Yx3df@u*QWl%W5F!))eIbQ[/R`$Feo|Ff>%v^s+U%c'{f )aZ[LU$Z}(ӰJ IM$4@l~pn:lQ?@ IMV.PF;9umg6Kdi2?3o_$}ֱ8# 4ODRE-?7m >1^OxG2C 7,$/6ņGx7^ElA|ؘXwyܗ%Z Iu/o8]>g|9Iqe @^4[Y  y#Y"0Ru|%`GqT[o7%ү7>τ,x`krp24ĝ& 6&S|֒kyiHK,NĖ_&KMJLbx_u7Oޗsau) bM4ss~:j̹0.Z#|"ߔ1B?Ѡ)O9}m159IC *YZbb<[=_>5ROКcw=oXe%ܵBή,qd|T*RJ }FCJ7m ^( 0: +ͯ$Vr+AU'uR 5j[Q 10FY C+hey=U> D!R:jhTd{AMs-MV6SǼa&*>=II}Q|&SM[^8"BI`qzIWw 7ә?{P/TO܇'͓1"*v2r "?FJJt)L1\ˁuS 9y GG]1c5b4Wn_yM1sfzC񠳄FW bv36*c*aP񑿎U?WETk9L[uIj"!{}ف33X2n2J4aW> {΂5LQW]}>S MEYn+Bd=ϮtAWNaɎ%odruGGP♟"5o>=FTڍiSiع=l>HfrJfQy>X (TmAJ] ` IR{kЪo {dgP޿o·rBvd{ =٫I nfaozah@|]/}>볝AQ]W|%jhrq791콆M+eG')5)ms^HP{,頥iWnEfRN=(y㯝:@v.q6`n[N_+B4hrdW\ U߿G#:?9tw5n+d*N;eb1QaC[m*lbU/K /[aot-_.}vSzǠ}͖1B.8L9Nm*z -&4DGI1KGrݶ;ixrzP^qa Ω%KV#T$EA5iԒ\>tDq[?+f0#@) tArtkl>2>?5SƎeTIbEZl w&%L\lhKńc()rRBvá. R4U rx^EEdzn$|cBk'ɿ_qMp\ @"%V62dCM}ǿXV/Ih>tʓ37-s?Wќ7xOC_wR*g}QQN;D^RǙØA toYoJ11skOxMN$QUPrR(RTy*|-n{-m0G+p -"U%pNSӼ?vΖ}RWnC$nuI&@K#\|;GI(ܻr[q8d.(٧!D(>u۞R\~L?ԧ*Bxwϗnr3mrHzJPeD vڜH٦l[ WF%THpRRCIX`~2tg^f<+,s{wAMO;L:+'쩩0Bs,5H;uߵPչ$R']qhGɡv(GR^0^1&*ܷ5/=oMUL" b#",P`@y͢ʲw^!ɢ,(%"uX2Q{>j԰s'14{$}dGqR~m (IPUU >Vw%[ܷ]7q]KX+r_'[/˅}k_ݦ[W27NGi+zg/Wܪ+/w~I/+=br;7EkCu8RWփ~w"n%zja] Y-F!w,)KVE m'76M珯y@U{b*0wP4D4TL1&@K.%=A0;EUlbRW:9[2mM+ɇ\ɮblG ϒ|38{:4*Y$HR\3m - D<|\C}U1kh sIf%6E~:(cL݃{{ x˳䏿Gc>\0B{$BG ݰAHB}jWɕsʁ__*xhRnj"#{ԈX3gc$FbR&HLQauPɚ&b,&[ w%>+b$$r Vzi26x_Mm=1jV0x3&$i uE%CDTe&@K.3nYЄ~(kF*RUYoCtFN tP;G2(.7@4͗bM!eýme$)o!aZUa*dQ`3("AIkz\KNͱIDU:φq yOൟ~?1:F([?gJRURUa^}䆟p!b>G{T ȩVa3l:cPj9`i"gL4I㈦VMZlE8h\v{ctϽta4VE=NA1 $ ;J]8>dLF)J^6VZ!DU!A(Ġ*liZzῪK]rwqW%] _~cW԰01K Rd~̰ie>mտ(4%Q:\BDj{{X2|#( #b|.(쒀 Cp͢9 ]F;L+1yx+?/$OH$wߊ.j8~3nS#|g1ΐE3JSX&& !@)Gywkņ1,F)O{~\FH% #KQ"0NƳWHt:%ACgEW%]H+OKL Gakf mE((0ɒ+Ēs܀BJ!A śkw|hep\mXtƿc,l3}GRVw & jgB.J2 G 'xK"6^NAF?)L-1(+ӎE-tߵ[Ay׿ T PbEȄſsZ/ӗ^$)rq(sfmn̑~9_UnyG*Iׯ{)…- aDsT2FߊvHy?ϑĸaÒ}ܘ*Q*A-&DRB e+mʦxSW82NTԹ#Rl9^Қ\B`DR F)6 o+Yh+I*FEc !7#jAx;|L +f+%fRc$~==^p eCk0H skO O:#Nl]}U/YAלRy%_k6j$ڶm~pO'BF *D+YG:#J@?4"7@H멱w#)zΑ[q-ܣyf5D4uW\.E5N~)#q~A>5ퟑQ(K csob]>A))[SI|z͸(s+6$#wy\ۣ#L"`-Z R;nS2?Ib'qC4(̏or,}0 IjBE5Ȥ1&.RIbKnS j1`;,ނ z G+M lO|&^ qW0rF~D5VV s" [S+j ij֖s010?κhbdQF۷)1$%"DUn˛oZO5am1};m|5aUdu X! DޫP ΃2ĎLLJFI)1l-T1gtG1*ia\^~**)3J[F #464rn.)cNTtbbn1v 9Q7AxF_ZF3H0w6AWSc.+~j}Sdn%YJ>)>&͔ATt^ɺ5f:1"uvrq|Dzjt-]|I壥f,LT~>4Æ>9f2?)qkd7HiƠ)ge>ׄ93&(mT>}/ׇv:!( dfXi0?M>ÜWbpո01e8YqqR#0֨Bvmk ^Oz1sqѯ#|w]ɿKڟ/t/a#;*WO9X_Q}ip$d<8vM1|h{Fl-Iuas6Bo}ko 7*`FIyzeq^[8k/L #gEu'mhA5<繌2_4vf;|?^tA)~ZS^]kTm 攉&5vՕ$)ߪsS!'=cٺS}Q.}uUs{YZΜDr.nXKJ& HL\sV_*7J'$%Irv.VsKgq MYQt ǵwP%͔Zi*-^”!?GO=Hd}߷YZs?upѻsDjw˜:I37{)u,uظ sbYhϭ丒 1Cl)uY |f}ă埯ҵkd߄?l)I*$etR |L HE}7/ I= .2=`uDjHc n `l&*Y"b!+DUC~%#%%FMA M*hH[h ݛ56fί@W05ŵ?q<'=1Nԡ 9ʈibJttT<߱)EMaM<]_zl_gh^vR Pܜ$ ͢>%.֕Ud4w['F?aj%xSO'%;V~Ӊ[{X m ABFA)= R ArՌ`ADh~RlJɡ$ cؚ{F-cn 6$y=B*quj#*6B4M!ZMZ'kwv ~6ܤcmAVB*dp;c) !(5NDt=eqw[;7p-ZH޾VsYfiQ)&VAV8t[iiGN>^<]ꞸݩQ:#:KKyZB6? 4ssWQV}!b=i]P4*UUԩJ '`爄X4ә' c<*Zo蛊&ܱŠtP.j m?;WD^[iYd՟RY]^8Zxv_McHx-"toVHb*TCyܓ] UW <-]9^t\xÆ@#^:*GͼR0h ]2B 4* n]$nJd~A-<gPg)?hˌURX5R,QM^#h]A^>Q4ZݣkgU224';ngVRhe-M%uVc_;Y{uZw;~V,9A]sL+UoJ")]-*gJDhFd5BIcD}=~ }'*^̤#v` =hN25]uMImeC8J.diL_ rǃsEz}f*'M[9eZ_I9k.Muz\N 5k|ȃ7evgfFұq&/F5/oȣu}/)pAzݼ27`n@]Q U`=e"_3$m"6@,ݤC5TBV}ݹ2HݧH"D5o$F|)S(^{YFs\?۲f Ћ 2{Hv&p j %MR?  IAD"Ix+ޓ4vgvz?ɄD4 )I!}\/dk*;BW= Kc&qA|v=`\ng~&MΤSeʄLT/zd#MCsNJ&'jtf%?N7u&3}6:8RTgʌԿɨ;]%fam|`G}8bO6bTUiQu_IvBR)'j|/{f,I5 #[IAk/'W_TCg9,]29U詇}5%'|ʩ[p̵.j$[0Ր4IchSI!ky/sf֮ʇ|jvM7ć=}fr&7Guⓘ <qA6y8UQa">s*Bϭ%4HSP)$ujfy`8H9 !_Fo\@v[:ȿ^i-3󋬜aEjTQJsovKG~wU酿.=j51L 41Ɵk"1#M#9_nҘaAO"Ʃdaě?o{QF  KYǤZf#tdnLp;>DT[8$¨i)tnQG$]Ny^#RaΊ^ۂЫ`Eo/ #x\@ŦieR$=]j]o%&8&Ԩ!wd-"@vڛMסH6X7 ~(ٺ8tIc[X́H}"çdHLjADD}o=o;8h@w? x1Mj┙,&@K!+CĽ0\((c.]sP;`4S>R&+w$eHzV5T] 4JXf, ݅QjEߝ7l5LEuQJn;M{uD-Vj;l$ܤ|93}QX3RS$V>a /0ԁb΋'Hxh'= Cm̌#(  mZvВ? o\} 'punz6.0G̏Α.;"LQƉ}xži[@x_hTlrס<;Q ~޺e |[Y +Pb8n_ƑBeJWuJ> &DW =.W?"c->;@t /%7'?nPE͛~MX1&RYR/lӬƒttD`q^;WduLrp;$eP3lxoJITM]+Ɖ53EƐA^. ֩z]ɥI+d-[ ܅a6ڟL1W:8Uy$!M'Eu\蠢;k_eDMϒyɯT G8:29<@HVD;Nmkri4)߿WU^r< "E7@ ڣ((iAS#fNS;0N6-;h/t./EUl(* h?Mڛ&BJś ,6YciT*\,Oux5\Y!I0{BO%|?& 5$Zk + JPzC}IY Šl+dՐus5[=?!bG*B(6P0㗠/frf.]_x|g^~"UVG]SJo_deXeJAE8HУ*uAO;HdL;QO=JDcide8%v4KJy.4NY:Vba >/BES6cdpk_mUW( hI˥wYY, 2Rz[MFAAXZ݀  ~Z l!t:`Zc*@]1*6NG`԰8f&:@X`ްaX4fq|Q<!G7=_| MHHH!yфNLpW_*r@tN~jVL3l1?bJ9t[#{UBufT1A"/ yeP((ȉ˻Z\1봦 IB)ݩxL (c2׽x߅ȍQ ⺴8fq+Uiʖexw7/>Ywq"&ڦ8Y dXdq``.ַUfǻ~\r7-h*6r"!Z2.財M&P1((,<NO?dN=pꊥ1cjW1 >bl T2;]3D{J*PUkzƹ˥wh=c$d n,$7KXr.TՃ_odkRO YJzt3,];}Iܙ|-IL r_aUjjG OPN ~ d9&J5԰C7ȁ$V* @/p⎸0⦽(~(y"vYx!AtjN 2عDvS q^>tYsH/3$&ݢeĄ3Ž)CA)8PV3YӷSEE~mFX_}$9Dq.,&h" MdԐ?N7bn !P+Ho( m4cjʟ'Mx&k03Wڻbi/W2b 0ړ6bH銜xu#~n+q ͛uqLdPUQ:B`kWa4jQDP,Wr>;gba%*ƻ kK Æ͇ȷV&FXJ OgԯT?ZDBTsT ͙R}E;ewr䞜}2?danш<Z~(}W?^to<L"YbՂ188YRڵh^>e]|% *ATw%¸!%$nqR^~b >#%ޡwشx9Y|~h=7[hHAL,] ܅Wg:׵.X1\BS0M:37\ ilRqʫfXXbiĠa n %:لWznPpŗq>jVM1gG`Ϫ$/㶋$bl]},#Wz)&sbP$o;UnkoBC_ГRsS7J IDATlRR! HJ>^tQeuh}e;EM+g5O+еNLEZT֌0.L:혠|8pzͭʇ^*1p}!#,@juTbr,I[LI+$bW?nt:]v8c1YkẸtR+V*l#'kW] ܅WʺblQR!vh^9F+TVzo=1Rb$ވ{oY2=b4EH-憊,itk;^oZsٸWaYW(ڦMمgXqV ņm&6^~UM3gna6IBύ]LUɈ5Vm*^|23; ^$x4LlǎYZ@Ɔv{'Dza !pވ3O4$ey ػ9(B Cr`K*MU7y(M \v= ׳EyiPW<#,J54&0]tR Κᮺr&W}@\JY53$yŖy  Q@R!b.EOFhԢ:\uaI&zC5h̨l̅nPl-qubT3G˦U3gt^K*#w|{>t2F5oȫyqL>5Vwu#ftLիY{8d8l7pѲn^pbEcD7N&4}UUKYmw:ڰjBSe7kT•wYӰiG<"TyoUG5'H] "•?TaFG5Q|%n[mڣmkd$ƁEkꪪ4y7߬ͭ;<٩"TP׾ex6ܵTlskjԭF2A_`i`$?]&◱H6u?w5pGo#+0smolBcR`R~Dp7L|M/\$'A<&aǥ92 cvxw cQ=s,9Np W wreÌ.g9f/F[Җ="Su K^-탢h1Zama:p<}}ѳ_dǐ#ǭZU{GPj~u>{Qj \#UؐuKdKcjLX5%[ج~V)"ɚ}l2:YwUFPژaۋt{wE\ zUEPjAB*ˀlE8-&U7?s+WF "!QhZ-DE>>k9|~̀SL7'5nH(m1oOEC@'b!D7I$ 95cε{o;~^j}T=Mծ:k1cn~L`j1vJeyڦ R(|&=to aXp*W_#pBJWB UMkX(TB"rv275 ~:8b H*r\c! $[vԜN(_h~V _3Q VaEA{?^߽Ma4z 4{{#J_Կq.nY6z+x!1B ,xDqRBeok!14#m`n 9y(^Q=! bbd(A}5hF*R&m!DΈö̠TIY'Cڎ?T|jH_^v^u~Гp-8Vwl?W*t$[2n"\\4ѫs7XP\wg-2C ,eO*Hf(iQ8cxсb/~qD<"E! $ڔm_x 3lfpW^3!@?5YR/ |ls@3PV.?i alGz3Lad4˕yBĺ gҧEzHnQUplP^Fm"crY!ff kB"7!p3TQ$?I[C_rv5+* )j;sgNSQUQ6١F4P36zBËM+7?^~OiS|/à  %'I3ܦnrZM<ӎp#H59:>w̓6E1ۯpbqD,517*#V#HQܶ4K1WAe,b'gΤHO>}Jĥ?7] [Ǩs\OG6n`rqߎ4'oKް@5Fq>[`I }Sx].Fs$#2X2Xq<*? 6kUItSIp8_/_.RŸ\?|$^>}7;1F:?+j%Qgll ᮼڎ-Q G-:T\9d֋22wAuLf+cG/C@֮!WoiGc/*MdiJMڢ6U(-G$hrB[+X*pPb"E3ܡ_԰UC|>N8,c*8 cOeV;pLmEp5C :fdA W|W{w֠C֣6k\=8~f|n,1?ˀώpIٻ9uJIhaжZž Τdzݹ!L"^v.^1=do]֦mȖwAcHfyZ)~!q\Ym#ܵQn?0F5Mm\n-@j2wJz\|1_3Q a[F}Cxýқ?ӎ`1@pq]zXayql7u+ KѴNۏ  o+ԙ9E3rpW_-%|"Jq\cd8b/7.`V/`Y8x-\Vccn-b<!#J=_Ѥd7E~5JuW9u{]F80&Oc^~ڸ%}q=;ߺKUFEH=V)'e(FWg:[Y!W᠘r]͒%#M4 jGa1"tڍ,J`&ؔ- "4o%6ƭtAWA:V:[:u3$TϺԿMAT;Qc^\}N;s}l{[OW%x<1ܺ-QDB;~nj^b\/ N*v )ш;7t_wէ{roQƪyêy^y,a"^WawUԿ5X=X5sL1܉ p[7Z^M2M@K4;+H"dx *:k/O|`,ɝ=388[;[.:JE&uP9ɒZ"l ݪ`ԦJuPyƏM:06-ذClB80c1ʘcR&$38ܺ&My&2QcrgpsO{T\ɭc^׎6u0_8q >̩rkM1tؽPӠm($!s\c?]_\݅aEZ\ҥ~`q8` B~S]T  6W4МKьX5Xb/a\c4$wF>mxݶ nGvx,Nl=stz/yJLQKIm_3l=ؚevUpˡ G\/ y%@0 ȑq{\Qf;[`Q|8٨b&􎍄PUuf)`&=F~A(@@5BA1Pw2Ec+[O^L+|hX PEܠLKw(: ڥF ZilgDP*UP,Lis Ϋq2 @zEeZbB}\u y46rZ`tҶ*A.k S9N] ?y*b{BpRƯM?'7[᚝vUʀ`"N[d&Y4 (lQjmZBAS:=SXmFx(cc&X4ư.*V@z- 'FNa:y։q>m?,WXcVaTxó>Cb [`hvR #lTԧ\".@T($XhTXm܈EK-!6 ѫ"MW!%Ixqwu8Ju+zÂv>7C"yQonjFQ++i[o7-/~ qm؆u'UJ MI-wJ_F/փY!ܵMXjNp h9n ~~h|`G٩!hNowj"d2#1zBT*X<(5eN cV89mَݮYjX8=JK7ן,{`,){m!,UU¶HF `oݎ6H8d$ $EvD -@R҉7M "5UЧ~Θ݂m-ٳ/{UPK](o<25\:ӿ%z1X/H_A?zJ`RfƋփ;c_D[5;W۶RTDNfJ-pt2lݎWOmTb7^*X4ֈn;lY%=22" `;`uAZ#'Ɖ".~p܁%\=]lmËvB2-x1Ax2o$B3!c<~cTj.}i[8}.fp_M| t %1UDaI9(O9Yة|4#lq hc430 h*kJNy&R6%-Xj RXi qS#|s8XcX5A*o#>,vg0C] C*5ڔ5/uE#2ԓp*b l)lyѺƝ9kps `4`ADS WΎ:{fj&ۂ?> clv\U1T_JR7-AWB8[;YB> j$nat-%5bn-N:1 [D`Mv(P6fѻJ}Ϩ6mm7$^7즫*lphݲ>ң*[ş2飒`'^=%j#7G)HKxn^Y.Ȫw_fԼ'H}NhpTE 1~O"j9:d=(2xh@@/ pM" N?1|4ɏo\=48xтG`+';o>ۻ #{/t_B˯`_D8 @Ύf^Nx#:Ƶ5AYgw8D^r6(VPcx-B8 CUJK+Hĕ5mpq]>=oz>Uڇrd(F$%mE/ kpH֠+Btnj;ힺ+(@ 6A uFYW7䃧zS,7N?nlOݷSԿ&짮 |q։F1 %|G1ЌAc4bOC-6[;_w.nv~1U7Y!$| z a4_"UHeZ&Z!6/#Q?6'?$k=p& '{(A=G*K+Hٚ3v DvAkDoCZ1Cߛ\˗C Ɇњb;`-q}m|o3d1H8ҝ"<T#0/ӏ% 33ÚuQ_Tc,dнqo\WkpH( F{t*QCiE*V4¬b&SBQ[%\G.1}*[m\%ɈV4&k`YK".{41`8!PBSH))'PR'(Y!V@$蠀 z$׎FiS okwv١ZjO5bt XPawfV4`7ҳ.nngܞkwN׳lqtQr:JϾQG-d{?RSJn|lփYp7Ym|TMJ yg aLR)QwDSш2,BYē5 =1pW(%L ]eP-QwIF=h :gtDsZH *$ŬȀ&mM ݏO?Q8AYtu(MVz/ ٳ5[fp7Y*Rzw$%v&i ۏG0;j;c!6ґQ :Ĺn{0-)5S5a&w", N?sC6k k5c2 F- E"p)]!6 u,¨v>7;^V]g%ƃtK$/܈?/;=wODLlN]wި3Pt3jfX1kCy+eJІWgk\3jt7Y*aPXTe*b8S)f 0)CIќJAA?2ɧ ۢdzLJ٘,%L(l5sٮk'd oGeo:3i2Tg@*1UH U5>zOiiFQ^x cWA\rBS9Z;!PUPh x}sb Bc闝S-)W+KB>B?w~'_g{>/YO"" "d!*yh_/6RaUzcx7-H x7 O쫹2|$UfpwY5*{?sFuw_ EѹRdd!T.|JԨzѫ+Io=MŬp,+-ޤmii mFQ:XcmTcR}k0 i5oJˏ酧cyޱ<?|wJӢUJ61pa QIGƄBGB* ;ٷtgkCu'g̊3gabKBqG+п&>BE`33"VfJ㍨ٚ`(j@V'ƗEv0!gZ.:v4BjvˋZnF=b6f P< NUn1n?6:NEl*e[F:R6t"O3N_ө> 8ڏ ۮ…n\~U˹y^;U4U^H@uv0FY*p$\Ñv(;;RdȂ\%~/lo5_.sv_'JvL{Y'(w PN2^}#''?؉E NV2e\'"d\0;7a$L*=J ]F'<{{ӹ +SA _kOKɉ0=y.֩s8SܴO ,(SqG V=] l;ߟkf1J*ƻufZ3DFUf|T=p@n[r4h)UK8lgB=mjڄ*+-(1AT4(y:n %HBMrF6֑v:ɱ ]U938`<<,;cM7-(pž A‘ȠEc`nhup߁Ng oxqGQ ?>=w^z6~zyCi^j?a6Y!tWc;[3~Q<g| ,x=_iA^&30: BӪqlc._9g DH7%G[q7lfg=.D[vD\3pw(˾}0R]035-oƤrEQV~6]肿z` )UcD!mc12xμ]<ɫk?o܆@dK#,1`\c8 n+XUC)h8`86+.3g#)J/]SHo,1QטԐ"θfԯuհLL9QRFQQՔOd"׭omNPTɉՃ,lkwu5oKay6aN@9{ѰU`AP E{Dv7sBQ4DTOjztk^mBҘ ;ES@ i:gNPБ! j̎8W PJ?T5‘vS]˟?B^= $`PAB3+\Ab]wBJяQ5j; $%$=I{XP%`]}16/Cğ~|xZif^A&X/ _~ $(2QsWsn)ab0CڠB[i}dfjb%~ٚu nȠ">p4'%P4Fa2d!YĭLh1i)9$RIyXXCJ b2*jm&f*O<'h`vutPd2T7*| 2./.4T|5ʦyB9V?$- MJz.ޯ>ZQ>@Ԇ*_W#)6R~'5qopuZ@N%T%A%kak"D!ة۽7@; Ǘo9'8%2D#zðe/=P['T *EwbL Oz[6||6]zj|q%a=gDHp*W 3 )jI4a)*Mefk5+ ;B[e̦~ᴲ;f31[SoޣO#(ZBc_GԘl$3Z_4JTPht*[@jjb [Aw91n.А !R2(sgnՕ_xnFX1sU> ꧳6L2&yIBZnO rs2 >abFme͊%A%;t@ %3?7}n%TZk%lSR(8r~ƶᾑƩ|5<Ri4XS]*L9gngE17 4'Rj0pb/cDTi#OƟz.u\KX9~s=Q(T jxsՓ+>0b2'@X4qw4q  dC":#1'j3\`9-!o7dh4vP2%Btx~E͛Q kĵ?>2pZ7^}Vc5G!]%A `bgd62|8U06 P1S2Ho{͉7+!A!5[5+ߊs>"[OsDZvنrf2Al܄rPXrg(UxYڄE8fk2ԣG8U$d+^R*8wնOlR_0wRy鄾YCoYˀ ~G_8" Y,;:K*U0a7lA $¥=>Qt](n+~r ,Kk{mKI _]ɗO/{"Rm\2+3kU3=e-,kOt)z!3`bu޲1/畓,&M[Bp &XÌBX0Ot`Atv*"7cZ-,j}Njw@Jns:8Ha)cBJ  IDATWX򱙯uğȯ_mcl_= \ܢ$[ᯥ D p^4Q_s^TSGaqj wK~1u2aBZz}BUqJBETF~鎐J)+Ph4s Ihixs L֏mI(]8`G(3tyGhXl[Q/ "t[ $F\ B*U?j%0F :& p!QWIǣ"%Q/:WSZҧNB-wAĽ4{dSzD$S%,DIG[Qbk|&Xe1eSn¶j -/& a3ږ3.x4<>{cPR64  X`XORB9Ө~jk_, ;TnXHSOK5+*f>7fq.< 99QeGM)t%F),E"3RO*)b؁_^pIs*ښʜJSY[; GCN0D,x[UĢuy$ajȅ>i{6tCL+pJD-D6aQP_ ѯfXXKLIUƞx}K@?c z1<<8&ba> Pg h?uZ\sG[ GTvУ3*d #%$\~ԨTQIJ B8[5+ۺ皥]@bEv$в01)̊j݄&MuL@IfVSh30iq?obyé- zkV#U-!+D p`*F~0 %;,.FˠZ>JdwOȯ#CB =(<:2Vz$$2)[(mi9"PU5*"[~.)@k.qZvAQIe}Io/΍xo T.^1Na|KH{ED *, mT:Ϣpx`9:NT{3UZ/|BB '$m$&BP*7+XB&y4 ZCaG{ ˀ'jvk%u|rVHlGV`GOI*R&7pimm~uQ"T+J_)2MǴ BJeꅗIP`K$SFuF&"Igb`Dp3?TB*,Om ^)|HV@D T=ErU ̈U0ԎQ%T9d4$K QZB˜d G(&% 2 (<F/Q’LkYIkMu'Ai׫eȝu,,"xtpp!)di!NhHBWgM}MO!~ߖaɃU B^{$h%!h 8*zK կ)~ U‰a<$jnab8p| {&2 ?# z蝑 ѯ1/&VK@co!MCD % =z%gY!HW9 %A]tpTP/rٚ| nkZDS~=>'}EE!dbY,30)[P,)adu~HK$ިlLf@K2!ɂw 5+"cd3|?9# w;,JM@KL$wS &d~DC4|LG!Z,Qd>{x-@**AQ++qcGJ7Ө}ϱq&3e(!{LmI<+nS l\B҉g3# ]q5$Y􄨈EHQ14E㹨ERS5fSHllMZ4@D5jbJ^h1id,Bʣq6k_^` B:w =$~$s):s7 OYt h9K!x+7ʑ Z uR%TށW)!%,/c,#c#K&я~uWh vIR)c X9֏E0뾫ƽ8,{p ,EZcܩ`#aT]<#mϻ戲 E4wZo]uGԨ0K档F`WL1̓|OlɽMgveY2K :("#˓j:`yC|Fݒ>zÎ pDe^>z}z!PB8#3@V;nE O|QrT5kl-NʍÌqne"0c1Z`l'Se ;aeb6O\{WUOQӮ;k=קTIJѸ4DG |h 9gARBVziN UR+i2-Ep;{ _Qa1tĐ*Ԋ[w 5 a" BEGYA\0׭7-@\TJvD!q)Sdë9C5fp\պ^hQY*㙪qdvLe1ǀe$B5ѧ4mazjM|F=:+VcRNװ #8/* iDŎ 5? wi!vӴX K“yrjӰ#փld{ް)VpNʨ@)${H=KB4cx}4V0 \ [-7.C!Wѿ,ﲦH[ B򎠿^P%GVsP fGbzǮ.Fd~L,e*"rOQ=gk?xOo{',{hGxV%VkwPL 鸷8b1: (IPP\tBfCŒBȀ}ZK!A]H2U/12"~k/&& "=3}=w/u]ݹ}>gfi]y7 ^'z{?Eblm'UCg [,Z7 6*D,)5WEAFK-3):i&'wÂ=}`CT%*c$ t3ô%\х~zL%+- eD<0j┆xV~`zbELÍOL/uvІ(ayzBmi6InLTonĀ|2OԼLtS/HM>MthZ-2>2qReҁ$3DD=@G! ~ԥw×|Tͩ5. w%4Z("qz !ٞE>2CUMtOY˶ tܬpm$~ u턭c8e%'ާJ22܍leYfFȄajJA)0Cg95cp ,N ^ 0Fq h4[dz@ 4GLHiKE"\)Fʰ! @V^RZ^S\CƃG.'@-Oo׶9. ǻ!h@Z✌ԋiWW?)kZ}[;P+7Z+֩$=򂉜IȞ(E X/pF/'Ou2I#9/EeRjrg,"eK PT S*JdG䠉TL>m:TMh%rJ؂);rm<414A:5i@n`}nNP^ <1uV sXcx*ϥK2 ?> %.*#8'ݔ^I\h9ZoA|~7nJT/tT t;@ZnJIm8IRB'v-  UР5a2:ZJRjO>$4 Zln}z`}A-ea|0i!ўs(91wSMXA(CMȖZQ6 w9OvO\Ա֯qjyRu[HD7 nϠa1J9Y" eUw_Z'։d͈@H%E-u;l2Lrhn GaC(!C ܧڳLӖ ip3qOs9pKh^nLMVatf:%I8gh4 =IzN~w1Y! _ d;ecY\<bF2,֌-^TF!gIbȾ%Oc6U ]d0j(مݟrG07[k#zϥxAiͪc"=_/5ߘ)(c7Il.@ϹM;螶2) Eb@ 1umLT10r,iKB}RJ) 2{Fk3'xL4u9hЖ-$^}[Zej )9~ŔYy6S&=t)m {B1/xMh^dļ5 :11l𔑅j10[8gZw^9tW|z'׵}3z޼|0-5)Y=ӱgyd߿z>y S:-qb2,h fFnC>"& 0_(cSv4Z5Ţ{Kf(Os. TrGѲЕi.`ρ^.lf5Ll X˥%$s7tq=٬ujm{gqm@( )(%:Jo|B & KB'wimt\:<9ǎ-:\xp/lKMNyHv^:&Oªf6];vczh`TcO1D˽Z9/a 'rAgex+αKq^s _%Vza)+J;Y6S^}W 턌P:sG)_r[Xj={E@G=|urhbwy&#g'SS_$&Ԝ7i|`v~h&ˉPq0_fI"M&l9؃Fjt KևpFl8gi/'eei =eN{D;8,{*A?WK϶1Ŗbv]",{/,)3;h@KSIסsOpS06pFxf!a톓\Nt (zݸy!;j!>X hZ62yoAۦmNMUӝ½ޤߟ!Ŏ >}PQdXB̍Xjh(tJZV%bhe_67H > rkzZ>ettuAN LD׾:_oN ~Moѫ?mXlhMRxgc?RSB?NZ/Kk,EBq 5 8p`(ls C/3MkGg|k2tH8 ,Sc,/Ugbi't\vq骕ؒ#j{Os^H&*ԧD[2u͸hMi5F2{]G+a)3f}C[4ބ)^v>V~^oO"sz/4fi-|U!2,q ׾u2kmyHMmnK ħoU0]ŗ}^kpѲ4uwmsMrisiE3=g2ٛgRhl%xdrȲ^ 5O\MY-)y )M.A3蝃)c10f;NGXZѡltQF"jv0xA_c }d/c6ܿr:Aa!o@1 ^;ZFx׀FS-p( ,Cy_^$1a((j"d`9XiyFاmG՛=8MM,`l T2$rJRP\0EO-(|އLK~ңKဘ j{1Y 1 D  )^,L 0 j{`>@:4$]C]ϽƄt~?E't*,]FЄN q\/8*kZ}^FS>7-:Dpk2P 9É^\j--QxܟN#vM5jNMZHƚa%l.[]Iq2 38ur;;FSflektZ sȳ 7E{1)v͍-B[<u@m+uõ{[SoW[V|LϼҖ њ -BL8gw?NxIy[?CbڇN%M}Np1~ a~_c<6m΁2 .JHBP9j5 IDATmeL0BH;qp)%p!( eox!ͣ[Ni Lu1ZeI@Ƚ.e%.\R`Fu"&vvc yXL:<զRӿ́R]ŕC:&&¼fLBB~Xuj=NBqJ[Ga(*P'&I$ԭ{Л`PM?4u.uhjcev% 8v Nmg< &2c"<7?گ)2Fmu| “/>Qd1SZ6byB7nW~:ԡɔd6Kx `M8¥YҚRzcQMwH JX+o@P`@ja^&<Df%mE]fXE )ȀFEG]v):7ܘj/O[TS(e~3\FQrAX-pVIU1h̖lKX+v Lӗ<mOoג?8Ǜq Pek2H> µfD h2s(/|(v]I݁efğ33>um]2ŌK/xǾln컦(./VEdh+iC8C(S9ؓ2Y͇PYf4E^O5̥Ћ>^:C3󌑫a2Oz}tN^b2*K.)ȉj;u'~$_M!9.\Ħh@۪XJ9u~S^08jTm3_Ny?DSe|1-L7DJwSmC#&` 4Y|\RhnnH'fUn*L0Qܤ2lT]ld`@jvL V =MF6I"nNPPׁp?dk(oܥ,ӼPLJ 9o>ܫ4!(u\nzb^wdO"щ^bDF4z=|>h+@QIǙ".2Eɝe9܀5Z߿ѯAILb n&TpVC%bx:+ |KQuGׇQ#ڰZlz{-qį !^jB+~/ըwho滩0XHܲ]|*hhXל'AshLj<-:|b૳8$\Zeapnr"d2Uc{F^qȭY|.e-p>b1Y;…([-d=o{My0er~Wiv* "]YqM2]o{Zk։$UeR9`/sС0 {E}w5[̅_) .I pR$(F@KE(1 jH@Wq,4[QN 4xN]JEx=폙{ꕜ44P5]S4C\,8c$1X~X$Fn㳝Jd]M?9ckЕ;CE Ci4L2D]6F6]ٿ7H1eH)9њ|KJ7@@ Tܜt0޵QdU2X@X6GsDЭdu-l0P֦}N >2١g1d1ƅ>ApVQ p(ExYhČZ wsa @ l=3Al"QJTu9H,v^v),4FU=a4Y:QP(\LjMRSw`LuPt `  h /} Yuojm'3oN;|$49f{h,΁w5mPKB3& x^='BeS?lYFM)l+ n.w%u HTL-g㘰I˜@g23ze&]1OEA0]=rDPH2Sɩ1a,A1;2NPPIUƶ5wf6/eY< HXtpA'r*k%=4-,e,1E9SF}/}Elv&N=fS3YMcZPF6]k֊<=y?s.8"VnR.<}UqITGzdt"H7F6eE5솰2KĜDNoO;liip ; -kՊ8ýTroIlgS6P&X0n(>,iYF*L(74`Ϭ`ФAZ(?$҄gAΚu=PgO6ŁQ ,1zalzYh,MPZ+-k7asMvF44sF{[tAr_&MBJń ETƱTPb/N;27쯼F3vR! @JAtU9""ne yQ9ߥjB#)RdCFO?ح.w2af'b1Qq`|*&掮`x B?Twp3D+mO//!(nujO^1HG]`ctaN&o yˇ0cS}[QNnTƞXF}_|旧Qtpb#݆0p4'HΣ1&ꦜ,kE/#c{ e].+¢fp] cA}V{EOTq\M|gQ&p5>Yd@hv[k kZቬ.wsu>r;m쓿c:D߅it /ǸȦuƃv0FLxȅD9O<9=2VI9x7—,Y&'y1qA4B `S{ܽܭ{~k#`αM8i!|GQBPMd,3Qs/~SFD/=ޥ b]{~Y;#za]#yRB~ݘ]pS.hWϿքr!l>@LZ"8/99XFцՀ᱂L7 nY&*Y}mm@Vms;Z&ų8W ,VQ8Ec(a3 Hs?ɼd,ݽ}A u"\Of`+ric`h6mbs>H;lj{Px}y^_NMQCV LQ^RrF|l+5B;4ɥfe \vBc8#3sXr틉ٵz/P;.J!xgn~oX]pj+WԿϨ E=u BO Fֽl;:Pw IJJAI"LqM0GѤ#(Ǖ7zWT'9)!HG%D鈗g%y"F3H:2:1!:Dd {i-dȖCz/5n"ç9xzd7Qa/F ~$2y#7Z/U^zGwuM.hLxj3 q0\k:1{;r~5a(R;6Pw-V{=Ptp, i"K?G/uz\xp-y" w~#066.3HEI |g]-O DkVT-#';E"kZI oӋqEx^hm1zn Hl*OI:eԊ8Z/'„FQΤ#{zS݌l`hri#J-,Ʌ$JL0vˍDH3`S rD ٛ p-ՄZqajp[XE&butbʤ2}k=aAm8Q#>t4rJ+ f&ꠏw׳F3*LZMㄸ;}J*6̩ .=B)M;]|~~b2Mƃ IfNx?@rέ1O^tȎW'nád"~>}dEٳi-G$a2b MebjeFgm)|XuHgOFѢwEM7_:B?NGD%nVSXB8;\T|bPFjЍ%9ZG=Y՞SG*A~t!i/(lSԎ=]`34I;.%Ι8wNA=ĉ[,op_,CZE%w{}|\&(S*GXH t ,T z[bZ{F(Ă0 p8"09̄F ]!n58tIF 21iPtQnPdH3nM^tFOZP~W/gyvAz@"pQ\ʯ(;U+>2X&aDǚp$(p6P5v|!á)IF*nqhP~N6ޘhCA?Lu0wsE `"I=V|bʤ]s|׺˷M>mԥRU1'B:jAX7iRS:1t沠pl(T(9][ |2MZ]P0y kL -@Ph hvȉ~L^zc"4&g,.[6:(n6݂>:n^?Ie; JӃi~m]0 FB 8jt}rhLve85zPl("#05wݽ:^Lk"牐ۻqOPǾ^o3-A8xAK.5w\_ˡ>Ӄ3Yn+[#fUQ*(>QJ+/ B`҆!d0P<H)3f#*,*_ %3*\bP(#-]|uz**T s0{I/3u]][L;Mt\WaO}7^kǵkwcwTIVэ9>`(( -*, Hܠ79Z/0A7ren$ & @]F^ $,tb.3 pe B{E]|+=hk4K5=)zKx,#ɰ3} Ctjh6ݛﵞa6µB_Hsh5pZBmh5#GXHli9m o6OtǬEÌ#aj5OH^Xe폾>}FW?NBfB6@ _~MHpXұ:5Fs5! &ͦ7U*4_CX.nhvK`xNM2iIh]XEq,Ś7ӛzC p2{- 8v%I}Rze\.zɺ \X+4ݩђП{AD@;Hyi?`44^y T@)mN|x̤ 0CEFti+<@dD"%!7΁ @FfXRQ &'FᦠZ" #" F;X| gԅI2W\tgbpSbsqNCL !}k&tWNm2);ʔYXk#\T?}u&2HL b.zTw !d"4)l)Ŕ0 ?ҀԑШgn^&jeco4BDZ!Dw & !e#RƩ{4b$Lg6 XZZZwXy|t::Hߵ㺫PP<-ZEо#;juc7!̛4~ԋד: aɗI #69@gD#p]!.34ZtT/OkÿIvHEPx g@<᐀.NFwMru&M^ƶ 0?cyZk:[nU?VgЩ ppR#?PDp$CX=Pୄ3oKhY`rgTL4ofa'Ha n - 2ѩ6$;1{m4MF8o _ku"\VL`gЁ{ "ssE@Rݟ|Bۣ?2\BoNg 9ҹ 0rÃ\Cu8,'> 2PqW \0Z)WjKA['`CJ_Ncgp[9qG҂)30I[hM=A+<6*4[ZZZwMT#<2pH#,6qTo`÷n|7E31UA wyҁX!Mo>;>с}EP8 A}.kM<͵hDO VӹMHoFJ5iޤL/L;κ{eљRI] (iBpgfZw9$o<rH5r+G=|ܗШ_sS¸{F;=;~ b}{Jc_H::>Ŏc޶ab1y ;@A>P"N-.}U/ǴO[5pQ*"\Yk#\WHŘ8f=>ᐱǎAƧҊ#7CxA8nq oىۧE쓳fC=iT'Ї+7Eԗ/o^?VO-ECϺI#w w/>&_Lqp~-O]kVk#\^T؟;ǠCq? |Ёt4´y;H`)FxvJTG6fY0l0hR}߇!<[A3'cT/1 ‰AL-%<2c^ǁ'a'\~ȿcvW1e@u\Zk#\U{㿏} Q: ۴#3eޠ'aNMV4[z^\88}C1ۊZFeV4P葽 :}~*ٗJZc(>M:"ũC>|r?La/pghdi»rӅ(hlcSNS;|Z6AK=z<| '(uh 9RhHHQ$+8#) eP#q$ Rf ;z»e=5vH#Lp&p@!@DM.N[LWeh"PMkLu"\/b%B& tM2X #A?W1OOjL?3Owe+8F:-WcmEe:1>"wbHklV1ϼ4\Bj88AaUOZk{UD}VLf 76 AS#iSt߀S/vO x" DXVJ!E B>rAډEMlDMK9 G7uD|NM~yF6vm4^ֺ^uG#< <B-@x~7ԅ -'šKA-2Ŵ67ܛOT KRPDم%ɡuw׶}26lh jV\tgnp3YA!YY,x| mMPOovćzIuó^Pp̗mo!cY@ږ|Jub "8&Jnډqd.&D[K')k=kF׺*YY")QFBAAY'﵏ [FBJJ f6͌'1D3-O;K^ jGo@#$4 d swLڹv[K.>Iő}Yk ZZ/ֺJ&qOEt(4yʍp2Gӝ>V=~nu y@Df_ͯR\&ktL}H\tu>/{b,,YF~[6`h X] }X |6`].kOгLcz'1{sP>,^ 2ܙl]ptFD? Nf^ 0lEu LwwuoƗ CgEzFJY~m % pPdFEdOX}@ 6D=32t ~'[%F$EXF4 NJ`2e&SFSf9Vm#o F3։pG_}%p m h>=v'LLj>~bY޽HUy~MuTwCDfH.ѰQ皌n"fM6]GtúhtfDJPF84l"Y@qަj'AνS{y88'ٗ֊p4ll.㻯:갹K-q@&!sW :pBrk0t;Gq? +;`JWr-9cg%~\.$NNrLy./O&ODNBֈ8qEi79wUGaOR}Cmyt {v YP`&k"d] l^B!HN ~HDu.> YP#4*Gx=3H  ]pD,_fs `;w:7D\gA,r&s"Zu1MpPLkɌ(я:w3e @煀 Dp9bDLvmpٙp9 ĞD/m~p _AP=¶nT̹g@;aض{2!DdD E) Vz_ A?Vji"TΉ,8myW% Ģ\^vF7>uE?YOF~FƉu<nךNa9@RNo!kW+@qp'(6t)SE'4NC껞X+JeZ62RĐQMJo\X3rc'3BbςB HbOEF!@RKR%/fAd$S" ,jOHמ2~TF3Q4*U²Sـ 9@P!8HCXݒ|BP& ~Z5"1 ȯH"iX>~fPh"Tt,R/ D $-;">tNAP8;)5ጰ!ie:8 k!mԹAR%L ." _>;pRL%?r@?ٔ*]",dar o22f{6.sPﻵ'>꜡WJ0مb3{ -g/M꜡P};#/c( žmR_8\P%~$2`3X 9(Yc# ٳ=7(*a5 +H\vf5Pt,[Vji"T~kT`@L+Jva0sf*unF?쳹s&obѐ IDAT.\L&Ă :՟mڴȉ=XPD}d29iҤ?xOm($aOʦN'뇕B/2_m~(._f':YX9o_f?Z[1TH{nnnےdee7O?Ȥh4JDǏD4w|UUUD4a_>o,"?#UTTYf֭jr׮]O^HI&9rj gy_/ٵkW&7f.//ooo/~`rVL!A>c0̙sX,jժB u޼yDbŊgϞ1cF$Ax5ESB8ҶF>z%K GFx=myZ}555+Fccc_ˇ̎;\z]_^ve}|'ܹ]=ޞL&(5k Y 3lkk+Dgg#<V^ vѢE7nܻw/3g"eE%B@"8:@6~P1[nݺuW\qESSic8cf̘nʕ.]|nOBL- %KoٲEDx"z饗$eA<1 ׽ũ8!>ԧz~5\}7vXfWWژ}//XE7pSsgWhll$m۶uݪ:9shB޵^KD݋Huu5577ȉ'zp>)$͛7XbӦMBss3Յ Gg oIDD·_ر6lkCby<92Ss&NmԗĵS\_jc8x<߾}ٔW(N8ٸqy睵|AXݻw1.Cy߾}D4eʔ|ISSoƍ㕕wSzg rX0[_J|wK.ȑ#a>b*%>|.B2eM8:׼u8Gϩ\'~G@UMd~)$ΙL/'_=p']㯍9Pe&s_ˋȉË-,//={vŔ)S(7/ի{[xq~ׯ ɓ=И1cbXccceA%ׯ>}z47n܃>x1mXy*%m޼:2eMr\}éy!k?/ʦ8ng?ppΜ9a;m=؞.\HDzkZ^t$~)jTI2տ QI@RߦRhX5*{ 8P@0h_ % \*y'P(D ׀r2\QSTM@\9bTP`hcd*OA  #0rd`e.k\R9h'V9 DHYp4T9`Ab )@. # # Modified by Anders Logg 2011 # Modified by Martin Alnæs 2014 # # The linearised bilinear form a(du, v) and linear form L(v) for # the Cahn-Hilliard equation. # # Compile this form with FFC: ffc -l dolfin -O -f split CahnHilliard2D.ufl cell = quadrilateral P1 = FiniteElement("Lagrange", cell, 1) R = FiniteElement("Real", cell, 0) ME = P1*P1 du = TrialFunction(ME) q, v = TestFunctions(ME) u = Coefficient(ME) # current solution u0 = Coefficient(ME) # solution from previous converged step # Split mixed functions dc, dmu = split(du) c, mu = split(u) c0, mu0 = split(u0) lmbda = Coefficient(R) # surface energy parameter dt = Coefficient(R) # time step theta = Coefficient(R) # time stepping parameter # mu_(n+theta) mu_mid = (1-theta)*mu0 + theta*mu # Compute the chemical potential df/dc c = variable(c) f = 100*c**2*(1-c)**2 dfdc = diff(f, c) F0 = c*q*dx - c0*q*dx + dt*dot(grad(mu_mid), grad(q))*dx F1 = mu*v*dx - dfdc*v*dx - lmbda*dot(grad(c), grad(v))*dx F = F0 + F1 J = derivative(F, u, du) demo/documented/cahn-hilliard/cpp/CahnHilliard3D.ufl000066400000000000000000000033371412460263600226450ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (C) 2006-2014 Garth N. Wells # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # Modified by Anders Logg 2011 # Modified by Martin Alnæs 2014 # # The linearised bilinear form a(du, v) and linear form L(v) for # the Cahn-Hilliard equation. # # Compile this form with FFC: ffc -l dolfin -O -f split CahnHilliard3D.ufl cell = tetrahedron P1 = FiniteElement("Lagrange", cell, 1) R = FiniteElement("Real", cell, 0) ME = P1*P1 du = TrialFunction(ME) q, v = TestFunctions(ME) u = Coefficient(ME) # current solution u0 = Coefficient(ME) # solution from previous converged step # Split mixed functions dc, dmu = split(du) c, mu = split(u) c0, mu0 = split(u0) lmbda = Coefficient(R) # surface energy parameter dt = Coefficient(R) # time step theta = Coefficient(R) # time stepping parameter # mu_(n+theta) mu_mid = (1-theta)*mu0 + theta*mu # Compute the chemical potential df/dc c = variable(c) f = 100*c**2*(1-c)**2 dfdc = diff(f, c) F0 = c*q*dx - c0*q*dx + dt*dot(grad(mu_mid), grad(q))*dx F1 = mu*v*dx - dfdc*v*dx - lmbda*dot(grad(c), grad(v))*dx F = F0 + F1 J = derivative(F, u, du) demo/documented/cahn-hilliard/cpp/documentation.rst000066400000000000000000000302651412460263600230270ustar00rootroot00000000000000.. Documentation for the Cahn-Hilliard demo from DOLFIN. .. _demo_pde_cahn_hilliard_cpp_documentation: Cahn-Hilliard equation ====================== .. include:: ../common.txt Implementation -------------- The implementation is split in three files: two form files containing the definition of the variational forms expressed in UFL and a C++ file containing the actual solver. Running this demo requires the files: :download:`main.cpp`, :download:`CahnHilliard2D.ufl`, :download:`CahnHilliard3D.ufl` and :download:`CMakeLists.txt`. UFL form files ^^^^^^^^^^^^^^ The UFL code for this problem in two and three dimensions are in :download:`CahnHilliard2D.ufl` and :download:`CahnHilliard3D.ufl` respectively. They differ only in the first line setting the cell: .. code-block:: python cell = quadrilateral First, a mixed function spaces of linear Lagrange functions on quadrilaterals is created: .. code-block:: python P1 = FiniteElement("Lagrange", cell, 1) ME = P1*P1 On the mixed space, trial and test functions are defined: .. code-block:: python du = TrialFunction(ME) q, v = TestFunctions(ME) The test functions have been split into components. Coefficient functions are now defined for the current solution (the most recent guess) and the solution from the beginning of the time step. Further, these functions (and the trial function) are split into their components: .. code-block:: python u = Coefficient(ME) # current solution u0 = Coefficient(ME) # solution from previous converged step # Split mixed functions dc, dmu = split(du) c, mu = split(u) c0, mu0 = split(u0) Various model parameters can be specified using the class :py:class:`Constant`. This means that their value can be changed without recompiling the UFL file. Lastly, the value of :math:`\mu_{n+\theta}` is computed. .. code-block:: python lmbda = Constant(cell) # surface energy parameter dt = Constant(cell) # time step theta = Constant(cell) # time stepping parameter # mu_(n+theta) mu_mid = (1-theta)*mu0 + theta*mu .. index:: automatic differentiation The chemical potential :math:`df/dc` will be computed using automated differentiation: .. code-block:: python # Compute the chemical potential df/dc c = variable(c) f = 100*c**2*(1-c)**2 dfdc = diff(f, c) Here, the first line declares that ``c`` is a variable that some function can be differentiated with respect to. The next line is the function :math:`f` defined in the problem statement, and the third line performs the differentiation of ``f`` with respect to the variable ``c``. The linear forms for the two equations can be summed into one form ``L``. We wish to drive the residual of this form to zero during the solution process. The directional derivative of ``L`` can be computed automatically, by calling ``derivative``, to form the bilinear form ``a`` representing the Jacobian matrix: .. code-block:: python F0 = c*q*dx - c0*q*dx + dt*dot(grad(mu_mid), grad(q))*dx F1 = mu*v*dx - dfdc*v*dx - lmbda*dot(grad(c), grad(v))*dx F = F0 + F1 J = derivative(F, u, du) C++ program ^^^^^^^^^^^ The first lines of this solver include the ``DOLFIN`` header files and the two files generated by the form compiler, and the ``DOLFIN`` namespace is used: .. code-block:: c++ #include #include "CahnHilliard2D.h" #include "CahnHilliard3D.h" using namespace dolfin; The class ``InitialConditions`` defines the initial conditions for the solver. In the constructor, the random number generator is seeded using the rank (process number) so that different processes will generate different sequences when running in parallel. The ``eval`` function evaluates the initial condition. The first value (``[0]``) corresponds to :math:`c` and the second value (``[1]``) corresponds to :math:`\mu`: .. code-block:: c++ // Initial conditions class InitialConditions : public Expression { public: InitialConditions() : Expression(2) { dolfin::seed(2 + dolfin::MPI::rank(MPI_COMM_WORLD)); } void eval(Array& values, const Array& x) const { values[0]= 0.63 + 0.02*(0.5 - dolfin::rand()); values[1]= 0.0; } }; The next class is a subclass of :cpp:class:`NonlinearProblem`. A :cpp:class:`NonlinearProblem` object can be passed to a :cpp:class:`NewtonSolver` to be solved. The requirements of a :cpp:class:`NonlinearProblem` subclass are that it provides the function ``void F(GenericVector& b, const GenericVector& x)`` for computing the residual vector and the function ``void J(GenericMatrix& A, const GenericVector& x)`` for computing the Jacobian matrix. The below class is designed to work for two different generated forms (2D and 3D), with the appropriate form chosen based on the geometric dimension of the mesh. The makes the class more complicated than would be the case if it supported a single form type. The class is first declared as a subclass of cpp:class:`NonlinearProblem`: .. code-block:: c++ // User defined nonlinear problem class CahnHilliardEquation : public NonlinearProblem { public: Its constructor takes the various arguments which are required to create the forms, and it calls a the templated private member function ``init``: .. code-block:: c++ // Constructor CahnHilliardEquation(std::shared_ptr mesh, std::shared_ptr dt, std::shared_ptr theta, std::shared_ptr lambda) { // Initialize class (depending on geometric dimension of the mesh). // Unfortunately C++ does not allow namespaces as template arguments dolfin_assert(mesh); if (mesh->geometry().dim() == 2) { init(mesh, dt, theta, lambda); } else if (mesh->geometry().dim() == 3) { init(mesh, dt, theta, lambda); } else error("Cahn-Hilliard model is programmed for 2D and 3D only."); } The function ``F`` computes the residual vector, which corresponds to assembly of the form ``L``: .. code-block:: c++ // User defined residual vector void F(GenericVector& b, const GenericVector& x) { // Assemble RHS (Neumann boundary conditions) Assembler assembler; assembler.assemble(b, *L); } The function ``J`` computes the Jacobian matrix, which corresponds to the assembly of the form ``a``. .. code-block:: c++ // User defined assemble of Jacobian void J(GenericMatrix& A, const GenericVector& x) { // Assemble system Assembler assembler; assembler.assemble(A, *a); } The following two functions are helper functions which allow access to the solution vectors: .. code-block:: c++ // Return solution function Function& u() { return *_u; } // Return solution function Function& u0() { return *_u0; } The private ``init`` function is responsible for creating the forms and functions associated with the problem. It is a templated function so that the 2D and 3D cases can be handled with the same code. Firstly, a shared pointer to a :cpp:class:`FunctionSpace` (``X``) is created. Then two shared pointers ``_u`` and ``_u0`` are set to point to :cpp:class:`Function` s from the space ``V``. A shared pointer is used so that the function space is not destroyed when the constructor exits. (The function space will not be destroyed until there are no more Functions or Forms that point to it.) Using the function space ``V``, bilinear and linear forms are created using ``new``, and the coefficient functions are attached. These forms are then wrapped in a shared pointer (using the ``reset`` function) which will take care of eventually destroying the forms. Finally, ``_u`` is set equal to the initial condition (by interpolation). .. code-block:: c++ private: template void init(std::shared_ptr mesh, std::shared_ptr dt, std::shared_ptr theta, std::shared_ptr lambda) { // Create function space and functions std::shared_ptr V(new X(mesh)); _u.reset(new Function(V)); _u0.reset(new Function(V)); // Create forms and attach functions Y* _a = new Y(V, V); Z* _L = new Z(V); _a->u = _u; _a->lmbda = lambda; _a->dt = dt; _a->theta = theta; _L->u = _u; _L->u0 = _u0; _L->lmbda = lambda; _L->dt = dt; _L->theta = theta; // Wrap pointers in a smart pointer a.reset(_a); L.reset(_L); // Set solution to intitial condition InitialConditions u_initial; *_u = u_initial; } The ``CahnHilliardEquation`` class stores the data required for computing the residual vector and the Jacobian matrix as private data: .. code-block:: c++ // Function space, forms and functions std::unique_ptr
a; std::unique_ptr L; std::shared_ptr _u; std::shared_ptr _u0; }; The main program is started, and declared such that it can accept command line arguments. Such are parsed to ``init``: .. code-block:: c++ int main(int argc, char* argv[]) { init(argc, argv); A mesh is then created with 97 (96 + 1) vertices in each direction: .. code-block:: c++ // Mesh auto mesh = std::make_shared( UnitSquareMesh::create({{96, 96}}, CellType::Type::quadrilateral)); A set of constants (required for the assembling of the forms) and two scalars (to be used in the time stepping) are then declared: .. code-block:: c++ // Time stepping and model parameters auto dt = std::make_shared(5.0e-6); auto theta = std::make_shared(0.5); auto lambda = std::make_shared(1.0e-2); double t = 0.0; double T = 50*(*dt); A ``CahnHilliardEquation`` object is created, which will be used in conjunction with a Newton solver, and references to solution functions are declared: .. code-block:: c++ // Create user-defined nonlinear problem CahnHilliardEquation cahn_hilliard(mesh, dt, theta, lambda); // Solution functions Function& u = cahn_hilliard.u(); Function& u0 = cahn_hilliard.u0(); A Newton solver is created which will use a LU linear solver, and various solver parameters are set: .. code-block:: c++ // Create nonlinear solver and set parameters NewtonSolver newton_solver; newton_solver.parameters["linear_solver"] = "lu"; newton_solver.parameters["convergence_criterion"] = "incremental"; newton_solver.parameters["maximum_iterations"] = 10; newton_solver.parameters["relative_tolerance"] = 1e-6; newton_solver.parameters["absolute_tolerance"] = 1e-15; A file is created for saving the solution at each time step in VTK format. The data will be compressed to reduce the file size. .. code-block:: c++ // Save initial condition to file File file("cahn_hilliard.pvd", "compressed"); file << u[0]; The solution process is based on stepping forward in time. At the beginning of each time step, time is incremented and :math:`u_{n} \leftarrow u_{n+1}`. The Newton solver is then used to solve the nonlinear equation and the first component of the solution (``u[0]``) is saved to a file, along with the time ``t``. .. code-block:: c++ // Solve while (t < T) { // Update for next time step t += *dt; *u0.vector() = *u.vector(); // Solve newton_solver.solve(cahn_hilliard, *u.vector()); // Save function to file file << std::pair(&(u[0]), t); } return 0; } Complete code ------------- Complete UFL files ^^^^^^^^^^^^^^^^^^ .. literalinclude:: CahnHilliard2D.ufl :start-after: # Compile :language: python .. literalinclude:: CahnHilliard3D.ufl :start-after: # Compile :language: python Complete main file ^^^^^^^^^^^^^^^^^^ .. literalinclude:: main.cpp :start-after: // Begin demo :language: c++ demo/documented/cahn-hilliard/cpp/main.cpp000066400000000000000000000112611412460263600210470ustar00rootroot00000000000000// Copyright (C) 2005-2016 Garth N. Wells // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // Modified by Anders Logg 2011 // // This program illustrates the use of the DOLFIN nonlinear solver for solving // the Cahn-Hilliard equation. // // The Cahn-Hilliard equation is very sensitive to the chosen parameters and // time step. It also requires fines meshes, and is often not well-suited to // iterative linear solvers. // Begin demo #include #include "CahnHilliard2D.h" #include "CahnHilliard3D.h" using namespace dolfin; // Initial conditions class InitialConditions : public Expression { public: InitialConditions(MPI_Comm comm) : Expression(2) { dolfin::seed(2 + dolfin::MPI::rank(comm)); } void eval(Array& values, const Array& x) const { values[0]= 0.63 + 0.02*(0.5 - dolfin::rand()); values[1]= 0.0; } }; // User defined nonlinear problem class CahnHilliardEquation : public NonlinearProblem { public: // Constructor CahnHilliardEquation(std::shared_ptr F, std::shared_ptr J) : _F(F), _J(J) {} // User defined residual vector void F(GenericVector& b, const GenericVector& x) { assemble(b, *_F); } // User defined assemble of Jacobian void J(GenericMatrix& A, const GenericVector& x) { assemble(A, *_J); } private: // Forms std::shared_ptr _F; std::shared_ptr _J; }; int main(int argc, char* argv[]) { dolfin::init(argc, argv); // Mesh auto mesh = std::make_shared( UnitSquareMesh::create({{96, 96}}, CellType::Type::quadrilateral)); // Create function space and forms, depending on spatial dimension // of the mesh std::shared_ptr V; std::shared_ptr F, J; if (mesh->geometry().dim() == 2) { V = std::make_shared(mesh); F = std::make_shared(V); J = std::make_shared(V, V); } else if(mesh->geometry().dim() == 3) { V = std::make_shared(mesh); F = std::make_shared(V); J = std::make_shared(V, V); } else error("This demo only supports two or three spatial dimensions."); // Create solution Functions (at t_n and t_{n+1}) auto u0 = std::make_shared(V); auto u = std::make_shared(V); // Set solution to intitial condition InitialConditions u_initial(mesh->mpi_comm()); *u0 = u_initial; *u = u_initial; // Time stepping and model parameters auto dt = std::make_shared(5.0e-6); auto theta = std::make_shared(0.5); auto lambda = std::make_shared(1.0e-2); // Collect coefficient into groups std::map> coefficients = {{"u", u}, {"lmbda", lambda}, {"dt", dt}, {"theta", theta}}; // Add extra coefficient for residual std::map> coefficients_F = coefficients; coefficients_F.insert({"u0", u0}); // Attach coefficients to form J->set_coefficients(coefficients); F->set_coefficients(coefficients_F); double t = 0.0; double T = 50*(*dt); // Create user-defined nonlinear problem CahnHilliardEquation cahn_hilliard(F, J); // Create nonlinear solver and set parameters NewtonSolver newton_solver; newton_solver.parameters["linear_solver"] = "lu"; newton_solver.parameters["convergence_criterion"] = "incremental"; newton_solver.parameters["maximum_iterations"] = 10; newton_solver.parameters["relative_tolerance"] = 1e-6; newton_solver.parameters["absolute_tolerance"] = 1e-15; // Save initial condition to file File file("cahn_hilliard.pvd", "compressed"); file << (*u)[0]; // Solve while (t < T) { // Update for next time step t += *dt; *u0->vector() = *u->vector(); // Solve newton_solver.solve(cahn_hilliard, *u->vector()); // Save function to file file << std::pair(&((*u)[0]), t); } return 0; } demo/documented/eigenvalue/000077500000000000000000000000001412460263600162615ustar00rootroot00000000000000demo/documented/eigenvalue/box_with_dent.xml.gz000066400000000000000000000212041412460263600222560ustar00rootroot00000000000000JQˊ0Oh'yA6O?z(/uz'Y,); :z Tdj>>yu]ÛPqGf5z󃴢S4t4*J:94k=b,߻LX9Fнq?2J^ϣik4?`n)Hs[,Fv.5N+ [JRK33Գ+)-FJ3̯;a@ccbiˁJ,s h$+1,<+OZlig7g@#%̲h$;+1< h$=~?zڒc\0n0pwr{F$rڶmYo?hI;mWжw>жw~l-.Puhq% m+z|ES~dѧ}MfMfMO酆4Q?tr3}bJm%, , bz;L1b'7 QSfb%߷_[_CKz\,m3KVzRҋԤKJu4X~?l~'~'~rɽ$?LbߌO>O@ML31 @$ )HiAr-}_b`/)c /pwA? | sWQ"(/Ay|P#@@/D9w\r'P"(?(AEP("sT(B7E0G|ʹ )' EP("()j*ABiF D[Avn7n7EP~Q"(f|)AF'PEP,"(A9{@oAy EP~P"(,ACڮE9T_A`<WN9L|6yO8nF_߽ħ^B]F_w!yTFĞMa䇑vy? Ga _bvB>H"Jc9UL87? >. >ǿ57+&A?A?A?aQ^5d 5=7y ~do^+Y$M?uǘy_7y~D?2vL~9+'z ϯ<~D?~*._|9+KMO<k|?IIIO=/xMg^؟~w'/}SnF7 ]/֏nC:H^|0?CY{#doGτgdkZ NPZab9E|٣3Lۑ}<}gL:#h2o~'CUy9󻯔wWrNpBɽ3ey {E^g~r{SfF70 ] IZ_~lPbaT};s^ o ב.gaދϿ<_+ec;sQtPA ‚(| 0 CW|0(@̫V?𱷄JLmkyDa~wЯRn8NzAşU6~ؼRs z 'ʭ ŵav,_ ϶s@tbKD5(D369?T|[GhJX*1R'8;՟``{&ď0 *LM8JnHcp4\a+Q-TC Y*4o})5Atи/vsU?@($"\VXN"1jY-KhM9`U`1 Z0$d_{J'OJQZh Ș h={t̩ @S@E+n 91S O+ja(ND׎bУ76Aޤ3ibkp$ }}/`C:W*mI O;e܌n aH XvG[n"v:;O!.v ߖYO (UFH" vϸ(> ;%U"(ʠ! d/(ʉW+\P _P-71'UFXDsg$;PϧAQZ)t+|ZT9ˍ0f'$;P?U@ |/Xwy/@Q (&rn":Ql~ 0WI_ GoZ,ŗKGwpIHZRπ"hIsىvA5T8Wyu7 pp)UN7ʤ;P JE~uWJ=puR\nE\l ؁TήJ|z{oyެY5B,ʷNwo͖JA}H(ko 729ư%K06 -AX5 R%^ !EdNg{ k%µ B4{ƿ0"'&lAP& JM3ޓj+ e%RhX~]g0cC@tLD 4 Su ~(Hg/̈́hEz팚A&JbHTT ;37D3[;Ƣ-)\S3R!ㅅWڹ"?JG0 0L+&c3A# < 9_uŔ#-mX{&Mpcw3s9f$wM#$Q'U]!t@ H3/kajϜ\u(_+3s6hacͪ~FUae 8sgrZΪuzd By9`Uuq̫CRpcMCBz! E ϝWYCq XU3ꐜDB8#/V hȮ\đXBy%Н!hx|8;aT7RX1tC<&:&Rȼabkb@0!Bbb9Ro@ Nd^5W};鮞Ր)ـ iG~8x{w1iN<#%B -xC C.PI-/'UO2n| !NTd^ J,5A +Do PI-/'[O2nzabmvI楐BXh-/Y![WC֨'__J(bWz_}9 HD6rmDU!BeYqQCFd=^n]t^aCXmo7x': %B6i/V*+CrV (YmW琾.Ҋ i.ONnOt^d@H̬D%O yeBj.Ǝ3)v<۹sD }WҳZy!!cÎ{LƎg;o΀(/JP'+qҟ3aJWR ,?%sg]c.Nwxyab_ 5Ψ'IT'cwJN\85+B5š"ℾ;X}t^ڵsʼnv{:\"Lp=qޚqB_$>]g 7X:/HK煈x=8Q'SD'n{B4[^$8#-Wx=$\kU3`H_ly$8 M?(ag7$hAV04r@!q-ǝ 3>!s=$5v̼8I/v̫Vc}-B|anf^JORIbt狙y n,|WY̼r6=ybA5'3#/{r'3/hѷbU;\3_1RH˱n-r1C$@;8PyϾyM];\K_1c Ƣ>%Q8aYDoaՐ$J boZu6ز)%`iC KksCxۛF*AD/{%XNh@)h"J9!M#J ID΋{%ػo@> wh}GεŞoWr^d.; 6'a_r^s R7Rկ $Bt%صh@[Z%5CtM#J I"$>Z4 cΐQv9 M{)^K1&iVJ|y^k!~cMN񷲶+A6%7$R(@wJ|ykCpc)Vבy%ȦAyyUD* []&`yk3!ۨZZd^ظȼP'QGؑyH JĒ/V i;k!ȼ/a :l)76VE#lAx}Z ZQ)CokICpcg2_y$I%?+=bb, x*}t"uyhLHQ~lILa;:٧}L[y՚A?tqy!Hb|B$ANWdY_pdEUkB8Z;6(\ArNd$'Y 8Hq"(8-0z- >Cr!w/Lc2/;~e2He1IdZ,@  %<^jy!82VUNJ$DzL$2z->  bWjL/1EIօvj"䍐S> J0e -QlUi/![ xbO"2#$ J0e YX-o-![ wQ /8i+|q%^2!kq/ZZ"ϵ/F%G7ʖFYDm>2D/r^ YOw9lx$| AJ6z\NЕx^̕)|O d^r/,I*Cc%cv0 b%XL" jNuSҚN%y]D>9B={1tdN3!۳ڨ֙bM2 "Q!hsCً񊠙 'vP-w@`_I,$W!tη2 2i&Cpb'QٹbM !{⫳TH]TWY5$3Gotp+rzbVZofB::'0 @8I*gCAJ/î1A`@9\Z$IhI!I D@ҋ3sO˶3Y$TIfXg^ Qg:Ⳏ 'Dg^ß\SμrIJ< $R\3BZoEKx,CK2|YL demo/documented/eigenvalue/common.txt000066400000000000000000000022571412460263600203200ustar00rootroot00000000000000 This demo illustrates how to: * Load a mesh from a file * Solve an eigenvalue problem * Use a specific linear algebra backend (PETSc) * Initialize a finite element function with a coefficient vector Problem definition ------------------ Sometimes one wants to solve an eigenvalue problem such as this one: find the eigenvalues :math:`\lambda \in \mathbb{R}` and the corresponding eigenvectors :math:`x \in \mathbb{R}^n` such that .. math:: A x = \lambda x. In the finite element world, the matrix :math:`A` often originates from some partial differential operator. For instance, :math:`A` can be the stiffness matrix corresponding to this bilinear form: .. math:: a(u, v) = \int_{\Omega} \nabla u \cdot \nabla v \ {\rm d} x. Here, we will let the space :math:`V` (of dimension :math:`n`) consist of continuous piecewise linear polynomials defined relative to some mesh (Lagrange finite elements). For this example, we will consider a 3-D mesh of tetrahedra generated elsewhere. With the above input the first eigenfunction will look as follows: .. image:: ../eigenvalue_x.png :scale: 75 :align: center In the following, we show how this eigenvalue problem can be solved. demo/documented/eigenvalue/cpp/000077500000000000000000000000001412460263600170435ustar00rootroot00000000000000demo/documented/eigenvalue/cpp/StiffnessMatrix.ufl.rst000066400000000000000000000004271412460263600235160ustar00rootroot00000000000000UFL input for the Poisson bilinear form ======================================= The bilinear form for a stiffness matrix (Poisson):: element = FiniteElement("Lagrange", tetrahedron, 1) v = TestFunction(element) u = TrialFunction(element) a = dot(grad(v), grad(u))*dx demo/documented/eigenvalue/cpp/main.cpp.rst000066400000000000000000000026221412460263600213040ustar00rootroot00000000000000A simple eigenvalue solver (C++) ================================ We recommend that you are familiar with the demo for the Poisson equation before looking at this demo. Implementation -------------- Running this demo requires the files: :download:`main.cpp`, :download:`StiffnessMatrix.ufl` and :download:`CMakeLists.txt`. Under construction .. code-block:: cpp #include #include "StiffnessMatrix.h" using namespace dolfin; int main() { #ifdef HAS_SLEPC // Create mesh auto mesh = std::make_shared("../box_with_dent.xml.gz"); // Build stiffness matrix auto A = std::make_shared(); auto V = std::make_shared(mesh); StiffnessMatrix::BilinearForm a(V, V); assemble(*A, a); // Create eigensolver SLEPcEigenSolver esolver(A); // Compute all eigenvalues of A x = \lambda x esolver.solve(); // Extract largest (first, n =0) eigenpair double r, c; PETScVector rx, cx; esolver.get_eigenpair(r, c, rx, cx, 0); cout << "Largest eigenvalue: " << r << endl; // Initialize function with eigenvector Function u(V); *u.vector() = rx; // Output eigenfunction to file XDMFFile("eigenfunction.xdmf").write(u); #else dolfin::cout << "SLEPc must be installed to run this demo." << dolfin::endl; #endif return 0; } demo/documented/eigenvalue/eigenvalue_x.png000066400000000000000000001201751412460263600214500ustar00rootroot00000000000000PNG  IHDRXW IDATxO5˒Dc`,Dfظ%&gA/ 1H+)}^ !ߖ`1] 2#2"2}9k=UUUz""Q*JgUwT*JSRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRU ,JҧVT*JZRT*}jKRݏoۿ;lgΔJҫއ7ow0W VKK@R}-w}>RRè@7Șk12j;G]1ݍld>)\T**&U'.pNC hLa+:dJ@J >~a7co@{( Os?dWů(?R@2ҽ`A 4wgݾXh3?Ӯ=`ᾇ`l8<=H?rtNzʩ$k / vD5)OswX8&^06m:nedGymCW <==">߃J~*>ލljxX܀G3ǯ@6C;FYa<;<Pk)UX-= O=WziZq7g!64:ߊ0w{`;c < =OOBFUTNA0.m߃^gۓ[C *whLn;x+`b=w;;w߿^wq'l{Puz+?>O+brƜ_Ev7 T'B; 8&3a#{ Ȇ|x L+b<)0ףs2FyʊzNs /߄`i^),.ϔDU?GL7@ʼ˻DWmCKZj1mGdxl1-`Fo=A ¹#>/2:#|.HR$ߪJc_w\!Ù)cr n?TƑK ֗{W ߃||_s?Ϣs. ?}~E/~x_iV?ή08\v>N;]K?A;xy ů`Y!bVz߼O O#|%=;{#pXKvo{L5}MN龸 $>r# _ $.Aʔ⌑#h%f;`w>Ez!!Bkwgi9++q-pwKϣrϥgw[;u>Yr>ƣx~n4_/WnqkWn=/k}{O: 7;?f>B]2wx%3Վ Tyչ޾f ࣫;i.;=rݝE,gՇя9BruwZ#ԏ_%[~DZFWu!)j嶨b]Y=x2ul7o8ტ}cM[:U'=3d7Ϯ@<HdLW{|4z\w~N @${;SüCσ~\ʧlx|ҏ >44@x9}Տ~Ug;HQ=vaOƆmq:Y )!1;!FBq̓PB ݄ɖU4ݧoWE߄}#|FyPg||#yWd&G3QNGNY<1{0=@ߤ gm,"&L_/vY1w ?~}~oT |:}O1vvp =w=+%i]qLJ*t pe0 dUnU5_b0o^u\2Okg+O:m齝~`:"F2=?֔P¡P֛2׾9GʼnIyf0gy`/ Pk;˚Gx]?хu*]?&)} !(tx_R?3)#mb0fi ݮoGcG˂r;}1Ce,.:Gx^u,a`6s k?>:{' ݑOFŸu۹N7z;t|8EGõt{z;j+(z-4AQ@:9£\Jy\t=X)[;hrk Ll|=G>8s ^\ *NPoC%84"VeH Xy8#uaq[$EO8>^n[hԀ5i5G|og#\_~׹C0uB}UT |.~Ǘ?S]v~hLfskڸ:Eӄ3X(cClm2x2>M !Q>o THKž]@̯0%|tqYv[o~qAli'}RL,<]C]L[:3d%m va^Z<9i@n'C84ܜȜ+ywU)pٰ8>54Ӂ;4f 7nݍs#=eOָШx3@JzlT{w)h72|2(JJ!naRbƫ=hbuȱ(RLCUYWAسu~d RF.z/>! ;X*OP">a7uW#EO1%ʈDźP pμ\&Ņ9䵷$_C#](&|m`d7(59nF󅟽3'A=\b8DN`};Hಆgv:c}[Bnb}_C`.?pUIn5ŷ}EA]'qu,f-Km-%,#2r&P(lu: Q$mocuLin?Ֆ]xNjc5"JI1;}3Z^|$#q~7nrB=-^l*,S] >w貃:"a9az٨:4^5&~% "۵OWTi1C$X@uSD`_EFN hbC+!"fӅzi͆15,7ߣc@Ok(^Qk=YaKA̅0 ^Sn:cÞ֍BoaG J ~`\q\se1$0ePg芑*]DikZl>"iN՚ JY9LtÑ̰Ga( *S)#sN_A-1YZ#ar -I?HYԃ\4eW` FGx՚ޱx_$3;Yxk}P<_IT |^ j:ݽl}~.mɵb>:%(hxZNct:1XAq+ 6x}eœH>wMC 5 *lh7_ ̺Ś^Gh˙f 7oDw> OoKRq 7!?KA$ 2Gu?Jyo;SuYcY? pM)bMR Vh-Ɖe'1@]QE6.h\zjPFf.`{J%̖dEw#'1#C8Hk;Hf9OSg~~d C|7i[x 3ӷ0p3Ppfh1Y[x~dBO#e*eV8TJSl#aY>7pQcU"?skܧjX!h~kBc0f镶*$τI:[2c@ӗ|pFʰ)@F4F9SwQmմ۫q{*2GH&(J@D38?74?|G4 b4O0L1Isyzy:%0ܖda'XXkI|N$SE#23nc%f'2b)4W۱ؑ Z%3Q݈~Z J,ѱS(8z,o$:y&hq%y!7u-< @_Ƅl3rAܶꇭgp$qN], :x;)uZ\Ne?~*G)OqoMRpF ;\ce Z]nǓwRӠɖ ]& o*}/8.J4g^|ض`t_xB|?%?!WK# ,(}VW*SF\AN3cG-WGZWB&H[g:HXr\8qn?Ꝅ@G#M9j}|aʿ-k8Ϸtm*˽=nW!]e}> LE@Ƭ%FpiICK,O6HLD>ޖk , t t~pqͳ עvf8{ Go'_?3vf%@s@Fw}|b*>ej  RpqzX #!6-%6 j!oRr9 ѧv4&t<GBوf !&(3hT̝H{j_^åPIWc`*e> w(F1)HssvR;rNLFP._67H::DuQG(Ճ  fNƞ{ $&ȰR'O]]/IAuoPSLGE!5B\ . Hh[:4n+Aލ+=O_t>FjrubmsGoGLgy.h>;-_c@pt7ץ`(ȏQP ಃW 3;迊:fW/fAx F\_URѮVq116(vyci{;ĭ?;BWvۨ,s@T9 ӿ9%hv0@AQ` ]xoNoe$3{D ՘5ͨ=^_7 LN$ͲО|j ԎCFh]gcKOk:|<[Cd* c<8HG236R)` b5݄FLX)Z ىO;ms!!֟d`p=hyqĖ/u`$J1ƓM9rg8V@:hN“)*\_*}xj޻)UD9H7Zo4)c Rb&wޤ@&uraW @:j"A;Բc}X9ׁ3>Z?ϡ{ a/J—Qvn4xK(7 |A >O j0. KYD=GD &Y(;qN !\tjdٍC>@q7cl\k-:+?VYˉʬyǔueU\T )(Pm IDATw&jPp׽ǂ>R`"$MIfa/PhM7R 5#\2bt;( $3;92aи̤Ɔ.<A;uX]β IWLa>.?c ; q%b{Rq)x"CdSPpLa##`8NDlwNwn1ܨ9@fO_$x#BZOV͵=R4Y *.X;s} XI2ٌZ 7j[_C){(8ow)(Î.xx4F!$ #ixA g x?sCÉi?sPx#_$ D @D%C9AK<:?eS@h n( )95/ OAk ua;4; zG8Q 7]~81bT3A0%ݧY ^K"&21kX)hwپ>5 -FOkv)TyDhR|FDݟ,@?k83߰46}thJOk6^f7YvV=zAPPU, .Hk#{+(gyLuig~h_jOV,0ks)W27pg:0}f<(Q,sJ,#L-7nY|&I:Q oBU |=M;Aw]A;*.pM}hPPޠ(ec38B__c(8ąiPTgH <"򂣖d 9}j ;P$g]KX&|:3~@64'#E,%m~X0h#aӳ]s9Y"KȯYz>_LtSpѺE9CARx(RpiV LAkH?ˁ`j~,^ӳ\sEyЙ̚jt3d !gXzoZ-/#~{Xc%_`!LJD'r B䴜g89#_>K ",> >=C#הˇ"v2C[|&n NYt *J$CAD ^Su4: vrz%m$}=ӚelÉAc1k^㲛v]?´4yAШ\){~Ө@"bCAQ@ 50" uBn>4QPnG.t;'9GAgP8S0"H@ S@ŨĘ\O@`ց31-\ D䃺q 3*hzlfJbNiFr?)rf* Kϣkƌ+ &Q_^Ԉ3Z &QjaFn ,ڈndCA{toZ;xUY 5RмSG6v+e*eBjM'; cVs[ GmS "M1)𜯍)`G6I<%IR ISI ^ԑEb>!.dy{mFPQi.F' W7U(:(iAѸ@qQ0?L6.&䆸PgCo .GDcTf<Mht1.Qp#\qь2M9BJ՞_(ỏYU3be1r7$4Ș#Yz`nm]R0r4D$Y8v1- 86 #<\'ژt0DH=r92hL)= O@ !\UL\ 'tQjQ֬,qf]RP"zTWG>3|b&F|~D ;ܚOмbG`&zFp+]\\Ȕ:&]lu /mn󍀐F*<اMuhߞH,΢r *"*>&Q 3 hMޡ*GIBu {@b>Vȧ3|6a~Dj&Fg4Όu;ZJڳ!y`(Cm3e> 0m2LԉߛIs ~bX[fu4f}߼Z4o/ye^Q=l >/~Qz&Tډڭ{E)BAx oH;aW4PH d\<8ھEAd7QP̫1y5R b,vzy}wi Kh i'j}qbQp-OKt6vlmɵ؛߅lFpL[3^‚p@qM e\Fp64.ZQMqtpiOJ;5!q!^Z9eI{T<  Qs Nډ =.*5̅DUZ1jK4)PWTf]AZ5 Sì\G(8gRhV\1L4^poA(udУ2 0za 0󴷉@:skW/P+*>}Z5DBT5 6 tt {6!$R8 Q} 4X`Bc_3(Y! s,&3I%r8ܔz\lRS4׏ed#6EEY@ɹ^rK-?5IŸޛ7^_b s! G( TG8Gf_ 0̌B=wH{C{"5*m W[[7!{Ap}Ŗ ԉne&࢝sD 4ҁ6 h8,@:1)P)^5UC2l7>) -* @ bvqGQ"j7@4K #ٲR.T^ZG=.z: MAo~ 6 Ss[KtZPFCoD\im|G>[cI5y[ gR'&p vM(s?iQ޲UQO f7"#Of_DiqHcX1OqwH~iݙ"L-[QU$W=SGaꦢ[)<:,$i*tns6%sYCX3jH}~о{( l[3Vi> g>pf_,ch!M@ԇFcM(+) DqD sk! mR{2@A +M&9H2gUUzJ].S Зz @U}h҅I;ӂ( QZ!R%*C|hIC0feɭT)n-uWcAbV :))@1iy>+-Bm$fQ_4c;C[(}}ʿ=@>R ).)e)W0SP}܃( ZCLrM 3@戥GqKLڃ ,`ltd=õ^OT7.&[xqDJK&)G4r ̃=w@N䜅 nD ,_*쳤i]ht7?^BQs.O0wi$F:yɅ@ZPQL"5 KfscH3{މZ6Q(so˿fTsONHh@8ٟgSm<(99.Zϩk*BŎ~ p7k j_`pRa,)L [Bn#yĚ"wtI,)6;4H_(FƭwƿLDj8c߽ 4Mp MSz N(J>Z)B( GF/}^G>1RyHX`:b.=MtAJϭk];BsL3bvtwaMG Ppc!2BYK8a 8$6GhXCm6ɔF`魿I3[ D A&FMd/m#Տ.S$NĭO-KaHH<gݯXWC7sE]'-xu_T |u oZ%sShBUMGGHsž$>/up4gy~JɻB$bk7ݭFm]lnj=儈֮l6#PV:;wzd֒St0z2c|8T)B-p̿Gfo]Ҧ= Pvp/Pup OДPn84m_xQЯ @(w1yHo,ݢ'J$]+LDҟ+'*1^6: < ԣ?Ǿ|ߗ nWAaf6(h)T |^̓ѕ(Ȅuh ,D`.ಀ q@KݡޯWHrn\,Ю ` m,{_DJ5 h6&Cn1rݮhpI1&')( .+51rf4N03@:kaRwYE/W^UѬNChɵ#hs.a[;:zLG=|`"+ۗf  [o&&i/6ZDa%8Vm~3&H2̈́Rg fr_K_3HZLWҸp vZrIϔ@ uޣI& ddi\o~%p']1^i`?Cee84VDV\tQS ݰT Qxy}:fUt(*f31C3{\GM)fӨ@Z}3R^S%+rl5q5<9ey3GO2nk4p"P#3co4G0Kሪyw8 4l_CZ+/R4a(( σ{guk57G ::"!8`)QLgGV%7 } 2r lVz5oUfZ)C ÆC5m݃rG#8_L<v`nz|`H5u0LI"{Lp·`q3$)8u5UfXO!y֜i1OSfl'џ,ԚnYzR_U Ԉ#6)J6k[s!aʀ^yz(~V)R!G( {|1H^jfڌvt£1ҙA5p5fz<7ܓ!*e2 1OpF &yD0c\<Ұ AWST4WyϯF0GgJLa&װsQ+J]Q3ubE}k\B<lCctg84hݙGcDd^n Qk95C0‡H ,$#(`tVO|(KzKOkk4n;@Lԗ}5TYsH"ˬ(,"pF0'gFL"ҕ|qj&?J;Z#YW}#8nܝƋM3 pp9:Vg6x4ƭYcvC>?'^R5.;xur:/HUz&_UQ^ePДzjtl[LsL (Y!W͑w5{kik `k& BIR0 $g2PF8 sgLX}wlA { @^r/=H7hiB ™`do2 K? /#(٨}&+[!?궽pjTS}vjl`兂~Ӵ;B! Fe8]Ixv@Ν;n|Z)G#n,o}ylX$<//"ݙhow>h@Yiw U |6(k_#9#,. Y&MM2=4I-.j$gPt*٣0{rJDzw8I-)fv>jک1!/v0@oq0h1`Ϗ.wh @tmD'śML-`ɶP w'XJY*.= /Fm6<#f"ʼnq=: Z( P/OҼaQ$1iv;%.Yr#;d}hhFBieGrT~qEbwZb;/Ȏw_WyEce4;ILf@..ZiU |%F#V%6^:FXepmk2/hJo ]mN`ޖaX^7u~YHu#|B+.*>uK-hbNA@еwM#d @UmE*~?<~;2 +}$RQ~N ЅC787nƮfyDA8C0ATAC5v2G;w0BAj_axc@g9Qw2C۴S@:zoϜ⮶&I߃f}aY\Y՘,%Obi|$}p.p"8wq޶f{EJ-Citt D$PH_;>ζӉL6:03]!F>+u1223\t`-;̼ )儌g}5/ @:j 2ᦘT\~c@>a_v@M(ٯCb'Y"W\8b0*o$ډL+1˃ ɋ#yAU;B,t֎:HV0ܒPL+@z,#hpU<uNQI,Q._/VK? /S|N1Գk8>PwN %.c[Q2v%m/k^ 6ky EI:6 Lf ~6-M̴ P3r Y;90b6S@<áP R[|f, d,PzV_@{3> Ji2DܒNAm0Z;sHa20M%[a j#DU<"D4oJaI=lNĶi`y_^Аjm ]L3n3ϧ22`, Aјoo2xv,X:NZ>\ ?mo{~`}[ӯ~oU?>}\Uhk)\O3lkXP Uш̶/H%;*O\lF &[O{'X(мLdZָ7i&A[ [9 ?'[~ p̠`8drPؿ 瞯cG20u&Z(پ sI]Jӕ^PT9We2U SO A{ݾ{}v{k/o޹ ND|!S؈&֒DW& 4yƂ50Q C j"%[B|f4 –ƴpC9O#BZAVXc V—9AQ]ÙBӺ` Y`ˤ`Y7 amB^p޼pziKpPЀp֋~RhaRb7ulcHxJ}HMQLD)= ?]4 f ;PJ t!ow>ák^LЉsF3vkXo3ePR G jzMHpo ƾKOr. ЬW*4? Q#¡=yv) 7 >H "~k7o_n_;o`6y.zXF8tBJɖDıQhhFSH20򅉳X!;bUrG7~c%]*ٹl=^' ($sO =a|3[7oCGv{ػbQ"NSlT(x/Lx1HߩvYnesLpn~ AAS3L<n-pR,u'ػhֿ҇erIҳ@rD-%~jIqxRp&o0|͘?2TaBR0|=2 h8Ƃo.BӜӸ.@`e606đ4[2>KJ`.F?hWK=!.(۹{l*N ovh;iOPn rq #B  V)bat1ބ ~o7Bw?]~d!Oj2q9 :~G rJ' `_ta) m9%N7hOD @ۚD1w8/qtLLƏhF%-@.瞡JϠ k Q_ 3Yd&ASv>k@2 \X0u9Q9<}ӆ}D=4v{_[\&ʧg)C-uAQe/xYeY_o7xC\Ƥ1>LKOOG{(-K[2k@`T߇߇5IsiNKA{HD`6 moz}iv,YD e/]쿔fo-Xa@l,Ts]k)ٶ{<" Vc,ѷ<_kx}xT`1pvDf-i唓Ipi~?l6Aғ@ֈ_{?j(h\I S>l֛ b#Ti(g/,pT=f $PV#:~Ltоɧeݲ, Juç qܷ@X5 ,!>ޢ_T.(_yagD|3>KO˫sI!4검 NL ptӮc΅)h-ho= ndw:/%K)1./JJ Ux7ك(s}ow}4g0ZZo;)9DDU tu; qsgNi3a1~Ax7H*tB*4AռWgΦ~Q;Md 脹Y#ʠ/{/XY QcfjVmڙ:4U/BAaowLؔiB7Jx05n4as b[_}oe a!Y:7P⢗3@5(?TbGh` 'Y rp`8Rhkx[I c\[H9.i&h[EKT"i&6>@} fաrIpƈ5v0,^Չr}_T|_I [AQo I "5#$Bq]\-# {M>gyJϨዋ7]BK b3D,'ҬŒIAd ^F>v}tߤ40Yb ?G`!e(b3 3j= Ц\ LVcKFQL Ch2>&<fsu1ۘԊ<;bĆqZG>1`U |Y}-_L e<!B4U0.B]pՠ/c GC +W *_ ea!v#hOFA rxR$iiL:n! VefG=P2l-~NIɨ,L~ 1{A_Dc:nXs"wda6@Y $rgDD{蠠5[!Xz|{ttKt~qQ{ըQg<-- v޾ɉϐgČWnְ*۔5jAr+ =Q, N v;<2X`60,:1uPP77ɠ:351:Q'8a6̤ aa!;&sx& xҩgwevpK-%q8=E 3Ç!\?&ɧ' g]f\psT |1} 4jWHF#6(\`T#(l?b =l#өюktZCSSLԶB]`ӿ,)(:4M-(+=ryA-S4V$vp&mA@o7w_ 48 rg03aySZqWU4_bbZPh4R"V+ ]އCn2Fgҿ/2;YBϲjL&d*t}0¿GIl1#w4b>z!ԅǒX /|~8.Ҙɿs57U5ꢦ{̈-ȬכtqBAЭX:7)CJO (r>Ix&o7PFN9`hRB'cQМMB; t$_H7qy gH [—QN/<)K%ɵ 6 o0PSFґGO濢 /,>Qw{Ү70)Z'%h籙Ė&raCAi&ܛ D&dŚW p# ǒ whgu58kIeg{ָ'Iד"=tsPedo_- b [B K5Q&qN3!0zu-:1&"Q3qܝ/q1JA燬;Mslӈ` /}BF6n^p`B‡FGlž"S `:-jq+RҗP~L(hF5~IAg UtXW4"e`2RΌxc}@xc;Lá Y/x2˂:~L̻fU҉Y8 D.;tC2!CUV.#(`X( b(8FBi- ^S^8#x BXawm [زЄB)[eoOS`&cH>\#KGù+ƺ58V5:ա $DLp~0Ga{I_k}(;FBӻ:ٯ3 |Ѩ?QC(r/'6\+Yh)ԴIJm~'£Q6ӿaS?/['`2YLbubļdtF~/H=B]T6FVcB 7؁tFMH mWR@*e|Y.8<WZg4 Q:N| x:5[_E7FYzn_U )YȔP=Q j2F&,u~:Ge?'t;w:vb!2 `ܤ}^VJν 5c4Ȕ; DCǭ]Tـa\T hP0VP,c w:B*bbsϾGDjd|itσ*-W*tW+!xULa1<t@> ]R>,9j7*Q:ȣۣ'=)Hp4q]nz%⒔G_F]LJ e+Dà6(h&J3Pyk$+aܐ*= s ǘpht.}·\^1;Ѝ~,>TT IDATa: #(,湫r'^- >ikm]![KF uBC{:p?-.lDnGhIfi,y+b0P7 /Y0f] "~<_^tzHA ̇f]@),` {Yh(Q[K|aݱ>(MF&Ll=Ԓs}yƍȲP`[lu%1h)8c}]|~4.) aV`r6M)PC,yO!m5o{֞ܪcTڤ#q}F QzZ:QBzc d:(xGG8)nx6ѵ0k-mL15D\!x-EKAlE41:>>+ҹ&\md96Q/c"rOD IM=M{js˩@S.ƭřb1};aQwΛ۬ݨvr5'ƄlaF jߧs}Wa:) 0Ё. txCVeaȭSٵ}/YLi#a+?ub`m km013jY+:*fP0iJϭOGDv]RP{$EukD f0ؾZqϴy(D$Òg}ըm|D^%Ccy DN>H ɇѬ4H561nYpu=IoIѯ]\-i\bx* /:3Ϟ!6꡸eG3`(~ n! Wv]"P'ޡ- BA,|?K>N2I ӗm}"&4)'ًh00 f\wpG;5:F1!ܩ)E%r4=m{xzUx=n!"W D t=3ݵG_*^fdvPk%~&K2 x'A}^X$f$8BKBAn,hhxs243pKqhI;8Hɿ S8 rsG8?ʛا=*1vp^JA#C' ,h|&mDh>K/kBٺq5R61c,at~[) ]Qw)i  .fk^дf%ļˠaDT)=:?w"E8}×$4zSh%c6flo+)gm,*?s'3ֶnaUT | ~܉/d0g e߱^@7(CtK'LDv:oBP=I*f1MM{[L[)<5z[71 Ӛ00P0!5ʼn"y8Fp |b׵οAA'\^gbX+;-5"Rz~_[w]!쬙O4ۜlKXSٕ֨@A@,cħ#V%;Lܹr z !7b/M)L{NF4VʬR44ě]f|l@~G81Ns<4"\CƋfN1Rylwf-8;:33g+4J\?}9Yz-_UwMETl%_F&|pZvp>\A҇f njW/yfH>B)A庆^{pw0vоYz#OQ۟3G?ێ@ۃQSLJ/K]jB2•zಀҺ1M$`4pdvs㼕\5[4w ˌOm"0W(L_+$BBؗBcap3Yv֒_x&\([t&, mC zDԴG=]#p!pUU.X/Vzr_P;"4t#@8zPA &=p1wLA!v :™<./LDvbI]RW!J& wci-v+Äm-ؗƄh.y/u8oc:%d ԓ8Ą8%Wz~_UP)bfI(UGl`cS킂fI"dGm7ܦ~qMamWۃ7t 4& TA 0xo@;F#ILJgQFFG`vU/FpEG!0ٓ "*/tX8*mEz~ܞ{ԔQоhfw^:u4fƂ4Nj6xڹ􋎲NUkKj p.Ӟ/ Y.i=x%޺w0`KϦ+s|6mH\+PP=5C)Rp~SFiXkfRԅC&wU[M76O}UC_1'Kr4US"Ж_F>_68n b ^zA`+y )DDر`v[kjǕ '9D$DHM6SWh>IU,VE!y7˚g_Wӱ]S (0١zkˏH;tR ʠ$) ̾E2i۟686N\)Me-Dci&$TdP ɌNsί B#2Sc|_yej|шb "r8Th=V!B5$4kZD[}Q,oBB İ U! S/K"Sj-)_#D3Ro(mj86N\mB7?T+ݮx!f.*PArmCMŝw3U B'd8%o\)-A^A* D Gt2vKFSnq7LUna84T!Ty|bщA)c 4 YS {f@=وSjL>ʿ;uqD1ߩI8- Q`um40?IEfzIw@%ҧVGEyur2Qq%#`#S~UeR B*ȡjh&"`^ `Hn [Ĕ`5#X6n|g$Q}; ,* 5[|~(G5f-:(`J%*YF15-UѱYp"(tɟԩ.X`ZzAZ aujj$ I]OLr dQPN:^01PCsAׂИC "| rRL "oDPDɨ;gIˇ!KhiA胂8 ͓ozfrI*M&]9M}cD+!Q@X7uP0um ,hKܣC3>"R`C6͛<`E"ƴ$Q@OԘ:0ܖʅR.lɷDRj `@B#Q}h4@ϸnQzsL˓iWA@Hk !UF_Yg>qgF-<*psDX5C|RQ3ɂ % TgءZ՘Vy"=M 8R[Rq/$۲TE۰#u(b`YSkRȖ V}+拙 H(&Itir(Ռے g2,ءEB008n.d=- 1QKeMV(tDbZ.,(TlJj o sa(E!@֏"lچTW1"֞B;)}aPh/gD%DjBq&b 0`41hHF]hS/K>tH?h*Yɂq̄AVGBKZqR[C'-AT W_猡 TByP S(+eĂqo٪P6[ PhlXKx)$w2._,YŢU1'|0.2@@:S jGJ NX`|j`%^ mԱ p"*Ȓ T\I'CbV sMYT_V!E6/LrġDwĔÊ5_䘨RX' O?(GPnjzRx#(B$"Z$F`},yMt3y*8 @33^Ԙ5-Bj2$¤]S1dAT̂_*_^@‰p{:a!4Rvu^IРPͅb0r!S ̫("-Sڙ U-!257P#iQ̔:@XIHHAE wK _hɣ<99} 45v5 N!e %b B@`&N^yOE`^V "~DuctDHޖ$S^%uf[8|UKWEuBz¯-.jX Z^(@;KYC+5 -Jvʧ )f`˅NLxxa#o/?Y`N+) ED" )"1b:TN|@hLдDb C뿶̧\}-řpD]0̻Wm6  vN*mAf! (=r _QE W)"4eDa@$ʂųUY>*Z sn7%(F Fh$_Q 5QswCh /1NU] J`a{.Dքd*SB_,' v_۬7)<1H䈠fAl5t%!RK K#S9/MM΍ܚ46KƱY@r QOg DYy.Ќ".i96Õʶ.5Fڡø C mg؊-14*;X=<(CfJtCdIo;h0++?`FTӡ~]>߳c[/"r}LiLH&P"AfA Mz7 "l((#4,ڡ!PW*a~f[?f@`mFp+0H&(Pn(P#+X;4^(@%^nsW^ek64rNVW92?(E;-5:$DD`GH1UHvz qXYn2J9M~/"8b.i2ࠎ> y]4#2,оRPAQp+oI]- <[ 'MFVFP'LBHpXObFY`eQ l3`R-iC(HE!T[;r*l'dcmKc=aDȂx|p]v(!F@ v.@3(>~5-j`t(+Б*]\qPiIDp"0-!_:5)?T|+S սUK ҇T7>9qLGup,ye RvOArL MuC!Nԇ+ae6?> BJ˴'Tˤ>S L(e4G^0_0CGtDe4 08nGU tu)*D$@#`RG%X*oEjicXixP4?GY3)2hR?)VTTy`5{h5_LjPS=h D5S5ɤ F~}]V -X IDATՎ(RbdbWr $8m67 1Iy|٫C݂Hiz=P`%.v;ꢥgZ5<2*8O,6aLTA}[A>[z _HT4,בJM@ 50H yQjH^L9iZTykM(R6/ZɈu:>&64bDh/sE|%'-#&R$æ@.+Œ^O+#V9eD˃i~V OZ\.*^N! ħŶܧjsA1R8HcPDR:48r9)4xJm=2fVÚ jv qn+%3[ lv'D5E C,`&lDM A[/L!H05 AȩI(e&^NQaJU 1B':9Hb7HY0d BV*;4z.WJ'$l0q4̓}&JKtSsutArt驜˹mDA:#M"RD\L iiy )ʋDC|s"VkR1#G۴xRHVDg}h*I@D1%c^#[SQ AFAoF"BD! c)Bߔ]:,( [R/, pl7M ;׾4QګumXQ0~2@Hǯ/ jf8@eǴITlOEAa m)H h/W>-y6mOIlɯ}+UAA;Gt,[ $EիhN\)Ép.TAP Zbo淕ڬ|DZ•"bPMzWCyP Mg "[zbG!e^1 M&*KvgJ50i5K(?1z@ @-@(ш3'Nc]^GR/nXLdBHWf= N`ӴrT_Ц 5.E >Tc6&!pG|>j5=!Th&bڱ_0ӆhA1I'\8/O_H^_ 1~Ą0BMܤ1 gȾBװLbfRP$"I~|ybs7-.] ‰pqD&# wgbU]r_v%4(6ZBZqQHdډ()#R; ;=[DRdn2;48YXL4+۔J!c/oQjA'EKP 4~jZC 'm\h^1zF zvQJUl%:hl@V.!^LwRa"DDUQB*m. `D rVPR>! MKj6oر!G'a9} 7N5yUxZ;Vrpd*v ZE(1}&w⩫. MdZgCQ(SPiUU8_ ؐ\+% vF dђI¢Ԏ(qhD̻W&h_#^ L8n4=p( k<2!eD:R׾0S&0ה;R h9;vd98Y|UUdA2) ;m ɯ)$GԒR#TOu(p9 S4+Z5+smjlp*)&VCk< Qؚ\JZ'iLO ' t8pO6#[wJRl堮ߚj9-PYPɏ&Ub[HLihGkr [!!IE"IY:eء:/B$ljX_iR@Hk7N["!=`ӢbP `:j"XrpoP(\ĖL^K.RKڍ铴[[Ē UQE&=RyMc\H+J!>AtL<(WrHcsD嘩 a6^ۜd&&È!EB^k#rPVmpld4 kC{ D4t¢_TrҖ"qHaV࿬7bC9>%aʒlUBM(Ζ{[6 ;&ǡviU0/WuEaDc('D{JL:dSeW+";kyP:dZmCD_f)U -t[5(Z)Z ZwV"J綈Ez/H삥m/x&*U98u#TokRFh8|FS' s k2W"5țz0Pr"W2상491jGt]Q{Jeo G,4b7nixgZ]KOiGTNMtȂ> 'Z^=]GTqDCڤWq{kr~2 9(b\iFbd)rs ,a.َBL8.Aّ_CHazJ;.oX;bP;=xԾB2 /` fB Ӟ!$Da:{Ǧp0&Mn26# @q9 VM` 2*<xNTgN6_nlR=]^8qsgF㾜q= Tnݩoco O d 4Qycf03yCvTH=iSqD Fyú}^SL=Hâxq+"j U-=JRҬj/[(T_h/`]h_j"OSv:(me:g|:Ԭik9MifK96N iTLm.4U3M#r!Jz8)vBe`$" vFh!3[ªZo27Q8اE u4r T2}W)vxbĂTn *˺CnmBpR aL_*IK;J$0\c #쎎mnXjgm5})`˰C VQP R^UWR$y#õ1EU9m:GZT\Ԃ#4X -$&6TՍFav A\J`2ƒt_8FVZ[ yC#eGupm,#DZ`0h@ J!5"408@ٓ()WPBov͂"SԬ]s;QDy8wF,aϬXP24{mUJG1Oy\/TP*s[źKD Xf@;༼H1^z˃IΤ\ ʇFD_L)J;NۡN[L 21D7i*P +c?&#qjm˹yp5:Oz_7f% Q:D1,bzkLc$%yMkl5<_cFC귲 IY0/u;t4=l8vs%;#M}hK+pc B'*_o̢mVU0_"ӊ&L%E;Sײc!""`Wպ.2EEI,C}~ +B їglWpѽM*wts7o ٵ!dyQL;"|$_|HDTR0=5kׁ AFN2wvD˂ݖۊ6p"t\}t|6u5L,(!MۗDK[I})l@FE\@ b {ʘv}xR4JwaL)ϮU/!Drɗ+X\\AefmL.A$J譙{0IkuH8:wIfÑa(UZL弱~Rk];Fd! 4b?QLZk1RSȑ( &鏋 l8rq!VvÉᘅgem5>|4f^!$lr|TК(nj "NN^f씝67BG)ϝwNǥģw2c>aIkz](@;z9h_i+%/G_\/S+NjQQfhc@eFF- !WCwN~N;t5c&i~/P%yvIA'L-(ן}T(o|@|zw6(;cl]Xs86~eܭ)Y%p71A"PZnp2Pyk 'Bc'p4[t8iQ4nׁz}b,uT>0нѡ‰pd3# 0,K :N-}Yŗ1eb&,yPA?f9.:n.z8ԇsIF)!G8\M^{FO:7NnuQÅi"\)!Ҕ5:sЉpsDp8 %g-udO])g[ 7Nw ?6^S1٘C'ͅ cvr,77Ncp Сgq8;KK.FÉp8zڥQp4.p8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4ñp"t8NÉp8; 'Bp4O:u5|x>?O]wuN7~/>3gN8wG sn !oƉoJ9>붃~^\xe&W:z("o=~8"}M?\s "tM=#;<c=vرbq 7 7|bq&/8y$"H쿕sG}m'!42CD[nAğgDO"ba\nv"G?"?xȑ穧:u""g"w=?饗fo}vsŋj8C{epFp'@|+W_}k뮻 .>?7x̙#G8qŋe/_WCٛË9ǹW_=z^NVbY?{ .h 5[?go][.\P~/s=NzΞ={w9Rcǎ?r18<3ztsϺeC${ep9Fqez)x{#߾ַo~n\.zgӥNz׾]8X8?0hk0^V?DWo4_}XF1Ɠ'O /tRW^?|#<7K_o~s|O>$qUW]uܹ/8Cw=$Fcopg vH qP?w1}W#K/:9sxf{ӈx}?OԩSimi=7xwxN >7 c9#">c?7{;>붗g%|A!!JIϟ'_!nI(zᇯcǎ}/ED<{ŋ/^|/\;ds /ޚVbY?{ .hO<CD{/"=zo{J}衇賟__S]UW]6ƽ+W/"6"_ox~ f VC[o5]yۊ9pg! 2CD/Wagv'^1:tVFťl9a:=nZ;fHf#ήcS|bp۝'lX:/p/[ٝjv6y1輰.1 f__ύCWi8:cDp8p8vNi8:cDp8p8vNi8:cDp8p8vNi8:cDp8p8vNi8:cDp8p8vNi 68q`pEp8p8vN۹IDATi?`. C++ program ^^^^^^^^^^^ The main solver is implemented in the :download:`main.cpp` file. At the top, we include the DOLFIN header file and the generated header file "HyperElasticity.h" containing the variational forms and function spaces. For convenience we also include the DOLFIN namespace. .. code-block:: cpp #include #include "HyperElasticity.h" using namespace dolfin; We begin by defining two classes, deriving from :cpp:class:`SubDomain` for later use when specifying domains for the boundary conditions. .. code-block:: cpp // Sub domain for clamp at left end class Left : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return (std::abs(x[0]) < DOLFIN_EPS) && on_boundary; } }; // Sub domain for rotation at right end class Right : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return (std::abs(x[0] - 1.0) < DOLFIN_EPS) && on_boundary; } }; We also define two classes, deriving from :cpp:class:`Expression`, for later use when specifying values for the boundary conditions. .. code-block:: cpp // Dirichlet boundary condition for clamp at left end class Clamp : public Expression { public: Clamp() : Expression(3) {} void eval(Array& values, const Array& x) const { values[0] = 0.0; values[1] = 0.0; values[2] = 0.0; } }; // Dirichlet boundary condition for rotation at right end class Rotation : public Expression { public: Rotation() : Expression(3) {} void eval(Array& values, const Array& x) const { const double scale = 0.5; // Center of rotation const double y0 = 0.5; const double z0 = 0.5; // Large angle of rotation (60 degrees) double theta = 1.04719755; // New coordinates double y = y0 + (x[1] - y0)*cos(theta) - (x[2] - z0)*sin(theta); double z = z0 + (x[1] - y0)*sin(theta) + (x[2] - z0)*cos(theta); // Rotate at right end values[0] = 0.0; values[1] = scale*(y - x[1]); values[2] = scale*(z - x[2]); } }; Next: .. code-block:: cpp int main() { Inside the ``main`` function, we begin by defining a tetrahedral mesh of the domain and the function space on this mesh. Here, we choose to create a unit cube mesh with 25 ( = 24 + 1) verices in one direction and 17 ( = 16 + 1) vertices in the other two directions. With this mesh, we initialize the (finite element) function space defined by the generated code. .. code-block:: cpp // Create mesh and define function space auto mesh = std::make_shared(24, 16, 16); auto V = std::make_shared(mesh); Now, the Dirichlet boundary conditions can be created using the class :cpp:class:`DirichletBC`, the previously initialized :cpp:class:`FunctionSpace` ``V`` and instances of the previously listed classes ``Left`` (for the left boundary) and ``Right`` (for the right boundary), and ``Clamp`` (for the value on the left boundary) and ``Rotation`` (for the value on the right boundary). .. code-block:: cpp // Define Dirichlet boundaries auto left = std::make_shared(); auto right = std::make_shared(); // Define Dirichlet boundary functions auto c = std::make_shared(); auto r = std::make_shared(); // Create Dirichlet boundary conditions DirichletBC bcl(V, c, left); DirichletBC bcr(V, r, right); std::vector bcs = {{&bcl, &bcr}}; The two boundary conditions are collected in the container ``bcs``. We use two instances of the class :cpp:class:`Constant` to define the source ``B`` and the traction ``T``. .. code-block:: cpp // Define source and boundary traction functions auto B = std::make_shared(0.0, -0.5, 0.0); auto T = std::make_shared(0.1, 0.0, 0.0); The solution for the displacement will be an instance of the class :cpp:class:`Function`, living in the function space ``V``; we define it here: .. code-block:: cpp // Define solution function auto u = std::make_shared(V); Next, we set the material parameters .. code-block:: cpp // Set material parameters const double E = 10.0; const double nu = 0.3; auto mu = std::make_shared(E/(2*(1 + nu))); auto lambda = std::make_shared(E*nu/((1 + nu)*(1 - 2*nu))); Now, we can initialize the bilinear and linear forms (``a``, ``L``) using the previously defined :cpp:class:`FunctionSpace` ``V``. We attach the material parameters and previously initialized functions to the forms. .. code-block:: cpp // Create (linear) form defining (nonlinear) variational problem HyperElasticity::ResidualForm F(V); F.mu = mu; F.lmbda = lambda; F.u = u; F.B = B; F.T = T; // Create Jacobian dF = F' (for use in nonlinear solver). HyperElasticity::JacobianForm J(V, V); J.mu = mu; J.lmbda = lambda; J.u = u; Now, we have specified the variational forms and can consider the solution of the variational problem. .. code-block:: cpp // Solve nonlinear variational problem F(u; v) = 0 solve(F == 0, *u, bcs, J); Finally, the solution ``u`` is saved to a file named ``displacement.pvd`` in VTK format. .. code-block:: cpp // Save solution in VTK format File file("displacement.pvd"); file << *u; return 0; } demo/documented/hyperelasticity/hyperelasticity.rst000066400000000000000000000101551412460263600233350ustar00rootroot00000000000000.. _hyperelasticity: Hyperelasticity background ========================== This example demonstrates the solution of a three-dimensional elasticity problem. In addition to illustrating how to use FunctionSpaces, Expressions and how to apply Dirichlet boundary conditions, it focuses on how to: * Minimise a non-quadratic functional * Use automatic computation of the directional derivative * Solve a nonlinear variational problem * Define compiled sub-domains * Use specific form compiler optimization options Equation and problem definition ------------------------------- By definition, boundary value problems for hyperelastic media can be expressed as minimisation problems, and the minimization approach is adopted in this example. For a domain :math:`\Omega \subset \mathbb{R}^{d}`, where :math:`d` denotes the spatial dimension, the task is to find the displacement field :math:`u: \Omega \rightarrow \mathbb{R}^{d}` that minimises the total potential energy :math:`\Pi`: .. math:: \min_{u \in V} \Pi, where :math:`V` is a suitable function space that satisfies boundary conditions on :math:`u`. The total potential energy is given by .. math:: \Pi = \int_{\Omega} \psi(u) \, {\rm d} x - \int_{\Omega} B \cdot u \, {\rm d} x - \int_{\partial\Omega} T \cdot u \, {\rm d} s, where :math:`\psi` is the elastic stored energy density, :math:`B` is a body force (per unit reference volume) and :math:`T` is a traction force (per unit reference area). At minimum points of :math:`\Pi`, the directional derivative of :math:`\Pi` with respect to change in :math:`u` .. math:: :label: first_variation L(u; v) = D_{v} \Pi = \left. \frac{d \Pi(u + \epsilon v)}{d\epsilon} \right|_{\epsilon = 0} is equal to zero for all :math:`v \in V`: .. math:: L(u; v) = 0 \quad \forall \ v \in V. To minimise the potential energy, a solution to the variational equation above is sought. Depending on the potential energy :math:`\psi`, :math:`L(u; v)` can be nonlinear in :math:`u`. In such a case, the Jacobian of :math:`L` is required in order to solve this problem using Newton's method. The Jacobian of :math:`L` is defined as .. math:: :label: second_variation a(u; du, v) = D_{du} L = \left. \frac{d L(u + \epsilon du; v)}{d\epsilon} \right|_{\epsilon = 0} . Elastic stored energy density ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To define the elastic stored energy density, consider the deformation gradient :math:`F` .. math:: F = I + \nabla u, the right Cauchy-Green tensor :math:`C` .. math:: C = F^{T} F, and the scalars :math:`J` and :math:`I_{c}` .. math:: J &= \det(F), \\ I_{c} &= {\rm trace}(C). This demo considers a common neo-Hookean stored energy model of the form .. math:: \psi = \frac{\mu}{2} (I_{c} - 3) - \mu \ln(J) + \frac{\lambda}{2}\ln(J)^{2}, where :math:`\mu` and :math:`\lambda` are the Lame parameters. These can be expressed in terms of the more common Young's modulus :math:`E` and Poisson ratio :math:`\nu` by: .. math:: \lambda = \frac{E \nu}{(1 + \nu)(1 - 2\nu)}, \quad \quad \mu = \frac{E}{2(1 + \nu)} . Demo parameters ^^^^^^^^^^^^^^^ We consider a unit cube domain: * :math:`\Omega = (0, 1) \times (0, 1) \times (0, 1)` (unit cube) We use the following definitions of the boundary and boundary conditions: * :math:`\Gamma_{D_{0}} = 0 \times (0, 1) \times (0, 1)` (Dirichlet boundary) * :math:`\Gamma_{D_{1}} = 1 \times (0, 1) \times (0, 1)` (Dirichlet boundary) * :math:`\Gamma_{N} = \partial \Omega \backslash \Gamma_{D}` (Neumann boundary) * On :math:`\Gamma_{D_{0}}`: :math:`u = (0, 0, 0)` * On :math:`\Gamma_{D_{1}}` .. math:: u = (&0, \\ &(0.5 + (y - 0.5)\cos(\pi/3) - (z - 0.5)\sin(\pi/3) - y)/2, \\ &(0.5 + (y - 0.5)\sin(\pi/3) + (z - 0.5)\cos(\pi/3) - z))/2) * On :math:`\Gamma_{N}`: :math:`T = (0.1, 0, 0)` These are the body forces and material parameters used: * :math:`B = (0, -0.5, 0)` * :math:`E = 10.0` * :math:`\nu = 0.3` With the above input the solution for :math:`u` will look as follows: .. image:: ../hyperelasticity_u0.png :scale: 75 :align: center .. image:: ../hyperelasticity_u1.png :scale: 75 :align: center demo/documented/hyperelasticity/hyperelasticity_u0.png000066400000000000000000001176111412460263600237220ustar00rootroot00000000000000PNG  IHDRXW IDATx[uY0vo MCIiA! CiRHT5!j&R\^4ҋ^0N@ 5sF)UT 06~ӋL" ## ßnza;F\w`wr%a@(t|wDD`e &f u``)3&B 0'?<\ V뷯^*` JAaB %YA"@F`*@9 6BA!@(y% 9rOzjZ:|t AQ̣ )x֦bLFPX=袸C[a5;6fطZ - tѭ}AQp2۾tT oT]LB Ue'm"F<2Rd5^0%mЄ@#(k#-4SBbI[[ VC'l^2OZ.BS3hOJ?`$F %iGhN\YXRIh% bXd˃!0 oFPYhec!>Wz$Ä$'0" V &S YȎ!o(HTE&eHp`R~?¶suOd3@bRrvDT&!|=ۧ2?)"*2V1$N1H v(4t} j>$jZϢG|:lN-D&!QBAMdr*=cR"GMtEyXEG0}28HHكB8"l YfBm=o2փt?d&aq `e3K5XJT¶ȝ %~AO<&_X(v zJǼG~#bbvR,( dȌD %ɷ ZQ Na~&'/E<BN2&殸2gPomZC)W_kgjh&fa[_`IPBa?iL+H8Zoc˕A*`r Re8?^ r4 |\3:=%Lzht736XY.0G;4zj~h泵Q'oㅨb[]~ڜhIe>Ի%ؘYHR!e=5Ԁ#}?1}ʹXsBH,+(dG(<8 u^42_8H=OXj=G5[4^++N'*Te`H`M{e\£98*Km(<)w &wao{ `OC%4* tZ BH!_0']0{IIiQ Jt;×HxLm=g5[6Zelg l+c6_U<_}LN\N[zU2,}NwIF/*f kf b;> 1~+4Ds| l*zIVQms\q \-S\G9L92Pqzb^"tR 1$, 1ax#J76¡vp'e!"LJAB֫UC[pycqxnךe:5X߹6J2Ź/k/' S,r4edN>SyobF: =d73]ND{.Kbbε%Exܐ*^-(p! _ _x_r'y 9a²*ihԹISҠ~.m@-/T TP"z,S 0w"f;k@`A0'* !is֣ 9A̿W]iji/;.ú!B-Se~ YJĽ8ႅix=_{>6[H/b#.JM@j G^{-Q/̩/T H~?_/=YG8z(zV5[)ũ%[;]ʶc8G G{)X_lKtLP?.%l~s/D,A0XZF {vm36;ѝr܉)7[O )[cL_[WJO,. ո<>­tbz7BV]N_(8J"Q-]]2JTy@}qFנxg8$&FL_l 7ߝo]r6A_cվTSxGRd-m̳+53fjPao~.A%{輾c KclTӏNXoc?r L<&.ιVqjGxz=5xobLR*-P3Z _Rtr4ʿSBuSb1Jui_JK| G[֠M jGz 19E,M(-[a[a+;vS)6l; v gȨtWM,\}47*;)'qԅ&v%=GiVㇵHjyDdj P-wF9m1ޡ[Wa{/1A?_ sխ +paS Ma {Hw'},wRaIZ3ZX^4l|}=X,p"屃BWeJ,: eJ~[Wm]'@>aLF\ՁbjI񡅎& ~ծVe? )OHCea*ꯅFFDY_ =(Z{ O|0Tݒ ga15lhj=5[Y׃WDo/iL92pX<,ڥo޲ZZBaҒ;C2g헸ԏ@= [Y fӤ`åF3Iϗ.@;4jy3ӁAӖ~?c`stRvayAxz<˯E~%h*O+"T'[Y:EA09̵}aXp6[bY*5+W}z t`)f#6YPjaoIέA;h'ugtp Edˌ\CU9mUwOo0wvMJsMvpOѽ§v0awRb ދT7$$:Q0r0fC## k$8Q\cߑ뾼N(8A{S>dXʭPEk#Htr" YO>/r?@UwWDƨC*[XaS %pf:.IC:p9aG RM#4)\sn%HBm?T~d-Dzc~00)(h?z Mfis^ jޮhh`*pjfyS+?U@! Ju[V[wTqԲy/r&UѣI| ^x)cvpW+ »֜ѸD[ePU'ӦQpBdYec{K NV1jx1kղ0.w_S5f1j (W~\મG_xX;|㢆1>vVsFz +)DzZIt~z!4  &I< [G –ၦSTu2_Jcb}ǿ~sx3K0ٻ=(1Q caj2*H-s'"2ˣυ A5DM`s};}#@J~"׽2AB;TbIzjMׯ hx3߼n^v+n 8L&My4q)# WRԴw,kQHSH3)߮P܏(K2*4 Z^g !PEPz& OԟVj/^stJ.wϾ%dOfAn=x_R^fAvOV?W`%Sح5c/AQlPL c+;@ĂA?D!'[u䰃B nx* !7|y'}{r%Z>Fe[|3߾m};&2pS9EDdD2[n/'y_vך6A|4ui0>+<"-s3QIA~@!M6AQ\D,8tpg}!]~Ǿt!Ј M;oE5ɟK`6;s8)[\t)WV/b'vЇ,ɥ<JzNj+:9Zry4~~_>lO]lF^mX}ɝ % Ԭ-Qw,KKQe?PSC-Kb pPܧ. 4 ( z>|LjaQ}V[@_#C7~q (x)tmCR2bp3=¿#A+RLֈe  R$0+Q Ï;s?8T=54ՆCfAe(v!s]R=O֩υX$~[t}{fL؎ 8%Cvv8l/" j,9u".Ϩpc;Oa \%hZD2D&b,I79ȴ` ;(8LJ'a0Mմ RZN [ (5*bh;@`LJ)],=0}t|ߏ߃jPg-fdDCs6[ظ~ _w_|P%Dy چiq _h6wg"jtry@<^L$iL* IY 46PGe GKa+k+2X4ћ5~p4wq-rT ϋ}{Nc!*S{.ҷ􅯡j35SP0[C'bѧdK(_&E (̐ ۲ Gj=^ S-g a"bod ޳itSǓ|O,m0FSdz]ͳ5 *K7Es713p3eGsMM /i )(p@Q(nb@< "d/s/|PY d%YcKHă4ƹLzZf- _DT^C+y.惌B_5ݒL&цZR –k5:ir.a"خsD43D&`6DLoxۛǸw\"џAhm:uD žmV9>.ɾ(kl'p.hU`MA:ňW=n,|?voƔ`+st4(-cڃf%f[̥duWÞ'XgY8Q9_`EK K:h w $n1YOVj޶2'Z庭I,48FZ}ׯmlK-+5 < ŵalm5Ek "(l2ēSʭ`̀%Y ]9Q[A@cצX #hh!SNC@ ]1Nf -%IFPKL n? D`i[ jrPGrĺ7k%`[tfmPyxYh̋M Ak_A#:jqQD2d' x#Wj=Mkͼ+h(Fq%e&ܡgZ:lo,C#e$P<'ň|>͟oga"PX5K^Xi򸤤ws5;7(C96ɕ(Sh9\K5|/zj޲ l9olM*4eu )ep䚪_Lp۬daVn&d2z74Bij'#,+"|`aJZf|}6l0QѾ[)0RTSF!Aђ)Rf =v2v0 jY ۖlx* J 3 6]fe(BFj UU +WfR˘xR|^;]yVMr^ N`K& 즱sj3 & uK r>0-)d#SXxK92a{FIdZhZϦH\48QP8i HwuVF5||M5Ys)JDzK$.j7^?^?ZaZK5:"N1z*#b6d =_s`GhQ]B^9(`mGz5jޢK 6oC)YƯov5t%k!PM|t<`}Sh0MPkOvP>A&_bqȞ/zq/?󝿁f-q%BNđ[[g6~D9 PC[?wŔ8R,f3K2Ek޽fb61? ֫R+ߐ,Yҥ³T劚)+ڏe1 @51A@igC2L}0'Ood2BN=`//Zw wx|m7| {VʷHOY"YD>? D F),zUj޲sFz31mbZw Z3lapj )1խ_]클»mzRk(|HD6X!,Q*3Lp0o;‚3 ֏a_v˳}+I.ʡQHy L,x)oDʪiI 5-af )[R. jv̾*%Kڕn5| lqJG!-ٲ>I:GG51[ p{?2MRZ3,d !]9ɗ|!<:t/o{ޑ7qQipchiG_X&aըAxÒbG&5X^"mp^'9ʹ3^lE7l-bh֓b`D67UO( RCNI3^'@'X)-A$oUov0B낯};Ew0{ esL`xhU9gQfE< ~lB#Num~02eR*#a3 hX?^u ;!ۓ1,Eq(D,F}mtQH=xs(cir)zw“e{St":jΖ|$s `^Aү)'Tؐ B/O.u*u}o5}&}ɼIƒr׏1.[1y$)a<pˍΔBK8A/zj޺Bf׸%RCtaDGI2E?'IO;-&&#m0z )Xe'hs0E&G\ï,-"22e 29XhlE>6Dx_`J1Ulh8BOCh4젙("k E q\~M33Ax AsJy¥zU~oC E )0nfsɐ3\l99Y&e9''yG ȝoeؔ]e8/QqMsЕNR>3 |;xPg%BYCi"n ^kx 0o#lWb]W j]}O<9+CN+"˘J9@BZ{8dQSQO>OϾ 忰pk e*Dlel tf()˖kmGOy3Ax]jeq}%l-k4eéb>HP{)3i^H!Sl4 c˲yqar'W[]33!IAL%Xhb,_Ha=+X6 3Afu_.xAkAь7'D5uWb[ r3,MTwe# IP)X ui:3Sy4`#)k_1Ļk"~IF zվ9҄jd#E{0nv JvQ2eX 2+UNJ"; 3lzYB%GCw0e HI^T0W [PrgIí-ӆd@vqlz 3_.%IPZf *4I(Rl.vj:5oW9@d^So}Skow:*A-GQ)JzVjSWO|ݡ?VJHj ZhTThbe`uzM[Ƀ񞟴_'1/ S)5xu2/OLC\tndO &cc= L_{6O ?NV+#ͬ łMs4ϫXhLIt:2E^2HADn2m>KXu & ,'CiJwA TSn<6'K%/roy+)#gd(V{#M8'ߴ?V'zZlC $\$`?z704hmuP*! "b[3 w1T2PIISf,eF/HE!>p8o\gg$k`d`,Ӵ[Bc?3> B- ìd!zaSJD~bςȷ0Xwe(lD 2 lҼH8$D.JGoJAb\oa ]syfXB2/2ϻ^3}<6[[dyVa)'D-o&0 v$(v)I&.{`Sbz/0H݋9v/SBNtpru524| ʵQ25$Rgp.:G]ixX` &/#LB 2MLox41Vzwt-i21MS?au?w{øpf?@#5fh& [[k,[Ỵ liz5oVrwRzO͛EE2a#&kK3T< :؉/P(C08ClK}2Fȗ>MYJdLoF;^r߄1sn%1p§[cH(a񝌚&c#Aejm,C,yJ6g^ {enX5[TH]gP˒ٲ1Oޤ&+Sq )97Nj2_;CVM_x%k4b@ oگ.i1 e5t91`Ԅt.00> ^1 #XzwM^ ͎ [OZ}'y8Tskwd6p0 $ci~= Qݽ/aWptxcml(e#\\J.u~`Oh r'S|\beq'P}5>ן:%kBǿD4yLG  q,/64j";hȜ\q~JFznг)z&5[/ Lv0D7•EsMWXiЫ'o&ufА= r }yaPӺ([FfSh+f>sF5# ՇN›>4 J=`O:G=,%j@˭޽rppx)/e3vx[gPƵ<~Hق%,.F>v%j?`.QyVblJ=/Q2/Ӯ Q0%(JAFPG>&6I$74_ѯZkhzdD:E*[j8BMxﯥj-tq$ٻ(pLBdy2֦Kh$>.S.#2Ή-?.@&hjA j%aw&8^{ǔф:@PG @C[;dSj%yLg<}pF;ہӃ<_CVՎvoEVrrTSȖ!Sܺd zǼUӲShAq(S{0$# IDAT=g\fs~>bj޸@tz Nw81ҥ\EY-Y Hun"eQ৆DmN1@ ڃax:7@a #idC)1tbb ON5n'_8mhm Q|[9i#p]뎿zuj޶ܬ "\ɮ^CYK4u(u,WY,ՄYmg_xAzDA(T/ *~{te|NL>Bzp%ȰQl~\ai !&~'tRv3rtjc!CLHpo13(`l=V –(̩#䮘Bb[h㧯!%Y&AQ ] /R7H9eXP' =,g["qQhՋ0)R,6F7qI$V]M[==SDy)z(@4KwbvXY!|GMQpE#~ -viVLrbs.,|iVj޲-\@'Zx4/3\B6aYHgDFKq* eeN `ؘB10Z_)$R2X AGu:S'&y45_8? `.3Ih^ޚX͒56T>rz:kfY.(h^ SҠ&`vaihCi.) ,ND +c^n`ҵ JMxdM[1!=t`b_3aF 2aH͐ڿux#"wQrjǔ-6=,sm[zް5 aYLQQÕX_D-łMy‚Ch#TaQ J֩rw`vl1ۏ"qth~M)`Uɦ!m ٰh7;z ɂ/}$0Q ,sAfNgd!\¶FZTƵmfdX.+<"뫐A\bo٢H!˔u"1gr*Ĉ h|%B2{8 T:R^w㥎=x&d!L@,1 HKt9/Ά8iynD0ND;k?Ol EmƐai[{z]|Ilkl:^9d;Cډ_G*"SayO2 ^JA¤,-TA K45N7 ?訬- w,;ߛڢ,{#e\-\Wo[P%:^eަR-I|rDb/rSr_ӮȫƆ^/A/SP_dn#CR`;Sw`.ԃ﬌}_Nr?SugS zRSc8maj޲o&r[.5nqi~RrYQj-bhXhv ntWkɯז}چw,q 1I 7zxƻ <́AAda ̏z%۳c8J MF>|qɗ!@gźܟ}~_d{N2CSJȻ<'aL:S0lw}1R ȲTe 6|Zbn BKC-l䓇U`B}g# 3іu(3Wj˭E>v%Z qN08,h9uGMrk.%>Rqkh0sšKf'( ptsf-^j0x).* D1ҫ)G<.Tx'&h!P.mb[Ζ||b {?<4mᭋ~-@zpn{rv~{bl2.rtF/`DAi3-_VR]B/DrGʩR&)CI[拷qwI iK̋ckc~KBc^ '"O?΍iOcԡ[VBi o'̋z!#zUz[^9>=B' i# IƁhyQٷ2՚JC T='_-(ߝl5L. +#pjC Kɽ'k Oƀp$_:1Ɇԃ\NCͨMy5?序RcN4S[U;VhOcuWe7EpƖav|lLN¥j$VPh J\6>PrS&;3eIL1#haZ6 #ʟ-_ݜ `?:ԩKqX9CCٲc VFv<R2 I1x&C4 >IAiغ.Azaӝ9ڱoOp+DF,m [R;=ʝ풮Vf墖mYɻRta% %_N'# }-|sRaΑ0v$_ X/JNI}ud۳' qh5 %X@̧GѸ;xf8{!Uϫ&_,X }81LY2b4(ʤ_f%3e Znĺ~3 [B:qcGVGo faj޸2;\QsA=>ˆXv,a .jG n$;*,P>LuW#jY>4Vf$gٱ@#u?SQ贫cZ7!i]:8vRb22M0A<`s9x2'T/6cb؀4KcD~aNQͳj1@JMe6MU;*P55p]ψ|J:dR9}?ZT;V8]k/+HdeʱM哮<ְF.0QմF<}@6(D:ndB;XaÛ`p<0EIBn)eTܡɤ1y&d#΁90w;b;OTu8g9]Q^#_ 0Oj=X[Pnç*sgOv~ibJRC=3y%0[RPmmM oRq Fͽ?0e-ՐC+bLzs_;3˔q_3ٯY_~LzA6R>(p߉~փԎSMZT%h\+t[,B'f״b2KΞj/TDMM)Gfj Ŵ2U'.Gx~p7~: dgK 4Er>$,^pJc(zc?k!{D)sxOa1Kn+Ag3zc9(U\Vq{`C*A(wC;ZS%ڐ;V> iWKY eԘAQI@` %20AH H w)KlɨtDtdYNpEO)I ;H 9D;d1R)lr5#X2*¥ } ,,z:4"w[>_DX؛Ѻur}C&Kz*}C'8aWVO;/3lY-鱅*ѵ9E[OB ;Mff{zN!qs'PH)Mgl$3wZ0鴗;[;c.b{☧}X}_LgoOVh 4:\Ⓐp"ݾ@Yl{3cC:J^`{ZOsV_,0A>Byd,Yh958lQS g\8r2jhIIzR_zJ%#bN}r/I(eZRF[ ͕S{^^A r"lbe'LQ#]IGJ|l?LəSԣ@VoTm'S)3vჲjRգ4(R,<gPs[-x+I nٹo,"aR[1+/#ذL^7b6򁃰(]~Worn28Hd)އÞ KEvRM2xSN)4NF=sJ%f\5$cH5(;`bkvkB2U|"BRv Xj(vjFZ Ҙ)k)1;#*0waOal{Acb^2j1& T x  g@&[@t5`|Pt6n{"Yv{3e|:WдS^uU –̭+mјzؽy j§bNu|225&È:sDt.H,TYE uNIa]Pu:bfgKjIΉw:ZK)±ʄ-݄͎/@Rhn x0SYC3E^)VN%;E6t=.zuFCt'$gMV&I%),;4{[WTZ%~[$6t rT' ,(6kUx=jTF)F 2INIjikou1&[3 O #u% =R+W Je׫ڈaRn3QjvjFdF}2-LSj'lPwq'Z _-9 -.zh@ cߗ"yH*kGz2`ThtZ4~5;L[GAxҬy[?zw}eZwryeED}ҔA:d)$AGSwt]Eޢ 0Jzu2ƕ5#'QmD:1ݲMy4D@o^dMU6\k8|܎7TT q"(&~cbl ä|bhq>Vjɼc9DWʨ+c4 xPKum);[t.k˘ztN{.lYBc`_.Em}bUϺ*V !ǔ6+5j=g3ːN736ON=#,zPH}@8⢃3J vVjGB'7{A*je"?[ScZ\g .R h{aeQ,$҇4 դgR]Pks{t4zrGLOFC48 es P' }F;Lu-BrκDAO/FŠI5:v^]Fh#l=\_dK<^{Տ~nnRwU4zBQ|Cդ2k6!Df(}Ւ sRT pgٻc$R'H3LQ',/O+MC'B9ɻY ?!PM844J#bw㎋vlv#eHь"#[Pj kerjA6xA77 \.WMe]7E9Cj!3914Ja#%_yD7(1at8NM؎&0 /3BBuBb\ZV;.Vj}z7diշYo,|h)r9kQ&4iCnL]WtiIZ&t6i%A-Kd#m}4e:ПbhCu6pC}SG\.$iE?@kk=E{(ZRwM[Xj vR5[$^/g>3hmjנ-SIߘ/,lS*{XN0?NJ(-D髄0`+upΦ k?0 i#h4COIlَ뉣GlyH - I94F֓ %$;lDG!ja ]}5t$R-CNN17*]zw VzKJ OPI<_=RD̯fܡt[1o-4(:?'R| V|*lQ M)KVz +ϲ[v~:mĘP7e4)+( IDAT@b2wb[gPf3N/zc <bWGSL`Ə ߊ\f2y?d"& &\ )FM;fp(.8va<ȿDØf ACHV<?h iF>l5̙5+%$v- hnDz"޲O ?N_MbO$ɦR0UnD U /x fLU'.?}@zc,#%Az(D<&ZgU'˴@C˵4BA!1kE|WDu҈2LϹ;^alTRA])^,ԯHj 2.%L B]u@!VmA &0 60Qi䴗=ҴHfP=ڏZ! -j1;VjGR4FJ~y5L'F=pj}Ge5?nO0=OɗSbΩkm_wXw&nEkWcJ\Li8ՙH i)f "U2U՝k^@4DPt bhz$#1`b3`5IR#ac$q2:0 APTHF5$!WM{c>M]zu}g}op (}G)$kpΔ" 5}PY. )#a{K4ъB)NVf:ss, +/D|/ȋJN!0M#Y ڞhr9RlXRX&) 8kJ dJŲlhDa:⏼jDޠ< >⵬ 8*^mkqq(8!X>sx.uʼnFcTU1-X))]emSПb]Vbi@("*X6YuHc=+9i"HaLz86{%,!”C@,qC |-Ѥ5$: Y Sfy8 O3pR.L>XF`"Ĵ98*(#ݚvcu5Gv!*:(fe #*S3wWaCϖ4B;9"),#7 f4ir/x91;'y@`IpQ4vb5nB %N,jv >i40КFݏ۲fg%JC,R7Rn*4+͢KyC9L@ClLId'c,E*䍢2AOҹa2bAͷ f+f+d,:y%&n.L}*u3h2x1DCY7)Gs'Jk8GP.Ĺ%2=Ujn`]_ܠD YXDD ɬikL#|i`D9T,ec䨖)2b8(q rj8ͩ,%5h}Vc1EW\RQyNR2_gA }ItGƋѫ-thۭA[͋Q>j44G܄8<ùtM\^I0kSb2 +]05B>)0W *:ž nAʁQ!L͉j\dFm4T 1k+=܅f u""A R(K.Jm,fzL8[ IS"\ czTll`Tj֠(}FBq٬ &Xa aDQG g1`""'fQ?>#$k v)PvZ5V  ZO VZ]hdBfPC.7z4wڄ*TGB+mh]^1D3,u0/z (*ZgY'LD8IA։P)l1ZmYޕ V0=)]jPTqFXEҠ ܘH `;c\O,TK 4bQ~FzpW0H#2L+㱇֔k_BlDs :v}K"պ*9)Yt:{~ VQhϒT,4$PKʄSTTc_{#Ca <=" LA MiԫӞ7;-[kȮR~[GۋO2@A O-閼ĘvJԱꆉ/ȑ7e 22U!3JMDO[tfX9R kViCa@/,fú*ZKPHao7Fn4 -`;a=Ό'wbz)QZN?}u9sL#Pz{ r%H9UL!>ym&R,`vہzD-fTƂ\ teؔnAȌ=9m r #}%3ۯ? |ZJől%ٷ@qQ/m.F$[ vN!Ep ~Cz -XO9lb]m1lJI67bL,8ph7F 3.s`S%ՈSՠdwpW'ͤvjRDPL FBl,c2>¼0`X7a;, f# Of>e8Fh4m/{7 ՞֪N ) דf:Y^BE݉#b^gHQ552<׶NƳ@N%c(0 bAC<icjn[qkqς5瑡=gۚ]׊Kx\oi:W@O(7񺽻6iz.Z'(WseQ#eBNi4U`kf\O^Fc^#ºWXTy S<#^9aWRu]4֕Q;iuڀm^8+2gbVeOdAY70t"a`-tT4$5FbݍVWaYc})L;}M^cgɬV}U21?3+YՔ\Թ !._6&QMf`$`3 RJ5#e[E 0)aBߺd,\H5=\*YGӀ_cB!Ԣ}L=}V秆TѧtIE{ ~wh-P L1A@c7d;؁zŊaƮ2ܑM=z]?ji3ޝq"ylj?:ǗUF۔yɣ&WJAZύDL畱::+iͼ1 *9s[!5iCrVYm vS Z\lTg6xQ&,@TN@H2 [Lp`]mvm!E)'3vf }$(!!>veN Ar\N D%%ڂ𠐚;12ɩ_Y[&T\ W3[ݎH ͣj wGT/HW7ݶcUL4,D rDà##e oEA#CrSYct71$S벆:kPH5ȴL{vӚ3]T/:JˢfέՍz|](_\B@ ~ZoD5E'ON> b]@}wۭOՏ6IK&g'?15&Xggttvn_tW͡GH%^t}A" @eӚ_'Y<44_< *"cܷ[uӫ1¶ۣH'sz3}@8:mEZ{ KMP< $s=[>ʪc,!FT98=TT>3L;@Bwka(\WdudP4ꫯ&qPsA86" 8tuC)%mwt8bWlY0ƦzYٝFn9zUdpKeRbrbuwSdKtNY?i.;Z88v` 0"?~v8r '2EO4`E7QQd܁9↔ g959yIݖLcQݯp,pDȎC(.IDdyQ )YSTvݐ4GɴjޜjS>s. 9mcRNoVhnWWXҽ IWEOipi%E"L9P' 1v!0"8'>M_%=m[[SUvh9B)uǯql.;z%%"ǎlA  aA]FXD9^0 (xEֳXKcle8Vj=XJmMJ~ʦzR#\CRCzSZfH#{Ks| 4M8@&좁@a c6V}YVG~磊a5)5nդ'Uڳm?.hruwZ2k;gPIg'_n9! &a‚L>vEF#u\}!U>n5f]z2qy RyhS`8S GiKJr0[)ߨ>]HZ-%6G&VD pL@*_imUN*(l5kh+0Ժ'JFT]PU;['sP~+ CGM"$>V lB:(=}^'Z6ɬoO {v-(^Xj:5GSg6&.!N}/^ruzB#4]-jqi܋p0 6js !a& D5<1Fm' zW5_ThLw:Z ֻu V9Z\BB:4u@jHxX>I_J@o"T<% j<JԢ,?v]՘?;.8@N2Ff='?BhE`Ji[:)@CDrۍJ&ȓ]$*c؊25BvT YQ)Ǡ+` g"DI"@+)O B4 -dM[+/Kc^iUr[6nfk]5\`#H%9,䮢/EQ9N;iR2fh /0DlB  2 > P ``C&SQK/\Du.5"6ZٌnՓvjok t w?q#b}EJ;:|0n_sRsEM qAv,fKrrVݚR]X?GHfNXBc%.oƅ90hX,.E%DAS-p:I;vYlk4?0DK4l5ck4pBFM!,{-R*U&s!{0RPw2g^[^k;X[iD>4)/oMH]4q`@fљif@|)Zy*R'A. 2B%'C*̈hޚssL&:ވj)3o`͂%˂uJt8.eUB/WCQ-FXw)E6)Pv;48[/i ]b-ҡ%2Us 5~*-X"` m'9&ˋo|ՆtpF{#'R3 L\:$$xN(좁MAa)Ne-ـ\qWwԯccu#M4IT$L%*B? \+-X@- }]z [pBзPjR5ߠ\-S (Qr F"L."[+n:|".ia IDATx|;0Ċ M4!Z0i?hd' x gJfAdl˧ߘuJOsyo5J $_H t#asjk@ SjF%0ATbt@nr*o֬j/'Uut_Ef:!(2*25jx(G#`m^ɵ9P쮓9jb=qh`Dp= M|pJlꏴu b8 &vOf>$ |hNpMERN-M](v 66 M&ܴ1Z\}JfA i4pPB}S=T*дQYGIˤbPNSDϊK Y  5o A3ex)yQBGCl7&1~ʧ@"$]4ES+h#YD烧S\qXGx'#!L( ÏW aR!mp% E 4,v mX뚂8 ^PIX CCDa` O,k/e REVx1NyÛ(jB0|2f'-XmWZ,"X!)`I d\eRP.t4XFL+ߛ!6A#PsaXe\-3?ڰT{gR^;7WQu\h6dFB9 zkgG) _̪jX,ȾB{E:j$Qh'Qum}?@@a`&*Ej륽<*>shU)X{ )iCl&-g_ 40_N%3h*kGr>4Z^# If:Zn6q^W2Wy7 9,#B?WZRꦻzjB[–R`0Po/DDhꗟ{3LSF#匔/4@쬞` # M;Uc>ԀD"M8(P ꐢH\{ʮE>MO/Iee]^bgkhJV˴7Lop`=&MF(1ϖ~-oUTMJ)LRJX^"2e86bduh Gf(" O 5o/EXdhr4Ak -" l}G@jƵ kL& S(dgj̧.TKD{EMt 1)=KE-UM7)c84 W$k# y,MԌEIfb E FOT{]zYR 5VYtZ XSʶR;.hDPՂPc\u ?2=*XEv6ܹvڰB:ڲJ A)dX}.좁Ga`3q7O0LK 1szg1"V'TKKހi9 'Y<) LF [EpaQOFTՅ Ӈ2)v5Q l%baVYBB'U(4.@Gb$@܇ˆ-Q-VJ"p5{VQ0 IaXR:LOr|*a " l9k ?&K)A"@6"@JKقj *4Ф:首UDI /.4 uL3>l&j>&K1]"5\FB`O kPNq9 BؔAz5NTxC [O?zY_h)'6XF"ER"Ym#LZ\"Їv݄УC6~ G̈Z6paeE#94&YicqĴgr@j̯]EiHn'a`K 0݁wlRJO!PJ9c 1%E%*@LS`6JpskւɄ$ 1%utP?j*Gc)QAMB}~_2{)j,Ж$<Ff*E6"#G %Uæ}tL=S7u6vQΈWg?^((XQ1*?o U3L.%! @99W < ii4i44Ӏ84,-c9D>LCJ"aiƶN2$ p@?KfT̡"rcmgwAY#XSD dAɚIG<堰Ĭ4[NVVV!X{ @$N `qtXni8`e@Ch2D8 6lgQ Ìȴ2Ctd.O cj*j4=|>_>K@pj(S%'F N#pRXVV !X;!X0DX …iPD%?5LdW5!RpxIV<?:\Ύc.9e*3D]1< GĬe"$Z\õh  l-0ֿzl_D$E)%ā4TG &Ph]Ȋ9HDB(/h6E\8 C>kկڵ+?m ojs=ozD|8gBaq>s{A\g+JD6(믿K.[q[axnGދ\pA=x`ԙEь-'?IDy%ڵk _,/olc߿=zW?7p|Shg:GyDvw~^]p}ы^t7~s;p|ӟu/袿ۿݶm~s>"6?X_*/wSX[oꪫ)_@w]zu]94cǎzֳ&}ַO|ছnڈ˜8?v:|گxnGfKRz__җ5\3Ϲ7͈xUWM&/| e+wyw;D|޷XOۣORzWVՙEьm>馛OO=u{X0uO:餔ғO>)%{ҳG}+_X3wq)m۶ߕdgGK1?/a# 7ܰ0s~ /7Mu-"O{qee3vog>g6Xy hʿO?}'p<0\#gwig3|AD| ^ %kkk/}Kom/2f<ߎ;8I|^GDox3ϔĸ{'?SKޥ^/3//r)'|r}я ]tQX"c8leǛf"ڿ[O>y{{ÇpeeϾkscG?s=weeO;)I3s >"6;^'MO@ " BcKdKqR ~I^!v+T^U>ܯ+m#pӎ;F*Ic{KOGnhw+wkJ>rm:?n!l/u*+~)kQa1St"*NgĿgB7a(!0B!9OƎπsq'fHWfBTTB!|G/.݇x!rK3&$`)ѳ?-*BU# ε^ '\Hzٯ$(Pkii q9' NLʌ+;_i豧 S=x˸Q_CP" \3a&`'H`BR8P qiKB@0B5,pg*]qe.ݿqz_(t} G #y&$$\?|esC*I ZR*Ҍ,Hfb='Bסpй'??%l [mD T˰}3w<'3.t"8WvtS G }_&D2o'aO[\]0_DHT|! : `Rfb3=yCkU8PVB6&BM wt.pyݙB1SuG1;f wOq3)wnjBlz@"N8H羛I!yAʾP)JPBb$E#&LJu·nIC=ާ aC&0~5L\h_ GsTqyG3.pyG'3.'gtrʧ'? G }07=xֽ̤aC`A~9?5c!g5[j UAl{$f +ȌH9GށIqOBרpc[|..0&. /_@yfu?t )`Qr-GfSx|F)]qNvt|B''$BעpcRO0~SpO g~8A1?P貀##$sJ #2Ì)dF<ˌNbcDCǘ~pXMD`†SDs~d.f#jKsZy};SiI.䌎Oxsvy:{nߡ ICnj'=T HQ I ĥGS e/)6љBrBb$T֣Pb!١ǀB} =.lK1GAC[@Fz#X=2pZ)/R@%S(8>]S|/+G[wBW8P=/ѓr1CK4(YhɅFAbCS3&$R4#&4)PV8PNԽK. OĮ 7x[~pV:AwqP{Fv38W ._Wv~߆# ]Bwt?CkAK- M:P!_vt8FzyAr )$L!RBJ:%J D:mtGQ;0#礻D` F<;otJJ;7qhVKh~^SΈvpe tmw(CT8P6OH/KwQDLY#$ 3B\i%*@J\SX^RB51Ę&'!Нp>rx\dSp^`"aF`56<\@g@6'&<:WptBGG|C ]Ul[.zn>S/a{ 2ujdʿp茠g!Ē, ;Dӌ\/viRNң;0/ݗn/'x7YO؃!/`spBY"ׅ~[pDmfƉnjoSsg3_/ :([{pCGpGO/uԟiDZ&d4P_哯+:Bx^~*88bAu.0[veԱPѰGn W5c?cdlPDM!ӌ4!%L $7Ow= :# =J⻾ y:jsrU];'V0xf"g r: UoޮW8ʸ7;zk=nlfQ~ 8S:˙3pt=_( ݡ Gz4w!RaUCd?p-=mƏ{m.`7[l/0@#mo:P`p1VBAX'RIl!z?"U0G!TL44ѴtfA(t*a薋FTe\ີrYoXXkϠ{a EIw\i--=v rQʄg9>G 8fKhDr*)'t|+xGGz\ GC0tkOy9:q]aHv7ZTI=txچ49>V|A@ 9|ؓDob0|6iCmV46-"V՞x(*fŕn:iiiB*C ?jkI;.mb c@GˠZ:34!` -S?2)*5<9 /!z!(W*_P6*aV)=syˀJUDkк^UGh58ޭqU(א&B$$L;մє0m?3`tI{slN1 d𬍄}2VBo&PMQeB H T)Tqr(N|B[p[G> ;B  EPV E f]yxrU.(5GT(H,“ iO-Ӗ6lZG._t&\]`s)Ƽ!wX);GY>}(`UVͧ3-'8:1}BGCCFi(T7a2+Q)!PݸYÇA uS,¤eִA tҴA`. :E t;d1ٺʼEC uDT.PI!P-m* VҜ%-7*TM e4aJl0Mpqxp9/af<;X3wQ0RC8~"R_Z $ f - L:WȁpXBB7C+#& fQ U !W(`L)<=wƕ"BǼiK7u4k{6&W]{͉L(%kRbͶRRN )#p)f4: :G?C3QG]#BxhYQ,m([=+^ \ǗaUFC7Sۏt_򂲫onT`g0w|T4+ÏUGA,gYt22c"Q0(&Q5Bʂ#UU.AQU*1baaQJfR4|{~'X0ttO8gꭐd]!A:]c?Q.08@Mli"mـ {L _C=뮕AoÿCtTfa5>@j9f۫vp5RfVuMdȮvy_;rF=<Cwn.~'$T(FD}7ь f-7GzDऔ7&*-¿[:_w(K#ڍ ߈nl3k.p9B_rû,v %*D[8:(TI * dHbGAn0aMNU8MЅO{2Z#^v7]\EyܓqJflL"&MApNr\$~POqEm΅ {__85)X}ܮ6ج_;: C{hqiGK 'յ[[g?(oM\rĶldf Ƞ?O6FM)o *4oɿ% aase'9dY=2Da %&6; D*e&(<ڴfBSCTw}D5y`Shi|kX$NRRǔQ VXA8"A_}l_5~ ֖[7 ruOJI`qrLY1trC?0;KCHsxR(ά Mmq?5;ɇC\ŠC7ZA f-66&@ +yA&|kZQt׫[q"jmt 碃݊ to|mB5_L B *ATSy;*5eSRq Gq9V ưV`rH5J{MF4WuilZ"\K +ORXA~8`)Z2Z߰Y=Iݙtƙ+8z|/v4tg)azP%³<G>r>VUSj0mVG5N7Hj BK\=W]ZOz_ni2f;Bc(-KS E1TL0IAj݄)H@Ͷ,>G A nP̳K :"yA'|Р%q yy/0_T\`ڀ7WH|w^- 6QJ,ƺ ݩrDD-?PaRCIG^*/Bծ\84Fs !QUoȫ^zB̄,C7GrR`N)p fG/jWC${`7,1tPrVb$n'j]L\K%e"LkFHii_dMZphb%LL旧"U(E՚jb, ~#ND"bK)6qY> T?\kKm/`s#B7_# ]{tCqug|qq5jzX9QA`BtLB/.s֡U ؖ.)ý84FG"v~OFdYGMQdjuGXpK 2ȩ9Mx*8>C}zt-T8_T[,rT\6% tYt: ( tDO*VVSê~U ƃPWctv¤EQ?*|EMMbѳst0۾5_3j;4T(dft0;Iiڨ4WV93+9?E;SٝHGZIs._Zh;3gpe27j Tz;«^{" ' 9LZׂ:Ĩbˁ_ vNB_R5;|ۛo2 .ܕ0 CןH@CW`V]$UhgWmui"XK`|,4>[3 PZqЎ W`;~IqnU_X _ݡrn bHјP);V bj!#L"E2eyg#sp-Dn0DA DD fMSt'x=^yPG )P)D25aDibm B\JQH^5&.^W6-`o &or:ٌә#0ۯpR"@svodVD 87h rv.02kv%@d0rB{^7Ь$ +b $U:,ؾJJg@"WcLd=]ۭDy%z]r}iڵeX 5Ԛ|168ďk ,# =W^l+lzN.Mv RB+ØjE S'n`U6?r VXc6PѶjmKPjbC6wu@K{e{L"2;r ?7Nrlߏ{1h6+aap_N %bc-E- wp-H`0*hc?d5A D ̿XhY>@j > h!槙 i/YXkdPZ~[娴-mebG?Um'ȦRs첃T˻敍s7@ nQr"q~4$\9(`^e첃үQ?\c+Dvi IDAT(*,u5{x_B[E1XX眫 ?T z%@KftۤBGS%:T-+UԾ] I<|_an(:CwS M]C>i v Nܔk +B %ZJi|N~y-)8Ȭp Z8tWVS>՛Z\:U8:"f곚Z2{TUN &MjPT#I5–(3 w( NCWSrpsu-zQp,iN&NH~Tj%t`l b3SZ;vtG+PsY+#;e"ub\jBE?)pHZ'T$o)WH)M7M?u𖯻n/P /6VAjh1]| a`sǀpWo|מE( NC W™F3o\yt2#C1 bObbC\Բ}c0SQ=PN_2 J*uW"!a9H0nb 0+AEԼ` )0=B&M5Yͅ3ufWV\cyfeB7Iкh@ 4jʅCy@@4/x5XM_ب6Ƹ(Ơk7J XbƉv-#XBpYHҐu+8Ao a1 hj@h%_pi\3Z&||(_?sWr߃Kl̄nuri4;-)h2 Œl_q˾d\Y3P.)؅LN0o^^oR=ä *f!5m?RXi,~1:aO>Z VL!)I3* GXm%˄)(.>FM2>&rWu)OVn-VDSBF;z=\BĥpF`4f -4R}aUML!%w$\?$L:2i"-s͐&R&RFH45JT@_ul?{~CkQ8Њ&UfqYqΝ6.UulmKX(ZӄR9ivfB ],t_23DMP,Q"YP ;6{R8+h J,T5_H)DvevUaeQƕ b{}ąHpx񆾬#V0@$/"^}_)=eKZ_` FM K`V ,# x]B3|}ļA(J*,1oV 3\P"] @rjhA+be2O bm%l K\TUY`Q2+:ݏjK"> ?{'2]{ ݘ%X݆Tu7/J.0?mV#C5x˳@0h1_ݡPWáSeRC ]< zQz{WHpUjaN, b2l,T!* R.aEMO%Y`l-y6f = F}W$|VM ,XKSd.j&nb%K>/r9GX(Th9%|Fn^o jJ&OYTXDpX4o;H^ h`XT&1HPj# '6،ۆ)Bl1j T%[(D~ 0CD"3*S84\-:JLDQ2 Ft!S eɶZ q?L3]cqR|Cm?;8\{}Dtܳ %Fs~60,.RCnH qENɞT r w"Y[! Pvlh*S̈́r_DXxrk,壺 -` 2"j{ #kPfBlŢrS>BVDcR,;:MR f^@ D*;Qu79".(!O^W0,.+m/ځ D38УahB?* B&$fSf`}^pK_3c&-`]D~:W|\~тl aR?g ))Pc#-wQW,S'q-]Q'Dsȴ"L*[׃"K +eU ;)[CREJfؾ owh%1I":z J>ꃢF)SZ|Pȼ%, sY"JK̄GصڙqqL`㟸()L*VXEP;ۧ-{(Ogmm Ju;q#+O<+dnPR(D%+UImj\Rܡvfjod\ e91C1M,JtPahTN cY3I k [VSşA-J ` 0s,/:]_WiVQ!bDZ >.Z(wL\URfKgp15@`)]6 ZV)HrH4)TqT! 1C| ʫ<)KPd'?k t_|GyʭB@0ԤDJh+HSBdpjAT3shk%/95iTd!ž vR1vns^n&]և_FɿJ“mWaJ䚣/uBVj^T.d4\RkG!P"ʔ, a@ 8 d!jDYm7C2'wwnQ&lm]Ra'`)%K,s@Q4cob .3+jl3Ў홉\`*<$BVƪIgVo5W͔z=`7R DEdKLXIUrtT% E~q gb̤\,@5/HAO"`P~`1ՈJH\L׎W ;#Sz4 *I(0e+~|jh4#O9z/2 (؇F[+ {J,t`1|N"Us43WЈMD]\VEY!cS"ES2g!N,vdIIPP6 =B@WByfCHh-S~,¥{Qbz%C PTH+H^/brߧL9QE%~v2BKWDk Kζ٥ jh!0 ho V+ :@;3 JBTpH+) B"dIaTQQU2 suDУ#eBKZD&`31iK)M+B]$ $afݵ$ Iy~fj]Ah; ^)6Y fc\tnMm52:gȳ TRޙׁSob)CCcUX'aF2Gȅ#aF8KY6K0%!Eޚ/,x& sh'q)XRYIω$[Y6D :,4%?:9ܯnV1;S%T=h/D4:-̟\0Pf}K9Qvuw;FZ$Z+0X9 (iN Twym&f.R@GCdDf!Dw0Q&ӝQ ZU":z4 h[ \-*BT3i?&,ٕU)Ú)J95c"QSif*Y5ʔiYt-_hiB-ή,YʭmffsL@)jI$anȥJJ*UX8Ԡ Z Hym R)cBg'JLsfbX077|3=60[ahEs_~Z \&S:٪X@ T`śӱF=0 [n7?TXa&:(n@a\ܞO+2L|B:;ss']hjeV/QT`UgI (Uu Bj8:Z͒Dƺ4/HVGD 4 6[fJьJDKGRn0[ah]uI9ŋ?TH)x<ޘ0pi j_ah[wJ߅EyDqtHXL- UJ:'sMAgg fk21ED@%dژYY<$Z@m58Z8G;"ZDGC7|C{Phu/՟Ma,i^Ʌ@M".RXG)%EP;##''m4u8Dݜj>:jl uNKGX)g ug3#8rxݡ.>#0X0/(( e!biVd\JeòPe;h5F?!(ڲZX8MnZ;%/|ˬR&Y~SNb 2;-Z, F~rQXB+/~6bV BFW>wH(@X-ml`w{YFKkB*BySQ&WHKb}PT/AK?9GG T㿂|I5qb2rjgJl!Pg|EꜢ2T`7SέK)>;[&H #]gy&] H[hJ9k\>y)%Q>0@I 0[hui KL` 铂 +gv81}B7*3Zg|r T] ju`GEE3gv4:[-εљTq}-w5 dЌ`HSC,$c!_ډF/(*D<  -%Y5D>l3O!SRz-]xD "+/R9ɟ()ibzlݿ Sz7dm?ʪjEE2-hwS"o%[j S{3QM7n=uVZGf2ژz.x9..'M+]zI:Oȗ]B}~?n\Ys5R #-;&7vLJu.q)KNstZʧ&< n^SFe1OOAnF0wZdE"\Kwja,M(C b'= yV:BaX1$Yf#Y~v|o}vP8wiԌ5{2XЕS(-h)%\k5BuQ(, G*{t9FjS]g|OUMV0wʧ, &D;%@ZQWA9}PDq=!;XοL$~dZ,/5;R㟖/=\0`ͪyAk紙Ӽ~.pZcѲ)L½%X*~8xE= 3U3[C%_~wEh+@&e n_x7X:e|&WK\$aQCS6=irוa-X~̌-n5l. ZwP[r 5|IHcΘ`Ba-*e6EY]1O*Y4),qGlIAb WifQk8@M^]t)1)UKoչhi{.Aq%qXXXsS.,cZupZڥi!F; kjF<Ϭ}7:/-RhpNf3|Y& HEIHŹ` kBi]C%ZlZԙ P塔#!$%!ZϠO Sh&+aZRu%Mh'pR<t3~R:SX; 0LuMvVH*4K&h?H]A4ռwբeL yA`gwՅG]5)(O8#cPM|MŬ;ݯ UiAֺkv'V`x狉/T|Bס3Ť8S|?f' i:(Vqrvl0ClY!j:ie]]NKsB] T5\q^$-]MPk@DBGT!rm-|Nr IDATVfT/:~]kɎΪff^-OQ̪Z4Og%Ahi4i𡛪BC ve-퀷6)52FkX+)ZT|3D\50ٮWKi*_b3CsҹQLa3yfD8'n|b;}Xnqw\wb%[LF;X"P_?f+_Ii OoKKHX2bς5Piv,Ԑk۪L+f bAqI}.e`lRS>á=Sjw4Y9; ū5hNҘ-êjmUټ Cpn֙We RV]kz'J @mиX/E.oL!Rh\DjT?MoyA{̜v'h?Tդx1;>ʶJX,^^L/BD^][O j3AR$[`@jqiJsŧ 0ꞶZM?թjd5؛k`qK+yA/w/u1k)\_*ψITSMy0kA$L"*T̪b?AaKѾ>gsWUUC~jxsV;fYp0t0t#?`e55F6[wKu-Ft¯#b={C:%A (2 ^#GDsaN-Yvq RFbՙ6?@W::EB6-NX^/ 3E퇑urqMP8ЍZ^f {/ bPM#PK jG6'|Nh'\ҟ+bEc%|iɿLGWdrS;V"f]y!ӛ9b)AXRk.KEAs>kO:Th^IHuYCù2>C~Q[r^ 6s &.)b3ۄ5)OXc])?W5iM36ZMtGF^:Qԩr#~`fw?HA &j+UvqJcnPo +Lan @7v gyx(e -eY=:h=. -/"m94 P)+ٛLxgݞ}p;<"ƔSף&h~P6ZK_h}PaerQTUDHXYTsy#F7 vv0[Y5Qn@7LI/6`+aƵ ^ D4'v,xqҴI["/ sH{%|UHuJz&VaQvի=PV:Ot*Hl[+/>B=\FǤԋb|4PXc~`+h=9}hHcʅa+aiON)={uM8T?*: h g;9,Jj €;g|BʚeYJoҾVRτ!G2]' 1ἔ_-041_lA<(.J,5ε|Ų%W,7w"͚3\P/@ۍ>cӻ1ow)a?0;#p_В2 1 p9h1@R=-⢸ ,0[JȧP&9yֈXssj(- G{ŸEh8 _z?k!T\NdaJ%)}}hy?8M Q#{ߏbV:Et 6Ȳָjx|"L ח!j )cV.T9>.m@Zܞ4EM } f~6wt=OHi3TTҗȨb\#Ͽ;.s¤ ϴ9׼sEU-8n\ ="NQ/vr,BWjr@WT0PˤkR#KIr1wX㥙Xjp3t0[L#HAjf RT ܬ: ae[6\2!l)y|P;@] m{c?ש}IO/n"z f _$jA,c> V"p?/ar'kSm-@%ȡ0D)g m=Pгʦ΁к즡q~4lzuewlG]и!Da?;ZH;/- m[-yNB7p` ;^3>"yOVuz&kۿݓRq'SG=E}`@<$ a*W/5s$.g5d FB@04챿P>t+"zi9Q0t3ͯ`=}tYEiC),-iS;Kwv>DSpgndDd5*}Pua,ظJQnEMmHFzojJβbZ;_hht&>qJ<w"qC#&t'EGf -,SXyd.ߏ|ΎW0t3fA-, ~v 6do]FqΗ~\Ey|_oS ye ,:o#Mܯ_t5ˋ|yJjo;^Uó .EkOO:OmY5]'oWE-䣣??x3%t3ug|O1FϜA4K,~;:A18>Бy)lGjzx5zB-u#g;;`4v(Ró1R)w8\zy}nG0t] nNyҬ4/UHl@V% aҝy8keV@~t'񁅾Nǝ]E PA6;"1)LrhzC)lh.9Q߻}i^&XC]_{ a: d_dR~w?s:;=U7'; ,o]_ mhic'g)P.9,v- ϚJ_7ߵ;@@[bUsۉ>5++)ektFzd#ؼ'bC :8߿ O1Qk 4#}@ّfп>ڃhA3~uoD rFDbW`< P|,zW$t?FAxw3֦kKb"ky,Nj]okϺ{i:iPH <ةHܹ8t#dώ̣.~PY#5+mun_ Sz8CJhz&R)\=F9Rg-Ygnda6gbq{d: tjoGAD}\}O;]UoU>$ M"DB"b ^4@  |K_MHChmQv(FHxBx9g]9ƜcZd}NߧRYkڵ֮95\JzfcH}5Ul "5GB@1xSp@g0m8~sHp݇Ρ)_>q5(\+0G/̘Gm U1G XHQ(b~T.ZC49=XxyW,<5|Oh~Y7Ģvz;5-RkLj<}YQ$>ԗ?M!DF#c6GHjek1g*dҕY%7H(/[( B|ayO (Qea*d3)+[}`Þw`[yPm5y|* 9x@ ~sm)p[߇u)(2LUS4F Z2K%@U WiP\ H6n~SyzQSE %.QnJj/8#OقAf!zNJmZevOmD3grm)nFS멥`kZFrcpa-j$Z4#L!164HAHeLm&.>T4ndu%|jnXx;PL=jBqoP|2>|LtYTEw&#hw_\O>:o2Y~WCAB4QpZ,d Lc8\ͩ,@q2TRӆDҁMݨBea0@-Z|a#\hHNQ*k M!nl+ӚKZGHZ?nܹ }XoG^k35_,7F 5YXJ,$R"ְCd`gD zLP"C,Ã>O!D 24LaXx%-V#*RFӠyI\9`0}Bj tʧulQ\H-1(J(FO$KCa0qQ,Twm(mYHr  (TJҡ|pD<#= $ϖozڴ5~fN4n8BH7?XwLJmR)W B׈~P Ƅ?,RBrl"$5%XZ5@'^^Mzjv~S[Җ0]HZ8چ[m4;)${XStڄO=ۺv#ՠ׼Y(:e8%7 tm~cHL)%_o\j jx1kZ ZR(ۆ0[RILah+.!Va! `+.!}H"-!\+@B\͸9]ۤ;>:6ד Pj_bkjؙݺ|]ux:\wŮFAˣ40jS i D!5LHg~-=5Vr&X(!P*IĂ@b䄟}@)Uo Ts~$6jS5@cL{ w<\6l@H80@uDDv+aNQ[#XM!C%"BX\LKQ׶m` # zNǥj3kP ?-cb10B8@9HSR&4ZMX8{"l%CT*a(TQ>:w jtLk͢MXF ͆uIPW`Ff,+WF{F(34 R)Yѹ|@m7ᰡWtu>l"%T/hzW7LaEhR b#dn4f$Rm`ȑ.Fft6LQgS9:Z|G+ IDATvʋGVG]qѡ}U3&@k#do" C윽`uM#ޒ#B_FIؖPZ:]@̗"R\%fb-@CUȵm*n曘m†FcM 2AH.a6# f$YX,` -nD ծ8RӤ'=ҔVO9HzDB{wšVۚIC k[Ґi)6. CG8c#BK-K.y&Vvn·|_YdE1 g(4jdeq E3'NT _BMlA #v JLXBu?I0x0W sz bLUwӓB-zU"*g#D#QbIa-7 UR &ea (\;CB׶\60]|f -U3RsѴP@`df2r 1 &' :e &bP83KCch)I`3"YLaܡɤ>] B0&dFS7uҁ8IvA Bk=@ bSDd9AZ;x|4WhM~E 2m)aߵ tmH fkیsxI+(p&l vƅF EpWX403!A^7D5D&bE87DžN5Vc!V/d9W㼛Q0j1b GW:ҀL:ju%(:_b!#`̿y5Lh1r8G|6YcZ}?)\J9])S~{ϸan{ )إ A"3H3^rɌ"Qs"P3C,ͅ35A@DXw /31#$^)4„29*564*Ům}lazAFPs!kP茣upQVwL oc&*śƧ~}%vm"&]?i .E_ͧZ2? (D0Jk0((\=BDm t7c)0" 0Ǯr1 c&edTElNpX;JeդKHQSG#m)t4&Y MMiZ>ZR"H鐈An_EP,SvR.PX=W+>0BuqǞMϨ4iz4)LLIZBRP9dD'0!'t 7 Dk ]oV]TR62YjMh6aqA-5D\˼`JPCkQP2f(VYCY("0>׎е=Rbob>t͔$0/.|/)8U((C114.ضМϨ)L!+)1G-i~O٤E[17RRWp_L+"Ph]H\TZ#0 q[ŭpI;+H-:9?+N[& @h]Pe%`% 7{p tm@Ib1b>CMʙ<ڨ#9TMP㢅`p3%WS PFns=] )$y6EFkA /:6`2&^~Ղ6S(Ғ{ CR#+A,}M35D'^z_|];ZB׶HaLa1#0!!t 6k0(vYhE0 Y &'bJsd -!#VRzV"hTSd]; v Rb)4+n &i씺dCJFAqh(#i/, sLt9zAE9Mm-lGuN<Q b`]0rSDrG@КC)F ,&ٴS@la:zSh|!iz$epL/`d9R2RhC_bTYeP5@:piʹ B™Gn _0hYnà tRf6MH`~ { tmF҄.1#3"ťk^ MLS<5:LSA!0# t2Rh r6[jF)8aD ] YP)S$!jp6K iR3aX V;-xN#ʶ1f#B9ڙ5AH@4' @!eе]Q(4S8dJje㯮ؼgVKuA1y0P0b!skXHL8LRZgҚD)p D)iRƈMDE nauMuu#68C'@ .-,,p(s crBI™T7r`ay ִl^_B\G Aʍ9)"if M[aJb + dH+K3)p,G( Mk78,,<.)@딼`J@1pJHX6G69-v6_ T~.PG\ ɓF )-RfcᗋE™d)##D@#(;B{J!]&9]'ɚ#R)"Hq9MfM(18U7鵁3e 1JD,J×[zQmQ CPY)! Ec S/,&*bkRDir3F]VW ҌƠs o.4'iƦ|T=De"Q)500S8&$x3'hT៴dxpH9]&)f)L"H~8C?C\Q)Lj 64,dP-L.B䥏eCH qd s K4-urAt J3„DM+NTQb iFtPT4jth "q {RZ 0oSfFnR]GACJY"s9ie՛翸BK)'vP_F_i;d GȠҔ~N|,2xA䗕$dWP 6h kgaт 8lä f3P B>!S-($雯ܨLZ9]#"(3D,Bs1)&SXc)$-F1l%dHo_H\;R3!' Os,( LaSHe!2H'$ ,,Md vJA5dsZA)caIn,`^7p\jPJ̓.=Co1',.0X%е-i )E1R?G?8L fk6j؊d2!)IZ0 pLSWuҍ`0ȼ\R4Pb2$s tԲPrJs@>] q3g G`9X}aÿ2AQ)f\Y~B  d+h$[%_u^LjIV?q咃еZj@1|39&d 90m>߯ <5Ү?!pB 8 aj@ !pb<_'&h03ҢA$up4O4s#[DMӇ\x.R0@ɮ `WPvHMh)@bc u1seJJ\S7W)|rG;h(ĉ\nݴ"0%}M#lԴѠ@Bȫ& IZLpyA!"~ )C$}e'+Qj K,%\pV Kt P LKTn4:L eP). CS(cY:biWoZA vA,?u0'Y)uFARk3cY 2w.mBH1']D?Gq\V%Yx7U B shH0'ULe!0 k !/dfQ)m/J8-B!26Mm-khu7.$ v)u$_&XJ-돼5QNՎT~{)vm-S,CkG(E/Sk#4a@AT&!gY`cXhHDDH[ʼcQAC Rùw130 EI EA;(tcX)X֎@ɺ@5E"#5ݮ@~P ֪hxct%9@`5/MJ֜@޲,)r .Av8t'TA8up4sn>'VrqPVZYÐ&;(tL1L RRdJH%#Ku% ^lpW]\+@%^Z:LVVXw/c.P&6-]`e#@& (hq-90wөDޒR~?֙`PR"*XXXpj?tSpy tm"Pfb5Y88i*p鯒L&.JlLaaaQa)$l "J$(pf5Sk'Qc ?"u:Rgȗmby>z_Z  d M.0bm N;Jm,ѵinbфhP4C. 0!%a񱿛ן~Nе=^8̜8%\3Ft]q-' r*KL?5WB65q(+L@1R"N5L@" 1ymAhkGxim$mj(5̶AAp6 NK%0>T@vE:BSٜ_ÿŎ1_X"G%_DL#gɭ @'K/kTJ- ݐSBJ5{D3i*(%.%.rSjP)rb""QJ1S^"iDtem0tűj:Lvn- mT7JYQ}!8B;v0\/+Sh65BPR߻,j`@Ӂ}5/H95x{.A."pp4_ڑ/jFę'=u2r '>oZa]b#D2 4ͅ3@3XC R ːCf 61OP[,Z'$KMVhAZiD C%;"r]M0aFG"8Q?d&BMʕ1cT4G{c}@)%m)剰0(Q1T2] 6ȩї[_40X?blhAuDlG:,B)şEK/d\}^YBJ9Ed$XXH{>q/|]G#5״RD$MLL(qnuo}sW\jPE4!dVP2i⒳3cEqYd1B% D!ɲAH)R@Hg9AKfRT|6sC[تA:?1S*1+탶ePJ:3VGW<+v0F=bu1%"+%.Jm)W>~~]Ghh4Qe$$.Gg ATNsV`/!h2 cpd#Q) B+ I͠r.ZA.oSS cZ8Œqm d o!@jJFrWber^+FL{{Xh H#H1?_BLo KP\0 {rd!Bne 4-`oh ׶U~n@"(bK xdhx@lwk׿d3%4$,l7G?|& IDATh/y|P](kDXPg4"3SVG#u`P*2qqZY/]1G*LD"oI 0,;jtV*oU_.5{נN7c(*#j^P-c &uE 6qњ8ß,oQ7G?|_7»9]#J,̳{L`Ո( K= }u$0B.*1b s_EHQ[%@&bYPm4n$ -.O ub|M|S>#뾕еJowQit`ИoyuLD Hw.0%s9dI ,qϘ˽7+aRb&J u{ 8J4(@68A!&8͉ @hkT`ِOa=&-?q6LJ|T gϹa>|Sn@]!k;#l҄vF9Y{ĞrWHL-$E1g Wa KLDW¤qvVL!95PZ&|aaN\[(Њ\J &hԒAjO]wB3#~/ZD '@ fn]*k]wGG8! b {9wvT9Oue0 cqd" +\ B#%YDB4mE` ָJ@Xg2]ҘRDj`)!PjdRRX 6Mteи?> &$| M3m`>s9]۩@в$EWQ9I;0J LD@ZND#(1%BbmäD)ERLKoDM[SlCyXDc' *u@ S,VpB /\ו41I' ;q?:]SB):4 JrLbeQ8Gvs~x*q:X j23/6FJLI\D.^01 f*Qv8`4m[DM[")Б JZz! b= Mlvϵ# tmfsL4C6ק99)xEǃARlgK #Q({H^13`mE6zNGaS /5(* cXXCܛҘ2i(q^!s7x:f{ٳ%k{egѡ D^lg%)bϩb siY̿f-lny)m b l(\PK( Kht$SE R54@=,h)e o1^Z@۟b$BRj|P5XttQL?"0og?QPNе݊_{䤧 /.AcU P'a]u#}.9- AGM#Bd E)(b۷)DF #Q3} [bDD+_"act1rۮ԰pi%T-zGH:GBN.1w#":-1P+DJ5*U3(Q@f!Eq"B+\3W`,tȕ@h>28FfD1"sl}tyrl ^Cin>sjM&v@vT4fR 52_RPGJ߼FA\7uC=I01e֙|5,ɍE @(EhkS|/Bw+Our}Ϸr2\*e{9+4%_Хl/IS(JNXLb/8l2E0rOv.)]nTVфF[:(rqLbDL{{>udA:| @H㊋Y9iZAG r&Ybe!OQOa/O~6uiznb4T2Lxڏ ,DD}ŐAŤ/Ehw/hhJ\ 8i#2 /t r/O <]7My:j b%@{L:-(K(KhC;12W-HmH5(*,Jd4g\RBu0Sd7k84b<].gyx5&G葃ux),9:( !CJ` |4r}iB#>Ÿ(1%DHD !8DIjORV"IF^ S,J tj` 'Nhq_?MA૞/F(оޯW>tmr柿vǛN&PᢡtkE#L(iP/+q~n29He6ِydS4[p $ʝQQäMA#ۖV:\,oq.Ze;JgR/׼#uA:P)ߓNIDQZrs==H=ҤEKsadq6XSHG$4M(}z:Qea6PHpAD9P¤Z mgW]\G;uTA:̚{VlP62RR'Ԣr$_=R>PQL&=@ ~f%B8pl,BZF o|63Mhuzڮ#G9nޣu_=#%SH,[(jD`HJ>&pbaanK:?_b~*eQ0Q|e{3(ɻ`}/ Q*Gil;)@k+,CE?P0Fq{%еC.Pv 3")f"cpûc('@HhMa~)#lnW"3א); M\2W$+S;wU#X?(^ZB9];Bw|I*2_ !#_o2ĥ^wy4" 3BR U)kk|I  Z5 (K1գJP9'A1hW<"%еse6g(JOU*Ldf\r{+,,oO D;B *& GNyI G k=!}j HbC{E'C3ݨ1$iG@RA)Gv}c}LVhKOau >HASq, 8dlG  wȒ84&EABS8Sd(G#nr2tk~g=)IB$!|(8]@0x2diUau+++SJODĔkGD)mm@̻#Ƽm_-j[GPo3vR]ra D ٶoSS) !5!0`:tkkR6+OVސ,FUXc'*ajcj.BH1i{GhZ מ11G.׈c{:(RI@R}@G]Ǔ O'XYڪDGV:Ea0oϑOi!bQS2k 1 9>C&1E9/|4#먑F];SDZ,.2okL%3õX&opg'H  [ e  E.Dd1a`L6eA_zzv9t"w95t1t=qj stPt܅\/Ó &Vpb!)g#J@P#j@-; l͟XؕR_||{>tI];Tw?MPLW Ji̾Nݙl"8@$݁yvѠ)D! - S˘_U\+30,0ul {>tn4[ H GK}cCj  ĉj_!ayyb#Rbln1ӽp@B O:E j_h2%SVGQ(R]Dzqs$ )D^'1Q#,81 ߿9_#)vNo& \jG;J }|4`0 #vtX[U`T/ScҁjSPșA6?n` 2GO ٌ "/6f;]{$wC0<’ф=cSv1Q.F#$qLDl@tb֘BzFD!8<77gĞp\#DDAֱm҄2b,N"Rd馈2Xn䳿4"*K 1Of0q;-!P[ cC!k;}lc{rkШ 3v2 wI@x&LZ V"`X!)ďyIG(hm"N!cQp@{M|.׽,w#C_/]Trl 'JEaG1jqֈR&n,2%mA#M,˻!>7v\$CA;h$[iIiVt+j("LA]z+s.Ϥ- eßG?(hEV͌A.̪ӣƈ<~9]muַ~O?Le{óP̭j IЃCnM!% e2m8T!k,R0I?o|s t\yuD7Ţ\8&yL(kÄ:9µ`%X%MB[v*ro_#1v8B.43t<[\A]Gyu2 O1ؚ¨͚B);%P_hD [s&'<=ҭl)t\"w#X{ƱqFxkG#L8Bc 5+R;*%S#\!u025̳2z0grpA:_hXgV!z8dl"(r9Ow\GM hQ)L1I"n' _r BzVLGusSO|ΪtĚ#DqkjhNajv0g '1a~P ?ȓu4R)3:`8wPLS`uRKfvMpkA(YX'Jf~wu \G<4:7ΐlBJ_WwuףK^[5|KaN#??g~DB3ˬ{rn1yCo΃)S[3>ݻwK'>m}ÇOr_|[oݽ{?}[/<=o?Dt'?S뮻wwޣ__\__߮7Cu>ϟԧ~~>l>ܙ0>yopg1ˬ{rnvڵ~x_j|߾}^xݻ/s=&ݭ7/~׾|ࡌ/w%|cvQzԡs(?̺';8sO8t OOl5cKs5|pYgm[śn co}[{/x/?;s'_~siM7?' oػw_MozvC?{l˿:;q-)}D8O]y啇r̡2랜?D dY_k׮n__m~Qw3?3~xB(Orԡ(qgG~GK.7oy[huu޽{΀5xɗ\yx]ws9nC9P~vuOOD{a4 f"ڽ{gqg|}[(>IO"|E(t|ы^48x![n嬳"g>\}-~s#N:E/zu]?#my7;W=_e]w;ٳ\uUs_"?s_x;B}C_+:P~vuOm>ӛgFDx3yty{iyGN!۷x]=A;[/<>餓VVV^Wd2!c;㢋."|SJ{=赯}6WDt|>7]˵Hs_"?t:=SskaK/l5ʺ'/xAr){g>}_%oo9PNu-BD{HMDW]u}έƗY=ϟgr1SZ03;SKc?|']tEey;餓N~p?x #kvN#kqHgWW_92#cw[܍C [<F^:rGr\r\K-rZBr-.Zj9].˵r\.k t\.RAr\r\K-rZBr-.Zj9].˵r\.k t\.RAr\r\K-rZBr-.Zj3r\.a;Br-.Zj9].˵sDO*+IENDB`demo/documented/mixed-poisson/000077500000000000000000000000001412460263600167335ustar00rootroot00000000000000demo/documented/mixed-poisson/cpp/000077500000000000000000000000001412460263600175155ustar00rootroot00000000000000demo/documented/mixed-poisson/cpp/MixedPoisson.ufl.rst000066400000000000000000000032601412460263600234560ustar00rootroot00000000000000UFL input for mixed formulation of Poisson Equation =================================================== First we define the variational problem in UFL which we save in the file called :download:`MixedPoisson.ufl`. We begin by defining the finite element spaces. We define two finite element spaces :math:`\Sigma_h = BDM` and :math:`V_h = DG` separately, before combining these into a mixed finite element space: :: BDM = FiniteElement("BDM", triangle, 1) DG = FiniteElement("DG", triangle, 0) W = BDM * DG The first argument to :py:class:`FiniteElement` specifies the type of finite element family, while the third argument specifies the polynomial degree. The UFL user manual contains a list of all available finite element families and more details. The * operator creates a mixed (product) space ``W`` from the two separate spaces ``BDM`` and ``DG``. Hence, .. math:: W = \{ (\tau, v) \ \text{such that} \ \tau \in BDM, v \in DG \}. Next, we need to specify the trial functions (the unknowns) and the test functions on this space. This can be done as follows :: (sigma, u) = TrialFunctions(W) (tau, v) = TestFunctions(W) Further, we need to specify the source :math:`f` (a coefficient) that will be used in the linear form of the variational problem. This coefficient needs be defined on a finite element space, but none of the above defined elements are quite appropriate. We therefore define a separate finite element space for this coefficient. :: CG = FiniteElement("CG", triangle, 1) f = Coefficient(CG) Finally, we define the bilinear and linear forms according to the equations: :: a = (dot(sigma, tau) + div(tau)*u + div(sigma)*v)*dx L = - f*v*dx demo/documented/mixed-poisson/cpp/main.cpp.rst000066400000000000000000000213511412460263600217560ustar00rootroot00000000000000Mixed formulation for Poisson equation (C++) ============================================ This demo illustrates how to solve Poisson equation using a mixed (two-field) formulation. In particular, it illustrates how to * Use mixed and non-continuous finite element spaces * Set essential boundary conditions for subspaces and H(div) spaces * Define a (vector-valued) expression using additional geometry information Equation and problem definition ------------------------------- An alternative formulation of Poisson equation can be formulated by introducing an additional (vector) variable, namely the (negative) flux: :math:`\sigma = \nabla u`. The partial differential equations then read .. math:: \sigma - \nabla u &= 0 \quad {\rm in} \ \Omega, \\ \nabla \cdot \sigma &= - f \quad {\rm in} \ \Omega, with boundary conditions .. math:: u = u_0 \quad {\rm on} \ \Gamma_{D}, \\ \sigma \cdot n = g \quad {\rm on} \ \Gamma_{N}. The same equations arise in connection with flow in porous media, and are also referred to as Darcy flow. After multiplying by test functions :math:`\tau` and :math:`v`, integrating over the domain, and integrating the gradient term by parts, one obtains the following variational formulation: find :math:`\sigma \in \Sigma` and :math:`v \in V` satisfying .. math:: \int_{\Omega} (\sigma \cdot \tau + \nabla \cdot \tau \ u) \ {\rm d} x &= \int_{\Gamma} \tau \cdot n \ u \ {\rm d} s \quad \forall \ \tau \in \Sigma, \\ \int_{\Omega} \nabla \cdot \sigma v \ {\rm d} x &= - \int_{\Omega} f \ v \ {\rm d} x \quad \forall \ v \in V. Here :math:`n` denotes the outward pointing normal vector on the boundary. Looking at the variational form, we see that the boundary condition for the flux (:math:`\sigma \cdot n = g`) is now an essential boundary condition (which should be enforced in the function space), while the other boundary condition (:math:`u = u_0`) is a natural boundary condition (which should be applied to the variational form). Inserting the boundary conditions, this variational problem can be phrased in the general form: find :math:`(\sigma, u) \in \Sigma_g \times V` such that .. math:: a((\sigma, u), (\tau, v)) = L((\tau, v)) \quad \forall \ (\tau, v) \in \Sigma_0 \times V where the variational forms :math:`a` and :math:`L` are defined as .. math:: a((\sigma, u), (\tau, v)) &= \int_{\Omega} \sigma \cdot \tau + \nabla \cdot \tau \ u + \nabla \cdot \sigma \ v \ {\rm d} x \\ L((\tau, v)) &= - \int_{\Omega} f v \ {\rm d} x + \int_{\Gamma_D} u_0 \tau \cdot n \ {\rm d} s and :math:`\Sigma_g = \{ \tau \in H({\rm div}) \text{ such that } \tau \cdot n|_{\Gamma_N} = g \}` and :math:`V = L^2(\Omega)`. To discretize the above formulation, two discrete function spaces :math:`\Sigma_h \subset \Sigma` and :math:`V_h \subset V` are needed to form a mixed function space :math:`\Sigma_h \times V_h`. A stable choice of finite element spaces is to let :math:`\Sigma_h` be the Brezzi-Douglas-Marini elements of polynomial order :math:`k` and let :math:`V_h` be discontinuous elements of polynomial order :math:`k-1`. We will use the same definitions of functions and boundaries as in the demo for Poisson's equation. These are: * :math:`\Omega = [0,1] \times [0,1]` (a unit square) * :math:`\Gamma_{D} = \{(0, y) \cup (1, y) \in \partial \Omega\}` * :math:`\Gamma_{N} = \{(x, 0) \cup (x, 1) \in \partial \Omega\}` * :math:`u_0 = 0` * :math:`g = \sin(5x)` (flux) * :math:`f = 10\exp(-((x - 0.5)^2 + (y - 0.5)^2) / 0.02)` (source term) With the above input the solution for :math:`u` and :math:`\sigma` will look as follows: .. image:: ../mixed-poisson_u.png :scale: 75 :align: center .. image:: ../mixed-poisson_sigma.png :scale: 75 :align: center Implementation -------------- The implementation is split in two files, a form file containing the definition of the variational forms expressed in UFL and the solver which is implemented in a C++ file. Running this demo requires the files: :download:`main.cpp`, :download:`MixedPoisson.ufl` and :download:`CMakeLists.txt`. UFL form file ^^^^^^^^^^^^^ The UFL file is implemented in :download:`MixedPoisson.ufl`, and the explanation of the UFL file can be found at :doc:`here `. C++ program ^^^^^^^^^^^ The solver is implemented in the :download:`main.cpp` file. At the top we include the DOLFIN header file and the generated header file containing the variational forms. For convenience we also include the DOLFIN namespace. .. code-block:: cpp #include #include "MixedPoisson.h" using namespace dolfin; Then follows the definition of the coefficient functions (for :math:`f` and :math:`G`), which are derived from the DOLFIN :cpp:class:`Expression` class. .. code-block:: cpp // Source term (right-hand side) class Source : public Expression { void eval(Array& values, const Array& x) const { double dx = x[0] - 0.5; double dy = x[1] - 0.5; values[0] = 10*exp(-(dx*dx + dy*dy) / 0.02); } }; // Boundary source for flux boundary condition class BoundarySource : public Expression { public: BoundarySource(const Mesh& mesh) : Expression(2), mesh(mesh) {} void eval(Array& values, const Array& x, const ufc::cell& ufc_cell) const { dolfin_assert(ufc_cell.local_facet >= 0); Cell cell(mesh, ufc_cell.index); Point n = cell.normal(ufc_cell.local_facet); const double g = sin(5*x[0]); values[0] = g*n[0]; values[1] = g*n[1]; } private: const Mesh& mesh; }; Then follows the definition of the essential boundary part of the boundary of the domain, which is derived from the :cpp:class:`SubDomain` class. .. code-block:: cpp // Sub domain for essential boundary condition class EssentialBoundary : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[1] < DOLFIN_EPS or x[1] > 1.0 - DOLFIN_EPS; } }; Inside the ``main()`` function we first create the ``mesh`` and then we define the (mixed) function space for the variational formulation. We also define the bilinear form ``a`` and linear form ``L`` relative to this function space. .. code-block:: cpp int main() { // Create mesh auto mesh = std::make_shared(32, 32); // Construct function space auto W = std::make_shared(mesh); MixedPoisson::BilinearForm a(W, W); MixedPoisson::LinearForm L(W); Then we create the source (:math:`f`) and assign it to the linear form. .. code-block:: cpp // Create source and assign to L auto f = std::make_shared(); L.f = f; It only remains to prescribe the boundary condition for the flux. Essential boundary conditions are specified through the class :cpp:class:`DirichletBC` which takes three arguments: the function space the boundary condition is supposed to be applied to, the data for the boundary condition, and the relevant part of the boundary. We want to apply the boundary condition to the first subspace of the mixed space. This space can be accessed through the `sub` member function of the :cpp:class:`FunctionSpace` class. Next, we need to construct the data for the boundary condition. An essential boundary condition is handled by replacing degrees of freedom by the degrees of freedom evaluated at the given data. The :math:`BDM` finite element spaces are vector-valued spaces and hence the degrees of freedom act on vector-valued objects. The effect is that the user is required to construct a :math:`G` such that :math:`G \cdot n = g`. Such a :math:`G` can be constructed by letting :math:`G = g n`. This is what the derived expression class ``BoundarySource`` defined above does. .. code-block:: cpp // Define boundary condition auto G = std::make_shared(*mesh); auto boundary = std::make_shared(); DirichletBC bc(W->sub(0), G, boundary); To compute the solution we use the bilinear and linear forms, and the boundary condition, but we also need to create a :cpp:class:`Function` to store the solution(s). The (full) solution will be stored in the :cpp:class:`Function` ``w``, which we initialise using the :cpp:class:`FunctionSpace` ``W``. The actual computation is performed by calling ``solve``. .. code-block:: cpp // Compute solution Function w(W); solve(a == L, w, bc); Now, the separate components ``sigma`` and ``u`` of the solution can be extracted by taking components. These can then be written to XDMF files. .. code-block:: cpp // Extract sub functions (function views) Function& sigma = w[0]; Function& u = w[1]; XDMFFile("sigma.xdmf").write(sigma); XDMFFile("u.xdmf").write(u); return 0; } demo/documented/mixed-poisson/mixed-poisson_sigma.png000066400000000000000000002312521412460263600234240ustar00rootroot00000000000000PNG  IHDRXW IDATxw\glҋ k%\zb&K&h$Fc{EP^ݙ$w^<2,ӆ8AUAğ!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $ 4ADF HA] B K#AHAti$ .!Aѥ $+/yVgAoP@!7ݙ h)Fp@1(-޻g Au$gb4-S'ֹ)>߃' M%Κc?x #AHW`|%J̓H0rC<;R8l f8XIQCjg? "AH 2(0.tkaC/~[I&R.VR?oInb.y=?k#eBo!."^/̼_yp=,Ml00kp38ADS4(X)8/cK"GJI? !AHn][x.s&LTdapHJW?Bn*lgNU?| #AHEE%Q ޔf%|5W ӂ" +RdD& X{WSQݔVNN_yum>/??WrͼϞ={n7)_E@3. T-:k(b=WC7Yړ @HTns /{ذdq:Ǽ^Up ^> GYu86o޼tғ'O`d2߿%++kҥG@Q駟:SVV{7tk{$_tw%~|tou;M^TCZLٵ -R?H{wY :[GRL~P.RQÞSzI;%mHqHtq=#W^1cr 4j^3gNQQN'>},_>/~M&Z_^ۃ'AH|[ ,U訲^NL?4 ˲'w%{]|а`^&,9B,RP)? e6WZOnܸG _^{W.]w=c"n?wEQN _ ;.6{K"XX e~k A3c6{6mM;&^y6EQΝO?*j-rp/ݴ7d 37 e6;v>]i(>I 7&i}Yvv-[~?C^^^RRe?߿p4((hʔ)?=xGH&~P`/i.;\vuD3qRV[4npY8%Fg1rHkG)x6^>}y€˂/}29k.cY=ARG{7M&Ƨ_}]w-^xĉWAx̙AvzA.]zk{$?ZL<ؿ$EG85PW*)z2Ŗ0]ae=:OTMIԉ,VE0̍lQaoj}ZJr8 `kiJuTڰf yD*R7 gaG=O>LvGdi ~O: sٲe-;wի(Ǎǧ|iii6 @LL=smH(?Q7ox,ZP7T``3r玲u,[u?pjXѴį> m.ebCW 5#b2eZoym94Щ#? VP `aKwZn4Ꝗ=Y țOئ}l̽T={c/+R4t@(xAĕpg0,XsUV=|/kkk;ow8׿{/ň*--M*B[2QatATa9Ġ8pqf70;``ԺeEIsD2 e$ڃ:mr`lpoz}b1Mݺ$. 8Iy9PiTdՍ}U`ӂkǴaFs[-'Oybg}!) 8;~xsrrm۶dɒ`nݺw޲iӦDakܹwʊGN,[+T1MݛY-A*Cv +8Ed3pQ#M6Wq ͜ROo^j0`* o**{Ƽ+Ρ+6/mahPFgn%KVxqb{L|{,5$Bz%kۃii)^xI1o'AwIZ:vx/챆)Al޽{3 BYpf]|]|}0UhMuih㧹36Wzgu3J@ &uSOaPIQi\ey>.D|gUChG )v\\}h;: lIggq?F_NXmG@HsB t 6bI?>SV?ӷ~R} q1)?ݻwr8bcc ɓ'4C0BCCCBB444L8Q"<HgJY+]W*D:|N_aRji]l O`Y+hpLQQ@0!|;%Q (vjNe8L_5/scYۍeYh>RO PE (f$?hBpQසmb*Nc{*f4lqԏv;v} #yʤO$LRxCY Η]dU_ VI?2((t>C$o/7mz-[t:6mݺu^^KJJjnn"0/;,Ba}hZ=M *Kvuub9lUl➃;ſCx@F"7T¦=&߾/(EZe*и$-Rs˷;MjpR>A Kv=`@@mMJi :pnݕ>f߹˶XAlC-K|{Eoި]3À_ssn6>r`}-CTeI)níYKRb4r{@yyytt4ϯXb޽&)<<|K,i&jŊ۶mkmm5k֓O>yS$_61K^b%m|  i0Pk6èTwC9p[|]GFkBS=Rj ㅜ32 -@qR-ɽ.=0wG&M >15äQ0Q-~[%DR``Eݒ-|@@c1QŤ`8+`0y&SQ]2E(UMIǃdA)cVhfY4?Y r,8~69~ t)@SJ ̹ N!4P`-B~hY*Bh[gOB٤7 =$oeK莄KS>%K!{y@9 }#cTa׎Mob>~>P3ȟy3E"ֆPv 0_l\ (q vץ/2}Z_rnސhۚN_k@[{ݠ҂c/) e=|sҗ(;~e02QM%l{&f/j<Ӝ]Ld㋮1ow=jJ}X &Es/abcӭ֚W(K7:=TgnkaQnGP^D&@nzGt8 _ U^"iݏiGZv[4Y5~]X~[doݼN~3!BF, 0M.KIPaϑBN3t;Fߢ,}< qFmT0aadkNz?׆qpWm&v$i}Go3BTӕ&Y}\C쯽P3=F /y?y},g[&0qSCR{_G_F.+߰YXNC]7nh,eSf+kO{G3vS e%Hđ}2yk4Mg|Y;(,sr_wΗ>x[],Dz,_ҴN<jZ *E!7dV[=.vK`7?jU|cb9)@&PpB妃~#Gse_?rPizhc;͗hO;c4`@BfFekATywv7()/;X;};|AfΗZYYw-Yۈ}KL t ) -:n3 vPp۩ <ರMJ6;Gҽ 52>J69r ! tsGm q59;.Y׾kv AxbH.ؘTdG?A8xW:lf=/zQH'NO8mWB\_GC5BZK;6vEX6bNjv ׫c i'G&* "]mi:$]lRSN[ M > r.5j->gʎ-5u&=k=B\$-mFcrWiȵ;ҲϤ$:Q[^tڨ# <wU} 3ۋB^,Kæ=&Fȹ1Sn[F2zt(OÆJtϔ) ʝ:)It(P1 t*,z y,5BOBr M. ;1@4a*).Sz|9-jox^J7I5?YU} 0:46ɾ.;.c薗׽}Wª+.jh@R$ GE=?S^ KBB ipzϐ8lP7Tݷ̔E*L]P+F'<cc;OfoXZ(pz1X?9}oѴ~5?O9X?p\PB`˲-paMG[o CN95pl7F _ 9Ut#5z3m@W-2~oe)Ph}zc3Nt|gPj:n)8iJB@XF0u&Qcs@i{LI vbNSpc?r|9˚'ȼܪ~Swϋ!UlgT$5y)}Y {§wz >whyO&'VO|>8>_!>luIq&<##~!7JL%it|Rm8L_lPJt^nY `kr>L!0ϐ />\z6S'tbKEN>+#8'T?r! G0RXAMUx9(ɶGJ(BfD5;T@ۭ5c8i!>h^gr29^FaELQL/J6`ꅄ/~l-Xk1$!h{j#EKM4Whw@ 7 t('C6I4> R@Wud?la?,l,Lh7 @q^ױFoq ZDrhgy-?24pr%5iE<;oJߦ#8Yȝ,,h@ ) ǐw0 !-8_ *k Idh&})J An͞%sUo.ec·ezi`[s~qIne`=7FɥrZö}zn̯UŶ{a F(M:DȣO힨yʙД2e]xӐ*tgrzt[C?^N8\')?D=XySnД6;( U9ϐi M L}F$Vs9V`OnMY& #h(ek&Yv"oOHԋ1MӲ7Q0;: 6&:SVþir}dVJ0Q~E?g#CGH*^5)7vD(,+$`扡[5Obcw&nY~&{ph¹WzH_Gdy6R%yo jwmlaBM-q^@@!w~zZ_YXRZJ|-%>lk2˚q-NX+ w8Җe:Z('6hcֱpcnS͌>M8R}zYe>7מ5l3G 45^㉾;x|stV;Z/<_ C`85y_J4xs9㙎O4|y`ŞpxjZ"v}BO(1a:Ak.KacW;MqAB揄H)rZ}Ri0~snu3dwjN)+`́RK_,6/NxW8({x5gv_4}p(m?gb?W_~iF)n>qiҵ^w5A{RK|&44 RY@&Mo'_di%ڡچu5B綺M폠48xU̴aʋ!Be,H ̲ -GumF^>is[~R .VU S2.qXp3|Ãg%G 2ft%*iU)^/%--!F?.]4"3)E5}^m3~S> # m~aozt>}`2JD%͑:Yy@FmYdʖ"Oǧ1vu[KwFD{扵oAe>Mʧ76$6,lkM}?:EW~ 74{77H{I=Q`>0"Q}ɇy>M[Mچ<Ҍ#Dsk-X8pڐ­n0*]XWdջUh-]=;"K'Kr(sn/:Bx m' FJ+N96Zqak=xw.ua̪_ޑ/tн?\ͣ7^B_pa)q1cF<92q4rg\(Peb}`)jY06|8򓠰4#N97OQx;y#_Gynja8PPIK4 Dǫ(kF¹9KV#΍gר {zuTɒ\鶡9#mFȨݞh=̚wˊBoWh $}_Ou(m$Plq%%R WiHјᒴen.Chǃn??yPhj_x`ؖ8^z>F*_)֧QKI vE1S6C?q:|.;4Zvy=i_E! $̒$/5cr4Quvp&V0n+'dOs>Fc<5+k|=ݥzmd,wM|spᵳP0&_Ofs;Hɗ|~J /Vm0Z;dY}v+c#J+Ey"ö<4gݦ,j{.}zm&9'o$2 irh[AB#Qr!E ZoS3Bo`* ܱ$X=}y2bF4撔Rs?V-*e!rc|9) =,ֽA%Wx@裁Օ7";7\-eD`єrqqw*4YbP4,ulc'A]>SL<;ug0G8R*߾E/_23ESbZ ˆ8fhbESEsaU2]W<&_TL9;>*YY yyF-m%ZNcX<4qeS8aLddCS$ ΚK=R7챩Aua ƽJ)2h礳>o)l;e~Sd]1?uL9Y;K&M\?9}; "J7NmU f̂\tuz_ HHe.i0[K0PTQ猚4$!BoGVoqݦ^H&+.+r |35qxaDKAɩe}3gTŽ\-`<4b:?@ g:uk LX #NUvڅѳUr<ۖ ?يnhu$nя(3Cc#HEUykIo eUy&B*O fǟ{a=קcK4@UO_韵ׂ)öգ,MnQq>i-Go*_voe>R?iXQ01QnSѿ{QI}G) ͽ"E*~U 3:N+F RaB=&ޠ1[zl^`q-[HM5i!?]19a`6V*H% ~ Nx:Hm/ouM& Xي.LGZn.ӿ/ox(THc@+66?\E!#AnB'1/ީL}R, M0-SaceQd^c*}aJwц [3Vw: AsGnOH203O)k[o?^܎ԥ./ׂ>3bC%Ǧq]#AH'SpZwW Kt&=m5^;k,+a XIAӏ`];ݚS0|np'c: (zia. C =|jo,ؒ=3o3#6$0Qc_Oxl:#fNN %+/\1sRVE.Ԏ}tCd#6$*no,O_=bz\DX Qu}W%`q[CrTGO=&S}1w5l3Ug yM;@so"N&+O|$Rj`+R ^7soחנoh>U5%0d*S ؙyJ/uoT)cYxmm7A /jZP[;]^{vfHC8װǶcJV#cmLuBp| lčKJ"RMyw:Yݸ;0dx72ĎLaJ0#Pv>̶٪*:gcV}To~EK~=+ E&n>hd[t" 3m@E+ iU `rAR}31n~4'({JNĉkR}[_5Pt3Ɩ kOAy%γYzE5,lʌ_y=W.kZo?7UMȨQWΒzdYLjbCe[("2^ JS$$]& lγ-luT)#Zs;Tn]`Q /WmIz/}=^5Ϛ3|\ӏ %/H4Ql $vnéj IDATɧGod=C-B^{v<Hkr'dḚ{ BO]ڨz[ք-|Ɓ ^Ym/78u$糳EçY(21**p}녕מ}/7[B2z RcMg_8KYؼJC~|>'OxMؔk^ޘuZ[+rW LGHvES미=4c(6rl P,VlJr1zLeljOn"mqVhgyhfalۙgUCiPkL.Hj>dٓV|+4S[e̥UPPؔ3*\l+|jr=-nG@}Kc=ߪĺi<{JZSN\=nU@$O[ȳhwO Ҧ(B~*)Vm.E)J^Lgm"`-vItvd/Ej}e>wށM?mw{ 2'*āP'"^Feҽf'I~KV+_ 4ߞA7jЪϛnWwz _z0R81;ڭ *rZmL$y뉁SL S:/Dc>;lxfm~׆A7L~NLծK}v7No멇}Żyþ<|!ZzhB^z /(֕lzuh.J*mMbqJkh쳸Q=' jX2L2N84OQ>jYEOx17Q= 񼔎ol-49C'*n8_KΣ%/C1Tkق*͵!`)f[텍}0+kwu#-fe@."aNup4fDU"7o,A`sR8B4 j\k.v.H_vagh:2g5_!pP ~$Ux͎{T}!Ԙ[l7 RjmRPjѴ5.J~-j3hndY .??7O/J@hOnQy$ r*債{و1%Oo\Wڱj=x-#3~p\>v`'S:{E:AvwIr'@]te;󞩲׿ϛj$ `.-$!tpl.xj_?ՠj:ep ?;D^{h eT @,@|!#ȀAQ39 Z zBHp2b5Ѫ]O9 ',t=!.Бg@HtӤЫ-3Z}*HcP}Mf 瞨n?E t&wVvqa`8vl ۔j1Y*+iE?UUO φS=^Jn|ڧ8@2%qG0KŲԅJ% D+t1ը5U~TJ1?M0 T? ."TRo*d_L'I%uz$'pt| X5볩Moo' pP &sȽj[Vޘo%;4錎nh,B!FKף<7wQcR40Ei,2QNͨl;^1GzU}n; JfrKUW [{S+gN!x-}i.e? X4!j?eVcbo^2trÖ0C\,*?J`1ۣe &W:?nrsJ'}a(~2jK?Mf3;GĊv!`'p!qkR-5ݜDMLTJtcƯb$b5iuj?;R*]DCu&MV0I"E4ݜ/d01tMqVuqvv14śQVMsvھ¹669{\vV\#Zu^g WAB6{צ#rz}ޏ|4׃ $P5лyBB {hK6w͍ܧ7=|CBuޚ6(s?(|Km.CKCO7'k?ƃ+ CIv.L!cʇP*p׿!M) DS-Ή-.y'[حQq–fsb]:=He`X!W&֭,mRpz_ sɄ敇oS#=!!~̹[oQ{Gҵ&8M։4s R<Y@&된DmɼƟJͨuV8ܘ;!uҰ^0#䓸iGӲ>ظ*W]P֧HYaE}mLX]@[o4IpTf9 G(3)xWCNoU{E5$ U\k4í ꡭ4 yi|lCa gEBմVnoq)BQ/>Z"$exrc҉Jm:^ּA#à_W6W ZM 8lPlCxN=}_WtM\@X~1  9~5J_./NC"#9tfzUFuc\xN*Hp/@@!.' c!!,AZAmQꌼdv!57>Wy F奐USk#%P4+裘iGAjlD,G'Dj;h_;Vgf>t A<[h[$6;AR' &z,qŠc;ۓ)BunW [2RCf xb(; ._GpT1}Conf=!}k_#v, $\] ]@>uH*&ՕCjvK¦V0~[8[ XU5ՠm;1f*TՋbN*A3pcyG}G$/ mrkZoC^Ċ \$c6]~ / _,L{?a6?P ^;m֘~km?`!dO\_SGw+僉uhؖ*AR^CN9~該_[xAr m};!!tVC0͚rc3\XDn,wF w- dW!ږjuW[f/^y7nxu7_'A2/+8tWTZzk r{ӗ';tDiLt%+O:3&aO[˛]pMd#.HI H3%#P-j@d{ gz~$I^>-nL"!aK'l B8(Bx1͞ҫAI$wm rήCtkMqEP 5;:R4/l%A"ZjԗkC,dsۄ3]}ʦaLU l]47g/~a]I%VS+j HN"`. Cf7jq)%/Bx-p' #.'g֖=Ј'W:~/&ХLąZqek|t)jv;@ML]!$"[1;9j }EZޒl6W!e\r% ;S%@꩑r X牤MP Xه7_mp9c/ڜoaF2ed]iDptMyNU8/#;CڻoԮ$P̟[1®r  ZP'G0 k\BQ!!$>~3Xߵ^#`vu-ʾu=9H2j7CL^GXHyI<bDmeGq:r~Y/&]Y޼V,z38b Н#Mh BB n7E]zN;HcNuY/7U .RjBB8: v ӴiՍu;Z]>mĀE#6 :47ʅJv$zkL;IKs8U\/grH![~cHPA;8 AѓL#ƓHO2{tk~'x;A#T2{ rzw㴸|  !!$Qo?uIƛAP?A),fh9 LMD1jM]Ԇ:dUJGu&UAqAMc R84S4iW,HA֗h ħ aXG[h Z2q6*og[.iz~`T!bHD9jFҳCY-QYѢxl!btd iV#H2"Pz:V1VXu^Q8Y4%{ KB8+xy|[`94V`k(Ct۫♮ܑ~^K鯴׽~n1-[-+u!pP wgÐ^ACd!>/55 3@y%!fz?!R(qk}y ұgE|mlH]1V:աXIMlRa/nTk'C۟"1 /BudFo ~ WsGyƲx덄&O^bgңRMѓxI;X۸$%AKiB2.^I DΚ#)N1Y#J`l/+2$Esbg]>n%\p+M!#oj}i-BB}yﶌ>FM-9|okC]5`qv+xX߅[j "^ IDV4C%YH"q H&'srFƈ\/b) > (υ>K0tSp`= pP ]RyQek*'mUÍ);H n̢KmG,=HT.6ㄼǴ:(YXbT)볪xc<|ߌA%xhXߺŧކ.{=[-G:UʎT._~l^a z'5ZChp*پ^og4}vnJr =i ZHFrpSw*JV =5Ȉ ͍!@UO"jM=P]Ruˌ^@ -;"ei z:V..!;}aҡ-~B%*pwTr֝E{6 /65va=:]4*+xA1#w!eQb ܜ &5s*6mC4 #RBV'Ǹw=4aGZgR DߦS.6j4rFF(]]HG0B8(BH0>y5k6u}p0}S3MDƌU 5ãKfEzC;MaH֤)uUtYO~LucxV<)qIg@1y \-uPü)F8NPنڦoj7%qMYxlU@\>Iϵ~aAYY/ %м{BB;B^_{_xdƂ{q2ɜ?o=sX-dhs"@k+`5}S<W199mVޠ8]#G7\< GBIN.`$(wX0Q![{3 IDAT% 94!8cޕaꮿ!k*i x&V4&ֿfs?fx ;z9\<#M[+~. K5gpbNN"³wDqN.`Xg0<+ʡdmCw@hV T,P0}eA!X,$ ˣt:qYQS ;;{С 6yS x-=nM_`|>:Ppny{U;]CٺJե0FUϥd іkNת[t2S HTDS9|ªctl n4ث R nP€*  Q3gά]{5o #$9Cgm vu#$xy_~ KYMm2Ȝ$6]L?`e@;ƳR L+ZwU77;4t!W#Ѿɢt!W{SLl]XzOSyc<.%n|4-FP4`E,bRgKrh¯=o3f HK,qw^.PsS׼!$[ސvJMP)S*уXatlMq$3-}Z PE7t Fl} MLkN:[W38I|n-zL8%bBBLzPVF[*`2, [$ BfPL=Νw(xGdiI̶׶vo.u+OJObJ(&冮I䏕h- dXw՗˞; WϤG۾q BIoPOE t tǡr !\dN:5--mX9gΜUTT@aaaJJJOs_ #FACVqJ*y-&m ±/}@ReFG-v2i{lۏ(궷j[:(_ڧ6i֛u%:ȟs(.쑘5+>OI2usYdX{[`(g?klKIe9]>[^jxa-|z_?Q.{K98ZS?8 I꼢x kgiVk'J ɍڼ28aҡ[+Z~{ˤG 媊rl&4^@7q{L233oY=XqqqAs֭]!c\٧5_nU}K]=ly0I%f[e/yuC&n6lOC2=5/7%dM2TYqۏXS#V ?) =9,MBukmMm$[_ c8A֕hy 5фteCE3hn1eOsa\L.sSCW^jZ.+||Q˅o͛{ٳg5o B =9+\3lۭ&v~iˋ 5o;#IjEv'\ڏiJݚH?;a z/ Pap͉:@7ƈ.(\N*k(2߉yTVCB8{ɓUʶh={W[MA!݁V]J#qˈП-^{~:??]1DAdbZZA(d[ZyyE<+ w@h-Q.Ʋ}\hw nYdВ0\8{O󮍾rK_GpܳBe˖={>}C/^L&WXmmm?… o7!EkZyUsf5:g+l䐲Ofߋ~/dзg?oRl޺3hCLZ ݔB_vܞ$(yo} $(zڶ ,ALB >M1S;w'Zwz)98׌ h,>>,9_t?6/ 7Nlquu hiq֮yBH00Wq Y^,<.D&4WxN/*тLZ&.O*:3,]>$r&)R{LE/& 'H \mtWgq_Twø]"FoNb8wT&5Xʙ4QE/[$%K qXm%J&I ١X֤GsNkX<}JҖk|_5ЋC zz0K]aun'3T!äGu!bdB2 P=+?oʅiiiØۼu!Lt-fDBvXL-4&6bfҔiI`tӣ]`V*Ct7 2X =-IX &cgDt+C=*JI!!l]lZ6}}. iN(%ĖmY-'ǐȅQYD\ŕyGo$r:R^K2%!.X&:47&:nFKѕ 4ڂy>FMUL:񋪖BV% Y_nZ%M8Z>L)Tֶ=BdېH{V9Ç r5ŕ3gδ7rk_LHx73UQ$8xͳV.KYΣ\ߧޮ>[>>bZݨvk(jWDϥWy gt &_v1֛[<3غK[a%P4^U-:n.YQ yWKj+ЕjU4MU$&=+λ: O_)~mI rբKFgatzO@]]]``ZfX.@Qkn%%%-[߾k L^-sر|߫d)ndT?@?+ mԐhNԴm9!wO>E={l߾=$$d B;4n׹0^I>ڴO i F1twҺ)VIdWrNAz B!N";dEH@A'v99W W'@4I. +F-[w'[tvvJ$Xd}X+8?ȑ#;f̘| jժg}N5#$QyTu.J ~ͣj1~KrC5.+`Eo h Fm5Tn_.aO&P'a=Mip?zHu|O1h~ioLjn oI"sųfQbITRSxlZP>MںeU)eݾDιa)٣.]‰gU t>W ɸ-dvvm32fs$'CӎwL/ º< cML7 ٢ .ns4 V&Ũ[9)B XIҨejeiB@0!{&o7d.B"I f3 H4[5Lp q΢K, t1E~J,=FЖk-= v &WP.`nҚT&(O˨Wɏ& ukN(+9$:teA{KG~{|/[x$˦'xzm' |ǐxt'3% [YMGh3ɶ=H%#!Җf}}$eKc"b6%Ч1(,y6_)mŗb vH |2 ȤڷɅ![^tRNa!M N;V0\Mz6 NJ9+O≣N-"3Ț"݅G`T^JӞߧ1Ü?V?+7Y:N*dD4QQPՖhx\T6?au%  @>|C>lyJڧ6[m_)AaQݭ&:9.nЧ1?P>X򍢐u nKY[ՉSj~O~H{fc;a)P5Hu&9z|mNb_mVS(Q{̢YX6ԭ vu1[j yf=E3jy]d5H}߀B =z`p Iö%5t~T q&[Pxs+Q{m/)f;àCGϰ I8x&M7 idRcd"ٻqBE'$2w)LŇ E \Q-8"$ih~A  @ @? uj ,Qf2t~Yk_]VL:9DEe >bRWN`4kQ*ɘGETE0[XdG"> DhHljc @;4%wUA|2n?BxNBySF_)efgx{_]Owܴ/OnfvNҜǷ0Aȥ;ئUmGcTϮo9CI`.uNNM)j=U%<[dx%vX3g/k"S(X'5 ^3BGX<^V+>' ":;{HT+ҏmCx!п|"a[bC7-AʵƄ!ʵxh"!!X{H)Ʉ1#vxK_1_z9KWNfo X_aHԚϪ`4}OyO>P1O?Kq(3d2 凭O*_x &芺#v%Ҷy{mɮI'5/\Z2r"t/ IDATt5"3M#.ҟ8a[(/ɘH-7S8t1u_hWĦvZSq;mLbm,!Ֆ M@PtAQ1RdIŢ+N畐B8(Bx>Pyzc2{cr?'KRM1ԧ|s=SzaY{~ɜM Y_ ]Xa > mu vcF(L (/**?+$u ]|A hm[8D[Zc: |chjWjDS!)TqIO I`ݺ j ξ} _2D]7*V8&sv(iuhx m.<\["QWcIV tu)y9 6^!!$NyOHH;lZ- ]Ѷk诒l],jɜ4Qї71bE#sJDΨ}6I8+Zpj ;ݽ\'%)-f /e(<(9*N> Qv~|2BeR:!pP ~!piX VVض4+dYAN<7?~`=7h>}8*Ln<ܨ\ 7?#3|hp{B8(BHp"%o :,N@9m_uZԽ}`< ~D5+crIp\eq) L0\Iϖy̐ܬL_{H:YhSSXN$m᧰jL2cv X..7E{Ëert1BS;X'?8 `ʱ M+-Y!W&`+IWKiIƊ1>P]V1cpd&),jו-<^?=T1g~T͜-WǴm8n=h$IVM 8^sA^:?9芵sCx?.:vfIn.t_DqQʠKZHohEl2?"tUh"AEu/M_ |G:ۅc$\oABg– R긏G߯RbOM)~+'zd [8R;t_ 2)Ѷ؝>Ozr뻻c(h˴ȌPXԾ^mF'|(:Q$2Rq{cgaןxH`L3rvȌ僾tqmj.ң& .@R{՟: (&?r޷!|7~w徫]B&[ ,lYVzoÄB+?#{7jA.zbtWzäޟh|ڹۃe3ęcH4d&a!P:/]x(eW(|*G3Lp_A@!dW]GwKTdefs@HR0te% 2o]ؗ"ʡ̤fd ZSeo\q.'z2kb6ABD8lE? O(rNFl\] 6RѲp'+_r hipk{R8]5?l^lru{Ww4Œ+/rxJL'hA1|:M{dw0!͍ D/jc"3Ȭ(*xVyf3[$&{̉>w?"q!!$p&5 NJ3`DޕNmz[ U[B6^EhwuOZaТ0uߪ5g,EGEW.[I%Unh)Bi̢Kh{;HT,S.< !d?Y`h5uP9wށMm=$#:([Pq ~""2eohn-My?NHrN#o$hs` @R{$!t~T*UOr,Jj >( >ST^f 7MǦPΨ[IJ 1dysM _ը4u:9,*JlZpBT;(j7PZ⹿jǴ[ Ǵ UǴ<.JRFg@ 4כ#9)raS4~ ]xjA4 ٚ5T&y aXA:!wp{Y"  (нM҅c\vJN` KRʾx#؆*{; ~B?0g V4N/֏ۘ o rHe6 P`{=E|V6T*KhL\aUj%df~ަ&&.ylJ3woS%,ҕvťQ疺pF<$^!gbs(4?*LdYt]n$|T p \>O% y;3g"C`>Hc'*p:cvP6Je\!Z]Ӻά/brawfQ=Y0]24!4B">"|2]/%=Ճg]'d_jL㛍x%[vU5= ?E.Sh~[8űO:2F,W+ځ/A@! _,_GBruxdy`pIHHo:F>J ;Ǡzm3_6X|"}.IÑ>ć||D_HBr}BF$DD\1AŠɥBj1?$nc7|@<,~K-Oxißi] 닮C4o30_~\Ί TZ4z,Z2އIpO*Sd .Y :7ѹ Afhuefnz^mE> =jX[DQ*<+Q'aTSr Eǜ%BȈpH H1_^Y\Fo/zs<: i|sT\dRzPpzTIoR`won0Ԛ:'j51c4֙h-덀3+حh 0- {?C~k*ig@uo@`eTʓ ksNc1R9W;Q- @~}UFo2S%~uD7gc?$? QPhj=B;J6~F8$Fx`zh!ڡ,|ͭ)5p#݀W9iQa-Sa7asmk'p/C.Xk^ʗ~)-ϴ^xz_L]!- s^ =1FBh;DQ4<@  [k&C@! F"65K}tWotP}>kB8%!7q_D 9*4_YTsC6z¸ȇ#2$$WiC5JBqyy~r_g 5Gbd9}DФٙkR$SSމ C2)2/vIYvX6]}BQGrfþF#5I  ӸE2"$^ٛ[X#}0:M#5Oz+ ' 47"Y"`I}vÉ̐5dd񈫭𑩪/vb?&%l (04C{bE:BjcHѵ\z JGh@*$9Q)TMQN>XzmةȈ $RL{Y&] VgsS!T>IA /{QtR<_9vZ .f'=ȵ҉vwP}TxS|ɥ\2"H#$!2|"fL_7X\)%P>Yl7ĵ0}m|= >=x+( (?T)p\}SP7A~ǎ@¯+Z_}#;z?>';P=Ld Za[ $ :Bުw'8),#4IabO!=!Eupq_A5~Ԋ<}Y{$ fZ~JBXiK+s@R 'qIs9X Mwv/6ƋTj[EV+֤[Vkϖ ޝn!~%S]PtA h3ٕ'toJ6]E?iCi$8?17Xk#p,qχznr dAQl;V(D=E`5 \We:AwLcRNo>g6Ufdk$jtN_|"݁vS "īvu:aWtT_k_Si`dz &Lfu_0~f>;?[z(D2IeQC$yIesIxIaK*"'ڗx[`3wHD7 g@S͟4@p6:7m6TOĴ%6iAy;IuiCi7 K} P@&@5Hkk`d;J5GyJ \w9 gUt8Lbwum8WSm}r%oXͯ L .֦G~V0egŷɋFWc;dg~{B1A;mYAs}I$$>NC.kr߫i7 ?@ѻg 1|VuJXj܉kO~i@f)Rb

uMoQI̐;4%@q@ } #z9ɈAJrH#H#$!2xϢj-Bo#ws!RD/I7* u&CSG {ovW _=unSͮmȧ=q6+2o/d,mF|[6Yهk?A>GWl< V@˃f>(kظ8F4!4Bʔ+@^|Hm(RE LaM;5.̭e{w#<텒Qo$Lwuhsᱜv45mfm'vD:Ne2t(mt p4-JvHú芍=U]ƿcԽڠX׻[ٽӕ z36\U o#T67cP'3V^ikiCi$xk J&K憾x.;'w#*V@+pfnG-~6'z_G`DGIijmFOL5s]Y-;䑚C٣ޥ-f2*[eQtF*Iez;{vVF:4n _+6r@gѱPLcʪ?w:?^LP順T*RL IDATIԵk38+k,uynΘeij^Wb Ϛ 4!4B'n j򨏁郞QDa!OuF3?"IxhJb T 0-0i8ySbnQ Exb vA1ݍO79-IC[=JrFHۤ6mXHgӭjӘ&(Iޑ/Ei=ufط&k:LFģ2`UZ׶5'I*~X[lZ+KU0FHc@womQZD@cEftG{#ĄOPag9%njyM{: aUUUJJʟ8 {nn:tN{ ǹs璓Kݻ8\WO3/k% k])X V>aeN;}uR)PeLSͽz )!̌Md.Y3{Vzi];p?>ռx3__1)^]}-f͔ul@w*iӇtfqM֤3oSfUd|%GJ4Gzs]!fW?cIIɴi0'+++2e`OYj3Lhd2eG-**z>[lo~̙n-;;?p8F4iݹ_{X(GF{~b]-;x(pqC*4'(#)?6mjnzg(^n^f_>?h~WKwS;udajôߦ߼1gg5Cg?6lR?6 ,0v&b4v"b!GI.c!X^;rrr|ɀ͖SR{$gΜ[x}c?l6R}v.kZ###;::7}/^<}#F̟?b?KkxC! b[mKZp87ppY_u!&Y"n!D]qD֯;zt-ιʵ?*fY[C$|UlF۳UEBaBrɡXNcaefı,!~K9WOas6G@2B~˗Rz^,[,_X`SN}8gΜݻw3̺:,F>|vS(JzUVoBBB}^s0TSJk`Bڄ3"W`*RfYw_ΏN&Q3{Ô'Uas ~`;_n3k1lEe1X!։MXh |?rkkQBZ~_rgECѱ$##ko&=`"++K O<9ydGNϕ$%%_{ >۷wvvyFݻw֬Y [ ߏ, b75#vN~ktO9D3j/CcaEi2Xhx2-t4zQ`4ӆbb\x_Pu;b\Y0,_wg*.);XUVYMMY}UIXUV0{z{vu'|,Tӻ $PQnJzoTfb?ω=h13Wu*ue|ի1g}ǏYQTT4lذ?ZiӦ믿={6ٳG׋Dcz:u_ 7N_tמq'"(QzD;L tC<7ѻvFy)4;AՕz+yNf,<]h(7h0;sGDZc[/xVY떵tܛ%ʣh=fQfSzxx"Jvv#3\`Q.D*@E T0i9mjXqNj~t o m~SV!I=t#祗^ؼychO?u^~eRhѢoJJJڦOjOlق`;nذᡇڹsɓFHgOQ<{ ' 9c+ kؼFPWmn$~ؽ;d8qs&$_HR&;N?IV?t ؎\9Okz Og.Pi\ěl N9)SIY,S )-RdjL]GEyΦ ?/:0>W&Lqoas›X/B熺}@kb08+Uvo`kzr~L#f%rto.qN$o鸼B _COT6#@5|D $L2jԨ^x[}͛GBz鰰+WJ$T՚_\k/h4豻{֭>,lr{ׯCፂ!A tRP JAg$S}R];́^`*ԘQ-vA }_U҃)J~:tX|X N9+/zmª ܗ a-#Vfwl,|+,@?{M^ B^ﲄ afBIuA80|pimmxl6V4RZ6$$˅t  DEEuvⲬ1#{VZ5k֬ʻFxC0GhJeyۏ(pәD6Y4P Ts]q-$' @]ُje\v_=_/E7u{LMlbkf,$y!+x.Ie,8 qJK\zuTՊOb_,* L~/n_OzLOE| MJrcr!Nonn u+F;޽^"׺5nEQV;k֬}-_|Ń/͟L.]ʄ 3sqe_Kͧ5L6o%?nvf9o1_}ԹĊ˛!܋YuzႲRCbݺ,-ula<0#Ph<|*sU7zW?X\Xx4]0.~Mm;sUUU}}=vv^y_̙3wuW={n!  6f ^Bk{AOw6wrb0q;- {?1~q%Oez2TG# !MXt1vgmX89EPEe7E=`ӭ*PXUx$RD%(L KjUY zޞ]^*P]]WzR2b~-i9I 3֐}_A |@QTR%&&>.0nFCQԩSyyyp~3fرc„ 'OJTwF]A/Ȟ4vއYǛ 8V?4~GW1?헺)+Wc[9_sLjzkAʄ+;{N-2[i?/ S<{Qbe##-وg"Z>j!, 4'Ԣ !  e"pt΁ {(Dž-zE~͗}Ioj07{z`F#r,6s}>X`;>bOc"GZC'pv r( !)tӱ0H&"fDzy{Ÿ>1 N+|O!s"c$2;k묗'џ$ؖ?ؾH׉@MM͒%K:e2ԩS_~吐K.6H1q۶m+W̜7oٳmNii)NONN={#<ٸq<FFxC0?Epdhk(/DRxOh dp@[o:]졮@3SyRmÀt^XVLח4B՟Ƌ@P yn4+klzk3e|f~Wѽͮ+';V.g !лi%fI8f+&e8Ѯ:+(^man5{3[m\ѐFxCPSm-*OA>BxO tMy\( ,*N& -@E='Jڧw;6@r.:o5NHu]WJ/ϯõTpc?59 モd\ "ٿj+w% 7*s%$N1mvW)a뮼eXx$d~ 6#iCi$8,%M\QEkGT j%Y?j:{j3JhF/}[y%q:<0.ޓ]#oE;e'A 1SwsXiқ8(E0 >UXLUm=:JT,5󧬦Uݿ\3dЪčy-}]@1dVD׷-s"H?:ܷlkr߫i$ǟ OBnwB,Y4Zi[ ː)/P~d 1^٧xMfq MKS7 yӿJjkӪ&,@LߘNA]O2y(,;sDŲ@$' @$ aXcRYJ qe.z%|qX<-+9DJ[\=H#H#$BFDy'upoX<./@۪L:! (wJvm] #'pVPx%x;T舆R=&|JbcV}ΐcætyYE cM_(5YqLF+R5 go6=?0%OٞBxْo ^>࠰j6VT-'*{MOmt,[Vc /qn@,ץ{.>u/* !OsW"{זEK֫ xOmGФIj,~_Dr9Ȉ`beP@jѽ[MA)ar }I8AMWo !>` UOaGP)T bCyؔ4*]LJ]?fDV PfTLcyzӝRy7IvU 昛\;GHsk"R)[q]@3:sQ >G;N@YPQ$Iw5oxb?2"!h\s>=e ~'`>8@ ~,'ưjR[<9 Ƶ# -'"qL Eie2?̑t@U'dYuT#ߔ.ҧw~3O$FDI!I.C/?}B:߹R/U3n^kڥJQDĆZ ⿿SBciN6>喝>|81벸]Z-4S܇#ljq-#DbI+0L$qPCV}Rg# tsOVsDh!2ˎ)sc؂2rjC+QTNoSݱ=M HG}~qM{ @E]bAq]VM,i͕ءl9;?+E3B@}=H#'qQcT:^t E -&{`J\"1?{ĭZI.l:c;q}킶J⾎q~<5\,BWbӓL4Xf3(e|є宿x$?&yao--_yaeזxVY'vSesCJ2ϳ'6 V;-~$#N;j(ջk \-FTWջsO#tcdHGC=uϹy$wF<ЎT{.@Yq2W>CUܰrv|$ IHDJq1?8c%|Qo;tk8KʔTo挩s6 _gJ@SdڡY,(BwXh ,AGVU_~ܓ\Խ(lKU=.op2juv)kqҤ-+pH_sCjb9l\sD=hB6[Ա{$EЀM $޴D>G%wDF2[ѣ{uiCi$q? G?(p+av0@hs(ʁ)4w"[9crٌߕf4k&X:Bo]ע+ #њMH BGc*H0,w01b?%bhu5.: 2́ư$v@_,s"jt0!d־%q4_nIH*![O{';c7ڳ462achl)OL ɒ=u 4/ e P|W ؝/v{a9HNHt1!+ۉa(F^&m{kr߫i$Wp65Y*^ub- ߪU/@2-|lJO.&Jfxjגhozӕbꅷ%Tw;W7IQT_X?0m,"8"AgĦiydKl[~   ᳼#b&"abچL$5PS>qqϩH|1>%ЮyeQb.o1e &|7XuB1vmMO[ - I~Q>=u<}FLG ^0w'`Z}i6g<ڶSvOނgDʞ# .=!mC& z?mzۡ;@<y:+I6Φ Ln(|"dFX3 p3 Є{ booA!JoM,lbE? )Ow J5Y*V@ȶ:v1^ 755iuh÷c%B F:ߵͳ{2SI=Ǎwɍgu)W߽s}f [2+7Frv,n#_l}|o%6#H\C|U4BO#!?=Љ 3kǮ,2 aNeiJTgS).E{J>WO7MiH ڜ(vQr:PC1ܨӣPڼk.=>P8U2jXo37mԾ*MB\sJwKrm!pH HƊWdKW<. @ʠ 2@h='o8BR>@A4gU9gL;oFw[|#*-6vIb; ~p$|Q`;L?|D.h@G8oj*jc_OyKy#bHn~WV?Y5}@ֶ#sSgU[29t6COU(nƈB:ޯ_0NtdŠo1yq[! pH saH[!P.sB^ȟcjacrӘ 6MUlFk]X6-F{˔D{W;@ 4.5\HY/?7i~hTqI.Dr~9ΐ' 'HHCrOߘ$#t6ݪ6jG{ت68ߵGI4^! Ÿϳ#CϬPNi{D^$GFש'a&oVxSWI|2*E\RCt_EOqacsLݑ ({k sS :7^.H&Ejsy(;Y]l[Y'aS[eڞ-ͺb\ Y$6@~OhH '\1scBm oHk\ٔuڱO]#U>,lV{@٩WSU+Ÿ;:MI>\wk_IצKk*A! ,qұA;k[I}+%\UՋ=6x3^$ļ߸#]' >09#CyGUm3eZzｒ$&HEqžEP,"("" -$HH''I(ˇs3g2a Lzk/ZHXe\{(^amcODJ z1:rBLJ;*w˅9:[[ !@/deҐgFTHKc[Q&^j% SSMwj{>ݢyILL~}7yϝ #r𯯱 E$b(KW6ڿ@O՞5m'F|Xw@Y$,n7-’>RWO+K6T7ӰQk{G]X9}_Qà|oo݉i-p@:K.em8 uN=MiK{ZvH6G{uc uQe:Ƿ CDτG)7c^}>Fy>"!5o]Sz9AxG__D?uV } \``0[HVsA l ŅRyC} ͛TJA>{ Mg>iy4=мo^oa>%CBhYk zm~K7V@{v5%~)8ՙqq.=s$8?xqH86}}Վ5NN@*"Qe)7&I n c i̋^"KER^Q]y϶bKRV}85|?Y oMҕ*Kw܉"jܢ9ݖ nۖuߩ;*6W۶f tjq7{}z*L8y"@5-m-] m$Zp(UI K%-Y# bI2S8="ʷ*Z;>HpJ~ߤssm;Pi{V7,i|[7|{ߧ[+:{iދ Ot_ 6Yd~+%NĖ F"wmK2v q*TոOfмIU7|Q<ﮣc~\t.UK*uL ;"']̕T+1nrQSg‘ | @jӨJM+=itR#e-6wXhˬ2D =Kǘ:M ǫ V]+.wNλK !ts{Cu}?4Ml;|J7E]F{(H&FDL:V1Bj09mxQ|x=}_RYcˑ֞汴5lޠ.ViK=֏u0$'coaW~ÕtoSUN9Ao8Ē~q&)b~ٜ+=%fy-!RhCAgcDD0iZìһ}rC7#_[yvA' 9AxGS+EA;}Sh胁rcGz5~KwvvEROrPPj__\NU0<{YgQYfQ/H}4A0J%V*H:Bq61E1}L۠㛿.F~ww<}^ذfi;;9;X=_$'&G7:pNC0IU)$o4 ħ=9QW^lէdpjq|ջ:ߖw rH^TD/uw,MJ_$LRNO<@ lUI.'Wr c4w}n9&>K4lv}~=9>[\%b8K&KnW}oj*kmq842+Lƙ|e|?늦8wڍ;wDNŵ#dqvq#т4.#!-f9"s Wj]k+Ghih3gkkD^ϖ 悗wYedzBc$jm޸@xIfacu5}nM.ȼ f[} fQވ_\eEcҕt>rJT@/T.p {VP&6Fb0ǡ=o'UD|+I܈Jw9eM؃@O'|w#Nqr B @д^06Ѩ*-K]]PxF Å4[3L : 5U eA5 pHQTk6k33]Wnw#6mtp*f^wöˣ IDAT\F7oԾ#*7$V$OW}Ǐ&TϦ?Dw]R7N]}}*OlǸײYCQWSW麮xQRYUh?}E~, ~:L[mp#s}chJmNAr BV[ .ƭNufPpO$,zI(}`t]4h39A8uXClo1`¤ LJ~d@SxK[Q671eԾpj  e  ΆV?|c4yX=ie'8o'j~og+m 55)hd z̯/`Y

꽗$̸WP 7GFĸ ~ {[f0`{ ~RgbwЋq, x1c{ :hjynRھ湵;>>_IoH0&`h3Qh@6A˽<2d." "mQ}3Ȟ#xnصpIQK=؟aׅN^ٳ0=k̖rYtjj#HC{|'ޯl\'A`^!wDN:uCMֵp`€ z{C#'qħԚ+V !E|F]7Rl t(TmW&LK]{!H<װBäӼ"6Eݛ?q&Ԝ1eU6Fݹl_1oE#2f9t%g5a .%^DdǁfElӷYK/hXzm#ayIs~Q-^C]c^XXIw9xNY0!o&YΗSpm܁E]ke@rf:;eef$sÐ #$v":AxG_\7stk]D+ wpqMh궲bUE\Y@*3e*v((S3k`iYLlD*ת\(BHI]Eן)0`LfhZՄ~X,M-ٔ7ixsa$t55UF,N|& LrqXfO{yAð}'f&?ґ\RmQ ZZoC=Ɖu;jiD`raFk _ zۢ_H,\1ˆǼ:Y*#V./m􀷪P#KsXNH$I(( - <'|ᘿchaC]L= m:['%wDNXA3guk%t@1LZoHbi`1ɮ"K3rC|QIpdL}5[\q^M$H=Gwr5ld w$# 32Wڌz=QҢ~ʒ3cu!xa?}6YV8c 4ikNͻ:BWȦ Ϝs|a= 8-HJKPTgsۍC>4*-|O%}j-'Ioʓԗmٶ6M+Ș[Lj@e5k!C0*OtBL%hYol.áW+ޝCu2Ewb:Κ|<خEhs84 Ӗ ALGS/ b;E->@ջ'kt-ɣ 3R~p %BջؾE !S`04ͤ؋PsZ F%fx,]ΦLSCrd 2tm8 Z(MXU0NS `?:5Q 6hTn;9˧+ܝ |C(TDKS1O龾Cf:aGcKWqnw]s`I]G*k7<ʵh[$¢9t/O_*i.ih5wdku| t[Ok3mjlu ^7ivav^f6MO.L *K;ͥƞem_UFJUmjdP$Ҩ2;@`rrЀ0d,0 PvPs~>ԦtAL,.NoƱ&3x1ŌEۿGbbl(N?-_*t ;"'F-k2 PetvN!9A-4Su77[W-=(C876]3O]lXa~EgNy׏+c6W"3Kc \{bݟT Ч mxΨs}+ 3Ժa9W҄ctSmm 0|WA x&"ܞYO"X1ۅ @jБƨdb 'brb/|•q)+wu,U0"j$$'cdQѭ?wX6o!Fh͇e\HޏR>y2) '\L>If”35Ϝp\&ZJl!nspr3tW#pXu0=USoA8AxSШD?[o@%)uVJH0жXZ@Ao2zM۩-rE ~pfi}ǤkfS|žC~oۻx`TDZ{0zǤ…lcL~LܑS߇mNe8nH{;^݂Sánc?AwY *t~ح4<"]@$§(IR QKyƖ\o}&4zv zO,ߣvO^=0 dz.6ꮲ44g5yijD̪!]5*{VJaS ^tU[69v=\Qv⡱yO^uV#go ˹g0&TԺɺ̧1e @__Pe@m?a\ˊu oǰGpB4C&t~Vkՙ':+\)+e29B]ERع@0|2sše ~Ty*eHuWn|}%Nɱ^w%Qb:f"j?bsz:B1FͣmPS0Q#Pvq%73ZjKՖ0LPFQʫ{Jc$ &-![T@е_T,3!ohW~Y! Mֹ'rdZrNͯm8s ^̮"Sikd Gv^Z* bq@'X f TA+*;;6,Lu@#,qǬ, <PmpvC$baV zTv P'EQXe(,RPp)S[7ӧ/gn.h-4Z`>]sq❚=ioWyܳ@=6y^l(-D>G4vP:e9hhj\=m *KTmU9t}tyQb<>TN}t4yo|co]yGcukx~  HK= Ԃ5`{6!41I ;mIaV- \ɹvgҿ$#8p5CuwKqdL}9{u{W+ @} b,UMi­e/g謰Ӥ"?zEQ ܈'9bVtM8ҚWuDB# :]:=f5 Ԭˤ)@*sx0k6W> ~KȬȍa 6\3 9^O_MEo6|}XX~6!nOY b`E/MJv/PU=Cl@[Y:͵r-&f'e{U[F0K)&,TuP4T7'󓈹7sp (ۑY+6l0wsz111k׮)6m5kVaa3g _||j6&&4LSL9x`ww7BxE#DF'p]h,:ň T^h_ܐi,ݫ%jҵ[ 紑$T2d`}˪66|wl)AR$[HV;noϋ0]ohLiQVjUF!_zw[$)g0Jxo%5kfLSq.( ~:?4߿< rg<0G3TT:-ɢXL0RS0"` ัH5SV^*yFk#]p_}TpAlA\o1hzTܤ0Bg zV{y?4 iܩ h"3_r̋bɐ56dQEp]ci~./n ˅ΚCǬ2&KnnQaZ֔G< ~ۨ6̂l _`)n_P#aWS1f;GHQIr[~=$ P*4R}_vJwwNsLQAYYY&L-ZtQPXRR" \v---ư[@9Dݢ&et^g%a@ֻ_FtVymLa ~*Gg-xz=* *Z4CTRUӼLucA~eW',0;{>lHq4UV`1'JEB5ql9oUxR+u ?WOrÏ)IOEƸ|XJ1\22+=B=h` a"÷z @%kHkC=zjQuhE}~U.%R, ӇU7wƨ_6F,%S{a% 7dWink#y3,<U4(6 &>-{3Jȃt!~RCzAϲ0Y~&x#ϭF`T=G*Ͷ;}hU4 _8) '~V}g  OټyY,2ҧdee}~^>ӥKr87Oc0ofddWtFX2S}5.y5M5M&-EPmfK[4em &#x `<{~g6^ `ŔέjXNZuQˆlخ<>ʢ'^pO}c O7"Y XC<_.OxG=g.ؓNSlMhV/9ܸzW=gS0Hidsk!ksK~yONwJ&2 Go{AUse- [Ѣ̑Gr .#`hVEաz>:+Y3)QGP뇍_qf>R5^Ij) e$N*)FK)S>ۦQr8ׯ_u '2m۶رc9SP=l `{..*~4Ey%x2|\BYae6S pndF/|*7W|ӽ<5[;V&smYő]7ÑC g>(]kml[&p}d#\6nm%b`y Ym%F"_ j6WyL[tZ::)qWi~6E=).?A0^ IDATHit䉆uW_mr'$?1s:f:f*j:fnEDJשs攇E>%o>Ȥ% Ȋ}zV& 0![l[6]hmboSu\`aIa/?._C7O}kH3<-I*v-,cc^),Qc5䠚}]gL)IS,Z˵r'\K)Oiݢ_7<.jM<{t%/C$f @p C7)be `WQy[Tbd%QϐeŘD#ސLMɕ01hd}!|7'Mz3ǵ!qrw+q m 鬙޷Ѯb*2[wf02ާ~‰e{$Iϳmtʤr<^7w\z wFl5 jD"D # ࣏>j(J,YΤ) w%m O uu t|'8N{cRWY"D$KH\_RU!wuNk 덞Y9RJ}zBEڡ i cϤō̝hYb-WjzՐ g1Է갎.8^,gW7WЉ3dSHRd_DEtl>M'ܒYos= 'DPHS@CCW+((t (xׯ_}vw}2ڴ@XZZJQ5Iia>Hi"k/A?ED9YC:h)]]xXkFו1Kwe;/( l,1(R;dGJTddW:> #g[6f5j9>RU gH3p,Igʹ=T jg]M?6XW ],, A8>?5*MmQቄ^;81Ǖ]|uW-~;cL*KUݩeS=&PF[=}(kCOL~4}$<犛3Mk+LfDQCU_>+rS/t#*N}=A./ 8"ƩWSXZ(d|QR E%\ߏrݠϴ?hF u8N {Շ`P7@<3'(iXXXIIRk{W)Ξ;wN۱cDŽ l6imߟ^/,--={YW>vX^^ BhBq38H ,1ξA^ۺ.4dY c"ͅ[5sL;cW +gr5{R "L=eLW/k/kg~] gH.kW%~cTNkA*\Udc4p=ا&f1/\r SEH?á 6M؄l~弶C6>rɭe{4S'?r=|X޹rt` /uZs,S &!vn6p!OPtes`!T= BFk]W7wBgS rbORn gV|T9v?ZwQ֟7QYYB(joo~lBCKTnٲm޼y...GJSSVc.\n;ZTTK/S@O"RUgL AKCu AOhɆ,Ι]3㶸]?K>W{ʃ`$IEC6Lf5Kw &CYiPH̪)Vx ,} dTV^d*Yp aeB{FmXhTL uS>lm#͠+k5ce6.)uȢ5>]o[Z"Doq'D=WDA\BJhsD,ݫ-ک`vR%۩zyp໲n5Yҩ ݧTws *5Ҟ6Sx Ղ zW zZ0޽?[ w;s_0^%ph멞s%nN(L 3JNg9iҤBBA~AAAcǎ9l2~m۶%|wy@LLLQQW]]N6M(^tɡNZPvFh[Y=Ƨ>TdM 3/v΂Ǜ|laҼU?RO ܉ړ}gKu]0U7Uzcwm396S?FD|D"ihh8rƍ ñcRSS+}3ft:Xp(V+HlGO>rfsAA;>Ç: t7ѝEʕ}kF>&IzK&Q(@]+@k漅)&Bg 0ic񻩭YYkМO{ɕ-dЁA Ӟ7f-4_V?!+2@Scȼbȁ+K[/B%!LTI|žp-b:ړ&x춳sKΔp\iO~Z&d%III LZ15E]\ A$x ԭd3hG2&ꯨmְ m|ջBǍXw#x-ZєkO"?)KdėYclD _li}ZTL:^e[VUU|W˖-y|J",ZhΝBPTڎNކo$Qi9AW֚' \0"ԭdM(FtUYi$brVvu*$? eA0$@hFA[ ͣUaҲ=KfiTk~SuqSxNW>U[cQ B@@o6'UFYk*uވǣ(7{0oMXh 6-f|F $I nzXZG4$>{zzpnb֞,+N$"(])KeJ-Yh[,)o=NŗqG7l0z&vl6hrFon56}9}rg8t.o oAUmg|쳢 ''?o o ;"gmUiLAL-$ 'j|X}BB;if#*aL ,5ȉm'yyUB.W)O^0Fڋ,$16$< f[HՃ`XjsҋwǔɏlF]::J[SVnӹ[. bD!#q6ĵqf_* 60 XT*gD{L{I='7Ǻ,7j&mv#"I14~} C/p.5Kc/;"Yïgw,[س蓪gYyדq,/KY `>߰DGM%u}"qdCrЩ}E&{C . Bt ̙ͬ>g(&APXK6܈\B3oȃ3F2y2BIJ f7r&~7x,ֻD[ ekq/`{ 7}VƍˣEtɄg(dzj×׹;,4wۭ.aT, ƀ#t#k+5)BAz\ f&O2-lt8 `m;1*H1u7m#ctֆ\x)m #&s4.;"׳; &-ϵga^- Jb {\dXX}Ɣ7wgL+N{stHyxu)t'ghѳٷ4|7/QWJa5WcWq{!szZM@1Ʉ59d>Qi$Lɪ12ڻ4s=U+BVB@@@FZ# 6K2hҴح=:>cbkw (MPL!$HBJ*{|E|9UuB=s]n*l N5ׄ8핡yv}}a_YWj7#O;౥oȺ=A5=:굻23J 3%.9IRu%7WuY[}#czcn?2ŴgL*{3}&gCw8\(??/6I+"~,eU'nt圸ѹ|޾JVpx\2K.R&o\}j{w5M ߽ި]ckUs^8ذ][K?*- rT]'4tdgcbڷϺ6/ncr* BCHKL,Ԧqse\UftKuj*4;r̓Cxu׺h?r3.I>7bX&jLd@9V.:!:Vׇ+QGp1;؃P5őp\hQ!P1ɔc*>#$y"ǣ <%(guG)|'&w㓎; g_ry"cJ`fLߨgdp l֌Vn16KYMֿ:5f٤hkWRL8nI]x55/rMu?}N|=4f|`3Zgw'ۖfd2  }9Ju&oOgwz*nZ4pkrgȜk;8^fphe'p5~|隿8piI\O0WuhK _0 ,IǮUxm>UEGAxJ9َ>Ze?r` UI H6 *Zș/59٠|Vx@eL#y\btig \.KFpo.yҜV$J{kSIqi ~@xC @UG! C3C̅!pGY^uVҰc_r) `{Q/1qQIkM5*{64w H榋\b% ]߽ .z;6K7>ftVW{"-:HUm WI=wGU ':EkY]X&bxvJmLN~b/@ 2nݐ&9s&J1<(ߪ>#`cPw*rBXv$o4J")Q.4MU%иц_oJJ*2m>sTC@rp7&IgIf@  e/v9 u[t%f * \ Х5nq~tr./UIDAT(/{PE>xmun7  !=qx쯾Z̾S_|uH!60%-˵v3i v'w7k5Zrth7>Q\}>k_m2';>3tж(1fޝh HP; d@3ԌGlKeqpy` )?S0eIhڪPw4Z%gl%0!Ś;j*7?^L:E?BDAHpL@μ8a:dIP_-f% 1pĆN2d >h8E3mε!c'0"}C?8IH>ۦ=֦(QRJF_g^usʴa근cn\ntJBwK& ;z9x c,YfU4lhtE̞m08 -+:>#4$`veGI&Jk4?Hd:4G9G{$gj0]*|nh  FnfQBCJlShʯmCFK5ԖZ h`Emۣ&qιwت& y gb q9xfև 7'Xܜ{{ܚAiӤk«m#B_g'@qF.'9oⲤPhzcr ! BE\i d_vFq9hhr8mg*40@sR1;KhpՋ"3.L+%O)/_i& ';zGμ>ևdn権K[q虼syꑵ*pw@}L?ohO'ζ*.В.0l]~{f9čȉP䁫WbzrZ\oP%`Q1pB7-0<"; @nDݷM ͱ鼻[ᢰFIA}Dg s']ʖf60c[۱]d0g3 KJ߇Zjo0ŀsnI6\3 $<_B~Ӽ]~El|򄀈caI_0;bMJ=,%ѬEۣqƓr$W m09{mͭFe~;.?$#E++Z PFw4)ݒ|1ceՏW[{zBwYӼsR{t ~pfr {0p(/ /rRlwPIimT8O+ lL@֗0?#B74%2 5Ô뗶V Y՚$5l ™2ƴ\>4hV跃@Z2Zb&nKd[4`i9lA[ 4]w_6h|]K3Et޺' 6]9pˎD{mG<|Ϸ Vu͑tRhC/*۵v<ԜtӤ}7SƘ&N4qλAԭ=[eͫ\}ﱗ%hA=9]qV+-{t"HvU(+[UOcRdh643hÂ^`nHAQ&UU8}@T^1;<]/N20^joC]:;J Hf4M{sb[ r3>v3#YTӥ'~-p@#~H/V. ycRfv3 );T+J onӗj09Iw< Fz 8|ʮ]ӟQw:zA )Pt#miG1B!9]zRP*3ҽbp)&Ir cLlTZPm*WEjhߩU pċ)p\U6>:(=ԾUlW-F[k g|aڄ$CVҿ מ%(ҰG4[%wS5YYjll(V&`ϥ;޵{@ZL]ua7X2D\_bꮏ/?v5p^a7Z30E;G]M0!g Brphjns hlZ+\4R.^^.fp8/CkohQ䮝7~KEۗ<]ҷw1&_*UĝN"_}b!ga *;a3[F4Rڵ HQsAU|J<#G\kP.{_rxaqQ9&?#GgYMmzp-B 4Ti7kֽvKlx@߀4Hr5.O}IzlB`eF^Dդ||S=z4MӌvԆl9orQ?^#͐aKbgC$=뽷PM6daGO9 zJn>6)%D&I}꽌9"9]5n NWl {|CэNx7qC2M޾75^t.?3 d(Iܤ~F8~) `fF\cߩZx^-q@qʿ^.{KOuy\u!:DkEhjE\ׁxBb @jv CoQ`K9 hQOsAE$ /6Z3@ z԰!L@ !9K-:  @HB>֪1f_jI7nЌN95;CnϷAd(,;U,հȉCg .,qEBAdb DϹ|sbs$<%p> $g7yw)(i'xfMt)^ h(Տ='[(n@qSRțTD5w7j*i-YBȹsow>]?fc])B(9/TOAAH!* SF !䜥dSX#( !D4 BB!B9ԟ TBhB"!!F !\%T*fN !D4 BB!BHDsrR !D4 BB!BHD $( !䜥׏'o޽[e/[VVv̑mTU-//?QB9VZViiiNNlB￿p͛7`r /_pm۶$$FAH!)KKK-{'̙SUUaz.4XdرcOWTB9ceee#==чO ?bSN=!'|bŊUBΐx};9o}-tM'+ BB!?Uyݒ$UUUSFu彃1&(//+cΝ+\ihBOꫯ>s`0hٲoVZZz 706rc޼y֭{z!'BO5sI&5}RyyRfdd>lٲaÆu9s|իWO2tB9jkk333;;;{3{쉏 hmmϿ;-Z|饗Νp8~b( ! ˖-{keddL<Y +ܷo_eeett1fOK]vYnnIt&B9}n~iٲemmmս⋅+V91Ƙ{4 $rp}cE,^s頃ξ[SRRyYf3ҥKy_l6d:r44J!$QEH!$QBhB"!!FAH!$QBhB"!!FAH!$QBhB"!!FAH!$QBhB"!!FAH!$QBhB"!!FAH!$QBhB"!!FAH!$QBhB"!!OH"$p@IENDB`demo/documented/mixed-poisson/mixed-poisson_u.png000066400000000000000000001026351412460263600225720ustar00rootroot00000000000000PNG  IHDRXW IDATxylY<߷w }9wք@f2`c 0 ,cC`c$f391+^`% xeH,!p9j}7]uا[MiWTO~yG* 0 Pq 0 21!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0B0 1!4 0a/`w 䲟a@U`L>}ݕN8Y{?$^8CM 21!4')>$Pk~\IgL 0!4-_s ?T[0.B8OZ:P`E:@W;IBøhL (oT0ZȢW_ G^L 8Zu:ܝs>'4*D0.k0s_뽛@se*+eh6nAøP썧a۩B/dBøƓg_i3Y ,E } f$~:|KHSL 6bBhOLlTIt"SL9BOm øM'zAFŊ~ U/i¹ML!m0oZ?)rq9)vNga_ԤCmĄ0?D)|iEOsGұOLa?&D*N)\JyFRA*1JHO5-4sƄ0/?>?O͂J%/M}:|k?)`b 1!4M-@Puc6vbmmr~ K_3Sh a<.~]q4)X_uMo9w^֒To/pqU}ia&P/io|LBf1+ɿ(es_0BxlWw45N+\r.MY/QD#-TPMLa&(ƉHd$wdQJ@΢2Bf <1!4{^Ű'rpVآ3yL hX *x uˉ<+?Lae?øZ2:I :ȕsX%1kGABJB#8k0a<w'CdR! &:½5/)&xg0* Qq-դItS3/;f(I(T^Zh]"Dy㦹Bx#4[M_ӥAmL \[բMĤ}hј"B/ϴ0!4[e堐EɔW >gҶ~N6@U2-4' a5_Mf Au-dp.S9N1H!0=+W!} i aI^p[#{^}aҿ$~XB5@ uGxg)4'c;XpV%҃M¦|Ļt RL12B%3 (/z_ڨra<1Gh{xիX&َ$vP$qrz%8K4K qUuR{_kO/01#'l`d3;T*dr}sGX:(R\ @ ۑg[k0'9BØe_GۗadQ9eb~)W}a:mn?b/?pt\{kkO0vHK iM 橋tL! BIdNqBHNN[ Vzׁd 蘏 ؇ a,d&.#,0Ym"eoBWe8CjLTzt|0Xh0&_kwy}|תIRV1[BhFɤ*IOvݒc|+˾4aLLF KՃ D QB&t N0ƤC4C vGV2cO sQ/-l`)x!${L)a1yFLț+!Η|=ؑ]uG'x_6ShOsQVuD HEjv`,&';Yj1GX^c=P@g3@zSvWf a08Y=(H,9R/ f|^q1SLCDŚ#B]:(bՌKt5GW)4Nj9BHƸ(NyZv :@ v͉&_iD#8P)l촏%MbGasXYzŤe^αwSRƓ0WCǕ/ ѯX^+jOF[N@e*q.ɕS;2?>1Hա(XPPUOϵs\frW\Y0 >>8sgU$f'U_8;&(~}?BPW7Sh9BQ tvp/SvTWs$o2& sj0W뤚t39iBvX\)4Ƅ0`fA6Ɖ<14vMCInrD3NUoKDG>+eHj+׬׷3 >Guǰgmdt Pi\qb6'a,#L,0UƷQr/D2Twwnf 0Gh:O](S[ܻg\#SNvjS('52"#Ԛm*D3.Vw1 q,8bUH^5սPw16.JvTS!D6͚FÉkU3DC`oBhFCgq`"(P$EM+S="H>B:ou!BK G,:gˠNK./X0n9ByE.V4qZ<TjƸh $ Tkp*\kSLFP0QBUS)'{k(4[cBh4ݚ5KO_ M]5;|7$5ZXzo{sh6_c Z"~,!ˡ)_c_E^[x`Bh45#bZ&4]*ȼKf<[}c>EQ675jd7(U*ظ@rU0LJf 㖘˳?u@t  4j]Tك?xEN@8 NuVx_?{g4?=M!Eȡ4rhYaZ8P^=K{s=p98O8:%so;;>ɚQ y؉Mx?]QBX.H]Y\,//Xb}^9=}3n1l1 :nu0 CjsyyQh :G/`wC;b2Skv&;J<繼^\#VX\D/e&4孿 LPik;\[VtШ1vNk߈"%V0H5Ϗ|!JDX\{Awy.-:tcތ-pNIgg?w^9 cv}U$|ĉFll6lqѳ 6 oxC!LZ"fIxxA3 gӇW~yseǮ2ԱPROA GΦzLp 2g?ó=GG8::5 u=Tk"֬`n&*SNثŲ. Ի@pd)icH)qQ5 qi˼Fy:x?S"9>=9G_1/S6F吤a㓪G׳et~G<ȍ1YH pu.e'UWǠC^r}jh|a~?Bռ5U'c^`G=QoLDYtkIbP0z6Opth8]Oߣt#}9r6 ><=|rՊWpn?۞a8`4IеqUZ!C_yr;e i9By`ר'}_%5PwAut \a O}7pkȼ9YZ>M19BByWz͆obY [SH7 /yЯ]KwPXIs+]nG]v9tյ%9|Z= )/\ajͻ?ٜb{0t+A a")_mԆи8&Z⟮*rxL>FG<-<~,KiBD D=*?|z|1% 8gy8t~RCEF}1R߳_f-<]o8;%-Rt0 & !vtf Äи0W(x%WO]UG%T\rZ`8B8xէ>vǮ[3p4 蘋%%eY^3X:"*J~9YV-Ӗ 5'v7㟝mO=p%k(05C-;v0L G:{*x^p1X:wz=ZM 8%W*o~=+XsBddU))HW4"xlr5DG) 7t{CX5q04R3!l {.0TL ʞkavlGb]9icOvknT(> ЀiuTA䕁?}B6O7f7v$Q c|&%XO~eét8 (Z2"Z'\xk4LBR%eXN77?i_(+m,AU0A xyzr`-t{Kddd S3l0pY %%<:~y=T Bj )is6ƄиWw1'1GWG8{|jH f/Ĺv';ʭ6eiꕫ8:bŊ%UoP bRuOz|Sl^HSD;v=%+Nxr oMm #¨)@5F t|˯^a!zMW_>"GwJfEV'Lu)Av,g4E"]?{zr rQAzV/'LU w^W3O Yʐ:.k5VǼz/Sݞ[ [m2hkG*^aB 7 *S&Z9r(FG%^m敫XX6"JױLqm,t [^in\ 4&c>a<0F[)$R㞠%cBh.v&p2 f8 m}pewEđ+i8ar sDO VGOBN}3!tq?FvKݒcOvc|w˼PNq0}r,XN()([:i|%I\tR|ܕ܌(p]P}c8ru'w~yG.NsõW"aQ1!4Ο]5QxP]7W-nB6ŌU#ᘵ,Y902W"G~=`r{/Ew::4 ѿ 1;fU׬ QNE }>`n.NcW:M 0b4cz};;oaOF+bc HlGOZkX#{QsɌIw[D$.rŊ2Mr[ \:6팹eZ)L/mln-_@m0B|QǀawP@y}t8PLsmɁДK'$  IDATҨTkhB60`.-ӚL!<\+*D{U{w Q?(Sғ Xa}-54%FQ]Wf|@@8 b JNFbS]*2Sh&&y=MƖ Fh0ƎvPqץ8 (haQz>;un\*mIcjg#MuL`@!FDQeU넹1d: eGjՌ-я\wu 2׌63&Sx{? BƹX螎GÛMTƱݒG,mLalx{,ˣ8T5yAlٍi™ !2m6KrOt%\S>S3Ѧl:]X)8e{C3 1FՐ|q"J1_a\4sC[n"`kwN|=I"qRɟQq|q\#).ʝp(h3݇5`#]݂eDäGŴd=[-l mf3qxw=8.W.ЯЯ:<"Gdm2 q>h韛 !29=ɯs)LWsd{LA|\5g BD#RG\߅ߥp)/A:|!TTnRd qoaeG']-U"FTShᤔ*qtn͗QI`ݨ @6m/7&۞h#M K H6N]aѭЏX`=BS9:TD R8 ,4j κv#@U4A!@Pc  gqWU_=G@1I2QphphFcHI6e8Lshtq1:crgBtxDS7P%^&H%s?2TW H[j_zs%.Jr:/;73L$0~ӃI5iJS*HS,(: 0RZ&^:Id/z21@mF:7"%G\axDƛ6*[A%qZ)"ME~s.0.sSB{"lDc5G-^poL*:5S;mmo5 I`DJhI?%])S[!CA)"iTL}6ϙID" T@$:p&)sk}~ٯ]ߩu飰*dc,qbBh<%t ժD˝Ѵ$Of礂o7_2z; ySUU8ߡcJzƵ~$C'5%HH !sDGa)wXy֢8y2=I‰@u#+6'p1HMOZcc}4BƓ~jqrZIխKsxFs hPvJGmձ4S~l"PA "!}BP1i2?g(C~54^(,: (|-%uIc~AD∫kK8 xhG̠Ƌ|Swٿbq#4<z`-^pR,ڜB [<iLҜ I탡-U :t} (܇!iZO_sM8M7%m]lLV_X /߀hO?[j8F4Tho%3 ݈K60BI\]LRá;i™.֠h "AQjRū! !CQLJS"j~x;Me DiKiKS6U9F_/09IPժ4WLa/*% ]~ѭ]:JIj̃v&A`BhkXgG׫#TjPJ*7{>{cqO◵0l ?qN禊x #8uK/qLg؞  "zE˵[sqdulO!!èad7_j6< Gd*b&(RE:pMі6 }Ʃ=\_hrt2?k|(d+\:)4јO%T6M3sS_MMuܫD`;({Fg6ΰ=vMlNG{Ѝ#zRRSHS |Yb N1=Ѣx03R/:EGc :߫t q#2 '+n ])Mg2&Rɨ6TL ^D~._s1hyda)NaU]NVy/0_uSETl}.eRv#m[Q>B6]ja 4IXAvSh G햔dV%}Dt>}o>_!ø0!4%vDk,љQUcD$ 4/:qHo``n8=ό|<*&& D-e_XtEjK44:Ir,ΊfwF" } @ РrKཷik3B 5Ksp_p)H[# 0 6:no뺹#(z+P>wrϮ爮NjG(;|=q>/E#ܶ6so2u5ܛ,֨y[q1L2;T(caNF@=SĜxCaj2g&Kkyntn/զy:wiN dڱ `,o0g!6߄ ӒsnPkv0Lq'm1a˃ZrJ^'cEnOס,]`i法S5TE]& )9ΦSƔ }FGJw.,)4Y+(ImdB(~jJ^(A Iƍgkt7(rp~s;0leÃOT5ST("(F3yCMrNW{ 3`F-d6Bv @cOưB1 bnGٛs LAmT0&XMa]1Tp! €)':sad: gcUwZ>]XfH`Lf-}3_&fc 11̦0^P#)t*ַGg7kw vbBh<VĦL*e4غCND4O- d'[ !1c7pWﻘ r]|" ؞upMҐhTI9!$DGc{~Jtأq&[)D)ժS"oR>JqH/afLGe̫XrT;BK`MD4DL1kBvmF"lώ@$谁_ $-$;V>:fF0({U0JImf|Bš6|a5*ha PG|7q0!4L9ɏObvjdb,Z&4 BjаEj]eW7=dİ;N]G6y񹙽H bpT)3%GXrB N6mW8m."e^)1:*iSɌ(L x4rF]FM*8mUP8HuUIVlj$;΁osԚ?9ȉQ:JIr8Pp0n&-)jg5) i5;At>@Fa#4\X*\n|_q6=a7 `na`D0UOv4N(զ83H<pfVA+j %SC1vjB'nq]㖈2M5mePJ: J[(C>@x76#H^1('c6rR0N٪Q%h8V ] Cou:@JR3+8`BFՀ=wGC$TbBJҮuGZ'C5IJ`tcZvsH.=[ Xޱ#=]O[M(1d [uҫ3 !Lab(rB۔ގNzQ*La/(& "߼ק15Y(P!E]Іq0!4#Om!A6v@[+Eپ+Mը WLԭm/@4;y뛆>&; pe8><0@Y31CjRx({k3c餬i&~ ^f:@RPTS q8@W7q{ |j0mg6dFD&|>'LhlGcv.Y 0 @:  )1d<{5qf~u8,fWN:][%RrUԉ -ko6ۊ -D5$=i#9T#ba E1OKp/"*Q2".0A1z dХPfrodZ-WtGk} &^qČgQmƆq1!4t㰃yD NU0:phh,(}^5{8D ^Fcl{%*GeüѣZE-oY|!P|4foм)s޼]Bm؃[E&ljd2?)9;#bjj6E rIi涿&@;/*1.iKfi&BL*X]O^q=at"…_d HQu=kXfФlݕr cBhL(Yf15wdkB-RMTD1&?7>s ܙϟϮB\( `W)btIӫ ]Bމ)(ZIioϴPһh!|tS&R]9}0 BQաyĴwpV,Zj U NKT]\;ppl_L^|Bi'Ri Ѷ}mnR/|me)yIֹܫR Ώd }ಿp@GACwb0 &FEFBɆcGc-E,*HՊ+.6'`]ћ5HHMxȅR&LFsikQ&v0ۜCk\t g D%uiT(~v&iU{8v rGG &2\CTe"FAs̴$dL]I`>9SX  ;ec9M1*l$cs?Mm9KcJׄ&"~壥"T4bj؜̎٧zY.;zswXCqbШIi73/NiXlq u%`I0I_O ;p` Xv,(uGt4l Μ"EZ)l+8U:BTۦ{!Rzn'W;>m$&FC_u_*9&uhտKirj&DaL 7/<r"euLh8غhal8 ?y7},DRJiL}9d C54+HcX_9MW0"&FB[&{%;X"sM#Sモ*GVP=͈N]sݒ'P2.?RڙinpY7_$ t#UK"p߇)Lu4*ݨ|5sŸM^xe)k9k(9j`vF LDHqB췃) ptn@YO1vyQ&Z⢍jN)o/= Lwt޳\^?a4HSE'05ѳlȽuf>QƊ UANƳK O:h.%5URc. 59*MJTdtv7GAON$G+ڻqOg*;hY*7hQUuP`{p|C~ IcBhVoBGN2\(#өRt/%5݆0L)X@s*}/,ٲ|$Ȃ86v3aQc38u !q:$!ӡΐIC0g $'jB F\; X}+8'+B'm7e.˽Q͞i%[hLN}C]Gu0I(Ž'Y-FJ0SY CvvV#R \bmȐ!29,dȢMbH19}ayu;J[`5bΩ:lZ#J&8QՁ6ec=͏ -JEU5 Yp"G1tvJPL A)DE !"P@ \!C a<Ǘ{!;5[%T 9idS4z6QQq7#ANL ",& ->[>_}]+(>6%zI ]{tB\]O)]Ĵ$R36&3^c˴3*;P#cL Xz6fbaKO NSTx`%d>[RyG%A@a@v{B0O6eվZwhWb~-Y3|mR[e=M:NLc*";;BRw)Ӳ-̤aqAWM1mƴ6<\lF ]r |L%$Fs2o=ݢbQXIAyxaԅH M0uN:Bs:+¾SO+U* ? 4l0' NxhgYj?A8ǹe~;֌`8ԅɔh̸-vgw_30B40L,9ma`NopEk_%ˎisiآhA I i#\Jf&DӅDؤK$wEz&5ph.&e :Y+/W+))8dH mʞ9 ڷb#!9(јT( ~ NxqN7[Xqdʀd|C AM 'eþ8Eh#R) I%Fm!"` 8N)L`iQd"'_gMgZtr.z^-u3NT.7H-N#`lȲpheK0v%HZ$ <ϧ48\ءdd\(vKhܤPjŠ_&tE {e\w`(PgiKt0k_lǟ { NQHߋ R$i-{-92M4c|c#mi!6Dsd(Ǣ$͚\]hQȖR $+ *B62Q:yyF:`cH YW6/xe""/[ߵIQihdT!±+)A["#6#{n6ʂҮRqK'%BbVSΘkՅ-X|=2v, ܙ`0Skqv`ㅃSN&&kL [- /Iz1E[d &4Yh2 SlЮbz\h"k/K]X& ?=ϝ QJE0 ) 3f]Hs#Oaj50 5w"&戦Ld#$k4Kڜ&C 5:~[AP(HLj% $F,{Fcc kʯ5u[j+NR`KJ) 2H%-L 0LC tsS`p Yy4ϸ!/UƭIBZњء$j()Ԃ%tsvsX:@vk, А@y"& Lh)d+ִ>Y$5{[(Y$Qϝ#߇0'H."H!CA 8@05.Xx1VrfE0 88 3o0nZ>mڕRfZ"bcZנA<|GԢnDcPeDLMSFQsd262)nbH(4hlc.$Qp**O=U ` n{9]$#H5oIOVHS$-IfTsͺ&"f.YZшENcb4W;۳"HL"HyVӘ S3*Z m@h-GjyJ0<8= aOR09T! $- HufI)5(z!{k7k]8k~eDT{#+~Ȕ:WC#Ef'YJQA 0>6c0(A>TMu2!Wc]=~ 9[N~,3"ioSc4źFsEEDRkL[%-qW&`[@VABºQ4vn`W0y4*v‚UyrՂPD3bN4i>vg$\ ZEvYiJ%mROQ !\ OCc2 2B9%)$UQvFR* IDATN򉬎#QLGї#O˷q~$5nL>Z8#ኰ_PWꑖ'EXg2EIDcPSԭr.dZʏSfV4R$;ф !S6:(V}"8K;Aws:AZzU yg`}VXx/0nE U$koEԬSO]vfxA EKs(Ge=hDyjR1o$6/= d7 -w{Y`rȒ `kAqhϰEs+heP$ZHИ#c.ny R~LYMq&gALf15F”[֣M26ϳtH88@ f˙uNW=b2;QaMBj?]n0 "H# x[ Ef6Z0ENA NxDؼDJ̌Vu%i>z(ȅN/qE'K]TӋ;4yD5q4wm&}˔.?@^^B$`Ϥc+죊/njt wl@iqN W=/JR," M%G(רX!d A-rVlBq-rM7Y&FvE!'HL& Acԑ4mRq#T0P+y嬬it a0~QI&-L"QplohRA#UMe`^M"L(H1@M^r+h,&n5dwaQA ̣ph0~n=dV0jEz花+63*bdNFe ٛLәb+%2/}Fˈ˴H4mgSmPW)[“^?3Y" \ ( ͭqxjZ> ,ƨ"f%2L1N24_d^r* A)OB=?+? گ),ޕI@ ,GpEt{Y [9HHF 4?n*Qt`ۉ,}`l5"I!rVq&zk};E6CuS{l4XZ-i GN{JMY}||{BSN;B8C/¬(U;*40TsK zJ:Hi8Nۅ#~}᧷| $qTj'2Q]zH R'XB\">(c۠Ymj *]/7ĭcs9/o\8F QОڹm= `c^Ej*D|\S7!H@`!@AA2vRtPrz~\`.Za*!W~↰}/m%CY t_42&o¡1̜y!|d7i|ESfMժId 9Ǥ1C,r](W8'F{EӾ>i7bA,_m9t'waMze`|v@RMuwG*W.f(@#A; ㊰>כ25NqYɻ%LfGբ|2n&+RTiRʟb^_W=MO6,&*:ͽ5QH=͝ \Rf {NuI#+zSjfe&ǎs"v ,4}꽇*J [H!Y!M5Pu!_HgH"C+ D)j">֪B>g2>[AgI!|f_uiTZ>o;8swZASh-BAu&rMZ*ʹG;X*c٫hrvKwN>1Ejg>?5ڗ:ksJvuvk Isg)3|Sm!;BIlmNؤd't8ˀ+ y5dc}ҎAxh L]>R!k2QWS$7cac4 I*?[ؕ},- *27>R XD:RpEX r;?l0y_Lq+DL1i^Mv&Kde|ͲWhgM) 3q+@0A}y]q3wT QX4.`~q":yRI&&qNݪy#8;'/ ڸ nj- iD4DE)Jô1tŢnj(0F VPȽypXeN3-Y eC Im&Q"j| bP_R6#EZ!(I&WOњV^2aB(֤ s_(':t8'F'"c A}qx/h57ˈ|c) }tMD~ c kDZ|EmL^Dž?jgRqE8 ʯsNm#ώ,ѐ*2://ZL}TzLi}|. /-0 H<\;pz&NQ)hlܧ#&#P F̋1׋>۹7򛝻OwYb̸;BDǘLі`O8UŽFF ie~cGzwEMD [}}oPBV:RqE8؆ښ#j靗?fVEճĐ=Fs84RAE,~H@-^.<1$I5-|RURS_Vdb*@"!IZ\X &!@04Fh ':;YNN4yk9qshogGFͻViѬ̐~p8mIjP+Tbp]9)l9'Ͼ-xz ;,H i%SrOi5o7?pXr򉼕Li{g "\:̜tb.1Y#993f#ݚ/!SFTHI 3C?tW [A[M߼OY姳Tɞ7k2ԣHb'4XNP?ʴ`u!0Y)\N.l#zq|h0-ع)-i*Mdov%WnkBf yLy%7'B^nma7<'Zsq̧"OPJƬ>'dpO @rɪ,QiފŽ_7}u{DF/g"Lμ$lCzlg&.墐d"D es)G͕ݟZDH*E~ }l9'#£>gE8p$XmV1AAD"REtT x֦AY>\N(1SG}*JBF-. yյCPD \ Ie&9@}dQs@zѣ2pBi3pV5|.Ii(M^xJDL)J5)w&Vٛ;yFYN5:54pVQʼrNѪZ2QqRuRvLᬙaz,1 .St\ L$'C>g(,. C^wy qPk)Ӆ"R IDLxAK# (Uk:ˏ+ByyoKㆅVaqܕV50]kA}Ԡ+KHŁwj3bJYf\:e_7L- mM/-PuAQ:>D((,2Jagy7c2Q&f3&ȽJRКB;5Q BoжD !jmx@mkvJ8xᱛWymL] z(`^GFv 0BZ QR\ac4v#tI搷0UjC5{6nRD/Ί239x翋0\Lc7g85&OԲhb5clZMP OB ]:++BǙ(l4эڭ !By1viZSk!DUEv"4Zp.*9Lw?*/˾nWN5=f!I}E7NvTVWܳ^3g⨧2X~ЕYr Z&WEm)($%yi$:++BǙ4*M[i>OUA9l^ ME̷L",H}&+ B(bYY/T+BݪWNO!cEYrz+BǙ@ÿ2YND4 0 6k8fqA07E;R"t eՕw."Aڭ"̤HȄ!YBgqE8ɑKv-.4q/#j`y/eY.X tV W3Z" MN @VPh SB(+L" 5wAhM~EZ*޸jkW3;홆XGAHe "Ǫ M Z C+]FL4qafH(P˪DJh} xQٍM:q&#_2-Hԉ,2G3HQ0{VvYA\:Τ7]E hG0DG$BP„6MBgqE8ѯ&v0Wh.]͇57 IL89ObNpE8=BpHMCT[ = [bΘqE8{8[{b7}DHtl&jb|2 -\l YY\:N?䔮BMn YіcZ0ZAhLAtC6?Wy"ȟ\c.yv v#ǠVP$ qö6{?s&Wb&gU-hT`) F8wLhP e*  "tp쟮l=ѦNE*٤DXAV h|6#aq?g#ݷVMٔj~N8QC^ͭ`^`9HA9gt8LssXRюSx99s~1w3="Z/K3{̡XUHhedGa2q熱.Y\:Nk"TQk#mՌೊ)P)@Ϊqz~1O,GU݃lLidAfqj9s9N!:HM7 ti5Rc҈g8+B/sU;H0i R'q}Xgq7#*qz1'@AU]! bD1H" @)$8 z(CS $tV7{H+>C݌iOv!1"g5pE8CgkH䎖[2exA# RPS^cL񆲰_!t'1Й󓲚 TW'.V(FsygpC82MLІIn)S{ h7ŅGZ7:CJ ladLTGl LR1SZ\xW :NBq2>mj Y! Tϐ9 Cڅm}ʾw:SgC|B$Lv @Mj$@ $98<Bq*,9eH"v&@ :E=Bq,<&rgF"O)`\' 8CYxtJ^ N+ؒE۹q-pC8b,<6 тS2Q^9h>878pC8qHPH{ V5bAR9xywg1^ƕW^~SO=ꫯ~Gs8~=ڵk͚5^x׿uyaRD>mڴ .Ǖ~k/5FYjK G?z;ޱiӦ_s5>Wǧ^ Q"63zYNfun޽{woڴiÆ [<34n/OOO#y7;;W^ysD%\v}[Bĩ)bx [ [ֹhؚ-? >Q@8+W8G\z/~t,eyއh2>{~;A׿#G⏲Qt,e3@{yD\nqȘ[++>^z(s>>|Ϭ{ 1R < 17xm޼9~;4{g뚽뛽4'hx%^ ʿ4IDAT؞t,e^:صkYgu7 7ܰ7YM4M F~ӟ^~x [oeΡC.(G0kyGYxu5Mo~lFYFn{w]xٳ]aGR֙v}E[.~_s5ţ}cU5O=ԅL> vB|;Q9{'x_|tMw}w߻w/"uYW]^nDqƍw^OD2R o|'|._$-#su==*KYg8"رcg+FFd21){%/}K!۷so䫯mCoF[n#"^qy{6>Zx'1; FǛ,iӦ‹/o}g}>QQyz{l?UΑݻw޽~w:o縌^uU8==cǎ葸뮻k=3 ~7ָl޼9~ַ6M0}1s/޷o߰椗$뮋nm۶nذᡇ_EFYȓO>~͇z(.uga{qy؞t,e;wDO}Sqd7aΘ s=wsÆ k׮+Wjj؜/޹sM7477K/tzzz۶m8=ey=CmL^MPq2y؈C'NkT&2$a`9&WǧW&OVֿ::k!/73S U`QT&!Ok2Nlr[_ T=kLL O9V:28u>y6y0d:<T|xq5nq^q5nq^q5nq^q5nq^q5nq^q5nq^q5nq^q5nq^q5nq^q5nq^q5HD>qq^q5nq^{+!IENDB`demo/documented/navier-stokes/000077500000000000000000000000001412460263600167275ustar00rootroot00000000000000demo/documented/navier-stokes/common.txt000066400000000000000000000065451412460263600207720ustar00rootroot00000000000000This demo solves the incompressible Navier-Stokes equations. It illustrates how to: * Implement a splitting method where different fields are coupled via a set of partial differential equations * Use different iterative solvers and different preconditioners for different steps of the solution process * Use time-dependent Expressions * Set boundary conditions based on geometric constraints * Perform time-stepping Equation and solution method ---------------------------- We consider the incompressible Navier-Stokes equations on a domain :math:`\Omega \subset \mathbb{R}^2`, consisting of a pair of momentum and continuity equations: .. math:: \dot{u} + \nabla u \cdot u - \nu \Delta u + \nabla p &= f, \\ \nabla \cdot u = 0. Here, :math:`u` is the unknown velocity, :math:`p` is the unknown pressure, :math:`\nu` is the kinematic viscosity, and :math:`f` is a given source. There exist many solution strategies for the incompressible Navier-Stokes equations. One of the oldest is the splitting method proposed by Chorin (1968) and Temam (1969), often refered to as Chorin's method. In Chorin's method, one first ignores the pressure in the momentum equation and computes the *tentative velocity* :math:`u_h^{\star}` according to: .. math:: \langle (u_h^{\star} - u_h^{n-1}) / \Delta t_n, v \rangle + \langle \nabla u_h^{n-1} \cdot u_h^{n-1}, v \rangle + \langle \nu \nabla u_h^{\star}, \nabla v \rangle = \langle f, v \rangle . Here, :math:`\langle \cdot, \cdot \rangle` denotes the :math:`L^2(\Omega)` inner product. Subsequently, the velocity is projected to the space of divergence free fields. This step may be obtained by subtracting the variational problem for the tentative velocity :math:`u_h^{\star}` from the incompressible Navier-Stokes equations and using the continuity equation. One obtains the following pair of equations for computing the velocity :math:`u_h^n` and pressure :math:`p_h^n` at time :math:`t = t_n` based on the tentative velocity :math:`u_h^{\star}`: .. math:: \langle \nabla p^n, \nabla q \rangle &= - \langle \nabla \cdot u_h^{\star}, q \rangle / \Delta t_n, \\ \langle u_h^n, v \rangle &= \langle u_h^{\star}, v \rangle - \Delta t_n \langle \nabla p^n, v \rangle. Problem definition ------------------ In this demo, we solve the incompressible Navier-Stokes equations on an L-shaped domain. The L-shape is the subset of the unit square obtained by removing the upper right quadrant. The flow is driven by an oscillating pressure :math:`p_{\mathrm{in}}(t) = \sin 3t` at the inflow :math:`y = 1` while the pressure is kept constant :math:`p_{\mathrm{out}} = 0` at the outflow :math:`x = 1`. At the inflow and outflow, we impose free flow ("do nothing") boundary conditions for the velocity and no-slip boundary conditions on the remaining boundary. The (kinematic) viscosity is set to :math:`\nu = 0.01`, the time step is :math:`\Delta t = 0.01` and the length of the time interval is :math:`T = 3`. The solution is computed using continuous vector-valued piecewise quadratics for the velocity, and continuous scalar piecewise linears for the pressure (the Taylor-Hood elements). With the above input the solution for the velocity :math:`u` and pressure :math:`p` will look as follows: .. image:: ../navier-stokes_u.png :scale: 75 :align: center .. image:: ../navier-stokes_p.png :scale: 75 :align: center demo/documented/navier-stokes/cpp/000077500000000000000000000000001412460263600175115ustar00rootroot00000000000000demo/documented/navier-stokes/cpp/PressureUpdate.ufl000066400000000000000000000025251412460263600232000ustar00rootroot00000000000000# Copyright (C) 2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2010-08-30 # Last changed: 2010-09-01 # # The bilinear form a(u, v) and linear form L(v) for the pressure # update step in Chorin's method for the incompressible Navier-Stokes # equations. # # Compile this form with FFC: ffc -l dolfin PressureUpdate.ufl. # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) R = FiniteElement("Real", triangle, 0) # Define trial and test functions p = TrialFunction(Q) q = TestFunction(Q) # Define coefficients k = Coefficient(R) u1 = Coefficient(V) # Define bilinear and linear forms a = inner(grad(p), grad(q))*dx L = -(1/k)*div(u1)*q*dx demo/documented/navier-stokes/cpp/TentativeVelocity.ufl000066400000000000000000000027151412460263600237100ustar00rootroot00000000000000# Copyright (C) 2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2010-08-30 # Last changed: 2011-06-30 # # The bilinear form a(u, v) and linear form L(v) for the tentative # velocity step in Chorin's method for the incompressible # Navier-Stokes equations. # # Compile this form with FFC: ffc -l dolfin TentativeVelocity.ufl. # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) R = FiniteElement("Real", triangle, 0) # Define trial and test functions u = TrialFunction(V) v = TestFunction(V) # Define coefficients k = Coefficient(R) u0 = Coefficient(V) f = Coefficient(V) nu = 0.01 # Define bilinear and linear forms eq = (1/k)*inner(u - u0, v)*dx + inner(grad(u0)*u0, v)*dx + \ nu*inner(grad(u), grad(v))*dx - inner(f, v)*dx a = lhs(eq) L = rhs(eq) demo/documented/navier-stokes/cpp/VelocityUpdate.ufl000066400000000000000000000025661412460263600231730ustar00rootroot00000000000000# Copyright (C) 2010 Anders Logg # # This file is part of DOLFIN. # # DOLFIN is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # DOLFIN is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with DOLFIN. If not, see . # # First added: 2010-08-30 # Last changed: 2010-09-01 # # The bilinear form a(u, v) and linear form L(v) for the velocity # update step in Chorin's method for the incompressible Navier-Stokes # equations. # # Compile this form with FFC: ffc -l dolfin TentativeVelocity.ufl. # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) R = FiniteElement("Real", triangle, 0) # Define trial and test functions u = TrialFunction(V) v = TestFunction(V) # Define coefficients k = Coefficient(R) u1 = Coefficient(V) p1 = Coefficient(Q) # Define bilinear and linear forms a = inner(u, v)*dx L = inner(u1, v)*dx - k*inner(grad(p1), v)*dx demo/documented/navier-stokes/cpp/documentation.rst000066400000000000000000000272071412460263600231240ustar00rootroot00000000000000.. Documentation for the incompressible Navier-Stokes demo from DOLFIN. .. _demo_pde_navier_stokes_cpp_documentation: Incompressible Navier-Stokes equations ====================================== .. include:: ../common.txt Implementation -------------- The implementation is split in four files: three form files containing the definition of the variational forms expressed in UFL and a C++ file containing the actual solver. Running this demo requires the files: :download:`main.cpp`, :download:`TentativeVelocity.ufl`, :download:`VelocityUpdate.ufl`, :download:`PressureUpdate.ufl` and :download:`CMakeLists.txt`. UFL form files ^^^^^^^^^^^^^^ The variational forms for the three steps of Chorin's method are implemented in three separate UFL form files. The variational problem for the tentative velocity is implemented as follows: .. code-block:: python # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) # Define trial and test functions u = TrialFunction(V) v = TestFunction(V) # Define coefficients k = Constant(triangle) u0 = Coefficient(V) f = Coefficient(V) nu = 0.01 # Define bilinear and linear forms eq = (1/k)*inner(u - u0, v)*dx + inner(grad(u0)*u0, v)*dx + \ nu*inner(grad(u), grad(v))*dx - inner(f, v)*dx a = lhs(eq) L = rhs(eq) The variational problem for the pressure update is implemented as follows: .. code-block:: python # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) # Define trial and test functions p = TrialFunction(Q) q = TestFunction(Q) # Define coefficients k = Constant(triangle) u1 = Coefficient(V) # Define bilinear and linear forms a = inner(grad(p), grad(q))*dx L = -(1/k)*div(u1)*q*dx The variational problem for the velocity update is implemented as follows: .. code-block:: python # Define function spaces (P2-P1) V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) # Define trial and test functions u = TrialFunction(V) v = TestFunction(V) # Define coefficients k = Constant(triangle) u1 = Coefficient(V) p1 = Coefficient(Q) # Define bilinear and linear forms a = inner(u, v)*dx L = inner(u1, v)*dx - k*inner(grad(p1), v)*dx Before the form files can be used in the C++ program, they must be compiled using FFC: .. code-block:: sh ffc -l dolfin TentativeVelocity.ufl ffc -l dolfin VelocityUpdate.ufl ffc -l dolfin PressureUpdate.ufl Note the flag ``-l dolfin`` which tells FFC to generate DOLFIN-specific wrappers that make it easy to access the generated code from within DOLFIN. C++ program ^^^^^^^^^^^ In the C++ program, :download:`main.cpp`, we start by including ``dolfin.h`` and the generated header files: .. code-block:: c++ #include #include "TentativeVelocity.h" #include "PressureUpdate.h" #include "VelocityUpdate.h" To be able to use classes and functions from the DOLFIN namespace directly, we write .. code-block:: c++ using namespace dolfin; Next, we define the subdomains that we will use to specify boundary conditions. We do this by defining subclasses of :cpp:class:`SubDomain` and overloading the function ``inside``: .. code-block:: c++ // Define noslip domain class NoslipDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return (on_boundary && (x[0] < DOLFIN_EPS || x[1] < DOLFIN_EPS || (x[0] > 0.5 - DOLFIN_EPS && x[1] > 0.5 - DOLFIN_EPS))); } }; // Define inflow domain class InflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[1] > 1.0 - DOLFIN_EPS; } }; // Define inflow domain class OutflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[0] > 1.0 - DOLFIN_EPS; } }; We also define a subclass of :cpp:class:`Expression` which we will use to specify the time-dependent boundary value for the pressure at the inflow. .. code-block:: c++ // Define pressure boundary value at inflow class InflowPressure : public Expression { public: // Constructor InflowPressure() : t(0) {} // Evaluate pressure at inflow void eval(Array& values, const Array& x) const { values[0] = sin(3.0*t); } // Current time double t; }; Note that the member variable ``t`` is not automatically updated during time-stepping, so we must remember to manually update the value of the current time in each time step. Once we have defined all classes we will use to write our program, we start our C++ program by writing .. code-block:: c++ int main() { For the parallel case, we turn off log messages from processes other than the the root process to avoid excessive output: .. code-block:: c++ // Print log messages only from the root process in parallel parameters["std_out_all_processes"] = false; We then load the mesh for the L-shaped domain from file: .. code-block:: c++ // Load mesh from file auto mesh = std::make_shared("../lshape.xml.gz"); We next define a pair of function spaces :math:`V` and :math:`Q` for the velocity and pressure, and test and trial functions on these spaces: .. code-block:: c++ // Create function spaces auto V = std::make_shared(mesh); auto Q = std::make_shared(mesh); The time step and the length of the interval are defined by: .. code-block:: c++ // Set parameter values double dt = 0.01; double T = 3; We next define the time-dependent pressure boundary value, and zero scalar and vector constants that will be used for boundary conditions below. .. code-block:: c++ // Define values for boundary conditions auto p_in = std::make_shared(); auto zero = std::make_shared(0.0); auto zero_vector = std::make_shared(0.0, 0.0); Before we can define our boundary conditions, we also need to instantiate the classes we defined above for the boundary subdomains: .. code-block:: c++ // Define subdomains for boundary conditions auto noslip_domain = std::make_shared(); auto inflow_domain = std::make_shared(); auto outflow_domain = std::make_shared() ; We may now define the boundary conditions for the velocity and pressure. We define one no-slip boundary condition for the velocity and a pair of boundary conditions for the pressure at the inflow and outflow boundaries: .. code-block:: c++ // Define boundary conditions DirichletBC noslip(V, zero_vector, noslip_domain); DirichletBC inflow(Q, p_in, inflow_domain); DirichletBC outflow(Q, zero, outflow_domain); std::vector bcu = {&noslip}; std::vector bcp = {{&inflow, &outflow}}; We collect the boundary conditions in the two arrays ``bcu`` and ``bcp`` so that we may easily iterate over them below when we apply the boundary conditions. This makes it easy to add new boundary conditions or use this demo program to solve the Navier-Stokes equations on other geometries. We next define the functions and the coefficients that will be used below: .. code-block:: c++ // Create functions auto u0 = std::make_shared(V); auto u1 = std::make_shared(V); auto p1 = std::make_shared(Q); // Create coefficients auto k = std::make_shared(dt); auto f = std::make_shared(0, 0); The next step is now to define the variational problems for the three steps of Chorin's method. We do this by instantiating the classes generated from our UFL form files: .. code-block:: c++ // Create forms TentativeVelocity::BilinearForm a1(V, V); TentativeVelocity::LinearForm L1(V); PressureUpdate::BilinearForm a2(Q, Q); PressureUpdate::LinearForm L2(Q); VelocityUpdate::BilinearForm a3(V, V); VelocityUpdate::LinearForm L3(V); Since the forms depend on coefficients, we have to attach the coefficients defined above to the appropriate forms: .. code-block:: c++ // Set coefficients a1.k = k; L1.k = k; L1.u0 = u0; L1.f = f; L2.k = k; L2.u1 = u1; L3.k = k; L3.u1 = u1; L3.p1 = p1; Since the bilinear forms do not depend on any coefficients that change during time-stepping, the corresponding matrices remain constant. We may therefore assemble these before the time-stepping begins: .. code-block:: c++ // Assemble matrices Matrix A1, A2, A3; assemble(A1, a1); assemble(A2, a2); assemble(A3, a3); // Create vectors Vector b1, b2, b3; // Use amg preconditioner if available const std::string prec(has_krylov_solver_preconditioner("amg") ? "amg" : "default"); We also created the vectors that will be used below to assemble right-hand sides. During time-stepping, we will store the solution in VTK format (readable by MayaVi and Paraview). We therefore create a pair of files that can be used to store the solution. Specifying the ``.pvd`` suffix signals that the solution should be stored in VTK format: .. code-block:: c++ // Create files for storing solution File ufile("results/velocity.pvd"); File pfile("results/pressure.pvd"); The time-stepping loop is now implemented as follows: .. code-block:: c++ // Time-stepping double t = dt; while (t < T + DOLFIN_EPS) { // Update pressure boundary condition p_in->t = t; We remember to update the current time for the time-dependent pressure boundary value. For each of the three steps of Chorin's method, we assemble the right-hand side, apply boundary conditions, and solve a linear system. Note the different use of preconditioners. Incomplete LU factorization is used for the computation of the tentative velocity and the velocity update, while algebraic multigrid is used for the pressure equation if available: .. code-block:: c++ // Compute tentative velocity step begin("Computing tentative velocity"); assemble(b1, L1); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A1, b1); solve(A1, *u1->vector(), b1, "gmres", "default"); end(); // Pressure correction begin("Computing pressure correction"); assemble(b2, L2); for (std::size_t i = 0; i < bcp.size(); i++) { bcp[i]->apply(A2, b2); bcp[i]->apply(*p1->vector()); } solve(A2, *p1->vector(), b2, "bicgstab", prec); end(); // Velocity correction begin("Computing velocity correction"); assemble(b3, L3); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A3, b3); solve(A3, *u1->vector(), b3, "gmres", "default"); end(); Note the use of ``begin`` and ``end``; these improve the readability of the output from the program by adding indentation to diagnostic messages. At the end of the time-stepping loop, we store the solution to file and update values for the next time step: .. code-block:: c++ // Save to file ufile << *u1; pfile << *p1; // Move to next time step *u0 = *u1; t += dt; return 0; } Complete code ------------- Complete UFL files ^^^^^^^^^^^^^^^^^^ .. literalinclude:: TentativeVelocity.ufl :start-after: # Compile :language: python .. literalinclude:: VelocityUpdate.ufl :start-after: # Compile :language: python .. literalinclude:: PressureUpdate.ufl :start-after: # Compile :language: python Complete main file ^^^^^^^^^^^^^^^^^^ .. literalinclude:: main.cpp :start-after: // Begin demo :language: c++ demo/documented/navier-stokes/cpp/main.cpp000066400000000000000000000121661412460263600211470ustar00rootroot00000000000000// Copyright (C) 2010-2011 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // First added: 2010-08-30 // Last changed: 2013-03-21 // // This demo program solves the incompressible Navier-Stokes equations // on an L-shaped domain using Chorin's splitting method. // Begin demo #include #include "TentativeVelocity.h" #include "PressureUpdate.h" #include "VelocityUpdate.h" using namespace dolfin; // Define noslip domain class NoslipDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return (on_boundary && (x[0] < DOLFIN_EPS || x[1] < DOLFIN_EPS || (x[0] > 0.5 - DOLFIN_EPS && x[1] > 0.5 - DOLFIN_EPS))); } }; // Define inflow domain class InflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[1] > 1.0 - DOLFIN_EPS; } }; // Define inflow domain class OutflowDomain : public SubDomain { bool inside(const Array& x, bool on_boundary) const { return x[0] > 1.0 - DOLFIN_EPS; } }; // Define pressure boundary value at inflow class InflowPressure : public Expression { public: // Constructor InflowPressure() : t(0) {} // Evaluate pressure at inflow void eval(Array& values, const Array& x) const { values[0] = sin(3.0*t); } // Current time double t; }; int main() { // Print log messages only from the root process in parallel parameters["std_out_all_processes"] = false; // Load mesh from file auto mesh = std::make_shared("../lshape.xml.gz"); // Create function spaces auto V = std::make_shared(mesh); auto Q = std::make_shared(mesh); // Set parameter values double dt = 0.01; double T = 3; // Define values for boundary conditions auto p_in = std::make_shared(); auto zero = std::make_shared(0.0); auto zero_vector = std::make_shared(0.0, 0.0); // Define subdomains for boundary conditions auto noslip_domain = std::make_shared(); auto inflow_domain = std::make_shared(); auto outflow_domain = std::make_shared() ; // Define boundary conditions DirichletBC noslip(V, zero_vector, noslip_domain); DirichletBC inflow(Q, p_in, inflow_domain); DirichletBC outflow(Q, zero, outflow_domain); std::vector bcu = {&noslip}; std::vector bcp = {{&inflow, &outflow}}; // Create functions auto u0 = std::make_shared(V); auto u1 = std::make_shared(V); auto p1 = std::make_shared(Q); // Create coefficients auto k = std::make_shared(dt); auto f = std::make_shared(0, 0); // Create forms TentativeVelocity::BilinearForm a1(V, V); TentativeVelocity::LinearForm L1(V); PressureUpdate::BilinearForm a2(Q, Q); PressureUpdate::LinearForm L2(Q); VelocityUpdate::BilinearForm a3(V, V); VelocityUpdate::LinearForm L3(V); // Set coefficients a1.k = k; L1.k = k; L1.u0 = u0; L1.f = f; L2.k = k; L2.u1 = u1; L3.k = k; L3.u1 = u1; L3.p1 = p1; // Assemble matrices Matrix A1, A2, A3; assemble(A1, a1); assemble(A2, a2); assemble(A3, a3); // Create vectors Vector b1, b2, b3; // Use amg preconditioner if available const std::string prec(has_krylov_solver_preconditioner("amg") ? "amg" : "default"); // Create files for storing solution File ufile("results/velocity.pvd"); File pfile("results/pressure.pvd"); // Time-stepping double t = dt; while (t < T + DOLFIN_EPS) { // Update pressure boundary condition p_in->t = t; // Compute tentative velocity step begin("Computing tentative velocity"); assemble(b1, L1); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A1, b1); solve(A1, *u1->vector(), b1, "gmres", "default"); end(); // Pressure correction begin("Computing pressure correction"); assemble(b2, L2); for (std::size_t i = 0; i < bcp.size(); i++) { bcp[i]->apply(A2, b2); bcp[i]->apply(*p1->vector()); } solve(A2, *p1->vector(), b2, "bicgstab", prec); end(); // Velocity correction begin("Computing velocity correction"); assemble(b3, L3); for (std::size_t i = 0; i < bcu.size(); i++) bcu[i]->apply(A3, b3); solve(A3, *u1->vector(), b3, "gmres", "default"); end(); // Save to file ufile << *u1; pfile << *p1; // Move to next time step *u0 = *u1; t += dt; cout << "t = " << t << endl; } return 0; } demo/documented/navier-stokes/lshape.xml.gz000066400000000000000000000065341412460263600213540ustar00rootroot00000000000000"JQKn0=o?" T` [b"dz-q]CYQQ}ݩoзGߑIwz~i8^ey݊~(멜GK]9]ێkx_ݩu&6`{7N F˜ܽY"=(2CxQ'&5*9tpBR:Pv4F?`LnW f+B'~ځCea1e"^R,SF#WK+$ ,KkyE&8TG;8Fܾ8XoC8cwQOg50 h 0oIuL)CS%gcu>棣f@Ȉ?EajKmcw p0/:(cX.>%hH:.y[*֣Hֳ=_њښ;z !LbzX hJ͇5"P}҆x1۬%oV93&!@=8O-!5ɏ\GPE{KvPVD//@HH݃j0-M)\Nd. )-uMvC]8i LuP{IM³zD3Y/ŃM7w+a'קʜ@_7P>Ur"A &H)dHJAaDkn6 t nዔ  !Cfp[cIQ u;N5Zl0Gn,[D%( @p A0,C|)+T)؂uҡ5DP@w1td(wc||;me<=Rr5Ebžl[ \n) 9pCTۿbtY#ywj-SjziЉv92TPhl)| w}#cll\Z0f.90=RcC0Hs>PTEdœ#סT9C[FlgzH( zGoF\^OirH11z3NG0 5ܽ%qNEaeMԤ-2QfCNzNwUWE/]G(6{m, ikZyWN+U⫧yDd"e"# R#D'dX7+cPL1F c" D" eY)4@mB #θocI{aFdg}NA 4 `6a d*hvNe*'`iLq<3 kp8^@* 䂠JȢzPdK]1/A +%|rUj푘Z9"8D}YSYYWQZT#j݈TG "H@#[& PG*(7Q,K(~>{埀.26딙aWj1UʞkrOW=ʲ)kںz _E.h` h?eTC`TV*6H# S\j] b+1YX#5Q0zA;Z (RUJo ڪ}Dzwyu đ5N!HC (\Mm ETԮz8^}G/G851k;r a-~Xr9D">4.FITGmb^ A-R\~k2 &%b]5Pkkr `/+ x/fgX޹D`Flp\E B?*:9\d'9}ۗ2αWbe٬v/{whH$]5 p{*l Ig#A&#μ%1/,fzw˪X&;Įk*YKuYٮ ^f~Dcb_*0_aKc)OmlX"YN|;^X]:Ye k:QvN~*weW3 Ch);n4 kg=K F )ZBw/5@쉥1ζ$2&p-diMro /ɮrW"帝dK&&B9Z01~Ц6"s:Dn-D,E7ޤRdhQ##Ѯn:@jh_Om|f1+5Vlc't5*^*{$hpCu%Oٿ"d/#(+&ř@8J}@A #~Fty52RgM$!5m lF`u\b@L|/ J-m #CG'ii<ڸb2RՑ^ǑuLk@cdԢ.)Ma{aehk2~@vR6QZ9=-;䧏9SnqrEOaebh-HH*f03_l?{ NSj?/u+I2Rw2eT:gFCT7/%HˢQgJd8k a['Po5Af&Ör߸2:CXe$ :CJwzGsIu[d#8CX+ۙ3әm-'D$:oԲOdA^pʂ%d Z"LWϐu4|$-#uDxvlv분9}{JކeA\;KDij5'*kKز5 ? ®|]=Ldemo/documented/navier-stokes/navier-stokes_p.png000066400000000000000000000703161412460263600225550ustar00rootroot00000000000000PNG  IHDRXW IDATxylU{%U f1 $F3Ɇ4 X2H!#j/6n1IH BHH Bjx7c{w|?.Yq<7)#I$Ir,7$IfB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB$I4)I$AB${ITHۄ/eR;$I1;$Uo<ݟ`ĿJۛy[ItIr~m3˸1$H!L]o d_@}L!L[ &I׿”o|l?R>_ &-C:$+<c %^ "9et^Z$)! I &S%3f0In-R^=mSMny@H4 A"O)\3I='0=yWYy'/`!_,#i&t2""^6ދ2$)mk!L~7-"ZoqHZv$In R[]ʷSᄏrY%GD`", U6y=2Ir BJ6'+>QQ[hPhB~/`yI#)^j-r2S}*8Z@RdJ0)jRqiU^fY0$)~m,rI|4<*;TscNRb ZhV&-D arnjMțښ #ONQw5UN!(PkDGڣ_=I 0yl6 62F ?Ni