From fd9129cbc094e284bdda88fd2dff7bf31de89b4e Mon Sep 17 00:00:00 2001 From: Luca Geretti Date: Sat, 6 Oct 2018 20:10:58 +0200 Subject: [PATCH 1/8] Update README to use the new repository name, add some extra compatibility info --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 688b3c39a..60c39f89f 100644 --- a/README.md +++ b/README.md @@ -2,16 +2,16 @@ # Ariadne Ariadne -[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![Build Status](https://travis-ci.org/ariadne-cps/development.svg?branch=master)](https://travis-ci.org/ariadne-cps/development) [![codecov](https://codecov.io/gh/ariadne-cps/development/branch/master/graph/badge.svg)](https://codecov.io/gh/ariadne-cps/development) +[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![Build Status](https://travis-ci.org/ariadne-cps/ariadne.svg?branch=master)](https://travis-ci.org/ariadne-cps/ariadne) [![codecov](https://codecov.io/gh/ariadne-cps/ariadne/branch/master/graph/badge.svg)](https://codecov.io/gh/ariadne-cps/ariadne) Ariadne is a tool for reachability analysis and model checking of hybrid systems. Additionally, it is a framework for rigorous computation featuring arithmetic, linear algebra, calculus, geometry, algebraic and differential equations, and optimization solvers. * This repository contains the main development fork of the tool. For a more stable version with a less sophisticated user interface, see the *release-1.0* repository. -* The latest stable tagged version is internal_release-1.9.0. However, the code in the master branch should always be usable. +* The latest internal release is [v1.9.0](https://github.com/ariadne-cps/ariadne/releases/tag/v1.9.0). However, the code in the master branch should always be usable. ### Installation ### -These installation instructions have been tested on Ubuntu 18.04 and macOS 10.13. +The installation instructions are presented for Ubuntu 18.04 and macOS 10.14 only. However, openSUSE Tumbleweed and Fedora 29 are known to be working when using their package managers. Windows installations are not supported yet. For the Ubuntu installation, we will refer to packages available on Aptitude. The macOS installation instead will assume you are using the Brew package manager. @@ -116,7 +116,7 @@ Due to limitations of the C++ standard library on macOS since C++11, you won't b ### Contribution guidelines ### -* If you would like to contribute to Ariadne, please contact the developers. We are especially interested to hear how the documentation and user interface could be improved. +If you would like to contribute to Ariadne, please contact the developers. We are especially interested to hear how the documentation and user interface could be improved. * Pieter Collins * Luca Geretti From 3f83b0d8eb5df82d28537e5dcfdea7f56ef33645 Mon Sep 17 00:00:00 2001 From: Luca Geretti Date: Sun, 7 Oct 2018 16:01:32 +0200 Subject: [PATCH 2/8] Clean up of code coverage configuration to exclude tests/ directory --- .codecov.yml | 30 ++++ CMakeLists.txt | 11 +- cmake/CodeCoverage.cmake | 303 --------------------------------- python/CMakeLists.txt | 10 +- python/source/CMakeLists.txt | 11 +- source/algebra/CMakeLists.txt | 4 + source/dynamics/CMakeLists.txt | 4 + source/function/CMakeLists.txt | 4 + source/geometry/CMakeLists.txt | 4 + source/hybrid/CMakeLists.txt | 4 + source/numeric/CMakeLists.txt | 4 + source/output/CMakeLists.txt | 4 + source/solvers/CMakeLists.txt | 4 + source/symbolic/CMakeLists.txt | 4 + source/utility/CMakeLists.txt | 4 + tests/algebra/CMakeLists.txt | 3 + tests/dynamics/CMakeLists.txt | 3 + tests/function/CMakeLists.txt | 3 + tests/geometry/CMakeLists.txt | 3 + tests/hybrid/CMakeLists.txt | 3 + tests/numeric/CMakeLists.txt | 3 + tests/output/CMakeLists.txt | 3 + tests/solvers/CMakeLists.txt | 3 + tests/symbolic/CMakeLists.txt | 3 + 24 files changed, 121 insertions(+), 311 deletions(-) create mode 100644 .codecov.yml delete mode 100755 cmake/CodeCoverage.cmake diff --git a/.codecov.yml b/.codecov.yml new file mode 100644 index 000000000..424cb7221 --- /dev/null +++ b/.codecov.yml @@ -0,0 +1,30 @@ +codecov: + notify: + require_ci_to_pass: yes + +coverage: + precision: 2 + round: down + range: "60...100" + + status: + project: yes + patch: yes + changes: no + +parsers: + gcov: + branch_detection: + conditional: yes + loop: yes + method: no + macro: no + +comment: + layout: "header, diff" + behavior: default + require_changes: no + +ignore: + - "tests" + - "tests/**/*" \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 93c306bdb..9122ea5f3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,10 +33,7 @@ if(NOT CMAKE_BUILD_TYPE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1") endif() -if(COVERAGE) - include(CodeCoverage) - APPEND_COVERAGE_COMPILER_FLAGS() -endif() +set(COVERAGE_COMPILER_FLAGS -O0 --coverage -fprofile-arcs -ftest-coverage) enable_testing() include(CTest) @@ -165,6 +162,12 @@ add_library(ariadne SHARED $ ) +if(COVERAGE) + target_link_libraries(ariadne gcov) + target_link_libraries(ariadne-kernel gcov) + target_link_libraries(ariadne-core gcov) +endif() + target_link_libraries(ariadne dl) target_link_libraries(ariadne-kernel dl) target_link_libraries(ariadne-core dl) diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake deleted file mode 100755 index f5db2e898..000000000 --- a/cmake/CodeCoverage.cmake +++ /dev/null @@ -1,303 +0,0 @@ -# Copyright (c) 2012 - 2017, Lars Bilke -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without modification, -# are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright notice, this -# list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright notice, -# this list of conditions and the following disclaimer in the documentation -# and/or other materials provided with the distribution. -# -# 3. Neither the name of the copyright holder nor the names of its contributors -# may be used to endorse or promote products derived from this software without -# specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# -# CHANGES: -# -# 2012-01-31, Lars Bilke -# - Enable Code Coverage -# -# 2013-09-17, Joakim Söderberg -# - Added support for Clang. -# - Some additional usage instructions. -# -# 2016-02-03, Lars Bilke -# - Refactored functions to use named parameters -# -# 2017-06-02, Lars Bilke -# - Merged with modified version from github.com/ufz/ogs -# -# -# USAGE: -# -# 1. Copy this file into your cmake modules path. -# -# 2. Add the following line to your CMakeLists.txt: -# include(CodeCoverage) -# -# 3. Append necessary compiler flags: -# APPEND_COVERAGE_COMPILER_FLAGS() -# -# 4. If you need to exclude additional directories from the report, specify them -# using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV. -# Example: -# set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*') -# -# 5. Use the functions described below to create a custom make target which -# runs your test executable and produces a code coverage report. -# -# 6. Build a Debug build: -# cmake -DCMAKE_BUILD_TYPE=Debug .. -# make -# make my_coverage_target -# - -include(CMakeParseArguments) - -# Check prereqs -find_program( GCOV_PATH gcov ) -find_program( LCOV_PATH NAMES lcov lcov.bat lcov.exe lcov.perl) -find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat ) -find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test) -find_program( SIMPLE_PYTHON_EXECUTABLE python ) - -if(NOT GCOV_PATH) - message(FATAL_ERROR "gcov not found! Aborting...") -endif() # NOT GCOV_PATH - -if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") - if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3) - message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") - endif() -elseif(NOT CMAKE_COMPILER_IS_GNUCXX) - message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") -endif() - -set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage" - CACHE INTERNAL "") - -set(CMAKE_CXX_FLAGS_COVERAGE - ${COVERAGE_COMPILER_FLAGS} - CACHE STRING "Flags used by the C++ compiler during coverage builds." - FORCE ) -set(CMAKE_C_FLAGS_COVERAGE - ${COVERAGE_COMPILER_FLAGS} - CACHE STRING "Flags used by the C compiler during coverage builds." - FORCE ) -set(CMAKE_EXE_LINKER_FLAGS_COVERAGE - "" - CACHE STRING "Flags used for linking binaries during coverage builds." - FORCE ) -set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE - "" - CACHE STRING "Flags used by the shared libraries linker during coverage builds." - FORCE ) -mark_as_advanced( - CMAKE_CXX_FLAGS_COVERAGE - CMAKE_C_FLAGS_COVERAGE - CMAKE_EXE_LINKER_FLAGS_COVERAGE - CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) - -if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") - message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading") -endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug" - -if(CMAKE_C_COMPILER_ID STREQUAL "GNU") - link_libraries(gcov) -else() - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") -endif() - -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# SETUP_TARGET_FOR_COVERAGE_LCOV( -# NAME testrunner_coverage # New target name -# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES testrunner # Dependencies to build first -# ) -function(SETUP_TARGET_FOR_COVERAGE_LCOV) - - set(options NONE) - set(oneValueArgs NAME) - set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT LCOV_PATH) - message(FATAL_ERROR "lcov not found! Aborting...") - endif() # NOT LCOV_PATH - - if(NOT GENHTML_PATH) - message(FATAL_ERROR "genhtml not found! Aborting...") - endif() # NOT GENHTML_PATH - - # Setup target - add_custom_target(${Coverage_NAME} - - # Cleanup lcov - COMMAND ${LCOV_PATH} --compat-libtool -directory . --zerocounters - # Create baseline to make sure untouched files show up in the report - COMMAND ${LCOV_PATH} --compat-libtool -c -i -d . -o ${Coverage_NAME}.base - - # Run tests - COMMAND ${Coverage_EXECUTABLE} - - # Capturing lcov counters and generating report - COMMAND ${LCOV_PATH} --compat-libtool --rc lcov_branch_coverage=1 --directory . --capture --output-file ${Coverage_NAME}.info - # add baseline counters - COMMAND ${LCOV_PATH} --compat-libtool -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --rc lcov_branch_coverage=1 --output-file ${Coverage_NAME}.total - COMMAND ${LCOV_PATH} --compat-libtool --rc lcov_branch_coverage=1 --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned - COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} --rc lcov_branch_coverage=1 ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned - COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total - - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." - ) - - # Show where to find the lcov info report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." - ) - -endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV - -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML( -# NAME ctest_coverage # New target name -# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES executable_target # Dependencies to build first -# ) -function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML) - - set(options NONE) - set(oneValueArgs NAME) - set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT SIMPLE_PYTHON_EXECUTABLE) - message(FATAL_ERROR "python not found! Aborting...") - endif() # NOT SIMPLE_PYTHON_EXECUTABLE - - if(NOT GCOVR_PATH) - message(FATAL_ERROR "gcovr not found! Aborting...") - endif() # NOT GCOVR_PATH - - # Combine excludes to several -e arguments - set(GCOVR_EXCLUDES "") - foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES}) - list(APPEND GCOVR_EXCLUDES "-e") - list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") - endforeach() - - add_custom_target(${Coverage_NAME} - # Run tests - ${Coverage_EXECUTABLE} - - # Running gcovr - COMMAND ${GCOVR_PATH} --xml - -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES} - --object-directory=${PROJECT_BINARY_DIR} - -o ${Coverage_NAME}.xml - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - COMMENT "Running gcovr to produce Cobertura code coverage report." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml." - ) - -endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML - -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML( -# NAME ctest_coverage # New target name -# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES executable_target # Dependencies to build first -# ) -function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML) - - set(options NONE) - set(oneValueArgs NAME) - set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT SIMPLE_PYTHON_EXECUTABLE) - message(FATAL_ERROR "python not found! Aborting...") - endif() # NOT SIMPLE_PYTHON_EXECUTABLE - - if(NOT GCOVR_PATH) - message(FATAL_ERROR "gcovr not found! Aborting...") - endif() # NOT GCOVR_PATH - - # Combine excludes to several -e arguments - set(GCOVR_EXCLUDES "") - foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES}) - list(APPEND GCOVR_EXCLUDES "-e") - list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") - endforeach() - - add_custom_target(${Coverage_NAME} - # Run tests - ${Coverage_EXECUTABLE} - - # Create folder - COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME} - - # Running gcovr - COMMAND ${GCOVR_PATH} --html --html-details - -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES} - --object-directory=${PROJECT_BINARY_DIR} - -o ${Coverage_NAME}/index.html - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - COMMENT "Running gcovr to produce HTML code coverage report." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." - ) - -endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML - -function(APPEND_COVERAGE_COMPILER_FLAGS) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) - message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}") -endfunction() # APPEND_COVERAGE_COMPILER_FLAGS diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index d939e56d5..ae6e3b34f 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -1,5 +1,9 @@ add_subdirectory(source) +if(COVERAGE) + set(GCOV_LIBRARIES gcov) +endif() + add_library(pyariadne MODULE $ $ @@ -7,7 +11,7 @@ add_library(pyariadne MODULE $ ) set_target_properties(pyariadne PROPERTIES PREFIX "" OUTPUT_NAME "ariadne" SUFFIX ".so") -target_link_libraries (pyariadne PUBLIC ariadne PRIVATE pybind11::module) +target_link_libraries (pyariadne PUBLIC ariadne ${GCOV_LIBRARIES} PRIVATE pybind11::module) add_library(pyariadne-numeric MODULE $ @@ -16,7 +20,7 @@ add_library(pyariadne-numeric MODULE $ ) set_target_properties(pyariadne-numeric PROPERTIES PREFIX "" OUTPUT_NAME "numeric" SUFFIX ".so") -target_link_libraries (pyariadne-numeric PUBLIC ${MPFR_LIBRARIES} ${GMP_LIBRARIES} PRIVATE pybind11::module) +target_link_libraries (pyariadne-numeric PUBLIC ${GCOV_LIBRARIES} ${MPFR_LIBRARIES} ${GMP_LIBRARIES} PRIVATE pybind11::module) add_library(pyariadne-algebra MODULE $ @@ -24,7 +28,7 @@ add_library(pyariadne-algebra MODULE $ ) set_target_properties(pyariadne-algebra PROPERTIES PREFIX "" OUTPUT_NAME "algebra" SUFFIX ".so") -target_link_libraries (pyariadne-algebra PUBLIC ariadne PRIVATE pybind11::module) +target_link_libraries (pyariadne-algebra PUBLIC ${GCOV_LIBRARIES} ariadne PRIVATE pybind11::module) execute_process(COMMAND ${PYTHON_EXECUTABLE} -m site --user-site OUTPUT_VARIABLE PYARIADNE_INSTALL_DIR) string(STRIP ${PYARIADNE_INSTALL_DIR} PYARIADNE_INSTALL_DIR) diff --git a/python/source/CMakeLists.txt b/python/source/CMakeLists.txt index 0e6ca31e9..8fa744562 100644 --- a/python/source/CMakeLists.txt +++ b/python/source/CMakeLists.txt @@ -40,4 +40,13 @@ add_library(pyariadne-module-obj OBJECT cotire(pyariadne-numeric-submodule-obj CONFIGURATIONS None) cotire(pyariadne-algebra-submodule-obj CONFIGURATIONS None) -cotire(pyariadne-extra-submodule-obj CONFIGURATIONS None) \ No newline at end of file +cotire(pyariadne-extra-submodule-obj CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(pyariadne-numeric-submodule-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(pyariadne-numeric-module-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(pyariadne-algebra-submodule-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(pyariadne-algebra-module-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(pyariadne-extra-submodule-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(pyariadne-module-obj PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/source/algebra/CMakeLists.txt b/source/algebra/CMakeLists.txt index 5de3fb7fb..acbc05e01 100644 --- a/source/algebra/CMakeLists.txt +++ b/source/algebra/CMakeLists.txt @@ -9,3 +9,7 @@ add_library(ariadne-algebra OBJECT ) cotire(ariadne-algebra CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-algebra PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/source/dynamics/CMakeLists.txt b/source/dynamics/CMakeLists.txt index 50bef713f..2d7048be6 100644 --- a/source/dynamics/CMakeLists.txt +++ b/source/dynamics/CMakeLists.txt @@ -7,3 +7,7 @@ add_library(ariadne-dynamics OBJECT ) cotire(ariadne-dynamics CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-dynamics PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/source/function/CMakeLists.txt b/source/function/CMakeLists.txt index 123f623ac..d0b792d4a 100644 --- a/source/function/CMakeLists.txt +++ b/source/function/CMakeLists.txt @@ -11,3 +11,7 @@ add_library(ariadne-function OBJECT ) cotire(ariadne-function CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-function PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/source/geometry/CMakeLists.txt b/source/geometry/CMakeLists.txt index 553beb3b5..1338cff5a 100644 --- a/source/geometry/CMakeLists.txt +++ b/source/geometry/CMakeLists.txt @@ -13,3 +13,7 @@ add_library(ariadne-geometry OBJECT ) cotire(ariadne-geometry CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-geometry PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() diff --git a/source/hybrid/CMakeLists.txt b/source/hybrid/CMakeLists.txt index 902297f2f..760f9068b 100644 --- a/source/hybrid/CMakeLists.txt +++ b/source/hybrid/CMakeLists.txt @@ -13,3 +13,7 @@ add_library(ariadne-hybrid OBJECT ) cotire(ariadne-hybrid CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-hybrid PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() diff --git a/source/numeric/CMakeLists.txt b/source/numeric/CMakeLists.txt index 4a498c869..39af04642 100644 --- a/source/numeric/CMakeLists.txt +++ b/source/numeric/CMakeLists.txt @@ -13,3 +13,7 @@ add_library(ariadne-numeric OBJECT ) cotire(ariadne-numeric CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-numeric PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() diff --git a/source/output/CMakeLists.txt b/source/output/CMakeLists.txt index 7087d18d2..fed5ab453 100644 --- a/source/output/CMakeLists.txt +++ b/source/output/CMakeLists.txt @@ -9,3 +9,7 @@ if(NOT GTK2_FOUND) else() message(STATUS "cotire disabled for the output module due to conflicts with the GTK2 library.") endif() + +if(COVERAGE) + target_compile_options(ariadne-output PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() diff --git a/source/solvers/CMakeLists.txt b/source/solvers/CMakeLists.txt index 687a87039..59cd8e329 100644 --- a/source/solvers/CMakeLists.txt +++ b/source/solvers/CMakeLists.txt @@ -9,3 +9,7 @@ add_library(ariadne-solvers OBJECT ) cotire(ariadne-solvers CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-solvers PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/source/symbolic/CMakeLists.txt b/source/symbolic/CMakeLists.txt index 0a2935176..ab616d6f0 100644 --- a/source/symbolic/CMakeLists.txt +++ b/source/symbolic/CMakeLists.txt @@ -5,3 +5,7 @@ add_library(ariadne-symbolic OBJECT ) cotire(ariadne-symbolic CONFIGURATIONS None) + +if(COVERAGE) + target_compile_options(ariadne-symbolic PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() diff --git a/source/utility/CMakeLists.txt b/source/utility/CMakeLists.txt index d0345ffaa..43d62c1ff 100644 --- a/source/utility/CMakeLists.txt +++ b/source/utility/CMakeLists.txt @@ -1,3 +1,7 @@ add_library(ariadne-utility OBJECT utility.cpp ) + +if(COVERAGE) + target_compile_options(ariadne-utility PUBLIC ${COVERAGE_COMPILER_FLAGS}) +endif() \ No newline at end of file diff --git a/tests/algebra/CMakeLists.txt b/tests/algebra/CMakeLists.txt index 743c5a20f..967e6fe5d 100644 --- a/tests/algebra/CMakeLists.txt +++ b/tests/algebra/CMakeLists.txt @@ -9,6 +9,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-core) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "algebra;primary;core;kernel") diff --git a/tests/dynamics/CMakeLists.txt b/tests/dynamics/CMakeLists.txt index 639b14851..653b90f8a 100644 --- a/tests/dynamics/CMakeLists.txt +++ b/tests/dynamics/CMakeLists.txt @@ -7,6 +7,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "dynamics;primary") diff --git a/tests/function/CMakeLists.txt b/tests/function/CMakeLists.txt index f9fb94faf..4845690d7 100644 --- a/tests/function/CMakeLists.txt +++ b/tests/function/CMakeLists.txt @@ -8,6 +8,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-kernel) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "function;primary;kernel") diff --git a/tests/geometry/CMakeLists.txt b/tests/geometry/CMakeLists.txt index 24e55ac54..d726f898d 100644 --- a/tests/geometry/CMakeLists.txt +++ b/tests/geometry/CMakeLists.txt @@ -10,6 +10,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-kernel) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "geometry;primary;kernel") diff --git a/tests/hybrid/CMakeLists.txt b/tests/hybrid/CMakeLists.txt index 66adc827b..81992eb3e 100644 --- a/tests/hybrid/CMakeLists.txt +++ b/tests/hybrid/CMakeLists.txt @@ -11,6 +11,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "hybrid;primary") diff --git a/tests/numeric/CMakeLists.txt b/tests/numeric/CMakeLists.txt index 3237875fc..ed99b3058 100644 --- a/tests/numeric/CMakeLists.txt +++ b/tests/numeric/CMakeLists.txt @@ -12,6 +12,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-core) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "numeric;primary;core;kernel") diff --git a/tests/output/CMakeLists.txt b/tests/output/CMakeLists.txt index fd7bc54f0..63d314dfa 100644 --- a/tests/output/CMakeLists.txt +++ b/tests/output/CMakeLists.txt @@ -4,6 +4,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() add_test(${TEST} ${TEST}) target_link_libraries(${TEST} ariadne-kernel) set_property(TEST ${TEST} PROPERTY LABELS "output;primary;kernel") diff --git a/tests/solvers/CMakeLists.txt b/tests/solvers/CMakeLists.txt index ee22943c1..26499c6d0 100644 --- a/tests/solvers/CMakeLists.txt +++ b/tests/solvers/CMakeLists.txt @@ -8,6 +8,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-kernel) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "solvers;primary;kernel") diff --git a/tests/symbolic/CMakeLists.txt b/tests/symbolic/CMakeLists.txt index 64da216ea..08ece33cf 100644 --- a/tests/symbolic/CMakeLists.txt +++ b/tests/symbolic/CMakeLists.txt @@ -4,6 +4,9 @@ set(UNIT_TESTS foreach(TEST ${UNIT_TESTS}) add_executable(${TEST} ${TEST}.cpp) + if(COVERAGE) + target_compile_options(${TEST} PUBLIC ${COVERAGE_COMPILER_FLAGS}) + endif() target_link_libraries(${TEST} ariadne-kernel) add_test(${TEST} ${TEST}) set_property(TEST ${TEST} PROPERTY LABELS "symbolic;primary;kernel") From d2a0aa5ef91e34e40334eab037aa406c0e5bb58c Mon Sep 17 00:00:00 2001 From: pietercollins Date: Tue, 9 Oct 2018 12:43:41 +0200 Subject: [PATCH 3/8] Moved templated expression code to expression.tpl.hpp. (#265) Minor cleanup of symbolic module. --- source/symbolic/assignment.hpp | 12 - source/symbolic/constant.hpp | 2 + source/symbolic/expression.cpp | 490 +---------------------------- source/symbolic/expression.hpp | 49 +-- source/symbolic/expression.tpl.hpp | 476 ++++++++++++++++++++++++++++ source/symbolic/operations.hpp | 18 -- source/symbolic/variables.hpp | 4 - 7 files changed, 514 insertions(+), 537 deletions(-) create mode 100644 source/symbolic/expression.tpl.hpp diff --git a/source/symbolic/assignment.hpp b/source/symbolic/assignment.hpp index a6f532278..82e1479d0 100644 --- a/source/symbolic/assignment.hpp +++ b/source/symbolic/assignment.hpp @@ -109,26 +109,14 @@ Variable::operator=(const T& val) const { template inline Assignment,Expression> LetVariable::operator=(const Expression& expr) const { return Assignment,Expression>(this->base(),Expression(expr)); } -template inline Assignment,Expression> -LetVariable::operator=(const Variable& var) const { - return this->operator=(Expression(var)); } -template inline Assignment,Expression> -LetVariable::operator=(const T& cnst) const { - return this->operator=(Expression(cnst)); } template inline Assignment,Expression> PrimedVariable::operator=(const Expression& expr) const { return Assignment,Expression>(*this,Expression(expr)); } -template inline Assignment,Expression> -PrimedVariable::operator=(const T& cnst) const { - return this->operator=(Expression(cnst)); } template inline Assignment,Expression> DottedVariable::operator=(const Expression& expr) const { return Assignment,Expression>(*this,expr); } -template inline Assignment,Expression> -DottedVariable::operator=(const T& cnst) const { - return this->operator=(Expression(cnst)); } template inline List,Expression>> LetVariables::operator=(const List>& rhs) { return elementwise([](Variableconst&l,Expressionconst&r){return let(l)=r;},this->_lhs,rhs); diff --git a/source/symbolic/constant.hpp b/source/symbolic/constant.hpp index 6de8b47a2..2455f7792 100644 --- a/source/symbolic/constant.hpp +++ b/source/symbolic/constant.hpp @@ -48,6 +48,8 @@ template class Constant explicit Constant(const String& str, const T& value) : T(value), _name(str) { } const Identifier& name() const { return _name; } const T& value() const { return *this; } + friend OutputStream& operator<<(OutputStream& os, Constant const& c) { + return os << c._name << "(=" << static_cast(c) << ")"; } private: Identifier _name; }; diff --git a/source/symbolic/expression.cpp b/source/symbolic/expression.cpp index ccb9f047d..8851de8b0 100644 --- a/source/symbolic/expression.cpp +++ b/source/symbolic/expression.cpp @@ -25,7 +25,6 @@ #include "../utility/standard.hpp" #include "../config.hpp" -#include "../numeric/operators.tpl.hpp" #include "../algebra/algebra.hpp" #include "../algebra/algebra_wrapper.hpp" @@ -39,17 +38,9 @@ #include "../function/formula.hpp" -namespace Ariadne { - -template -struct ExpressionNode { - mutable Nat count; - Operator op; - virtual ~ExpressionNode() = default; - explicit ExpressionNode(const Operator& o) : count(0u), op(o) { } - explicit ExpressionNode(OperatorCode cd, OperatorKind knd) : count(0u), op(cd,knd) { } -}; +#include "expression.tpl.hpp" +namespace Ariadne { template<> class SymbolicAlgebraWrapper,Real> @@ -125,138 +116,6 @@ Expression::operator Algebra() const { } -template struct ConstantExpressionNode : public ExpressionNode { - T val; - ConstantExpressionNode(const T& v) : ExpressionNode(OperatorCode::CNST,OperatorKind::NULLARY), val(v) { } -}; -template struct VariableExpressionNode : public ExpressionNode { - Identifier var; - VariableExpressionNode(const Identifier& v) : ExpressionNode(OperatorCode::VAR,OperatorKind::VARIABLE), var(v) { } -}; -template struct UnaryExpressionNode : public ExpressionNode { - Expression arg; - UnaryExpressionNode(const Operator& oper, Expression const& a) - : ExpressionNode(oper), arg(a) { } -}; -template struct BinaryExpressionNode : public ExpressionNode { - Expression arg1; Expression arg2; -}; -template struct BinaryExpressionNode : public ExpressionNode { - Expression arg1; Expression arg2; - BinaryExpressionNode(const Operator& oper, Expression const& a1, Expression const& a2) - : ExpressionNode(oper), arg1(a1), arg2(a2) { } -}; -template struct BinaryExpressionNode::Type,T,T> : public ExpressionNode::Type> { - typedef typename Logic::Type R; typedef T A; - Expression arg1; Expression arg2; - BinaryExpressionNode(const Operator& oper, Expression const& a1, Expression const& a2) - : ExpressionNode(oper), arg1(a1), arg2(a2) { } -}; -template struct ScalarExpressionNode : public UnaryExpressionNode { - N num; - ScalarExpressionNode(const Operator& oper, Expression const& a, N n) - : UnaryExpressionNode(oper,a), num(n) { } -}; - -template inline OutputStream& operator<<(OutputStream& os, const ExpressionNode* e) { - return os << (const Void*)(e); -} - - -template Expression::Expression() : _root(new ConstantExpressionNode(T())) { } -template Expression::Expression(const T& c): _root(new ConstantExpressionNode(c)) { } -template Expression::Expression(const Constant& c): _root(new ConstantExpressionNode(c.value())) { } -template Expression::Expression(const Variable& v) : _root(new VariableExpressionNode(v.name())) { } -template Expression Expression::constant(const T& c) { - return Expression(SharedPointer>(new ConstantExpressionNode(c))); } -template Expression Expression::variable(const Identifier& v) { - return Expression(SharedPointer>(new VariableExpressionNode(v))); } - -template const Operator& Expression::op() const { - return node_ptr()->op; } -template OperatorCode Expression::code() const { - return node_ptr()->op.code(); } -template OperatorKind Expression::kind() const { - return node_ptr()->op.kind(); } -template const T& Expression::val() const { - return static_cast*>(node_raw_ptr())->val; } -template const Identifier& Expression::var() const { - return static_cast*>(node_raw_ptr())->var; } -template const Expression& Expression::arg() const { - return static_cast*>(node_raw_ptr())->arg; } -template const Int& Expression::num() const { - return static_cast*>(node_raw_ptr())->num; } -template const Expression& Expression::arg1() const { - return static_cast*>(node_raw_ptr())->arg1; } -template const Expression& Expression::arg2() const { - return static_cast*>(node_raw_ptr())->arg2; } -template template const Expression& Expression::cmp1(A*) const { - return static_cast*>(node_raw_ptr())->arg1; } -template template const Expression& Expression::cmp2(A*) const { - return static_cast*>(node_raw_ptr())->arg2; } - -template Set Expression::arguments() const { - const Expression& e=*this; - switch(e.kind()) { - case OperatorKind::VARIABLE: return Set{Variable(e.var())}; - case OperatorKind::NULLARY: return Set(); - case OperatorKind::UNARY: return e.arg().arguments(); - case OperatorKind::BINARY: return join(e.arg1().arguments(),e.arg2().arguments()); - case OperatorKind::COMPARISON: { - const BinaryExpressionNode* rlp = dynamic_cast*>(e.node_raw_ptr()); - if(rlp) { return join(rlp->arg1.arguments(),rlp->arg2.arguments()); } - const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); - if(strp) { return join(strp->arg1.arguments(),strp->arg2.arguments()); } - [[fallthrough]]; - } - default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { - ARIADNE_FAIL_MSG("Comparison must return a logical type."); } -template<> inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { - Real* real_ptr=0; return os << "(" << f.cmp1(real_ptr) << symbol(f.op()) << f.cmp2(real_ptr) << ")"; } -template<> inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { - String* string_ptr=0; return os << "(" << f.cmp1(string_ptr) << symbol(f.op()) << f.cmp2(string_ptr) << ")"; } -//FIXME: Distinguish String and Integer comparisons - -template OutputStream& Expression::_write(OutputStream& os) const { - const Expression& f=*this; - switch(f.op()) { - case OperatorCode::CNST: - os << f.val(); return os; - case OperatorCode::VAR: - return os << f.var(); - case OperatorCode::ADD: - return os << f.arg1() << '+' << f.arg2(); - case OperatorCode::SUB: - os << f.arg1() << '-'; - switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } - return os; - case OperatorCode::MUL: - switch(f.arg1().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::DIV: os << '(' << f.arg1() << ')'; break; default: os << f.arg1(); } - os << '*'; - switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } - return os; - case OperatorCode::DIV: - switch(f.arg1().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::DIV: os << '(' << f.arg1() << ')'; break; default: os << f.arg1(); } - os << '/'; - switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::MUL: case OperatorCode::DIV: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } - return os; - case OperatorCode::POW: - return os << "pow" << '(' << f.arg() << ',' << f.num() << ')'; - default: - switch(f.kind()) { - case OperatorKind::UNARY: return os << f.op() << "(" << f.arg() << ")"; - case OperatorKind::BINARY: return os << f.op() << "(" << f.arg1() << "," << f.arg2() << ")"; - // FIXME: Type-cast comparison arguments correctly - case OperatorKind::COMPARISON: return _write_comparison(os,f); - default: ARIADNE_FAIL_MSG("Cannot output expression with operator "<; template class Expression; template class Expression; @@ -264,33 +123,6 @@ template class Expression; template class Expression; - -template inline -Expression make_expression(const Constant& c) { - return Expression(std::make_shared>(c)); } -template inline -Expression make_expression(const R& c) { - return Expression(std::make_shared>(c)); } -template inline -Expression make_expression(OperatorCode op, const Expression& e) { - return Expression(std::make_shared>(op,e)); } -template inline -Expression make_expression(OperatorCode op, const Expression& e, N n) { - return Expression(std::make_shared>(op,e,n)); } -template inline -Expression make_expression(OperatorCode op, const Expression& e1, Expression e2) { - return Expression(std::make_shared>(op,e1,e2)); } - -template inline -Expression make_expression(Op op, const Expression e) { - return make_expression(op.code(),e); } -template inline -Expression make_expression(Op op, const Expression& e, N n) { - return make_expression(op.code(),e,n); } -template inline -Expression make_expression(Op op, const Expression& e1, Expression e2) { - return make_expression(op.code(),e1,e2); } - Expression operator&&(Expression const& e1, Expression const& e2) { return make_expression(AndOp(),e1,e2); } Expression operator||(Expression const& e1, Expression const& e2) { @@ -416,164 +248,21 @@ Expression min(Expression const& e1, Expression const& e2) { Expression abs(Expression const& e) { return make_expression(Abs(),e); } +template String evaluate(const Expression& e, const Valuation& x); +template Integer evaluate(const Expression& e, const Valuation& x); +template Real evaluate(const Expression& e, const Valuation& x); +template Boolean evaluate(const Expression& e, const Valuation& x); +template Boolean evaluate(const Expression& e, const Valuation& x); +template Kleenean evaluate(const Expression& e, const Valuation& x); -Expression operator+(Expression const& e, Real const& c) { return e + Expression::constant(c); } -Expression operator-(Expression const& e, Real const& c) { return e - Expression::constant(c); } -Expression operator*(Expression const& e, Real const& c) { return e * Expression::constant(c); } -Expression operator/(Expression const& e, Real const& c) { return e / Expression::constant(c); } -Expression operator+(Real const& c, Expression const& e) { return Expression::constant(c) + e; } -Expression operator-(Real const& c, Expression const& e) { return Expression::constant(c) - e; } -Expression operator*(Real const& c, Expression const& e) { return Expression::constant(c) * e; } -Expression operator/(Real const& c, Expression const& e) { return Expression::constant(c) / e; } - -Expression operator<=(Expression const& e, Real const& c) { return e <= Expression::constant(c); } -Expression operator< (Expression const& e, Real const& c) { return e < Expression::constant(c); } -Expression operator>=(Expression const& e, Real const& c) { return e >= Expression::constant(c); } -Expression operator> (Expression const& e, Real const& c) { return e > Expression::constant(c); } -Expression operator<=(Real const& c, Expression const& e) { return Expression::constant(c) <= e; } -Expression operator< (Real const& c, Expression const& e) { return Expression::constant(c) < e; } -Expression operator>=(Real const& c, Expression const& e) { return Expression::constant(c) >= e; } -Expression operator> (Real const& c, Expression const& e) { return Expression::constant(c) > e; } - - - - -template -typename Logic::Type -evaluate(const Expression::Type>& e, const Map& x) -{ - typedef typename Logic::Type R; - A* aptr=0; - switch(e.kind()) { - case OperatorKind::NULLARY: return static_cast(e.val()); - case OperatorKind::UNARY: return compute(e.op(),evaluate(e.arg(),x)); - case OperatorKind::BINARY: return compute(e.op(),evaluate(e.arg1(),x),evaluate(e.arg2(),x)); - case OperatorKind::COMPARISON: return compare(e.op(),evaluate(e.cmp1(aptr),x),evaluate(e.cmp2(aptr),x)); - default: ARIADNE_FAIL_MSG("Cannot evaluate expression "< -T -evaluate(const Expression& e, const Map& x) -{ - switch(e.kind()) { - case OperatorKind::VARIABLE: return x[e.var()]; - case OperatorKind::NULLARY: return e.val(); - case OperatorKind::UNARY: return compute(e.op(),evaluate(e.arg(),x)); - case OperatorKind::BINARY: return compute(e.op(),evaluate(e.arg1(),x),evaluate(e.arg2(),x)); - case OperatorKind::GRADED: return compute(e.op(),evaluate(e.arg(),x),e.num()); - default: ARIADNE_FAIL_MSG("Cannot evaluate expression "<& e, const Map& x); - -String evaluate(const Expression& e, const StringValuation& x) { - switch(e.op()) { - case OperatorCode::CNST: return e.val(); - case OperatorCode::VAR: return x[e.var()]; - default: ARIADNE_FAIL_MSG("Cannot evaluate expression "<& e, const Valuation& x) { - return evaluate(e,x.values()); -} - -Boolean evaluate(const Expression& e, const Valuation& x) { - return evaluate(e,x.values()); -} - -Kleenean evaluate(const Expression& e, const Valuation& x) { - return evaluate(e,x.values()); -} - -Real evaluate(const Expression& e, const Valuation& x) { - return evaluate(e,x.values()); -} - +template Real evaluate(Expression const&, Map const&); -template Set arguments(const Expression& e) -{ - switch(e.kind()) { - case OperatorKind::VARIABLE: return Set{e.var()}; - case OperatorKind::NULLARY: return Set(); - case OperatorKind::UNARY: return arguments(e.arg()); - case OperatorKind::BINARY: return join(arguments(e.arg1()),arguments(e.arg2())); - case OperatorKind::COMPARISON: { - const BinaryExpressionNode* rlp = dynamic_cast*>(e.node_raw_ptr()); - if(rlp) { return join(arguments(rlp->arg1),arguments(rlp->arg2)); } - const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); - if(strp) { return join(arguments(strp->arg1),arguments(strp->arg2)); } - [[fallthrough]]; - } - default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< arguments(const Expression& e); template Set arguments(const Expression& e); template Set arguments(const Expression& e); - - - - -namespace { -template inline const Expression& _substitute_variable(const I& ie, const I& is, const Expression& e, const Expression& s) { - ARIADNE_ASSERT_MSG(ie!=is,"Cannot substitute expression "< inline const Expression& _substitute_variable(const I& ie, const I& is, const Expression& e, const Expression& s) { - return ie==is ? s : e; } -} // namespace - -template Expression substitute(const Expression& e, const I& v, const Expression& s) { - switch(e.kind()) { - case OperatorKind::COMPARISON: { - Y* yptr=0; - const Expression& c1=e.cmp1(yptr); - const Expression& c2=e.cmp2(yptr); - return make_expression(e.op(),substitute(c1,v,s),substitute(c2,v,s)); } - case OperatorKind::BINARY: return make_expression(e.op(),substitute(e.arg1(),v,s),substitute(e.arg2(),v,s)); - case OperatorKind::UNARY: return make_expression(e.op(),substitute(e.arg(),v,s)); - case OperatorKind::NULLARY: return make_expression(e.val()); - case OperatorKind::VARIABLE: return _substitute_variable(e.var(),v,e,s); - case OperatorKind::GRADED: return make_expression(e.op(),substitute(e.arg(),v,s),e.num()); - default: ARIADNE_FAIL_MSG("Cannot substitute "< Expression substitute(const Expression& e, const Variable& v, const Expression& s) { - return substitute(e,v.name(),s); -} - -template Expression substitute(const Expression& e, const Variable& v, const Y& c) { - return substitute(e,v.name(),Expression::constant(c)); -} - -template Expression substitute(const Expression& e, const Assignment,Expression>& a) { - return substitute(e,a.lhs,a.rhs); -} - -template Expression substitute(const Expression& e, const List,Expression>>& a) { - Expression r=e; - for(SizeType i=0; i!=a.size(); ++i) { - r=substitute(r,a[i]); - } - return r; -} - -template SizeType substitute(const Vector>& e, const List< Assignment< Variable, Expression > >& a) { - Vector> r(e.size()); - for(SizeType i=0; i!=e.size(); ++i) { - r[i]=substitute(e[i],a); - } - return r; -} - template Expression substitute(const Expression& e, const Variable& v, const Kleenean& c); template Expression substitute(const Expression& e, const Variable& v, const Real& c); template Expression substitute(const Expression& e, const Variable& v, const Real& c); @@ -581,124 +270,9 @@ template Expression substitute(const Expression& e, const Variable substitute(const Expression& e, const List< Assignment< Variable, Expression > >& c); template Expression substitute(const Expression& e, const List< Assignment< Variable, Expression > >& c); - -namespace { - -template inline Expression _simplify(const Expression& e) { - return e; -} - - -inline Expression _simplify(const Expression& e) { - typedef Real R; - - if(e.kind() == OperatorKind::UNARY) { - Expression sarg=simplify(e.arg()); - if(sarg.op()==OperatorCode::CNST) { - return Expression(compute(e.op(),sarg.val())); - } else { - return make_expression(e.op(),sarg); - } - } - - if(e.kind() == OperatorKind::GRADED) { - Expression sarg=simplify(e.arg()); - Expression one(static_cast(1)); - switch(e.op()) { - case OperatorCode::POW: - switch (e.num()) { - case 0: return one; - case 1: return sarg; - default: return make_expression(OperatorCode::POW,sarg,e.num()); - } - default: - return make_expression(e.op(),sarg,e.num()); - } - } - - if(e.kind() != OperatorKind::BINARY) { return e; } - - Expression sarg1=simplify(e.arg1()); - Expression sarg2=simplify(e.arg2()); - Expression zero(static_cast(0)); - Expression one(static_cast(1)); - switch(e.op()) { - case OperatorCode::ADD: - if(identical(sarg2,zero)) { return sarg1; } - if(identical(sarg1,zero)) { return sarg2; } - break; - case OperatorCode::SUB: - if(identical(sarg2,zero)) { return sarg1; } - if(identical(sarg1,zero)) { return -sarg2; } - break; - case OperatorCode::MUL: - if(identical(sarg1,zero)) { return zero; } - if(identical(sarg2,zero)) { return zero; } - if(identical(sarg1,one)) { return sarg2; } - if(identical(sarg2,one)) { return sarg1; } - break; - case OperatorCode::DIV: - if(identical(sarg1,zero)) { return sarg1; } - if(identical(sarg1,one)) { return rec(sarg2); } - if(identical(sarg2,one)) { return sarg1; } - default: - break; - } - return make_expression(e.op(),sarg1,sarg2); -} - -template inline Expression _simplify(const Expression& e) { - typedef Kleenean T; - - if( e.kind()==OperatorKind::UNARY ) { - Expression sarg=simplify(e.arg()); - if(e.op()==OperatorCode::NOT) { - if( sarg.op()==OperatorCode::NOT ) { - return sarg.arg(); - } - if( sarg.op()==OperatorCode::CNST ) { - return Expression(compute(e.op(),sarg.val())); - } - } - return make_expression(e.op(),sarg); - } - - if( e.kind()==OperatorKind::BINARY ) { - Expression sarg1=simplify(e.arg1()); - Expression sarg2=simplify(e.arg2()); - if( sarg1.op()==OperatorCode::CNST && sarg2.op()==OperatorCode::CNST ) { - if(e.op()==OperatorCode::AND) { return Expression(sarg1.val() && sarg2.val()); } - if(e.op()==OperatorCode::OR) { return Expression(sarg1.val() || sarg2.val()); } - return Expression(compute(e.op(),sarg1.val(),sarg2.val())); - } else if(sarg1.op()==OperatorCode::CNST) { - if(e.op()==OperatorCode::AND && definitely(sarg1.val())) { return sarg2; } - if(e.op()==OperatorCode::AND && definitely(not sarg1.val())) { return sarg1; } - if(e.op()==OperatorCode::OR && definitely(sarg1.val())) { return sarg1; } - if(e.op()==OperatorCode::OR && definitely(not sarg1.val())) { return sarg2; } - } else if(sarg2.op()==OperatorCode::CNST) { - if(e.op()==OperatorCode::AND && definitely(sarg2.val())) { return sarg1; } - if(e.op()==OperatorCode::AND && definitely(not sarg2.val())) { return sarg2; } - if(e.op()==OperatorCode::OR && definitely(sarg2.val())) { return sarg2; } - if(e.op()==OperatorCode::OR && definitely(not sarg2.val())) { return sarg1; } - } else { - return make_expression(e.op(),sarg1,sarg2); - } - } - return e; -} - - -} // namespace - -template Expression simplify(const Expression& e) { - return Ariadne::_simplify(e); -} - template Expression simplify(const Expression& e); template Expression simplify(const Expression& e); - - Expression indicator(Expression e, Sign sign) { switch(e.op()) { case OperatorCode::CNST: { @@ -728,25 +302,13 @@ Expression indicator(Expression e, Sign sign) { } -template Bool is_constant(const Expression& e, const typename Expression::ValueType& c) { - switch(e.op()) { - case OperatorCode::CNST: return decide(e.val()==c); - default: return false; - } -} template Bool is_constant(const Expression&, const Real&); template Bool is_constant(const Expression&, const Kleenean&); - -template Bool is_variable(const Expression& e, const Variable& v) { - switch(e.op()) { - case OperatorCode::VAR: return e.var()==v.name(); - default: return false; - } -} - template Bool is_variable(const Expression&, const Variable&); +template Bool identical(const Expression&, const Expression&); + Bool is_constant_in(const Expression& e, const Set>& vs) { switch(e.kind()) { @@ -814,36 +376,6 @@ Bool is_additive_in(const Vector>& ev, const Set } -template Bool identical(const Expression& e1, const Expression& e2) -{ - if(e1.node_raw_ptr()==e2.node_raw_ptr()) { return true; } - if(e1.op()!=e2.op()) { return false; } - switch(e1.kind()) { - case OperatorKind::VARIABLE: - return e1.var()==e2.var(); - case OperatorKind::NULLARY: - return same(e1.val(),e2.val()); - case OperatorKind::UNARY: - return identical(e1.arg(),e2.arg()); - case OperatorKind::GRADED: - return identical(e1.arg(),e2.arg()) && e1.num() == e2.num(); - case OperatorKind::BINARY: - switch(e1.op()) { - case OperatorCode::MUL: case OperatorCode::ADD: - return (identical(e1.arg1(),e2.arg1()) && identical(e1.arg2(),e2.arg2())) || - (identical(e1.arg1(),e2.arg2()) && identical(e1.arg2(),e2.arg1())); - default: - return identical(e1.arg1(),e2.arg1()) && identical(e1.arg2(),e2.arg2()); - } - default: - return false; - } -} - -template Bool identical(const Expression&, const Expression&); - - - Bool opposite(Expression e1, Expression e2) { OperatorCode e1op; diff --git a/source/symbolic/expression.hpp b/source/symbolic/expression.hpp index 9ebde7a1d..a5c603cef 100644 --- a/source/symbolic/expression.hpp +++ b/source/symbolic/expression.hpp @@ -84,12 +84,15 @@ class Expression Expression(); //! \brief Construct an expression from a numerical value. Expression(const T& c); + template> =dummy> Expression(const U& c) : Expression(T(c)) { } //! \brief Construct an expression from a named constant. Expression(const Constant& c); //! \brief Construct an expression from a variable. Expression(const Variable& v); //! \brief Construct a constant expression from a value. static Expression constant(const ValueType& c); + //! \brief Construct a constant expression from a named variable value. + static Expression constant(const Constant& c); //! \brief Construct an expression from a name. static Expression variable(const Identifier& c); @@ -127,24 +130,29 @@ class Expression //! \name Evaluation and related operations. //! \related Expression +template LogicType evaluate(const Expression>& e, const Valuation& x); +template T evaluate(const Expression& e, const Valuation& x); + Boolean evaluate(const Expression& e, const DiscreteValuation& q); -Boolean evaluate(const Expression& e, const StringValuation& q); -String evaluate(const Expression& e, const StringValuation& q); -Integer evaluate(const Expression& e, const IntegerValuation& q); -Real evaluate(const Expression& e, const Valuation& q); -Kleenean evaluate(const Expression& e, const Valuation& q); +template X evaluate(const Expression& e, const ContinuousValuation&); +template Kleenean evaluate(const Expression&, const ContinuousValuation&); //! \brief Evaluate expression \a e on argument \a x which is a map of variable identifiers to values of type \c A. -template typename Logic::Type evaluate(const Expression::Type>& e, const Map& x); - +template LogicType evaluate(const Expression>& e, const Map& x); //! \brief Evaluate expression \a e on argument \a x which is a map of variable identifiers to values of type \c A. template T evaluate(const Expression& e, const Map& x); //! \brief Extract the arguments of expression \a e. template Set arguments(const Expression& e); +//! \brief Substitute all occurrences of variable \a v of type \c Y with constant value \a c. +template Expression substitute(const Expression& e, const Variable& v, const Y& c); +//! \brief Substitute all occurrences of variable \a v of type \c Y with expression value \a se. +template Expression substitute(const Expression& e, const List< Assignment< Variable,Expression > >& a); +template Vector> substitute(const Vector>& e, const List< Assignment< Variable,Expression > >& a); + //! \brief Returns \a true if the expression\a e is syntactically equal to the constant \a c. -template Bool is_constant(const Expression& e, const typename Expression::ValueType& c); +template Bool is_constant(const Expression& e, const SelfType& c); //! \brief Returns \a true if the expression \a e is syntactically equal to the variable with name \a vn. template Bool is_variable(const Expression& e, const Identifier& vn); @@ -152,6 +160,15 @@ template Bool is_variable(const Expression& e, const Identifier& vn) //! \brief Returns \a true if the expression \a e is syntactically equal to the variable \a v. template Bool is_variable(const Expression& e, const Variable& v); +//! \brief Returns \a true if the expression \a e is syntactically constant in the variables \a vs. +Bool is_constant_in(const Expression& e, const Set>& vs); +//! \brief Returns \a true if the expression \a e is syntactically affine in the variables \a vs. +Bool is_affine_in(const Expression& e, const Set>& vs); +//! \brief Returns \a true if the vector expression \a e is syntactically affine in the variables \a vs. +Bool is_affine_in(const Vector>& e, const Set>& vs); +//! \brief Returns \a true if the vector expression \a e is syntactically additive in the variables \a vs. +Bool is_additive_in(const Vector>& e, const Set>& vs); + //! \brief Simplify the expression \a e. template Expression simplify(const Expression& e); @@ -167,22 +184,6 @@ Bool opposite(Expression p, Expression q); //! \brief Given \a sign when the predicate \a p is true. Expression indicator(Expression p, Sign sign=Sign::POSITIVE); -//! \brief Substitute all occurrences of variable \a v of type \c Y with constant value \a c. -template Expression substitute(const Expression& e, const Variable& v, const Y& c); - -//! \brief Substitute all occurrences of variable \a v of type \c Y with expression value \a se. -template Expression substitute(const Expression& e, const List< Assignment< Variable,Expression > >& a); -template Vector> substitute(const Vector>& e, const List< Assignment< Variable,Expression > >& a); - -//! \brief Returns \a true if the expression \a e is syntactically constant in the variables \a vs. -Bool is_constant_in(const Expression& e, const Set>& vs); -//! \brief Returns \a true if the expression \a e is syntactically affine in the variables \a vs. -Bool is_affine_in(const Expression& e, const Set>& vs); -//! \brief Returns \a true if the vector expression \a e is syntactically affine in the variables \a vs. -Bool is_affine_in(const Vector>& e, const Set>& vs); -//! \brief Returns \a true if the vector expression \a e is syntactically additive in the variables \a vs. -Bool is_additive_in(const Vector>& e, const Set>& vs); - //! \brief Simplify the expression \a e. Expression derivative(const Expression& e, Variable v); diff --git a/source/symbolic/expression.tpl.hpp b/source/symbolic/expression.tpl.hpp new file mode 100644 index 000000000..ead6d9c2e --- /dev/null +++ b/source/symbolic/expression.tpl.hpp @@ -0,0 +1,476 @@ +/*************************************************************************** + * expression.tpl.hpp + * + * Copyright 2009--17 Pieter Collins + * + ****************************************************************************/ + +/* + * 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 2 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 FOperatorCode::OR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "utility/standard.hpp" + +#include "numeric/operators.tpl.hpp" + +#include "algebra/algebra.hpp" +#include "algebra/algebra_wrapper.hpp" + +#include "symbolic/constant.hpp" +#include "symbolic/variables.hpp" +#include "symbolic/assignment.hpp" +#include "symbolic/space.hpp" +#include "symbolic/valuation.hpp" + +#include "function/formula.hpp" + +namespace Ariadne { + +template +struct ExpressionNode { + mutable Nat count; + Operator op; + virtual ~ExpressionNode(); + explicit ExpressionNode(const Operator& o) : count(0u), op(o) { } + explicit ExpressionNode(OperatorCode cd, OperatorKind knd) : count(0u), op(cd,knd) { } +}; + + +template struct ConstantExpressionNode : public ExpressionNode { + T val; + ConstantExpressionNode(const T& v) : ExpressionNode(OperatorCode::CNST,OperatorKind::NULLARY), val(v) { } +}; +template struct NamedConstantExpressionNode : public ConstantExpressionNode { + Identifier name; + NamedConstantExpressionNode(const Constant& v) : ConstantExpressionNode(v), name(v.name()) { } +}; +template struct VariableExpressionNode : public ExpressionNode { + Identifier var; + VariableExpressionNode(const Identifier& v) : ExpressionNode(OperatorCode::VAR,OperatorKind::VARIABLE), var(v) { } +}; +template struct UnaryExpressionNode : public ExpressionNode { + Expression arg; + UnaryExpressionNode(const Operator& op, Expression const& a) : ExpressionNode(op), arg(a) { } +}; +template struct BinaryExpressionNode : public ExpressionNode { + Expression arg1; Expression arg2; +}; +template struct BinaryExpressionNode : public ExpressionNode { + Expression arg1; Expression arg2; + BinaryExpressionNode(const Operator& op, Expression const& a1, Expression const& a2) + : ExpressionNode(op), arg1(a1), arg2(a2) { } +}; +template struct BinaryExpressionNode::Type,T,T> : public ExpressionNode::Type> { + typedef typename Logic::Type R; typedef T A; + Expression arg1; Expression arg2; + BinaryExpressionNode(const Operator& op, Expression const& a1, Expression const& a2) + : ExpressionNode(op), arg1(a1), arg2(a2) { } +}; +template struct ScalarExpressionNode : public UnaryExpressionNode { + N num; + ScalarExpressionNode(const Operator& op, Expression const& a, N n) + : UnaryExpressionNode(op,a), num(n) { } +}; + +template ExpressionNode::~ExpressionNode() { } + +template inline OutputStream& operator<<(OutputStream& os, const ExpressionNode* e) { + return os << static_cast(e); +} + + +template Expression::Expression() : _root(new ConstantExpressionNode(T())) { }; +template Expression::Expression(const T& c): _root(new ConstantExpressionNode(c)) { }; +template Expression::Expression(const Constant& c): _root(new NamedConstantExpressionNode(c)) { }; +template Expression::Expression(const Variable& v) : _root(new VariableExpressionNode(v.name())) { } +template Expression Expression::constant(const T& c) { + return Expression(SharedPointer>(new ConstantExpressionNode(c))); } +template Expression Expression::constant(const Constant& c) { + return Expression(SharedPointer>(new NamedConstantExpressionNode(c))); } +template Expression Expression::variable(const Identifier& v) { + return Expression(SharedPointer>(new VariableExpressionNode(v))); } + +template const Operator& Expression::op() const { + return node_ptr()->op; } +template OperatorCode Expression::code() const { + return node_ptr()->op.code(); } +template OperatorKind Expression::kind() const { + return node_ptr()->op.kind(); } +template const T& Expression::val() const { + return static_cast*>(node_raw_ptr())->val; } +template const Identifier& Expression::var() const { + return static_cast*>(node_raw_ptr())->var; } +template const Expression& Expression::arg() const { + return static_cast*>(node_raw_ptr())->arg; } +template const Int& Expression::num() const { + return static_cast*>(node_raw_ptr())->num; } +template const Expression& Expression::arg1() const { + return static_cast*>(node_raw_ptr())->arg1; } +template const Expression& Expression::arg2() const { + return static_cast*>(node_raw_ptr())->arg2; } +template template const Expression& Expression::cmp1(A*) const { + return static_cast*>(node_raw_ptr())->arg1; } +template template const Expression& Expression::cmp2(A*) const { + return static_cast*>(node_raw_ptr())->arg2; } + +template Set Expression::arguments() const { + const Expression& e=*this; + switch(e.kind()) { + case OperatorKind::VARIABLE: return Set{Variable(e.var())}; + case OperatorKind::NULLARY: return Set(); + case OperatorKind::UNARY: return e.arg().arguments(); + case OperatorKind::BINARY: return join(e.arg1().arguments(),e.arg2().arguments()); + case OperatorKind::COMPARISON: { + const BinaryExpressionNode* rlp = dynamic_cast*>(e.node_raw_ptr()); + if(rlp) { return join(rlp->arg1.arguments(),rlp->arg2.arguments()); } + const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); + if(strp) { return join(strp->arg1.arguments(),strp->arg2.arguments()); } + } + default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { + ARIADNE_FAIL_MSG("Comparison must return a logical type."); } +template<> inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { + Real* real_ptr=0; return os << "(" << f.cmp1(real_ptr) << symbol(f.op()) << f.cmp2(real_ptr) << ")"; } +template<> inline OutputStream& _write_comparison(OutputStream& os, const Expression& f) { + String* string_ptr=0; return os << "(" << f.cmp1(string_ptr) << symbol(f.op()) << f.cmp2(string_ptr) << ")"; } +//FIXME: Distinguish String and Integer comparisons + +} + +template OutputStream& Expression::_write(OutputStream& os) const { + const Expression& f=*this; + switch(f.op()) { + //case OperatorCode::CNST: return os << std::fixed << std::setprecision(4) << fptr->val; + case OperatorCode::CNST: + if(auto fp=std::dynamic_pointer_castconst>(f._root)) { return os << fp->name; } + else if(auto afp=std::dynamic_pointer_castconst>(f._root)) { os << + "c"<val; return os; } + else { return os << "dcf"; } + //if(f.val()==0.0) { return os << 0.0; } if(abs(f.val())<1e-4) { os << std::fixed << f.val(); } else { os << f.val(); } return os; + case OperatorCode::VAR: + return os << f.var(); + case OperatorCode::ADD: + return os << f.arg1() << '+' << f.arg2(); + case OperatorCode::SUB: + os << f.arg1() << '-'; + switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } + return os; + case OperatorCode::MUL: + switch(f.arg1().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::DIV: os << '(' << f.arg1() << ')'; break; default: os << f.arg1(); } + os << '*'; + switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } + return os; + case OperatorCode::DIV: + switch(f.arg1().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::DIV: os << '(' << f.arg1() << ')'; break; default: os << f.arg1(); } + os << '/'; + switch(f.arg2().op()) { case OperatorCode::ADD: case OperatorCode::SUB: case OperatorCode::MUL: case OperatorCode::DIV: os << '(' << f.arg2() << ')'; break; default: os << f.arg2(); } + return os; + case OperatorCode::POW: + return os << "pow" << '(' << f.arg() << ',' << f.num() << ')'; + default: + switch(f.kind()) { + case OperatorKind::UNARY: return os << f.op() << "(" << f.arg() << ")"; + case OperatorKind::BINARY: return os << f.op() << "(" << f.arg1() << "," << f.arg2() << ")"; + // FIXME: Type-cast comparison arguments correctly + case OperatorKind::COMPARISON: return _write_comparison(os,f); + default: ARIADNE_FAIL_MSG("Cannot output expression with operator "< inline +Expression make_expression(const Constant& c) { + return Expression(std::make_shared>(c)); } +template inline +Expression make_expression(const R& c) { + return Expression(std::make_shared>(c)); } +template inline +Expression make_expression(OperatorCode op, const Expression& e) { + return Expression(std::make_shared>(op,e)); } +template inline +Expression make_expression(OperatorCode op, const Expression& e, N n) { + return Expression(std::make_shared>(op,e,n)); } +template inline +Expression make_expression(OperatorCode op, const Expression& e1, Expression e2) { + return Expression(std::make_shared>(op,e1,e2)); } + +template inline +Expression make_expression(Op op, const Expression e) { + return make_expression(op.code(),e); } +template inline +Expression make_expression(Op op, const Expression& e, N n) { + return make_expression(op.code(),e,n); } +template inline +Expression make_expression(Op op, const Expression& e1, Expression e2) { + return make_expression(op.code(),e1,e2); } + + + +template typename Logic::Type evaluate(const Expression::Type>& e, const Map& x) { + typedef typename Logic::Type R; + A* aptr=0; + switch(e.kind()) { + case OperatorKind::NULLARY: return static_cast(e.val()); + case OperatorKind::UNARY: return compute(e.op(),evaluate(e.arg(),x)); + case OperatorKind::BINARY: return compute(e.op(),evaluate(e.arg1(),x),evaluate(e.arg2(),x)); + case OperatorKind::COMPARISON: return compare(e.op(),evaluate(e.cmp1(aptr),x),evaluate(e.cmp2(aptr),x)); + default: ARIADNE_FAIL_MSG("Cannot evaluate expression "< T evaluate(const Expression& e, const Map& x) { + switch(e.kind()) { + case OperatorKind::VARIABLE: return x[e.var()]; + case OperatorKind::NULLARY: return e.val(); + case OperatorKind::UNARY: return compute(e.op(),evaluate(e.arg(),x)); + case OperatorKind::BINARY: return compute(e.op(),evaluate(e.arg1(),x),evaluate(e.arg2(),x)); + case OperatorKind::GRADED: return compute(e.op(),evaluate(e.arg(),x),e.num()); + default: ARIADNE_FAIL_MSG("Cannot evaluate expression "< T evaluate(const Expression& e, const Valuation& x) { + return evaluate(e,x.values()); +} + +template typename Logic::Type evaluate(const Expression::Type>& e, const Valuation& x) { + return evaluate(e,x.values()); +} + + +template Set arguments(const Expression& e) { + switch(e.kind()) { + case OperatorKind::VARIABLE: return Set{e.var()}; + case OperatorKind::NULLARY: return Set(); + case OperatorKind::UNARY: return arguments(e.arg()); + case OperatorKind::BINARY: return join(arguments(e.arg1()),arguments(e.arg2())); + case OperatorKind::COMPARISON: { + const BinaryExpressionNode* rlp = dynamic_cast*>(e.node_raw_ptr()); + if(rlp) { return join(arguments(rlp->arg1),arguments(rlp->arg2)); } + const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); + if(strp) { return join(arguments(strp->arg1),arguments(strp->arg2)); } + } + default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< inline const Expression& _substitute_variable(const I& ie, const I& is, const Expression& e, const Expression& s) { + ARIADNE_ASSERT_MSG(ie!=is,"Cannot substitute expression "< inline const Expression& _substitute_variable(const I& ie, const I& is, const Expression& e, const Expression& s) { + return ie==is ? s : e; } +} // namespace + +template Expression substitute(const Expression& e, const Variable& v, const Expression& s) { + switch(e.kind()) { + case OperatorKind::COMPARISON: { + Y* yptr=0; + const Expression& c1=e.cmp1(yptr); + const Expression& c2=e.cmp2(yptr); + return make_expression(e.op(),substitute(c1,v,s),substitute(c2,v,s)); } + case OperatorKind::BINARY: return make_expression(e.op(),substitute(e.arg1(),v,s),substitute(e.arg2(),v,s)); + case OperatorKind::UNARY: return make_expression(e.op(),substitute(e.arg(),v,s)); + case OperatorKind::GRADED: return make_expression(e.op(),substitute(e.arg(),v,s),e.num()); + case OperatorKind::NULLARY: return make_expression(e.val()); + case OperatorKind::VARIABLE: return _substitute_variable(e.var(),v.name(),e,s); + default: ARIADNE_FAIL_MSG("Cannot substitute "< Expression substitute(const Expression& e, const Variable& v, const Y& c) { + return substitute(e,v,Expression::constant(c)); +} + +template Expression substitute(const Expression& e, const Assignment,Expression>& a) { + return substitute(e,a.lhs,a.rhs); +} + +template Expression substitute(const Expression& e, const List,Expression>>& a) { + Expression r=e; + for(SizeType i=0; i!=a.size(); ++i) { + r=substitute(r,a[i]); + } + return r; +} + +template SizeType substitute(const Vector>& e, const List< Assignment< Variable, Expression > >& a) { + Vector> r(e.size()); + for(SizeType i=0; i!=e.size(); ++i) { + r[i]=substitute(e[i],a); + } + return r; +} + +namespace { + +template inline Expression _simplify(const Expression& e) { + return e; +} + + +inline Expression _simplify(const Expression& e) { + typedef Real R; + + if(e.kind() == OperatorKind::UNARY) { + Expression sarg=simplify(e.arg()); + if(sarg.op()==OperatorCode::CNST) { + return Expression(compute(e.op(),sarg.val())); + } else { + return make_expression(e.op(),sarg); + } + } + + if(e.kind() == OperatorKind::GRADED) { + Expression sarg=simplify(e.arg()); + Expression one(static_cast(1)); + switch(e.op()) { + case OperatorCode::POW: + switch (e.num()) { + case 0: return one; + case 1: return sarg; + default: return make_expression(OperatorCode::POW,sarg,e.num()); + } + default: + return make_expression(e.op(),sarg,e.num()); + } + } + + if(e.kind() != OperatorKind::BINARY) { return e; } + + Expression sarg1=simplify(e.arg1()); + Expression sarg2=simplify(e.arg2()); + Expression zero(static_cast(0)); + Expression one(static_cast(1)); + switch(e.op()) { + case OperatorCode::ADD: + if(identical(sarg2,zero)) { return sarg1; } + if(identical(sarg1,zero)) { return sarg2; } + break; + case OperatorCode::SUB: + if(identical(sarg2,zero)) { return sarg1; } + if(identical(sarg1,zero)) { return -sarg2; } + break; + case OperatorCode::MUL: + if(identical(sarg1,zero)) { return zero; } + if(identical(sarg2,zero)) { return zero; } + if(identical(sarg1,one)) { return sarg2; } + if(identical(sarg2,one)) { return sarg1; } + break; + case OperatorCode::DIV: + if(identical(sarg1,zero)) { return sarg1; } + if(identical(sarg1,one)) { return rec(sarg2); } + if(identical(sarg2,one)) { return sarg1; } + default: + break; + } + return make_expression(e.op(),sarg1,sarg2); +} + +template inline Expression _simplify(const Expression& e) { + typedef Kleenean T; + + if( e.kind()==OperatorKind::UNARY ) { + Expression sarg=simplify(e.arg()); + if(e.op()==OperatorCode::NOT) { + if( sarg.op()==OperatorCode::NOT ) { + return sarg.arg(); + } + if( sarg.op()==OperatorCode::CNST ) { + return Expression(compute(e.op(),sarg.val())); + } + } + return make_expression(e.op(),sarg); + } + + if( e.kind()==OperatorKind::BINARY ) { + Expression sarg1=simplify(e.arg1()); + Expression sarg2=simplify(e.arg2()); + if( sarg1.op()==OperatorCode::CNST && sarg2.op()==OperatorCode::CNST ) { + if(e.op()==OperatorCode::AND) { return Expression(sarg1.val() && sarg2.val()); } + if(e.op()==OperatorCode::OR) { return Expression(sarg1.val() || sarg2.val()); } + return Expression(compute(e.op(),sarg1.val(),sarg2.val())); + } else if(sarg1.op()==OperatorCode::CNST) { + if(e.op()==OperatorCode::AND && definitely(sarg1.val())) { return sarg2; } + if(e.op()==OperatorCode::AND && definitely(not sarg1.val())) { return sarg1; } + if(e.op()==OperatorCode::OR && definitely(sarg1.val())) { return sarg1; } + if(e.op()==OperatorCode::OR && definitely(not sarg1.val())) { return sarg2; } + } else if(sarg2.op()==OperatorCode::CNST) { + if(e.op()==OperatorCode::AND && definitely(sarg2.val())) { return sarg1; } + if(e.op()==OperatorCode::AND && definitely(not sarg2.val())) { return sarg2; } + if(e.op()==OperatorCode::OR && definitely(sarg2.val())) { return sarg2; } + if(e.op()==OperatorCode::OR && definitely(not sarg2.val())) { return sarg1; } + } else { + return make_expression(e.op(),sarg1,sarg2); + } + } + return e; +} + +} // namespace + +template Expression simplify(const Expression& e) { + return Ariadne::_simplify(e); +} + +template Bool is_constant(const Expression& e, const SelfType& c) { + switch(e.op()) { + case OperatorCode::CNST: return decide(e.val()==c); + default: return false; + } +} + +template Bool is_variable(const Expression& e, const Variable& v) { + switch(e.op()) { + case OperatorCode::VAR: return e.var()==v.name(); + default: return false; + } +} + + +template Bool identical(const Expression& e1, const Expression& e2) +{ + if(e1.node_raw_ptr()==e2.node_raw_ptr()) { return true; } + if(e1.op()!=e2.op()) { return false; } + switch(e1.kind()) { + case OperatorKind::VARIABLE: + return e1.var()==e2.var(); + case OperatorKind::NULLARY: + return same(e1.val(),e2.val()); + case OperatorKind::UNARY: + return identical(e1.arg(),e2.arg()); + case OperatorKind::GRADED: + return identical(e1.arg(),e2.arg()) && e1.num() == e2.num(); + case OperatorKind::BINARY: + switch(e1.op()) { + case OperatorCode::MUL: case OperatorCode::ADD: + return (identical(e1.arg1(),e2.arg1()) && identical(e1.arg2(),e2.arg2())) || + (identical(e1.arg1(),e2.arg2()) && identical(e1.arg2(),e2.arg1())); + default: + return identical(e1.arg1(),e2.arg1()) && identical(e1.arg2(),e2.arg2()); + } + default: + return false; + } +} + +} // namespace Ariadne diff --git a/source/symbolic/operations.hpp b/source/symbolic/operations.hpp index 3a06dd6a1..acbaf0514 100644 --- a/source/symbolic/operations.hpp +++ b/source/symbolic/operations.hpp @@ -198,24 +198,6 @@ template<> struct DeclareExpressionOperations { friend Expression min(Expression const& e1, Expression const& e2); //! \related Expression \brief %Real absolute value expression. friend Expression abs(Expression const& e); - - friend Expression operator+(Expression const& e, Real const& c); - friend Expression operator-(Expression const& e, Real const& c); - friend Expression operator*(Expression const& e, Real const& c); - friend Expression operator/(Expression const& e, Real const& c); - friend Expression operator+(Real const& c, Expression const& e); - friend Expression operator-(Real const& c, Expression const& e); - friend Expression operator*(Real const& c, Expression const& e); - friend Expression operator/(Real const& c, Expression const& e); - - friend Expression operator<=(Expression const& e, Real const& c); - friend Expression operator< (Expression const& e, Real const& c); - friend Expression operator>=(Expression const& e, Real const& c); - friend Expression operator> (Expression const& e, Real const& c); - friend Expression operator<=(Real const& c, Expression const& e); - friend Expression operator< (Real const& c, Expression const& e); - friend Expression operator>=(Real const& c, Expression const& e); - friend Expression operator> (Real const& c, Expression const& e); }; diff --git a/source/symbolic/variables.hpp b/source/symbolic/variables.hpp index 33beb7c33..828f36bae 100644 --- a/source/symbolic/variables.hpp +++ b/source/symbolic/variables.hpp @@ -196,8 +196,6 @@ template class LetVariable friend LetVariable let(const Variable& var) { return LetVariable(var); } //! \brief Construct an assignment statement representing the algebraic equation \a var := \a expr. inline Assignment,Expression> operator=(const Expression& expr) const; - inline Assignment,Expression> operator=(const Variable& expr) const; - inline Assignment,Expression> operator=(const T& c) const; private: explicit LetVariable(const Variable& var) : ExtendedVariable(var,VariableCategory::SIMPLE) { } }; @@ -213,7 +211,6 @@ template class PrimedVariable friend PrimedVariable prime(const Variable& var) { return PrimedVariable(var); } //! \brief Construct an assignment statement representing the differential equation \a var' := \a expr. inline Assignment,Expression> operator=(const Expression& e) const; - inline Assignment,Expression> operator=(const T& c) const; private: explicit PrimedVariable(const Variable& var) : ExtendedVariable(var,VariableCategory::PRIMED) { } }; @@ -229,7 +226,6 @@ template class DottedVariable friend DottedVariable dot(const Variable& var); //! \brief Construct an assignment statement representing the differential equation \a dot(var) := \a expr. inline Assignment,Expression> operator=(const Expression& e) const; - inline Assignment,Expression> operator=(const T& c) const; private: explicit DottedVariable(const Variable& var) : ExtendedVariable(var,VariableCategory::DOTTED) { } }; From fc43f1a842fa958235a8450062675d1652bc7e1c Mon Sep 17 00:00:00 2001 From: Pieter Collins Date: Tue, 9 Oct 2018 14:40:25 +0200 Subject: [PATCH 4/8] =?UTF-8?q?Fixed=20-Wimplicit-fallthrough,=20-Wshadow?= =?UTF-8?q?=20and=20extra=20=E2=80=98;=E2=80=99=20warnings=20with=20g++?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/symbolic/expression.tpl.hpp | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/source/symbolic/expression.tpl.hpp b/source/symbolic/expression.tpl.hpp index ead6d9c2e..cc4789024 100644 --- a/source/symbolic/expression.tpl.hpp +++ b/source/symbolic/expression.tpl.hpp @@ -62,26 +62,26 @@ template struct VariableExpressionNode : public ExpressionNode { }; template struct UnaryExpressionNode : public ExpressionNode { Expression arg; - UnaryExpressionNode(const Operator& op, Expression const& a) : ExpressionNode(op), arg(a) { } + UnaryExpressionNode(const Operator& o, Expression const& a) : ExpressionNode(o), arg(a) { } }; template struct BinaryExpressionNode : public ExpressionNode { Expression arg1; Expression arg2; }; template struct BinaryExpressionNode : public ExpressionNode { Expression arg1; Expression arg2; - BinaryExpressionNode(const Operator& op, Expression const& a1, Expression const& a2) - : ExpressionNode(op), arg1(a1), arg2(a2) { } + BinaryExpressionNode(const Operator& o, Expression const& a1, Expression const& a2) + : ExpressionNode(o), arg1(a1), arg2(a2) { } }; template struct BinaryExpressionNode::Type,T,T> : public ExpressionNode::Type> { typedef typename Logic::Type R; typedef T A; Expression arg1; Expression arg2; - BinaryExpressionNode(const Operator& op, Expression const& a1, Expression const& a2) - : ExpressionNode(op), arg1(a1), arg2(a2) { } + BinaryExpressionNode(const Operator& o, Expression const& a1, Expression const& a2) + : ExpressionNode(o), arg1(a1), arg2(a2) { } }; template struct ScalarExpressionNode : public UnaryExpressionNode { N num; - ScalarExpressionNode(const Operator& op, Expression const& a, N n) - : UnaryExpressionNode(op,a), num(n) { } + ScalarExpressionNode(const Operator& o, Expression const& a, N n) + : UnaryExpressionNode(o,a), num(n) { } }; template ExpressionNode::~ExpressionNode() { } @@ -91,9 +91,9 @@ template inline OutputStream& operator<<(OutputStream& os, const Expres } -template Expression::Expression() : _root(new ConstantExpressionNode(T())) { }; -template Expression::Expression(const T& c): _root(new ConstantExpressionNode(c)) { }; -template Expression::Expression(const Constant& c): _root(new NamedConstantExpressionNode(c)) { }; +template Expression::Expression() : _root(new ConstantExpressionNode(T())) { } +template Expression::Expression(const T& c): _root(new ConstantExpressionNode(c)) { } +template Expression::Expression(const Constant& c): _root(new NamedConstantExpressionNode(c)) { } template Expression::Expression(const Variable& v) : _root(new VariableExpressionNode(v.name())) { } template Expression Expression::constant(const T& c) { return Expression(SharedPointer>(new ConstantExpressionNode(c))); } @@ -137,6 +137,7 @@ template Set Expression::arguments() const { if(rlp) { return join(rlp->arg1.arguments(),rlp->arg2.arguments()); } const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); if(strp) { return join(strp->arg1.arguments(),strp->arg2.arguments()); } + [[fallthrough]]; } default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< Set arguments(const Expression& e) { if(rlp) { return join(arguments(rlp->arg1),arguments(rlp->arg2)); } const BinaryExpressionNode* strp = dynamic_cast*>(e.node_raw_ptr()); if(strp) { return join(arguments(strp->arg1),arguments(strp->arg2)); } + [[fallthrough]]; } default: ARIADNE_FAIL_MSG("Cannot compute arguments of expression "< Date: Wed, 19 Sep 2018 01:04:41 +0200 Subject: [PATCH 5/8] Removed possibility of omitting 'Multivariate' or domain in function aliases. --- examples/noisy/noisy-utilities.hpp | 9 +- python/source/calculus_submodule.cpp | 172 ++++--- python/source/function_submodule.cpp | 114 ++--- python/source/geometry_submodule.cpp | 16 +- python/source/optimization_submodule.cpp | 36 +- python/source/solver_submodule.cpp | 46 +- python/source/symbolic_submodule.cpp | 4 +- source/dynamics/differential_inclusion.cpp | 134 ++--- source/dynamics/differential_inclusion.hpp | 58 +-- source/dynamics/flowtube.hpp | 6 +- source/dynamics/map.hpp | 6 +- .../dynamics/simulation_toolbox_interface.hpp | 18 +- source/dynamics/vector_field.hpp | 6 +- source/dynamics/vector_field_evolver.cpp | 4 +- source/function/affine_model.cpp | 2 +- source/function/affine_model.hpp | 28 +- source/function/affine_model.tpl.hpp | 10 +- source/function/calculus_base.hpp | 34 +- source/function/constraint.hpp | 38 +- source/function/function.cpp | 468 +++++++++--------- source/function/function.decl.hpp | 82 +-- source/function/function.hpp | 114 ++--- source/function/function_interface.hpp | 35 +- source/function/function_mixin.hpp | 8 +- source/function/function_mixin.tpl.hpp | 2 +- source/function/function_model.hpp | 53 +- source/function/function_model.tpl.hpp | 46 +- source/function/function_model_interface.hpp | 8 +- source/function/function_model_mixin.hpp | 30 +- source/function/procedure.cpp | 6 +- source/function/procedure.hpp | 2 +- source/function/procedure.tpl.hpp | 2 +- source/function/scaled_function_patch.hpp | 50 +- source/function/scaled_function_patch.tpl.hpp | 4 +- source/function/symbolic_function.hpp | 48 +- source/function/taylor_function.cpp | 4 +- source/function/taylor_model.hpp | 6 +- source/function/user_function.hpp | 36 +- source/geometry/affine_set.cpp | 2 +- source/geometry/affine_set.hpp | 2 +- source/geometry/box.cpp | 6 +- source/geometry/box.hpp | 6 +- source/geometry/enclosure.cpp | 184 +++---- source/geometry/enclosure.hpp | 84 ++-- source/geometry/function_set.cpp | 88 ++-- source/geometry/function_set.hpp | 44 +- source/geometry/paver.cpp | 42 +- source/geometry/zonotope.cpp | 4 +- source/geometry/zonotope.hpp | 4 +- source/hybrid/hybrid_automaton-composite.cpp | 10 +- source/hybrid/hybrid_automaton-composite.hpp | 10 +- .../hybrid/hybrid_automaton-restrictive.cpp | 22 +- .../hybrid/hybrid_automaton-restrictive.hpp | 28 +- source/hybrid/hybrid_automaton.cpp | 26 +- source/hybrid/hybrid_automaton.hpp | 10 +- source/hybrid/hybrid_automaton_interface.hpp | 10 +- source/hybrid/hybrid_enclosure.cpp | 52 +- source/hybrid/hybrid_enclosure.hpp | 58 +-- source/hybrid/hybrid_evolver.cpp | 142 +++--- source/hybrid/hybrid_evolver.hpp | 62 +-- source/hybrid/hybrid_simulator.cpp | 16 +- source/output/drawer.cpp | 6 +- source/solvers/constraint_solver.cpp | 26 +- source/solvers/constraint_solver.hpp | 22 +- source/solvers/integrator.cpp | 88 ++-- source/solvers/integrator.hpp | 38 +- source/solvers/integrator_interface.hpp | 22 +- source/solvers/nonlinear_programming.cpp | 138 +++--- source/solvers/nonlinear_programming.hpp | 130 ++--- source/solvers/runge_kutta_integrator.cpp | 4 +- source/solvers/runge_kutta_integrator.hpp | 4 +- source/solvers/solver.cpp | 122 ++--- source/solvers/solver.hpp | 30 +- source/solvers/solver_interface.hpp | 16 +- source/symbolic/expression.cpp | 4 +- source/symbolic/expression.hpp | 8 +- source/symbolic/expression_set.cpp | 8 +- source/symbolic/function_expression.hpp | 30 +- source/symbolic/predicate.hpp | 6 +- tests/algebra/check_algebra.hpp | 2 +- tests/dynamics/test_continuous_evolution.cpp | 30 +- .../dynamics/test_differential_inclusion.cpp | 2 +- tests/dynamics/test_discrete_evolution.cpp | 6 +- tests/function/check_function.hpp | 16 +- tests/function/test_function.cpp | 54 +- tests/function/test_procedure.cpp | 2 +- tests/function/test_taylor_function.cpp | 80 +-- tests/geometry/test_function_sets.cpp | 48 +- tests/geometry/test_paving.cpp | 2 +- tests/hybrid/test_hybrid_evolution.cpp | 6 +- tests/hybrid/test_hybrid_evolver.cpp | 4 +- tests/output/test_graphics.cpp | 10 +- tests/solvers/test_constraint_solver.cpp | 18 +- tests/solvers/test_integrator.cpp | 64 +-- tests/solvers/test_nonlinear_programming.cpp | 50 +- tests/solvers/test_solvers.cpp | 56 +-- tests/symbolic/test_expression.cpp | 16 +- .../rigorous_numerics_tutorial.cpp | 10 +- 98 files changed, 1919 insertions(+), 1916 deletions(-) diff --git a/examples/noisy/noisy-utilities.hpp b/examples/noisy/noisy-utilities.hpp index 60cb930a9..400084f28 100644 --- a/examples/noisy/noisy-utilities.hpp +++ b/examples/noisy/noisy-utilities.hpp @@ -55,7 +55,7 @@ template Reverse reverse(C const& c) { return Reverse(c); } void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw) { - typedef typename ValidatedVectorFunctionModelType::NumericType NumericType; + typedef typename ValidatedVectorMultivariateFunctionModelType::NumericType NumericType; typedef typename NumericType::PrecisionType PrecisionType; PrecisionType prec; @@ -65,13 +65,14 @@ void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution StopWatch sw; - List flow_functions = integrator.flow(ivp,evolution_time); + List flow_functions = integrator.flow(ivp,evolution_time); sw.click(); - List reach_sets = map([](ValidatedVectorFunctionModelType const& fm){return ValidatedConstrainedImageSet(fm.domain(),fm);},flow_functions); + List reach_sets = map([](ValidatedVectorMultivariateFunctionModelType const& fm){return ValidatedConstrainedImageSet(fm.domain(),fm);},flow_functions); auto final_set = flow_functions.back(); - ValidatedVectorFunctionModelType evolve_function = partial_evaluate(final_set,final_set.argument_size()-1,NumericType(evolution_time,prec)); + ValidatedVectorMultivariateFunctionModelType evolve_function = + partial_evaluate(final_set,final_set.argument_size()-1,NumericType(evolution_time,prec)); auto evolve_set = ValidatedConstrainedImageSet(evolve_function.domain(),evolve_function); std::cout << "score: " << score(evolve_set) << ", time: " << sw.elapsed() << " s" << std::endl; diff --git a/python/source/calculus_submodule.cpp b/python/source/calculus_submodule.cpp index 2f29c4640..16c8186cc 100644 --- a/python/source/calculus_submodule.cpp +++ b/python/source/calculus_submodule.cpp @@ -44,31 +44,27 @@ namespace Ariadne { -//ValidatedNumericType evaluate(const ValidatedScalarFunctionModelDP& f, const Vector& x) { return f(x); } -//Vector evaluate(const ValidatedVectorFunctionModelDP& f, const Vector& x) { return f(x); } +//ValidatedNumericType evaluate(const ValidatedScalarMultivariateFunctionModelDP& f, const Vector& x) { return f(x); } +//Vector evaluate(const ValidatedVectorMultivariateFunctionModelDP& f, const Vector& x) { return f(x); } -//ValidatedScalarFunctionModelDP partial_evaluate(const ValidatedScalarFunctionModelDP&, SizeType, const ValidatedNumericType&); -//ValidatedVectorFunctionModelDP partial_evaluate(const ValidatedVectorFunctionModelDP&, SizeType, const ValidatedNumericType&); +//ValidatedScalarMultivariateFunctionModelDP partial_evaluate(const ValidatedScalarMultivariateFunctionModelDP&, SizeType, const ValidatedNumericType&); +//ValidatedVectorMultivariateFunctionModelDP partial_evaluate(const ValidatedVectorMultivariateFunctionModelDP&, SizeType, const ValidatedNumericType&); -//ValidatedScalarFunctionModelDP antiderivative(const ValidatedScalarFunctionModelDP&, SizeType, ValidatedNumericType); -//ValidatedVectorFunctionModelDP antiderivative(const ValidatedVectorFunctionModelDP&, SizeType, ValidatedNumericType); +//ValidatedScalarMultivariateFunctionModelDP antiderivative(const ValidatedScalarMultivariateFunctionModelDP&, SizeType, ValidatedNumericType); +//ValidatedVectorMultivariateFunctionModelDP antiderivative(const ValidatedVectorMultivariateFunctionModelDP&, SizeType, ValidatedNumericType); -//ValidatedScalarFunctionModelDP compose(const ValidatedScalarFunctionModelDP&, const ValidatedVectorFunctionModelDP&); -//ValidatedScalarFunctionModelDP compose(const ValidatedScalarFunction&, const ValidatedVectorFunctionModelDP&); -//ValidatedVectorFunctionModelDP compose(const ValidatedVectorFunctionModelDP&, const ValidatedVectorFunctionModelDP&); -//ValidatedVectorFunctionModelDP compose(const ValidatedVectorFunction&, const ValidatedVectorFunctionModelDP&); +//ValidatedScalarMultivariateFunctionModelDP compose(const ValidatedScalarMultivariateFunctionModelDP&, const ValidatedVectorMultivariateFunctionModelDP&); +//ValidatedScalarMultivariateFunctionModelDP compose(const ValidatedScalarMultivariateFunction&, const ValidatedVectorMultivariateFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP compose(const ValidatedVectorMultivariateFunctionModelDP&, const ValidatedVectorMultivariateFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP compose(const ValidatedVectorMultivariateFunction&, const ValidatedVectorMultivariateFunctionModelDP&); -//ValidatedVectorFunctionModelDP join(const ValidatedScalarFunctionModelDP&, const ValidatedScalarFunctionModelDP&); -//ValidatedVectorFunctionModelDP join(const ValidatedScalarFunctionModelDP&, const ValidatedVectorFunctionModelDP&); -//ValidatedVectorFunctionModelDP join(const ValidatedVectorFunctionModelDP&, const ValidatedScalarFunctionModelDP&); -//ValidatedVectorFunctionModelDP join(const ValidatedVectorFunctionModelDP&, const ValidatedVectorFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP join(const ValidatedScalarMultivariateFunctionModelDP&, const ValidatedScalarMultivariateFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP join(const ValidatedScalarMultivariateFunctionModelDP&, const ValidatedVectorMultivariateFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP join(const ValidatedVectorMultivariateFunctionModelDP&, const ValidatedScalarMultivariateFunctionModelDP&); +//ValidatedVectorMultivariateFunctionModelDP join(const ValidatedVectorMultivariateFunctionModelDP&, const ValidatedVectorMultivariateFunctionModelDP&); -template OutputStream& operator<<(OutputStream& os, const Representation< ScalarFunctionModel >& frepr) { - static_cast&>(frepr.reference()).repr(os); return os; -} - -template OutputStream& operator<<(OutputStream& os, const Representation< VectorFunctionModel >& frepr) { - static_cast&>(frepr.reference()).write(os); return os; +template OutputStream& operator<<(OutputStream& os, const Representation< FunctionModel >& frepr) { + static_cast&>(frepr.reference()).repr(os); return os; } ValidatedVectorTaylorFunctionModelDP __getslice__(const ValidatedVectorTaylorFunctionModelDP& tf, Int start, Int stop) { @@ -172,12 +168,12 @@ template List keys(const TaylorModel& tm) { return r; } -ValidatedScalarFunction unrestrict(const ValidatedScalarFunctionModelDP& fm) { - return ValidatedScalarFunction(fm.raw_pointer()->_clone()); +ValidatedScalarMultivariateFunction unrestrict(const ValidatedScalarMultivariateFunctionModelDP& fm) { + return ValidatedScalarMultivariateFunction(fm.raw_pointer()->_clone()); } -ValidatedVectorFunction unrestrict(const ValidatedVectorFunctionModelDP& fm) { - return ValidatedVectorFunction(fm.raw_pointer()->_clone()); +ValidatedVectorMultivariateFunction unrestrict(const ValidatedVectorMultivariateFunctionModelDP& fm) { + return ValidatedVectorMultivariateFunction(fm.raw_pointer()->_clone()); } } // namespace Ariadne @@ -319,16 +315,16 @@ Void export_approximate_taylor_model(pybind11::module& module) Void export_scalar_function_model(pybind11::module& module) { - pybind11::class_ scalar_function_model_class(module,"ValidatedScalarMultivariateFunctionModel"); - scalar_function_model_class.def(pybind11::init()); + pybind11::class_ scalar_function_model_class(module,"ValidatedScalarMultivariateFunctionModel"); + scalar_function_model_class.def(pybind11::init()); scalar_function_model_class.def(pybind11::init()); - scalar_function_model_class.def("argument_size", &ValidatedScalarFunctionModelDP::argument_size); - scalar_function_model_class.def("domain", &ValidatedScalarFunctionModelDP::domain); - scalar_function_model_class.def("codomain", &ValidatedScalarFunctionModelDP::codomain); - scalar_function_model_class.def("range", &ValidatedScalarFunctionModelDP::range); - scalar_function_model_class.def("clobber", &ValidatedScalarFunctionModelDP::clobber); - scalar_function_model_class.def("error", &ValidatedScalarFunctionModelDP::error); - scalar_function_model_class.def("__call__", (FloatDPBounds(ValidatedScalarFunctionModelDP::*)(const Vector&)const) &ValidatedScalarFunctionModelDP::operator()); + scalar_function_model_class.def("argument_size", &ValidatedScalarMultivariateFunctionModelDP::argument_size); + scalar_function_model_class.def("domain", &ValidatedScalarMultivariateFunctionModelDP::domain); + scalar_function_model_class.def("codomain", &ValidatedScalarMultivariateFunctionModelDP::codomain); + scalar_function_model_class.def("range", &ValidatedScalarMultivariateFunctionModelDP::range); + scalar_function_model_class.def("clobber", &ValidatedScalarMultivariateFunctionModelDP::clobber); + scalar_function_model_class.def("error", &ValidatedScalarMultivariateFunctionModelDP::error); + scalar_function_model_class.def("__call__", (FloatDPBounds(ValidatedScalarMultivariateFunctionModelDP::*)(const Vector&)const) &ValidatedScalarMultivariateFunctionModelDP::operator()); scalar_function_model_class.def(self+self); scalar_function_model_class.def(self-self); scalar_function_model_class.def(self*self); @@ -341,78 +337,78 @@ Void export_scalar_function_model(pybind11::module& module) scalar_function_model_class.def(ValidatedNumericType()-self); scalar_function_model_class.def(ValidatedNumericType()*self); scalar_function_model_class.def(ValidatedNumericType()/self); - scalar_function_model_class.def("__str__", &__cstr__); - scalar_function_model_class.def("__repr__", &__crepr__); + scalar_function_model_class.def("__str__", &__cstr__); + scalar_function_model_class.def("__repr__", &__crepr__); - module.def("evaluate", (ValidatedNumericType(*)(const ValidatedScalarFunctionModelDP&,const Vector&)) &evaluate); - module.def("partial_evaluate", &_partial_evaluate_); + module.def("evaluate", (ValidatedNumericType(*)(const ValidatedScalarMultivariateFunctionModelDP&,const Vector&)) &evaluate); + module.def("partial_evaluate", &_partial_evaluate_); - module.def("compose", _compose_); - module.def("compose", _compose_); + module.def("compose", _compose_); + module.def("compose", _compose_); - module.def("unrestrict", (ValidatedScalarFunction(*)(const ValidatedScalarFunctionModelDP&)) &unrestrict); + module.def("unrestrict", (ValidatedScalarMultivariateFunction(*)(const ValidatedScalarMultivariateFunctionModelDP&)) &unrestrict); - module.def("antiderivative", &_antiderivative_); + module.def("antiderivative", &_antiderivative_); } Void export_vector_function_model(pybind11::module& module) { - //using VectorFunctionModelType = ValidatedVectorFunctionModelDP; - //using ScalarFunctionModelType = ValidatedScalarFunctionModelDP; + //using VectorMultivariateFunctionModelType = ValidatedVectorMultivariateFunctionModelDP; + //using ScalarMultivariateFunctionModelType = ValidatedScalarMultivariateFunctionModelDP; - pybind11::class_ vector_function_model_class(module,"ValidatedVectorMultivariateFunctionModel"); - vector_function_model_class.def(pybind11::init()); -// vector_function_model_class.def(pybind11::init([](Array ary){return ValidatedVectorFunctionModelDP(Vector(ary));})); + pybind11::class_ vector_function_model_class(module,"ValidatedVectorMultivariateFunctionModel"); + vector_function_model_class.def(pybind11::init()); +// vector_function_model_class.def(pybind11::init([](Array ary){return ValidatedVectorMultivariateFunctionModelDP(Vector(ary));})); vector_function_model_class.def(pybind11::init()); - vector_function_model_class.def("result_size", &ValidatedVectorFunctionModelDP::result_size); - vector_function_model_class.def("argument_size", &ValidatedVectorFunctionModelDP::argument_size); - vector_function_model_class.def("domain", &ValidatedVectorFunctionModelDP::domain); - vector_function_model_class.def("codomain", &ValidatedVectorFunctionModelDP::codomain); - vector_function_model_class.def("range", &ValidatedVectorFunctionModelDP::range); + vector_function_model_class.def("result_size", &ValidatedVectorMultivariateFunctionModelDP::result_size); + vector_function_model_class.def("argument_size", &ValidatedVectorMultivariateFunctionModelDP::argument_size); + vector_function_model_class.def("domain", &ValidatedVectorMultivariateFunctionModelDP::domain); + vector_function_model_class.def("codomain", &ValidatedVectorMultivariateFunctionModelDP::codomain); + vector_function_model_class.def("range", &ValidatedVectorMultivariateFunctionModelDP::range); //vector_function_model_class.def("__getslice__", (ValidatedVectorTaylorFunctionModelDP(*)(const ValidatedVectorTaylorFunctionModelDP&,Int,Int))&__getslice__); - vector_function_model_class.def("__getitem__", &__getitem__); - vector_function_model_class.def("__setitem__",&__setitem__); - //vector_function_model_class.def("__setitem__",&__setitem__); - vector_function_model_class.def("__call__", (Vector(ValidatedVectorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorFunctionModelDP::operator()); + vector_function_model_class.def("__getitem__", &__getitem__); + vector_function_model_class.def("__setitem__",&__setitem__); + //vector_function_model_class.def("__setitem__",&__setitem__); + vector_function_model_class.def("__call__", (Vector(ValidatedVectorMultivariateFunctionModelDP::*)(const Vector&)const) &ValidatedVectorMultivariateFunctionModelDP::operator()); // NOTE: Not all operations are exported in C++ API. - //define_vector_algebra_arithmetic(module,vector_function_model_class); - //define_vector_arithmetic(module,vector_function_model_class); + //define_vector_algebra_arithmetic(module,vector_function_model_class); + //define_vector_arithmetic(module,vector_function_model_class); - vector_function_model_class.def("__str__", &__cstr__); - vector_function_model_class.def("__repr__", &__crepr__); - //export_vector_function_model.def(pybind11::module& module, "__repr__",&__repr__); + vector_function_model_class.def("__str__", &__cstr__); + vector_function_model_class.def("__repr__", &__crepr__); + //export_vector_function_model.def(pybind11::module& module, "__repr__",&__repr__); -// module.def("evaluate", (Vector(*)(const ValidatedVectorFunctionModelDP&,const Vector&)) &evaluate); - module.def("partial_evaluate", &_partial_evaluate_); +// module.def("evaluate", (Vector(*)(const ValidatedVectorMultivariateFunctionModelDP&,const Vector&)) &evaluate); + module.def("partial_evaluate", &_partial_evaluate_); - module.def("compose", &_compose_); - module.def("compose", &_compose_); + module.def("compose", &_compose_); + module.def("compose", &_compose_); - module.def("unrestrict", (ValidatedVectorFunction(*)(const ValidatedVectorFunctionModelDP&)) &unrestrict); + module.def("unrestrict", (ValidatedVectorMultivariateFunction(*)(const ValidatedVectorMultivariateFunctionModelDP&)) &unrestrict); - module.def("join", &_join_); - module.def("join", &_join_); - module.def("join", &_join_); - module.def("join", &_join_); + module.def("join", &_join_); + module.def("join", &_join_); + module.def("join", &_join_); + module.def("join", &_join_); - module.def("combine", &_combine_); - module.def("combine", &_combine_); + module.def("combine", &_combine_); + module.def("combine", &_combine_); - module.def("antiderivative", &_antiderivative_); - module.def("antiderivative", &_antiderivative_); + module.def("antiderivative", &_antiderivative_); + module.def("antiderivative", &_antiderivative_); -// to_python< List >(); +// to_python< List >(); } Void export_scalar_taylor_function(pybind11::module& module) { using FunctionModelType = ValidatedScalarTaylorFunctionModelDP; -// using FunctionType = ScalarFunction>; - using GenericFunctionType = ScalarFunction; +// using FunctionType = ScalarMultivariateFunction>; + using GenericFunctionType = ScalarMultivariateFunction; using NumericType = NumericType; using GenericNumericType = GenericType; @@ -430,7 +426,7 @@ Void export_scalar_taylor_function(pybind11::module& module) scalar_taylor_function_class.def(pybind11::init()); scalar_taylor_function_class.def(pybind11::init()); scalar_taylor_function_class.def(pybind11::init< ExactBoxType,SweeperDP >()); - scalar_taylor_function_class.def(pybind11::init< ExactBoxType, const EffectiveScalarFunction&,SweeperDP >()); + scalar_taylor_function_class.def(pybind11::init< ExactBoxType, const EffectiveScalarMultivariateFunction&,SweeperDP >()); scalar_taylor_function_class.def(pybind11::init< ExactBoxType, Expansion, FloatDPError, SweeperDP >()); scalar_taylor_function_class.def("error", (const FloatDPError&(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::error); scalar_taylor_function_class.def("set_error", (Void(ValidatedScalarTaylorFunctionModelDP::*)(const FloatDPError&)) &ValidatedScalarTaylorFunctionModelDP::set_error); @@ -461,7 +457,7 @@ Void export_scalar_taylor_function(pybind11::module& module) scalar_taylor_function_class.def("__call__", (FloatDPApproximation(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::operator()); scalar_taylor_function_class.def("__call__", (FloatDPBounds(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::operator()); scalar_taylor_function_class.def("gradient", (Covector(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::gradient); - scalar_taylor_function_class.def("function", (ValidatedScalarFunction(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::function); + scalar_taylor_function_class.def("function", (ValidatedScalarMultivariateFunction(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::function); scalar_taylor_function_class.def("polynomial", (Polynomial(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::polynomial); scalar_taylor_function_class.def("restriction", &_restriction_); module.def("restrict", &_restriction_); @@ -497,13 +493,13 @@ Void export_scalar_taylor_function(pybind11::module& module) Void export_vector_taylor_function(pybind11::module& module) { - //using VectorFunctionModelType = ValidatedVectorFunctionModelDP; - using ScalarFunctionModelType = ValidatedScalarFunctionModelDP; - using NumericType = NumericType; + //using VectorMultivariateFunctionModelType = ValidatedVectorMultivariateFunctionModelDP; + using ScalarMultivariateFunctionModelType = ValidatedScalarMultivariateFunctionModelDP; + using NumericType = NumericType; typedef SizeType I; - typedef ValidatedScalarFunction SFN; - typedef ValidatedVectorFunction VFN; + typedef ValidatedScalarMultivariateFunction SFN; + typedef ValidatedVectorMultivariateFunction VFN; typedef ValidatedScalarTaylorFunctionModelDP SF; typedef ValidatedVectorTaylorFunctionModelDP VF; typedef typename VF::DomainType D; @@ -511,7 +507,7 @@ Void export_vector_taylor_function(pybind11::module& module) typedef typename VF::NumericType X; typedef Vector VX; - Tag scalar_taylor_function_tag; + Tag scalar_taylor_function_tag; Tag> number_vector_tag; pybind11::class_ vector_taylor_function_class(module,"ValidatedVectorMultivariateTaylorFunctionModel"); @@ -519,7 +515,7 @@ Void export_vector_taylor_function(pybind11::module& module) // vector_taylor_function_class.def( pybind11::init>()); vector_taylor_function_class.def( pybind11::init([](Array ary){return ValidatedVectorTaylorFunctionModelDP(Vector(ary));})); vector_taylor_function_class.def( pybind11::init< SizeType, ExactBoxType, SweeperDP >()); - vector_taylor_function_class.def( pybind11::init< ExactBoxType,const EffectiveVectorFunction&,SweeperDP >()); + vector_taylor_function_class.def( pybind11::init< ExactBoxType,const EffectiveVectorMultivariateFunction&,SweeperDP >()); vector_taylor_function_class.def(pybind11::init< ExactBoxType, Vector< Expansion >, Vector, SweeperDP >()); vector_taylor_function_class.def( pybind11::init< Vector >()); vector_taylor_function_class.def("_len_", &ValidatedVectorTaylorFunctionModelDP::result_size); @@ -552,7 +548,7 @@ Void export_vector_taylor_function(pybind11::module& module) vector_taylor_function_class.def("__call__", (Vector(ValidatedVectorTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorTaylorFunctionModelDP::operator()); vector_taylor_function_class.def("jacobian", (Matrix(ValidatedVectorTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorTaylorFunctionModelDP::jacobian); vector_taylor_function_class.def("polynomials", (Vector< Polynomial >(ValidatedVectorTaylorFunctionModelDP::*)()const) &ValidatedVectorTaylorFunctionModelDP::polynomials); - vector_taylor_function_class.def("function", (ValidatedVectorFunction(ValidatedVectorTaylorFunctionModelDP::*)()const) &ValidatedVectorTaylorFunctionModelDP::function); + vector_taylor_function_class.def("function", (ValidatedVectorMultivariateFunction(ValidatedVectorTaylorFunctionModelDP::*)()const) &ValidatedVectorTaylorFunctionModelDP::function); vector_taylor_function_class.def_static("constant",(ValidatedVectorTaylorFunctionModelDP(*)(const ExactBoxType&, const Vector&,SweeperDP))&ValidatedVectorTaylorFunctionModelDP::constant); vector_taylor_function_class.def_static("constant",[](const ExactBoxType& bx, const Vector& c,SweeperDP swp){return ValidatedVectorTaylorFunctionModelDP::constant(bx,Vector(c,swp.precision()),swp);}); @@ -585,8 +581,8 @@ Void export_vector_taylor_function(pybind11::module& module) module.def("antiderivative", &_antiderivative_); module.def("antiderivative", &_antiderivative_); - module.def("compose", &_compose_); - module.def("compose", &_compose_); + module.def("compose", &_compose_); + module.def("compose", &_compose_); } diff --git a/python/source/function_submodule.cpp b/python/source/function_submodule.cpp index bacb9d441..f5d09fd4e 100644 --- a/python/source/function_submodule.cpp +++ b/python/source/function_submodule.cpp @@ -81,12 +81,8 @@ OutputStream& operator<<(OutputStream& os, const PythonRepresentation OutputStream& operator<<(OutputStream& os, const Representation< ScalarFunction >& frepr) { - static_cast&>(frepr.reference()).repr(os); return os; -} - -template OutputStream& operator<<(OutputStream& os, const Representation< VectorFunction >& frepr) { - static_cast&>(frepr.reference()).repr(os); return os; +template OutputStream& operator<<(OutputStream& os, const Representation< Function >& frepr) { + static_cast&>(frepr.reference()).repr(os); return os; } }// namespace Ariadne @@ -219,8 +215,8 @@ template Void export_function_evaluation(pybind11::class_& function_ -template Void export_scalar_function_evaluation(pybind11::class_>& scalar_function_class) { - using FP=ScalarFunction

; +template Void export_scalar_function_evaluation(pybind11::class_>& scalar_function_class) { + using FP=ScalarMultivariateFunction

; export_function_evaluation(scalar_function_class); def_gradient>(scalar_function_class); def_gradient>(scalar_function_class); @@ -228,15 +224,15 @@ template Void export_scalar_function_evaluation(pybind11::class_>(scalar_function_class); } -template<> Void export_scalar_function_evaluation(pybind11::class_>& scalar_function_class) { +template<> Void export_scalar_function_evaluation(pybind11::class_>& scalar_function_class) { using P=ApproximateTag; - using FP=ScalarFunction

; + using FP=ScalarMultivariateFunction

; export_function_evaluation(scalar_function_class); def_gradient>(scalar_function_class); def_gradient>(scalar_function_class); } -Void export_function_evaluation(pybind11::class_>& scalar_function_class) +Void export_function_evaluation(pybind11::class_>& scalar_function_class) { def_call>(scalar_function_class); def_call>(scalar_function_class); @@ -247,46 +243,46 @@ Void export_function_evaluation(pybind11::class_> def_evaluate>(scalar_function_class); } -template Void export_vector_function_evaluation(pybind11::class_>& vector_function_class){ +template Void export_vector_function_evaluation(pybind11::class_>& vector_function_class){ export_function_evaluation(vector_function_class); } template Void export_scalar_function(pybind11::module& module) { - pybind11::class_> scalar_function_class(module,(class_name

()+"ScalarMultivariateFunction").c_str()); - scalar_function_class.def(pybind11::init>()); + pybind11::class_> scalar_function_class(module,(class_name

()+"ScalarMultivariateFunction").c_str()); + scalar_function_class.def(pybind11::init>()); scalar_function_class.def(pybind11::init()); - scalar_function_class.def("argument_size", &ScalarFunction

::argument_size); - scalar_function_class.def("derivative", &ScalarFunction

::derivative); - define_elementary_algebra,Number

>(module,scalar_function_class); + scalar_function_class.def("argument_size", &ScalarMultivariateFunction

::argument_size); + scalar_function_class.def("derivative", &ScalarMultivariateFunction

::derivative); + define_elementary_algebra,Number

>(module,scalar_function_class); if constexpr (IsSame::value) { - scalar_function_class.def(pybind11::init>()); - pybind11::implicitly_convertible,ScalarFunction>(); + scalar_function_class.def(pybind11::init>()); + pybind11::implicitly_convertible,ScalarMultivariateFunction>(); } //FIXME -// scalar_function_class.def("__eq__", &__eq__,Number

>,ScalarFunction

,Number

>); -// scalar_function_class.def("__le__", &__le__,Number

>,ScalarFunction

,Number

>); -// scalar_function_class.def("__ge__", &__ge__,Number

>,ScalarFunction

,Number

>); +// scalar_function_class.def("__eq__", &__eq__,Number

>,ScalarMultivariateFunction

,Number

>); +// scalar_function_class.def("__le__", &__le__,Number

>,ScalarMultivariateFunction

,Number

>); +// scalar_function_class.def("__ge__", &__ge__,Number

>,ScalarMultivariateFunction

,Number

>); - scalar_function_class.def("__str__", &__cstr__>); - scalar_function_class.def("__repr__", &__crepr__>); + scalar_function_class.def("__str__", &__cstr__>); + scalar_function_class.def("__repr__", &__crepr__>); - scalar_function_class.def_static("constant", (ScalarFunction

(*)(SizeType,Number

)) &ScalarFunction

::constant); - scalar_function_class.def_static("coordinate", (ScalarFunction

(*)(SizeType,SizeType)) &ScalarFunction

::coordinate); + scalar_function_class.def_static("constant", (ScalarMultivariateFunction

(*)(SizeType,Number

)) &ScalarMultivariateFunction

::constant); + scalar_function_class.def_static("coordinate", (ScalarMultivariateFunction

(*)(SizeType,SizeType)) &ScalarMultivariateFunction

::coordinate); - scalar_function_class.def("gradient", (Covector(ScalarFunction

::*)(const Vector&)const) &ScalarFunction

::gradient); + scalar_function_class.def("gradient", (Covector(ScalarMultivariateFunction

::*)(const Vector&)const) &ScalarMultivariateFunction

::gradient); if constexpr (not IsSame::value) { - scalar_function_class.def("gradient", (Covector(ScalarFunction

::*)(const Vector&)const) &ScalarFunction

::gradient); + scalar_function_class.def("gradient", (Covector(ScalarMultivariateFunction

::*)(const Vector&)const) &ScalarMultivariateFunction

::gradient); } - module.def("derivative", (ScalarFunction

(ScalarFunction

::*)(SizeType)const) &ScalarFunction

::derivative); + module.def("derivative", (ScalarMultivariateFunction

(ScalarMultivariateFunction

::*)(SizeType)const) &ScalarMultivariateFunction

::derivative); - module.def("evaluate", (Scalar(*)(const ScalarFunction

&,const Vector&)) &evaluate); + module.def("evaluate", (Scalar(*)(const ScalarMultivariateFunction

&,const Vector&)) &evaluate); if constexpr (not IsSame::value) { - module.def("evaluate", (Scalar(*)(const ScalarFunction

&,const Vector&)) &evaluate); + module.def("evaluate", (Scalar(*)(const ScalarMultivariateFunction

&,const Vector&)) &evaluate); } export_scalar_function_evaluation(scalar_function_class); @@ -295,15 +291,15 @@ template Void export_scalar_function(pybind11::module& module) template Void export_vector_function(pybind11::module& module) { - pybind11::class_> vector_function_class(module,(class_name

()+"VectorMultivariateFunction").c_str()); - vector_function_class.def(pybind11::init>()); + pybind11::class_> vector_function_class(module,(class_name

()+"VectorMultivariateFunction").c_str()); + vector_function_class.def(pybind11::init>()); vector_function_class.def(pybind11::init()); if constexpr (IsSame::value) { - vector_function_class.def(pybind11::init>()); -// pybind11::implicitly_convertible,VectorFunction>(); + vector_function_class.def(pybind11::init>()); +// pybind11::implicitly_convertible,VectorMultivariateFunction>(); } // NOTE: This must go *after* the conversion constructor - vector_function_class.def(pybind11::init([](std::vector> const& lst){return VectorMultivariateFunction

(lst);})); + vector_function_class.def(pybind11::init([](std::vector> const& lst){return VectorMultivariateFunction

(lst);})); vector_function_class.def("result_size", &VectorMultivariateFunction

::result_size); vector_function_class.def("argument_size", &VectorMultivariateFunction

::argument_size); @@ -311,36 +307,36 @@ template Void export_vector_function(pybind11::module& module) vector_function_class.def("__setitem__", &VectorMultivariateFunction

::set); // TODO: Put these in C++ API - // define_vector_algebra_arithmetic,ScalarFunction

,Number

>(module,vector_function_class); + // define_vector_algebra_arithmetic,ScalarMultivariateFunction

,Number

>(module,vector_function_class); // FIXME: Define vector function operations for Validated and Approximate if constexpr (IsSame::value) { - define_vector_algebra_arithmetic,ScalarFunction

>(module,vector_function_class); + define_vector_algebra_arithmetic,ScalarMultivariateFunction

>(module,vector_function_class); } export_vector_function_evaluation(vector_function_class); - vector_function_class.def("jacobian", (Matrix(VectorFunction

::*)(const Vector&)const) &VectorFunction

::jacobian); + vector_function_class.def("jacobian", (Matrix(VectorMultivariateFunction

::*)(const Vector&)const) &VectorMultivariateFunction

::jacobian); if constexpr (not IsSame::value) { - vector_function_class.def("jacobian", (Matrix(VectorFunction

::*)(const Vector&)const) &VectorFunction

::jacobian); + vector_function_class.def("jacobian", (Matrix(VectorMultivariateFunction

::*)(const Vector&)const) &VectorMultivariateFunction

::jacobian); } - vector_function_class.def("__str__", &__cstr__>); - vector_function_class.def("__repr__", &__crepr__>); + vector_function_class.def("__str__", &__cstr__>); + vector_function_class.def("__repr__", &__crepr__>); - vector_function_class.def_static("identity", (VectorFunction

(*)(SizeType)) &VectorFunction

::identity); + vector_function_class.def_static("identity", (VectorMultivariateFunction

(*)(SizeType)) &VectorMultivariateFunction

::identity); - module.def("evaluate", (Vector(*)(const VectorFunction

&,const Vector&)) &evaluate); + module.def("evaluate", (Vector(*)(const VectorMultivariateFunction

&,const Vector&)) &evaluate); if constexpr (not IsSame::value) { - module.def("evaluate", (Vector(*)(const VectorFunction

&,const Vector&)) &evaluate); + module.def("evaluate", (Vector(*)(const VectorMultivariateFunction

&,const Vector&)) &evaluate); } - module.def("join", (VectorFunction

(*)(const ScalarFunction

&, const ScalarFunction

&)) &join); - module.def("join", (VectorFunction

(*)(const VectorFunction

&, const ScalarFunction

&)) &join); - module.def("join", (VectorFunction

(*)(const ScalarFunction

&, const VectorFunction

&)) &join); - module.def("join", (VectorFunction

(*)(const VectorFunction

&, const VectorFunction

&)) &join); + module.def("join", (VectorMultivariateFunction

(*)(const ScalarMultivariateFunction

&, const ScalarMultivariateFunction

&)) &join); + module.def("join", (VectorMultivariateFunction

(*)(const VectorMultivariateFunction

&, const ScalarMultivariateFunction

&)) &join); + module.def("join", (VectorMultivariateFunction

(*)(const ScalarMultivariateFunction

&, const VectorMultivariateFunction

&)) &join); + module.def("join", (VectorMultivariateFunction

(*)(const VectorMultivariateFunction

&, const VectorMultivariateFunction

&)) &join); - module.def("compose", (ScalarFunction

(*)(const ScalarFunction

&,const VectorFunction

&)) &compose); - module.def("compose", (VectorFunction

(*)(const VectorFunction

&,const VectorFunction

&)) &compose); + module.def("compose", (ScalarMultivariateFunction

(*)(const ScalarMultivariateFunction

&,const VectorMultivariateFunction

&)) &compose); + module.def("compose", (VectorMultivariateFunction

(*)(const VectorMultivariateFunction

&,const VectorMultivariateFunction

&)) &compose); export_vector_function_evaluation(vector_function_class); } @@ -349,7 +345,7 @@ template Void export_procedure(pybind11::module& module) { typedef Paradigm P; pybind11::class_> procedure_class(module,(class_name

()+"Procedure").c_str()); procedure_class.def("__str__", &__cstr__>); - module.def("make_procedure", (Procedure(*)(ScalarFunction

const&)) &make_procedure); + module.def("make_procedure", (Procedure(*)(ScalarMultivariateFunction

const&)) &make_procedure); module.def("evaluate", (X(*)(Procedure const&, Vector const&)) &evaluate); module.def("gradient", (Covector(*)(Procedure const&, Vector const&)) &gradient); module.def("hessian", (X(*)(Procedure const&, Vector const&, Vector const&)) &hessian); @@ -359,19 +355,19 @@ Void export_scalar_functions(pybind11::module& module) { export_scalar_function(module); export_scalar_function(module); export_scalar_function(module); - pybind11::implicitly_convertible,ScalarFunction>(); - pybind11::implicitly_convertible,ScalarFunction>(); - pybind11::implicitly_convertible,ScalarFunction>(); - module.def("lie_derivative", (ScalarFunction(*)(const ScalarFunction&,const VectorFunction&)) &lie_derivative); + pybind11::implicitly_convertible,ScalarMultivariateFunction>(); + pybind11::implicitly_convertible,ScalarMultivariateFunction>(); + pybind11::implicitly_convertible,ScalarMultivariateFunction>(); + module.def("lie_derivative", (ScalarMultivariateFunction(*)(const ScalarMultivariateFunction&,const VectorMultivariateFunction&)) &lie_derivative); } Void export_vector_functions(pybind11::module& module) { export_vector_function(module); export_vector_function(module); export_vector_function(module); - pybind11::implicitly_convertible,VectorFunction>(); - pybind11::implicitly_convertible,VectorFunction>(); - pybind11::implicitly_convertible,VectorFunction>(); + pybind11::implicitly_convertible,VectorMultivariateFunction>(); + pybind11::implicitly_convertible,VectorMultivariateFunction>(); + pybind11::implicitly_convertible,VectorMultivariateFunction>(); } diff --git a/python/source/geometry_submodule.cpp b/python/source/geometry_submodule.cpp index 0e0d7ce06..8720952d9 100644 --- a/python/source/geometry_submodule.cpp +++ b/python/source/geometry_submodule.cpp @@ -359,7 +359,7 @@ Void export_boxes(pybind11::module& module) { pybind11::implicitly_convertible(); module.def("widen", (UpperBoxType(*)(ExactBoxType const&, FloatDPValue eps)) &widen); - module.def("image", (UpperBoxType(*)(UpperBoxType const&, ValidatedVectorFunction const&)) &_image_); + module.def("image", (UpperBoxType(*)(UpperBoxType const&, ValidatedVectorMultivariateFunction const&)) &_image_); } /* @@ -388,7 +388,7 @@ Void export_zonotope(pybind11::module& module) module.def("orthogonal_over_approximation", (Zonotope(*)(const Zonotope&)) &orthogonal_over_approximation); module.def("error_free_over_approximation", (Zonotope(*)(const Zonotope&)) &error_free_over_approximation); -// module.def("image", (Zonotope(*)(const Zonotope&, const ValidatedVectorFunction&)) &image); +// module.def("image", (Zonotope(*)(const Zonotope&, const ValidatedVectorMultivariateFunction&)) &image); } Void export_polytope(pybind11::module& module) @@ -438,7 +438,7 @@ Void export_affine_set(pybind11::module& module) affine_set_class.def("boundary", &ValidatedAffineConstrainedImageSet::boundary); affine_set_class.def("__str__",&__cstr__); - module.def("image", (ValidatedAffineConstrainedImageSet(*)(ValidatedAffineConstrainedImageSet const&,ValidatedVectorFunction const&)) &_image_); + module.def("image", (ValidatedAffineConstrainedImageSet(*)(ValidatedAffineConstrainedImageSet const&,ValidatedVectorMultivariateFunction const&)) &_image_); } Void export_constraint_set(pybind11::module& module) @@ -470,7 +470,7 @@ Void export_constraint_set(pybind11::module& module) module.def("intersection", (BoundedConstraintSet(*)(ConstraintSet const&, BoundedConstraintSet const&)) &_intersection_); module.def("intersection", (BoundedConstraintSet(*)(BoundedConstraintSet const&, ConstraintSet const&)) &_intersection_); - module.def("image", (ConstrainedImageSet(*)(BoundedConstraintSet const&, EffectiveVectorFunction const&)) &_image_); + module.def("image", (ConstrainedImageSet(*)(BoundedConstraintSet const&, EffectiveVectorMultivariateFunction const&)) &_image_); } @@ -491,10 +491,10 @@ Void export_constrained_image_set(pybind11::module& module) validated_constrained_image_set_class(module,"ValidatedConstrainedImageSet", pybind11::multiple_inheritance()); validated_constrained_image_set_class.def(pybind11::init()); validated_constrained_image_set_class.def(pybind11::init()); - validated_constrained_image_set_class.def(pybind11::init()); - validated_constrained_image_set_class.def(pybind11::init()); - validated_constrained_image_set_class.def(pybind11::init >()); - validated_constrained_image_set_class.def(pybind11::init()); + validated_constrained_image_set_class.def(pybind11::init()); + validated_constrained_image_set_class.def(pybind11::init()); + validated_constrained_image_set_class.def(pybind11::init >()); + validated_constrained_image_set_class.def(pybind11::init()); validated_constrained_image_set_class.def("domain", &ValidatedConstrainedImageSet::domain); validated_constrained_image_set_class.def("function", &ValidatedConstrainedImageSet::function); validated_constrained_image_set_class.def("constraint", &ValidatedConstrainedImageSet::constraint); diff --git a/python/source/optimization_submodule.cpp b/python/source/optimization_submodule.cpp index 73e8ebb70..06ff4633e 100644 --- a/python/source/optimization_submodule.cpp +++ b/python/source/optimization_submodule.cpp @@ -55,33 +55,33 @@ Void export_slackness(pybind11::module& module) Void export_constraint(pybind11::module& module) { pybind11::class_ effective_nonlinear_constraint_class(module,"EffectiveConstraint"); - effective_nonlinear_constraint_class.def(pybind11::init()); + effective_nonlinear_constraint_class.def(pybind11::init()); effective_nonlinear_constraint_class.def("__str__",&__cstr__); pybind11::class_ validated_nonlinear_constraint_class(module,"ValidatedConstraint"); - validated_nonlinear_constraint_class.def(pybind11::init()); + validated_nonlinear_constraint_class.def(pybind11::init()); validated_nonlinear_constraint_class.def(pybind11::init()); validated_nonlinear_constraint_class.def(pybind11::init()); validated_nonlinear_constraint_class.def("lower_bound", &ValidatedConstraint::lower_bound); validated_nonlinear_constraint_class.def("upper_bound", &ValidatedConstraint::upper_bound); - validated_nonlinear_constraint_class.def("function", (const ValidatedScalarFunction&(ValidatedConstraint::*)()const) &ValidatedConstraint::function); + validated_nonlinear_constraint_class.def("function", (const ValidatedScalarMultivariateFunction&(ValidatedConstraint::*)()const) &ValidatedConstraint::function); validated_nonlinear_constraint_class.def("__str__",&__cstr__); } Void export_optimiser_interface(pybind11::module& module) { pybind11::class_ optimiser_interface_class(module,"OptimiserInterface"); - optimiser_interface_class.def("minimise", (Vector(OptimiserInterface::*)(ValidatedScalarFunction, ExactBoxType, ValidatedVectorFunction, ExactBoxType)const) &OptimiserInterface::minimise); - optimiser_interface_class.def("minimise", (Vector(OptimiserInterface::*)(ValidatedScalarFunction, ExactBoxType, ValidatedVectorFunction, ValidatedVectorFunction)const) &OptimiserInterface::minimise); - optimiser_interface_class.def("feasible", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType)const) &OptimiserInterface::feasible); - optimiser_interface_class.def("feasible", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ValidatedVectorFunction)const) &OptimiserInterface::feasible); - optimiser_interface_class.def("almost_feasible_point", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,FloatApproximationVector, FloatDPApproximation)const) &OptimiserInterface::almost_feasible_point); - optimiser_interface_class.def("is_feasible_point", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,ExactFloatVector)const) &OptimiserInterface::is_feasible_point); - optimiser_interface_class.def("validate_feasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,ExactVector)const) &OptimiserInterface::validate_feasibility); - optimiser_interface_class.def("validate_feasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,ExactVector,ExactVector)const) &OptimiserInterface::validate_feasibility); - optimiser_interface_class.def("validate_infeasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,ExactVector,ExactVector)const) &OptimiserInterface::validate_feasibility); - optimiser_interface_class.def("validate_infeasibility", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,FloatBoundsVector)const) &OptimiserInterface::contains_feasible_point); - optimiser_interface_class.def("is_infeasibility_certificate", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorFunction, ExactBoxType,FloatBoundsVector)const) &OptimiserInterface::contains_feasible_point); + optimiser_interface_class.def("minimise", (Vector(OptimiserInterface::*)(ValidatedScalarMultivariateFunction, ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType)const) &OptimiserInterface::minimise); + optimiser_interface_class.def("minimise", (Vector(OptimiserInterface::*)(ValidatedScalarMultivariateFunction, ExactBoxType, ValidatedVectorMultivariateFunction, ValidatedVectorMultivariateFunction)const) &OptimiserInterface::minimise); + optimiser_interface_class.def("feasible", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType)const) &OptimiserInterface::feasible); + optimiser_interface_class.def("feasible", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ValidatedVectorMultivariateFunction)const) &OptimiserInterface::feasible); + optimiser_interface_class.def("almost_feasible_point", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,FloatApproximationVector, FloatDPApproximation)const) &OptimiserInterface::almost_feasible_point); + optimiser_interface_class.def("is_feasible_point", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,ExactFloatVector)const) &OptimiserInterface::is_feasible_point); + optimiser_interface_class.def("validate_feasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,ExactVector)const) &OptimiserInterface::validate_feasibility); + optimiser_interface_class.def("validate_feasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,ExactVector,ExactVector)const) &OptimiserInterface::validate_feasibility); + optimiser_interface_class.def("validate_infeasibility", (Bool(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,ExactVector,ExactVector)const) &OptimiserInterface::validate_feasibility); + optimiser_interface_class.def("validate_infeasibility", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,FloatBoundsVector)const) &OptimiserInterface::contains_feasible_point); + optimiser_interface_class.def("is_infeasibility_certificate", (ValidatedKleenean(OptimiserInterface::*)(ExactBoxType, ValidatedVectorMultivariateFunction, ExactBoxType,FloatBoundsVector)const) &OptimiserInterface::contains_feasible_point); //NOTE: Not in C++ API //optimiser_interface_class.def("__str__", &__cstr__); } @@ -109,11 +109,11 @@ Void export_constraint_solver(pybind11::module& module) { pybind11::class_ constraint_solver_class(module,"ConstraintSolver"); constraint_solver_class.def(pybind11::init<>()); - constraint_solver_class.def("hull_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarFunction&,const ExactIntervalType&)const) &ConstraintSolver::hull_reduce); - constraint_solver_class.def("box_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarFunction&,const ExactIntervalType&,Nat)const) &ConstraintSolver::box_reduce); - constraint_solver_class.def("monotone_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarFunction&,const ExactIntervalType&,Nat)const) &ConstraintSolver::monotone_reduce); + constraint_solver_class.def("hull_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarMultivariateFunction&,const ExactIntervalType&)const) &ConstraintSolver::hull_reduce); + constraint_solver_class.def("box_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarMultivariateFunction&,const ExactIntervalType&,Nat)const) &ConstraintSolver::box_reduce); + constraint_solver_class.def("monotone_reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedScalarMultivariateFunction&,const ExactIntervalType&,Nat)const) &ConstraintSolver::monotone_reduce); constraint_solver_class.def("reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const List&)const) &ConstraintSolver::reduce); - constraint_solver_class.def("reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedVectorFunction&,const ExactBoxType&)const) &ConstraintSolver::reduce); + constraint_solver_class.def("reduce", (Bool(ConstraintSolver::*)(UpperBoxType&,const ValidatedVectorMultivariateFunction&,const ExactBoxType&)const) &ConstraintSolver::reduce); } diff --git a/python/source/solver_submodule.cpp b/python/source/solver_submodule.cpp index 819878663..e94cd4501 100644 --- a/python/source/solver_submodule.cpp +++ b/python/source/solver_submodule.cpp @@ -52,21 +52,21 @@ class SolverWrapper FloatDPValue maximum_error() const { return this->get_override("maximum_error")(); } Void set_maximum_number_of_steps(Nat ns) { this->get_override("set_maximum_number_of_steps")(ns); } Nat maximum_number_of_steps() const { return this->get_override("maximum_number_of_steps")(); } - ValidatedVectorType zero(const ValidatedVectorFunction& f, const ExactBoxType& bx) const { + ValidatedVectorType zero(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { return this->get_override("zero")(f,bx); } - ValidatedVectorType fixed_point(const ValidatedVectorFunction& f, const ExactBoxType& bx) const { + ValidatedVectorType fixed_point(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { return this->get_override("fixed_point")(f,bx); } - ValidatedVectorType solve(const ValidatedVectorFunction& f, const ValidatedVectorType& pt) const { + ValidatedVectorType solve(const ValidatedVectorMultivariateFunction& f, const ValidatedVectorType& pt) const { return this->get_override("solve")(f,pt); } - ValidatedVectorType solve(const ValidatedVectorFunction& f, const ExactBoxType& bx) const { + ValidatedVectorType solve(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { return this->get_override("solve")(f,bx); } - ValidatedVectorFunctionModelDP implicit(const ValidatedVectorFunction& f, const ExactBoxType& pd, const ExactBoxType& bx) const { + ValidatedVectorMultivariateFunctionModelDP implicit(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& pd, const ExactBoxType& bx) const { return this->get_override("implicit")(f,pd,bx); } - ValidatedScalarFunctionModelDP implicit(const ValidatedScalarFunction& f, const ExactBoxType& pd, const ExactIntervalType& ivl) const { + ValidatedScalarMultivariateFunctionModelDP implicit(const ValidatedScalarMultivariateFunction& f, const ExactBoxType& pd, const ExactIntervalType& ivl) const { return this->get_override("implicit")(f,pd,ivl); } - ValidatedVectorFunctionModelDP continuation(const ValidatedVectorFunction& f, const ApproximateVectorType& a, const ExactBoxType& X, const ExactBoxType& A) const { + ValidatedVectorMultivariateFunctionModelDP continuation(const ValidatedVectorMultivariateFunction& f, const ApproximateVectorType& a, const ExactBoxType& X, const ExactBoxType& A) const { return this->get_override("continuation")(f,a,X,A); } - Set< ValidatedVectorType > solve_all(const ValidatedVectorFunction& f, const ExactBoxType& bx) const { + Set< ValidatedVectorType > solve_all(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { return this->get_override("solve_all")(f,bx); } Void write(OutputStream& os) const { this->get_override("write")(os); } }; @@ -84,17 +84,17 @@ class IntegratorWrapper this->get_override("set_maximum_error")(me); } double maximum_error() const { return this->get_override("maximum_error")(); } - Pair flow_bounds(const ValidatedVectorFunction& vf, const ExactBoxType& D, const StepSizeType& h) const { + Pair flow_bounds(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& D, const StepSizeType& h) const { return this->get_override("flow_bounds")(vf,D,h); } - ValidatedVectorFunctionModelDP flow_step(const ValidatedVectorFunction& vf, const ExactBoxType& D, StepSizeType& h) const { + ValidatedVectorMultivariateFunctionModelDP flow_step(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& D, StepSizeType& h) const { return this->get_override("flow_step")(vf,D,h); } - ValidatedVectorFunctionModelDP flow_step(const ValidatedVectorFunction& vf, const ExactBoxType& D, const StepSizeType& h, const UpperBoxType& B) const { + ValidatedVectorMultivariateFunctionModelDP flow_step(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& D, const StepSizeType& h, const UpperBoxType& B) const { return this->get_override("flow_step")(vf,D,h,B); } - ValidatedVectorFunctionModelDP flow_to(const ValidatedVectorFunction& vf ,const ExactBoxType& D, const Real& tf) const { + ValidatedVectorMultivariateFunctionModelDP flow_to(const ValidatedVectorMultivariateFunction& vf ,const ExactBoxType& D, const Real& tf) const { return this->get_override("flow_to")(vf,D,tf); } - List flow(const ValidatedVectorFunction& vf, const ExactBoxType& D, const Real& t0, const Real& tf) const { + List flow(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& D, const Real& t0, const Real& tf) const { return this->get_override("flow")(vf,D,t0,tf); } - List flow(const ValidatedVectorFunction& vf, const ExactBoxType& D, const Real& tf) const { + List flow(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& D, const Real& tf) const { return this->get_override("flow")(vf,D,tf); } Void write(OutputStream& os) const { this->get_override("write")(os); } @@ -106,10 +106,10 @@ class IntegratorWrapper Void export_solvers(pybind11::module& module) { pybind11::class_ solver_interface_class(module,"SolverInterface"); - solver_interface_class.def("solve", (Vector(SolverInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&)const) &SolverInterface::solve); - solver_interface_class.def("implicit",(ValidatedVectorFunctionModelDP(SolverInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&,const ExactBoxType&)const) &SolverInterface::implicit); - solver_interface_class.def("implicit",(ValidatedScalarFunctionModelDP(SolverInterface::*)(const ValidatedScalarFunction&,const ExactBoxType&,const ExactIntervalType&)const) &SolverInterface::implicit); - solver_interface_class.def("solve_all",(Set< Vector >(SolverInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&)const) &SolverInterface::solve_all); + solver_interface_class.def("solve", (Vector(SolverInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&)const) &SolverInterface::solve); + solver_interface_class.def("implicit",(ValidatedVectorMultivariateFunctionModelDP(SolverInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&,const ExactBoxType&)const) &SolverInterface::implicit); + solver_interface_class.def("implicit",(ValidatedScalarMultivariateFunctionModelDP(SolverInterface::*)(const ValidatedScalarMultivariateFunction&,const ExactBoxType&,const ExactIntervalType&)const) &SolverInterface::implicit); + solver_interface_class.def("solve_all",(Set< Vector >(SolverInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&)const) &SolverInterface::solve_all); solver_interface_class.def("__str__",&__cstr__); pybind11::class_ interval_newton_solver_class(module,"IntervalNewtonSolver"); @@ -124,11 +124,11 @@ Void export_solvers(pybind11::module& module) Void export_integrators(pybind11::module& module) { pybind11::class_ integrator_interface_class(module,"IntegratorInterface"); - integrator_interface_class.def("flow_bounds",(Pair(IntegratorInterface::*)(const ValidatedVectorFunction&, const ExactBoxType&, const StepSizeType&)const)&IntegratorInterface::flow_bounds); - integrator_interface_class.def("flow_step",(ValidatedVectorFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorFunction&, const ExactBoxType&, StepSizeType&)const)&IntegratorInterface::flow_step); - integrator_interface_class.def("flow_step",(ValidatedVectorFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&,const StepSizeType&,const UpperBoxType&)const)&IntegratorInterface::flow_step); - integrator_interface_class.def("flow_to",(ValidatedVectorFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&,const Real&)const)&IntegratorInterface::flow_to); - integrator_interface_class.def("flow",(List(IntegratorInterface::*)(const ValidatedVectorFunction&,const ExactBoxType&,const Real&)const)&IntegratorInterface::flow); + integrator_interface_class.def("flow_bounds",(Pair(IntegratorInterface::*)(const ValidatedVectorMultivariateFunction&, const ExactBoxType&, const StepSizeType&)const)&IntegratorInterface::flow_bounds); + integrator_interface_class.def("flow_step",(ValidatedVectorMultivariateFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorMultivariateFunction&, const ExactBoxType&, StepSizeType&)const)&IntegratorInterface::flow_step); + integrator_interface_class.def("flow_step",(ValidatedVectorMultivariateFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&,const StepSizeType&,const UpperBoxType&)const)&IntegratorInterface::flow_step); + integrator_interface_class.def("flow_to",(ValidatedVectorMultivariateFunctionModelDP(IntegratorInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&,const Real&)const)&IntegratorInterface::flow_to); + integrator_interface_class.def("flow",(List(IntegratorInterface::*)(const ValidatedVectorMultivariateFunction&,const ExactBoxType&,const Real&)const)&IntegratorInterface::flow); integrator_interface_class.def("__str__", &__cstr__); pybind11::class_ taylor_picard_integrator_class(module,"TaylorPicardIntegrator"); diff --git a/python/source/symbolic_submodule.cpp b/python/source/symbolic_submodule.cpp index 427299550..f62fcab9b 100644 --- a/python/source/symbolic_submodule.cpp +++ b/python/source/symbolic_submodule.cpp @@ -293,8 +293,8 @@ Void export_expressions(pybind11::module& module) continuous_predicate_class.def("__str__",&__cstr__); module.def("make_function", (RealScalarUnivariateFunction(*)(RealVariable const&, RealExpression const&)) &make_function); - module.def("make_function", (RealScalarFunction(*)(RealSpace const&, RealExpression const&)) &make_function); - module.def("make_function", (RealVectorFunction(*)(RealSpace const&, Vector const&)) &make_function); + module.def("make_function", (RealScalarMultivariateFunction(*)(RealSpace const&, RealExpression const&)) &make_function); + module.def("make_function", (RealVectorMultivariateFunction(*)(RealSpace const&, Vector const&)) &make_function); pybind11::implicitly_convertible(); pybind11::implicitly_convertible(); diff --git a/source/dynamics/differential_inclusion.cpp b/source/dynamics/differential_inclusion.cpp index 0747bccd7..9f5a3c8d3 100644 --- a/source/dynamics/differential_inclusion.cpp +++ b/source/dynamics/differential_inclusion.cpp @@ -106,7 +106,7 @@ Pair centered_variables_transformation(RealVar return Pair(assignments,new_bounds); } -Tuple,BoxDomainType> +Tuple,BoxDomainType> expression_to_function(DottedRealAssignments const& dynamics, const RealVariablesBox& inputs) { auto transformations = centered_variables_transformation(inputs); @@ -142,9 +142,9 @@ expression_to_function(DottedRealAssignments const& dynamics, const RealVariable for (auto var : var_spc.indices()) { f_dyn[var.second] = f_expr[var.first]; } - ValidatedVectorFunction f = make_function(var_spc,f_dyn); + ValidatedVectorMultivariateFunction f = make_function(var_spc,f_dyn); - Vector g(gs.size()); + Vector g(gs.size()); SizeType i = 0; for (auto in : inputs.variables()) { @@ -152,19 +152,19 @@ expression_to_function(DottedRealAssignments const& dynamics, const RealVariable for (auto var : var_spc.indices()) { g_dyn[var.second] = gs[in][var.first]; } - g[i++] = ValidatedVectorFunction(make_function(var_spc,g_dyn)); + g[i++] = ValidatedVectorMultivariateFunction(make_function(var_spc,g_dyn)); } RealSpace inp_spc(List(inputs.variables())); RealSpace full_spc = var_spc.adjoin(inp_spc); - ValidatedVectorFunction F = make_function(full_spc,Vector(right_hand_sides(substituted_dynamics))); + ValidatedVectorMultivariateFunction F = make_function(full_spc,Vector(right_hand_sides(substituted_dynamics))); return make_tuple(F,f,g,V); } -inline Box apply(VectorFunctionconst& f, const Box& bx) { +inline Box apply(VectorMultivariateFunctionconst& f, const Box& bx) { return apply(f,Box(bx)); } @@ -377,11 +377,11 @@ InclusionIntegrator::InclusionIntegrator(List approximations static const SizeType NUMBER_OF_PICARD_ITERATES=6; -List InclusionIntegrator::flow(DifferentialInclusionIVP const& ivp, Real tmax) { +List InclusionIntegrator::flow(DifferentialInclusionIVP const& ivp, Real tmax) { ARIADNE_LOG(2,"\n"< InclusionIntegrator::flow(DifferentialInclu PositiveFloatDPValue hsug(this->_step_size); - ValidatedVectorFunctionModelDP evolve_function = ValidatedVectorTaylorFunctionModelDP::identity(X0,this->_sweeper); + ValidatedVectorMultivariateFunctionModelDP evolve_function = ValidatedVectorTaylorFunctionModelDP::identity(X0,this->_sweeper); auto t=PositiveFloatDPValue(0.0); Map approximation_global_frequencies, approximation_local_frequencies; @@ -401,7 +401,7 @@ List InclusionIntegrator::flow(DifferentialInclu approximation_local_frequencies[appro] = 0; } - List result; + List result; SizeType step = 0; @@ -451,8 +451,8 @@ List InclusionIntegrator::flow(DifferentialInclu PositiveFloatDPValue new_t=cast_positive(cast_exact((t+h).lower())); - ValidatedVectorFunctionModelDP reach_function; - ValidatedVectorFunctionModelDP best_reach_function, best_evolve_function; + ValidatedVectorMultivariateFunctionModelDP reach_function; + ValidatedVectorMultivariateFunctionModelDP best_reach_function, best_evolve_function; SharedPointer best; FloatDP best_volume(0); @@ -550,14 +550,14 @@ List InclusionIntegrator::flow(DifferentialInclu return result; } -ValidatedVectorFunctionModelType -InclusionIntegrator::reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const { +ValidatedVectorMultivariateFunctionModelType +InclusionIntegrator::reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorMultivariateFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const { auto n = di.num_variables(); auto m = di.num_inputs(); PositiveFloatDPValue new_t=cast_positive(cast_exact((t+h).lower())); - ValidatedVectorFunctionModelType result; + ValidatedVectorMultivariateFunctionModelType result; if (this->_approximator->kind() != InputApproximation::PIECEWISE) { auto e=this->_approximator->compute_errors(h,B); @@ -599,22 +599,22 @@ InclusionIntegrator::reach(DifferentialInclusion const& di, BoxDomainType D, Val return result; } -Vector InclusionIntegrator::build_secondhalf_piecewise_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto zero = ValidatedScalarFunction::zero(n+2*m+1); - auto one = ValidatedScalarFunction::constant(n+2*m+1,1_z); +Vector InclusionIntegrator::build_secondhalf_piecewise_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto zero = ValidatedScalarMultivariateFunction::zero(n+2*m+1); + auto one = ValidatedScalarMultivariateFunction::constant(n+2*m+1,1_z); - auto result = Vector(m); + auto result = Vector(m); for (auto i : range(m)) { auto Vi = ExactNumber(DVh[n+i].upper()); - auto p0 = ValidatedScalarFunction::coordinate(n+2*m+1,n+i); - auto p1 = ValidatedScalarFunction::coordinate(n+2*m+1,n+m+i); + auto p0 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+i); + auto p1 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+m+i); result[i] = (definitely (DVh[n+i].upper() == 0.0_exact) ? zero : p0+(one-p0*p0/Vi/Vi)*p1); } return result; } -ValidatedVectorFunctionModelDP InclusionIntegrator::build_secondhalf_piecewise_reach_function( - ValidatedVectorFunctionModelDP evolve_function, ValidatedVectorFunctionModelDP Phi, SizeType m, PositiveFloatDPValue t, +ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::build_secondhalf_piecewise_reach_function( + ValidatedVectorMultivariateFunctionModelDP evolve_function, ValidatedVectorMultivariateFunctionModelDP Phi, SizeType m, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const { // Evolve function is e(x,a,2*m) at s; Flow is phi(x,h,b,2*m) @@ -645,8 +645,8 @@ ValidatedVectorFunctionModelDP InclusionIntegrator::build_secondhalf_piecewise_r return compose(Phi,join(ef,bf,mf,hf)); } -ValidatedVectorFunctionModelDP InclusionIntegrator::build_reach_function( - ValidatedVectorFunctionModelDP evolve_function, ValidatedVectorFunctionModelDP Phi, PositiveFloatDPValue t, +ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::build_reach_function( + ValidatedVectorMultivariateFunctionModelDP evolve_function, ValidatedVectorMultivariateFunctionModelDP Phi, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const { // Evolve function is e(x,a) at s; flow is phi(x,b,h) @@ -675,11 +675,11 @@ ValidatedVectorFunctionModelDP InclusionIntegrator::build_reach_function( return compose(Phi,join(ef,bf,hf)); } -ValidatedVectorFunctionModelDP InclusionIntegrator::evaluate_evolve_function(ValidatedVectorFunctionModelDP reach_function, PositiveFloatDPValue t) const { +ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::evaluate_evolve_function(ValidatedVectorMultivariateFunctionModelDP reach_function, PositiveFloatDPValue t) const { return partial_evaluate(reach_function,reach_function.argument_size()-1,t); } -ValidatedVectorFunctionModelDP add_errors(ValidatedVectorFunctionModelDP phi, Vector const& e) { +ValidatedVectorMultivariateFunctionModelDP add_errors(ValidatedVectorMultivariateFunctionModelDP phi, Vector const& e) { assert(phi.result_size()==e.size()); ValidatedVectorTaylorFunctionModelDP& tphi = dynamic_cast(phi.reference()); for (auto i : range(e.size())) { @@ -688,15 +688,15 @@ ValidatedVectorFunctionModelDP add_errors(ValidatedVectorFunctionModelDP phi, Ve return phi; } -ValidatedVectorFunction build_Fw(ValidatedVectorFunction const& F, Vector const& w) { +ValidatedVectorMultivariateFunction build_Fw(ValidatedVectorMultivariateFunction const& F, Vector const& w) { auto n = F.result_size(); auto m = w.size(); auto p = w[0].argument_size(); - auto coordinates = ValidatedVectorFunction::coordinates(p); + auto coordinates = ValidatedVectorMultivariateFunction::coordinates(p); - auto substitution = ValidatedVectorFunction::zeros(n+m,p); + auto substitution = ValidatedVectorMultivariateFunction::zeros(n+m,p); for (auto i : range(n)) { substitution.set(i,coordinates[i]); } @@ -708,7 +708,7 @@ ValidatedVectorFunction build_Fw(ValidatedVectorFunction const& F, Vector InclusionIntegrator::flow_bounds(ValidatedVectorFunction f, BoxDomainType V, BoxDomainType D, PositiveFloatDPApproximation hsug) const { +Pair InclusionIntegrator::flow_bounds(ValidatedVectorMultivariateFunction f, BoxDomainType V, BoxDomainType D, PositiveFloatDPApproximation hsug) const { PositiveFloatDPValue h=cast_exact(hsug); UpperBoxType wD = D + (D-D.midpoint()); @@ -729,8 +729,8 @@ Pair InclusionIntegrator::flow_bounds(Validat } -ValidatedVectorFunctionModelDP InclusionIntegrator:: -compute_flow_function(ValidatedVectorFunction const& dyn, BoxDomainType const& domain, UpperBoxType const& B) const { +ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator:: +compute_flow_function(ValidatedVectorMultivariateFunction const& dyn, BoxDomainType const& domain, UpperBoxType const& B) const { auto n=dyn.result_size(); auto swp=this->_sweeper; @@ -773,68 +773,68 @@ template BoxDomainType InputApproximatorBase::build_flow_domain(BoxD return product(result,IntervalDomainType(-h,+h)); } -template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto result = Vector(m); +template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto result = Vector(m); for (auto i : range(0,m)) - result[i] = ValidatedScalarFunction::zero(n+1); + result[i] = ValidatedScalarMultivariateFunction::zero(n+1); return result; } -template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto result = Vector(m); +template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto result = Vector(m); for (auto i : range(0,m)) - result[i] = ValidatedScalarFunction::coordinate(n+m+1,n+i); + result[i] = ValidatedScalarMultivariateFunction::coordinate(n+m+1,n+i); return result; } -template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto zero = ValidatedScalarFunction::zero(n+2*m+1); - auto one = ValidatedScalarFunction::constant(n+2*m+1,1_z); - auto three = ValidatedScalarFunction::constant(n+2*m+1,3_z); - auto t = ValidatedScalarFunction::coordinate(n+2*m+1,n+2*m); - auto h = ValidatedScalarFunction::constant(n+2*m+1,ExactNumber(DVh[n+2*m].upper())); +template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto zero = ValidatedScalarMultivariateFunction::zero(n+2*m+1); + auto one = ValidatedScalarMultivariateFunction::constant(n+2*m+1,1_z); + auto three = ValidatedScalarMultivariateFunction::constant(n+2*m+1,3_z); + auto t = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+2*m); + auto h = ValidatedScalarMultivariateFunction::constant(n+2*m+1,ExactNumber(DVh[n+2*m].upper())); - auto result = Vector(m); + auto result = Vector(m); for (auto i : range(m)) { auto Vi = ExactNumber(DVh[n+i].upper()); - auto p0 = ValidatedScalarFunction::coordinate(n+2*m+1,n+i); - auto p1 = ValidatedScalarFunction::coordinate(n+2*m+1,n+m+i); + auto p0 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+i); + auto p1 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+m+i); result[i] = (definitely (DVh[n+i].upper() == 0.0_exact) ? zero : p0+three*(one-p0*p0/Vi/Vi)*p1*(t-h/2)/h); } return result; } -template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto zero = ValidatedScalarFunction::zero(n+2*m+1); - auto one = ValidatedScalarFunction::constant(n+2*m+1,1_z); - auto pgamma = ValidatedScalarFunction::constant(n+2*m+1,1.1464_dec); - auto gamma = ValidatedScalarFunction::constant(n+2*m+1,4.162586_dec); - auto t = ValidatedScalarFunction::coordinate(n+2*m+1,n+2*m); - auto h = ValidatedScalarFunction::constant(n+2*m+1,ExactNumber(DVh[n+2*m].upper())); +template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto zero = ValidatedScalarMultivariateFunction::zero(n+2*m+1); + auto one = ValidatedScalarMultivariateFunction::constant(n+2*m+1,1_z); + auto pgamma = ValidatedScalarMultivariateFunction::constant(n+2*m+1,1.1464_dec); + auto gamma = ValidatedScalarMultivariateFunction::constant(n+2*m+1,4.162586_dec); + auto t = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+2*m); + auto h = ValidatedScalarMultivariateFunction::constant(n+2*m+1,ExactNumber(DVh[n+2*m].upper())); - auto result = Vector(m); + auto result = Vector(m); for (auto i : range(m)) { auto Vi = ExactNumber(DVh[n+i].upper()); - auto p0 = ValidatedScalarFunction::coordinate(n+2*m+1,n+i); - auto p1 = ValidatedScalarFunction::coordinate(n+2*m+1,n+m+i); + auto p0 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+i); + auto p1 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+m+i); result[i] = (definitely (DVh[n+i].upper() == 0.0_exact) ? zero : p0+(one-p0*p0/Vi/Vi)*pgamma*p1*sin((t-h/2)*gamma/h)); } return result; } -template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { - auto zero = ValidatedScalarFunction::zero(n+2*m+1); - auto one = ValidatedScalarFunction::constant(n+2*m+1,1_z); +template<> Vector InputApproximatorBase::build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const { + auto zero = ValidatedScalarMultivariateFunction::zero(n+2*m+1); + auto one = ValidatedScalarMultivariateFunction::constant(n+2*m+1,1_z); - auto result = Vector(m); + auto result = Vector(m); for (auto i : range(m)) { auto Vi = ExactNumber(DVh[n+i].upper()); - auto p0 = ValidatedScalarFunction::coordinate(n+2*m+1,n+i); - auto p1 = ValidatedScalarFunction::coordinate(n+2*m+1,n+m+i); + auto p0 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+i); + auto p1 = ValidatedScalarMultivariateFunction::coordinate(n+2*m+1,n+m+i); result[i] = (definitely (DVh[n+i].upper() == 0.0_exact) ? zero : p0-(one-p0*p0/Vi/Vi)*p1); } return result; @@ -846,13 +846,13 @@ LohnerReconditioner::LohnerReconditioner(SweeperDP sweeper, Nat number_of_variab this->verbosity = 0; } -ValidatedVectorFunctionModelDP LohnerReconditioner::expand_errors(ValidatedVectorFunctionModelDP f) const { +ValidatedVectorMultivariateFunctionModelDP LohnerReconditioner::expand_errors(ValidatedVectorMultivariateFunctionModelDP f) const { BoxDomainType domain=f.domain(); BoxDomainType errors=cast_exact(cast_exact(f.errors())*FloatDPUpperInterval(-1,+1)); // FIXME: Avoid cast; ARIADNE_LOG(6,"Uniform errors:"<_sweeper); + ValidatedVectorMultivariateFunctionModelDP error_function=ValidatedVectorTaylorFunctionModelDP::identity(errors,this->_sweeper); return embed(f,errors)+embed(domain,error_function); } @@ -875,7 +875,7 @@ struct IndexedFloatDPErrorComparator } }; -Void LohnerReconditioner::simplify(ValidatedVectorFunctionModelDP& f) const { +Void LohnerReconditioner::simplify(ValidatedVectorMultivariateFunctionModelDP& f) const { ARIADNE_LOG(6,"simplifying\n"); ARIADNE_LOG(6,"f="< step_size; Generator number_of_steps_between_simplifications; Generator number_of_variables_to_keep; -using ValidatedScalarFunctionModelType = ValidatedScalarFunctionModelDP; -using ValidatedVectorFunctionModelType = ValidatedVectorFunctionModelDP; +using ValidatedScalarMultivariateFunctionModelType = ValidatedScalarMultivariateFunctionModelDP; +using ValidatedVectorMultivariateFunctionModelType = ValidatedVectorMultivariateFunctionModelDP; using ThresholdSweeperDP = ThresholdSweeper; using GradedSweeperDP = GradedSweeper; @@ -64,7 +64,7 @@ using ExactTimeStepType = PositiveFloatDPValue; Pair centered_variable_transformation(RealVariable const& v, RealInterval const& bounds); Pair centered_variables_transformation(RealVariablesBox const& inputs); -Tuple,BoxDomainType> expression_to_function(DottedRealAssignments const& dynamics, const RealVariablesBox& inputs); +Tuple,BoxDomainType> expression_to_function(DottedRealAssignments const& dynamics, const RealVariablesBox& inputs); BoxDomainType bounds_to_domain(RealVariablesBox const& var_box); inline Vector const& cast_exact(Vector const& v) { @@ -77,9 +77,9 @@ inline Bool refines(Vector const& v1, UpperBoxType const& bx2 Box> over_approximation(Box> const&); -ValidatedVectorFunctionModelDP add_errors(ValidatedVectorFunctionModelDP phi, Vector const& e); +ValidatedVectorMultivariateFunctionModelDP add_errors(ValidatedVectorMultivariateFunctionModelDP phi, Vector const& e); -ValidatedVectorFunction build_Fw(ValidatedVectorFunction const& F, Vector const& w); +ValidatedVectorMultivariateFunction build_Fw(ValidatedVectorMultivariateFunction const& F, Vector const& w); template decltype(auto) combine(F1 const& f1, F2 const& f2, F3 const& f3, FS const& ... fs) { return combine(combine(f1,f2),f3,fs...); } @@ -106,9 +106,9 @@ class DifferentialInclusion { private: DottedRealAssignments _dynamics; RealVariablesBox _inputs; - ValidatedVectorFunction _F; - ValidatedVectorFunction _f_component; - Vector _g_components; + ValidatedVectorMultivariateFunction _F; + ValidatedVectorMultivariateFunction _f_component; + Vector _g_components; BoxDomainType _V; Bool _is_input_additive; Bool _has_singular_input; @@ -116,9 +116,9 @@ class DifferentialInclusion { DifferentialInclusion(DottedRealAssignments const& dynamics, const RealVariablesBox& inputs); DottedRealAssignments const& dynamics() const { return _dynamics; } RealVariablesBox const& inputs() const { return _inputs; } - ValidatedVectorFunction const& F() const { return _F; } - ValidatedVectorFunction const& f_component() const { return _f_component; } - Vector const& g_components() const { return _g_components; } + ValidatedVectorMultivariateFunction const& F() const { return _F; } + ValidatedVectorMultivariateFunction const& f_component() const { return _f_component; } + Vector const& g_components() const { return _g_components; } BoxDomainType const& V() const { return _V; } Bool is_input_additive() const { return _is_input_additive; } Bool has_singular_input() const { return _has_singular_input; } @@ -328,7 +328,7 @@ class InputApproximatorInterface { virtual InputApproximation kind() const = 0; virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const = 0; virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const = 0; - virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const = 0; + virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const = 0; }; @@ -344,7 +344,7 @@ class InputApproximator : public InputApproximatorInterface { virtual InputApproximation kind() const override { return _impl->kind(); } virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const override { return _impl->compute_errors(h,B); } virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const override { return _impl->build_flow_domain(D,V,h); } - virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override { return _impl->build_w_functions(DVh,n,m); } + virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override { return _impl->build_w_functions(DVh,n,m); } virtual ~InputApproximator() = default; }; @@ -365,15 +365,15 @@ class InputApproximatorBase : public InputApproximatorInterface { virtual InputApproximation kind() const override { return _kind; } virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const override { return _processor->process(h,B); } virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const override; - virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override; + virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override; virtual ~InputApproximatorBase() = default; }; class Reconditioner { public: - virtual Void simplify(ValidatedVectorFunctionModelType& phi) const = 0; - virtual ValidatedVectorFunctionModelType expand_errors(ValidatedVectorFunctionModelType Phi) const = 0; + virtual Void simplify(ValidatedVectorMultivariateFunctionModelType& phi) const = 0; + virtual ValidatedVectorMultivariateFunctionModelType expand_errors(ValidatedVectorMultivariateFunctionModelType Phi) const = 0; }; @@ -384,17 +384,17 @@ class LohnerReconditioner : public Reconditioner, public Loggable { LohnerReconditioner(SweeperDP sweeper, Nat number_of_variables_to_keep); void set_sweeper(SweeperDP sweeper) { _sweeper = sweeper; } void set_number_of_variables_to_keep(Nat num_variables_to_keep) { _number_of_variables_to_keep = num_variables_to_keep; } - virtual ValidatedVectorFunctionModelType expand_errors(ValidatedVectorFunctionModelType f) const override; - virtual Void simplify(ValidatedVectorFunctionModelType& f) const override; + virtual ValidatedVectorMultivariateFunctionModelType expand_errors(ValidatedVectorMultivariateFunctionModelType f) const override; + virtual Void simplify(ValidatedVectorMultivariateFunctionModelType& f) const override; virtual ~LohnerReconditioner() = default; }; class InclusionIntegratorInterface { public: - virtual List flow(DifferentialInclusionIVP const& di_ivp, Real T) = 0; - virtual Pair flow_bounds(ValidatedVectorFunction f, BoxDomainType V, BoxDomainType D, ApproximateTimeStepType hsug) const = 0; - virtual ValidatedVectorFunctionModelType reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const = 0; + virtual List flow(DifferentialInclusionIVP const& di_ivp, Real T) = 0; + virtual Pair flow_bounds(ValidatedVectorMultivariateFunction f, BoxDomainType V, BoxDomainType D, ApproximateTimeStepType hsug) const = 0; + virtual ValidatedVectorMultivariateFunctionModelType reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorMultivariateFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const = 0; }; class InclusionIntegrator : public virtual InclusionIntegratorInterface, public Loggable { @@ -414,16 +414,16 @@ class InclusionIntegrator : public virtual InclusionIntegratorInterface, public InclusionIntegrator& set(NumberOfVariablesToKeep n) { _number_of_variables_to_keep=n; return *this; } template InclusionIntegrator& set(A a, AS... as) { this->set(a); this->set(as...); return *this; } - virtual List flow(DifferentialInclusionIVP const& di_ivp, Real T) override; + virtual List flow(DifferentialInclusionIVP const& di_ivp, Real T) override; - virtual Pair flow_bounds(ValidatedVectorFunction f, BoxDomainType V, BoxDomainType D, ApproximateTimeStepType hsug) const override; - virtual ValidatedVectorFunctionModelType reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const override; + virtual Pair flow_bounds(ValidatedVectorMultivariateFunction f, BoxDomainType V, BoxDomainType D, ApproximateTimeStepType hsug) const override; + virtual ValidatedVectorMultivariateFunctionModelType reach(DifferentialInclusion const& di, BoxDomainType D, ValidatedVectorMultivariateFunctionModelType evolve_function, UpperBoxType B, PositiveFloatDPValue t, PositiveFloatDPValue h) const override; private: - ValidatedVectorFunctionModelType compute_flow_function(ValidatedVectorFunction const& dyn, BoxDomainType const& domain, UpperBoxType const& B) const; - ValidatedVectorFunctionModelDP build_reach_function(ValidatedVectorFunctionModelDP evolve_function, ValidatedVectorFunctionModelDP Phi, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const; - ValidatedVectorFunctionModelDP evaluate_evolve_function(ValidatedVectorFunctionModelDP reach_function, PositiveFloatDPValue t) const; - ValidatedVectorFunctionModelDP build_secondhalf_piecewise_reach_function(ValidatedVectorFunctionModelDP evolve_function, ValidatedVectorFunctionModelDP Phi, SizeType m, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const; - Vector build_secondhalf_piecewise_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const; + ValidatedVectorMultivariateFunctionModelType compute_flow_function(ValidatedVectorMultivariateFunction const& dyn, BoxDomainType const& domain, UpperBoxType const& B) const; + ValidatedVectorMultivariateFunctionModelDP build_reach_function(ValidatedVectorMultivariateFunctionModelDP evolve_function, ValidatedVectorMultivariateFunctionModelDP Phi, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const; + ValidatedVectorMultivariateFunctionModelDP evaluate_evolve_function(ValidatedVectorMultivariateFunctionModelDP reach_function, PositiveFloatDPValue t) const; + ValidatedVectorMultivariateFunctionModelDP build_secondhalf_piecewise_reach_function(ValidatedVectorMultivariateFunctionModelDP evolve_function, ValidatedVectorMultivariateFunctionModelDP Phi, SizeType m, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const; + Vector build_secondhalf_piecewise_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const; }; template InclusionIntegrator::InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size_, AS... attributes) diff --git a/source/dynamics/flowtube.hpp b/source/dynamics/flowtube.hpp index cadb7a258..ea3019e8c 100644 --- a/source/dynamics/flowtube.hpp +++ b/source/dynamics/flowtube.hpp @@ -37,7 +37,7 @@ template class Orbit; using ValidatedImageSet = ValidatedConstrainedImageSet; class FlowTube { - ValidatedVectorFunctionModelDP _phi; + ValidatedVectorMultivariateFunctionModelDP _phi; List _variable_names; public: SizeType number_of_state_variables() const { return _phi.result_size(); } @@ -47,8 +47,8 @@ class FlowTube { decltype(auto) time_range() const { SizeType n=this->number_of_state_variables(); return _phi.domain()[n]; } decltype(auto) initial_time() const { return time_range().lower(); } decltype(auto) final_time() const { return time_range().upper(); } - ValidatedVectorFunctionModelDP reach_function() const; - ValidatedVectorFunctionModelDP final_function() const; + ValidatedVectorMultivariateFunctionModelDP reach_function() const; + ValidatedVectorMultivariateFunctionModelDP final_function() const; ValidatedImageSet initial_set() const; ValidatedImageSet reach_set() const; ValidatedImageSet final_set() const; diff --git a/source/dynamics/map.hpp b/source/dynamics/map.hpp index 8b2d72d4a..562682a5d 100644 --- a/source/dynamics/map.hpp +++ b/source/dynamics/map.hpp @@ -49,13 +49,13 @@ class IteratedMap //! \brief The type used to describe the state space. typedef EuclideanSpace StateSpaceType; public: - IteratedMap(const EffectiveVectorFunction& f) : _function(f) { } + IteratedMap(const EffectiveVectorMultivariateFunction& f) : _function(f) { } virtual IteratedMap* clone() const { return new IteratedMap(*this); } virtual ~IteratedMap() = default; - const EffectiveVectorFunction& function() const { return _function; } + const EffectiveVectorMultivariateFunction& function() const { return _function; } Grid grid() const { return Grid(_function.argument_size()); } private: - EffectiveVectorFunction _function; + EffectiveVectorMultivariateFunction _function; }; inline OutputStream& operator<<(OutputStream& os, const IteratedMap& vf) { diff --git a/source/dynamics/simulation_toolbox_interface.hpp b/source/dynamics/simulation_toolbox_interface.hpp index fa706ae2b..35fdd0662 100644 --- a/source/dynamics/simulation_toolbox_interface.hpp +++ b/source/dynamics/simulation_toolbox_interface.hpp @@ -34,8 +34,8 @@ namespace Ariadne { -class ScalarFunction; -class VectorFunction; +class ScalarMultivariateFunction; +class VectorMultivariateFunction; /*! \brief Tools for analysing dynamical systems by simulation. */ @@ -45,9 +45,9 @@ class SimulationToolboxInterface typedef FloatDP RealType; typedef FloatDP TimeType; typedef ExactPoint StateType; - typedef ScalarFunction PredicateType; - typedef VectorFunction MapType; - typedef VectorFunction VectorFieldType; + typedef ScalarMultivariateFunction PredicateType; + typedef VectorMultivariateFunction MapType; + typedef VectorMultivariateFunction VectorFieldType; public: //! \brief Virtual destructor. virtual ~SimulationToolboxInterface() = default; @@ -56,15 +56,15 @@ class SimulationToolboxInterface //! satisfies the constraint, \a false if the point does not satisfy the constraint, and //! indeterminate if the point lies on the boundary. virtual ValidatedKleenean - active(const ScalarFunction& guard, + active(const ScalarMultivariateFunction& guard, const ExactPoint& state) const = 0; //! \brief Computes the time at which points in the \a initial_point cross the zero-set of the //! the \a guard under evolution of the \a vector_field, for times up to \a maximum_time. //! The crossing must be (differentiably) transverse. virtual TimeType - crossing_time(const ScalarFunction& guard, - const VectorFunction& vector_field, + crossing_time(const ScalarMultivariateFunction& guard, + const VectorMultivariateFunction& vector_field, const ExactPoint& initial_state, const TimeType& maximum_time) const = 0; @@ -76,7 +76,7 @@ class SimulationToolboxInterface //! \brief Computes the points reached by evolution of the \a initial_state under the flow //! given by \a vector_field. The \a step_size gives the time the points should be flowed. virtual StateType - integration_step(const VectorFunction& vector_field, + integration_step(const VectorMultivariateFunction& vector_field, const ExactPoint& initial_state, const TimeType& step_size) const = 0; diff --git a/source/dynamics/vector_field.hpp b/source/dynamics/vector_field.hpp index e7b3f1e96..f4bfb2c65 100644 --- a/source/dynamics/vector_field.hpp +++ b/source/dynamics/vector_field.hpp @@ -56,18 +56,18 @@ class VectorField typedef Enclosure EnclosureType; public: VectorField(List const& dynamics); - VectorField(EffectiveVectorFunction const& function) : _function(function) { } + VectorField(EffectiveVectorMultivariateFunction const& function) : _function(function) { } virtual ~VectorField() = default; virtual VectorField* clone() const { return new VectorField(*this); } SizeType dimension() const { return _function.result_size(); } RealSpace state_space() const; - const EffectiveVectorFunction& function() const { return _function; } + const EffectiveVectorMultivariateFunction& function() const { return _function; } Grid grid() const { return Grid(_function.argument_size()); } friend OutputStream& operator<<(OutputStream& os, const VectorField& vf) { return os << "VectorField( " << vf.function() << " )"; } private: List _variable_names; - EffectiveVectorFunction _function; + EffectiveVectorMultivariateFunction _function; }; } // namespace Ariadne diff --git a/source/dynamics/vector_field_evolver.cpp b/source/dynamics/vector_field_evolver.cpp index b396f44ce..461856f98 100644 --- a/source/dynamics/vector_field_evolver.cpp +++ b/source/dynamics/vector_field_evolver.cpp @@ -201,8 +201,8 @@ _evolution_step(List< TimedEnclosureType >& working_sets, Semantics semantics, Bool reach) const { - typedef EffectiveVectorFunction FunctionType; - typedef ValidatedVectorFunctionModelDP FlowModelType; + typedef EffectiveVectorMultivariateFunction FunctionType; + typedef ValidatedVectorMultivariateFunctionModelDP FlowModelType; EnclosureType current_set_model; TimeStepType current_time; diff --git a/source/function/affine_model.cpp b/source/function/affine_model.cpp index 368274d31..f3a440da0 100644 --- a/source/function/affine_model.cpp +++ b/source/function/affine_model.cpp @@ -53,7 +53,7 @@ template struct AlgebraOperations>; template struct AlgebraOperations>; template struct AlgebraOperations>; -template AffineModel affine_model(const ExactBoxType&, const ScalarFunction&, DoublePrecision); +template AffineModel affine_model(const ExactBoxType&, const ScalarMultivariateFunction&, DoublePrecision); } //namespace Ariadne diff --git a/source/function/affine_model.hpp b/source/function/affine_model.hpp index 9a2c74d73..bf496efef 100644 --- a/source/function/affine_model.hpp +++ b/source/function/affine_model.hpp @@ -86,7 +86,7 @@ class AffineModel explicit AffineModel(const Affine>& affine); explicit AffineModel(const Affine& affine, PrecisionType precision); - AffineModel(const BoxDomainType& domain, const ApproximateScalarFunction& function, PrecisionType precision); + AffineModel(const BoxDomainType& domain, const ApproximateScalarMultivariateFunction& function, PrecisionType precision); AffineModel(const TaylorModel&); AffineModel& operator=(const CoefficientType& c) { @@ -125,8 +125,8 @@ class AffineModel private: OutputStream& _write(OutputStream&) const; private: public: - static AffineModel _compose(const ScalarFunction

& f, Vector> const& g); - static Vector> _compose(const VectorFunction

& f, Vector> const& g); + static AffineModel _compose(const ScalarMultivariateFunction

& f, Vector> const& g); + static Vector> _compose(const VectorMultivariateFunction

& f, Vector> const& g); private: CoefficientType _c; Covector _g; @@ -203,8 +203,8 @@ class AffineModel private: OutputStream& _write(OutputStream&) const; private: public: - static AffineModel _compose(const ScalarFunction

& f, Vector> const& g); - static Vector> _compose(const VectorFunction

& f, Vector> const& g); + static AffineModel _compose(const ScalarMultivariateFunction

& f, Vector> const& g); + static Vector> _compose(const VectorMultivariateFunction

& f, Vector> const& g); private: CoefficientType _c; Covector _g; @@ -240,13 +240,13 @@ template inline Vector> affine_models(const V // DEPRECATED -template AffineModel> affine_model(const BoxDomainType& domain, const ScalarFunction

& function, PR precision); -template inline Vector>> affine_models(const BoxDomainType& domain, const VectorFunction

& function, PR precision); +template AffineModel> affine_model(const BoxDomainType& domain, const ScalarMultivariateFunction

& function, PR precision); +template inline Vector>> affine_models(const BoxDomainType& domain, const VectorMultivariateFunction

& function, PR precision); -template inline AffineModel> affine_model(const BoxDomainType& domain, const ScalarFunction& function, PR precision) { - return affine_model(domain,ScalarFunction(function),precision); } -template inline Vector>> affine_models(const BoxDomainType& domain, const VectorFunction& function, PR precision) { - return affine_models(domain,VectorFunction(function),precision); } +template inline AffineModel> affine_model(const BoxDomainType& domain, const ScalarMultivariateFunction& function, PR precision) { + return affine_model(domain,ScalarMultivariateFunction(function),precision); } +template inline Vector>> affine_models(const BoxDomainType& domain, const VectorMultivariateFunction& function, PR precision) { + return affine_models(domain,VectorMultivariateFunction(function),precision); } template inline AffineModel affine_model(const TaylorModel& taylor_model) @@ -265,7 +265,7 @@ template Vector> affine_models(const Vector Vector>> affine_models(const BoxDomainType& domain, const VectorFunction

& function, PR precision) +template Vector>> affine_models(const BoxDomainType& domain, const VectorMultivariateFunction

& function, PR precision) { typedef RawFloat F; SizeType rs=function.result_size(); @@ -281,11 +281,11 @@ template Vector::RangeType> ranges(c //Vector::RangeType> r(f.size(),f.zero_element().range()); for(SizeType i=0; i!=f.size(); ++i) { r[i]=f[i].range(); } return r; } -template Vector> compose(const VectorFunction

& f, Vector> const& g) { +template Vector> compose(const VectorMultivariateFunction

& f, Vector> const& g) { return AffineModel::_compose(f,g); } -template AffineModel compose(const ScalarFunction

& f, Vector> const& g) { +template AffineModel compose(const ScalarMultivariateFunction

& f, Vector> const& g) { return AffineModel::_compose(f,g); } diff --git a/source/function/affine_model.tpl.hpp b/source/function/affine_model.tpl.hpp index 3b8930bfd..f7dbf5a74 100644 --- a/source/function/affine_model.tpl.hpp +++ b/source/function/affine_model.tpl.hpp @@ -350,7 +350,7 @@ template AffineModel::AffineModel(const TaylorModel AffineModel> affine_model(const BoxDomainType& domain, const ScalarFunction

& function, PR precision) +template AffineModel> affine_model(const BoxDomainType& domain, const ScalarMultivariateFunction

& function, PR precision) { ValidatedScalarTaylorFunctionModelDP tf(domain,function,AffineSweeper>(precision)); return affine_model(tf.model()); @@ -444,7 +444,7 @@ template OutputStream& AffineModel::_write(OutputStream } template auto -AffineModel::_compose(const ScalarFunction

& f, Vector> const& g) -> AffineModel { +AffineModel::_compose(const ScalarMultivariateFunction

& f, Vector> const& g) -> AffineModel { auto c=values(g); auto b=f(c); auto A=f.gradient(c); @@ -452,7 +452,7 @@ AffineModel::_compose(const ScalarFunction

& f, Vector auto -AffineModel::_compose(const VectorFunction

& f, Vector> const& g) -> Vector> { +AffineModel::_compose(const VectorMultivariateFunction

& f, Vector> const& g) -> Vector> { auto c=values(g); auto b=f(c); auto A=f.jacobian(c); @@ -460,7 +460,7 @@ AffineModel::_compose(const VectorFunction

& f, Vector auto -AffineModel::_compose(const ScalarFunction

& f, Vector> const& g) -> AffineModel { +AffineModel::_compose(const ScalarMultivariateFunction

& f, Vector> const& g) -> AffineModel { auto d = ranges(g); auto r = cast_singleton(d); auto c=values(g); @@ -470,7 +470,7 @@ AffineModel::_compose(const ScalarFunction

& f, Vector auto -AffineModel::_compose(const VectorFunction

& f, Vector> const& g) -> Vector> { +AffineModel::_compose(const VectorMultivariateFunction

& f, Vector> const& g) -> Vector> { auto d = ranges(g); auto r = cast_singleton(d); auto c=values(g); diff --git a/source/function/calculus_base.hpp b/source/function/calculus_base.hpp index 9f6d581e3..a97bbae26 100644 --- a/source/function/calculus_base.hpp +++ b/source/function/calculus_base.hpp @@ -43,7 +43,7 @@ namespace Ariadne { template class Array; class IntervalDomainType; -class VectorFunction; +class VectorMultivariateFunction; template class Vector; class BoxDomainType; @@ -79,8 +79,8 @@ class CalculusBase typedef BoxDomainType BoxType; typedef FloatDP TimeType; - typedef VectorFunction VectorFunctionType; - typedef ScalarFunction ScalarFunctionType; + typedef VectorMultivariateFunction VectorMultivariateFunctionType; + typedef ScalarMultivariateFunction ScalarMultivariateFunctionType; typedef SetModelType EnclosureType; protected: ValidatedKleenean _tribool(const IntervalType& ivl) const { @@ -110,7 +110,7 @@ class CalculusBase //! \brief Computes an over-approximation to the time interval for which the \a initial_set_model //! touch the set specified by the \a guard model under the \a flow_model. The \a minimum and \a maximum_time //! gives the minimum and maximum time for which the evolution is valid. - virtual IntervalDomainType touching_time_interval(const ScalarFunction& guard, + virtual IntervalDomainType touching_time_interval(const ScalarMultivariateFunction& guard, const FlowModelType& flow_model, const SetModelType& initial_set_model) const { @@ -124,7 +124,7 @@ class CalculusBase //! \brief Computes an over-approximation to the time interval for which the \a initial_set_model //! touch the set specified by the \a guard model under the \a flow_model. The \a minimum and \a maximum_time //! gives the minimum and maximum time for which the evolution is valid. Deprecated - virtual IntervalDomainType scaled_touching_time_interval(const ScalarFunction& guard, + virtual IntervalDomainType scaled_touching_time_interval(const ScalarMultivariateFunction& guard, const FlowSetModelType& flow_set_model) const { BaseModelType guard_flow_set_model=apply(guard,flow_set_model); @@ -144,7 +144,7 @@ class CalculusBase //! \brief Computes the time at which points in the \a initial_set_model cross the zero-set of the //! the \a guard under evolution of the \a flow_model. //! The crossing must be (differentiably) transverse. - virtual TimeModelType crossing_time(const ScalarFunction& guard, + virtual TimeModelType crossing_time(const ScalarMultivariateFunction& guard, const FlowModelType& flow_model, const SetModelType& initial_set_model) const { @@ -158,7 +158,7 @@ class CalculusBase //! \brief Computes the time at which points in the \a initial_set_model cross the zero-set of the //! the \a guard under evolution of the \a flow_model. //! The crossing must be (differentiably) transverse. - virtual TimeModelType scaled_crossing_time(const ScalarFunction& guard, + virtual TimeModelType scaled_crossing_time(const ScalarMultivariateFunction& guard, const FlowSetModelType& flow_set_model) const { return this->scaled_crossing_time(apply(guard,flow_set_model)); @@ -195,7 +195,7 @@ class CalculusBase //! domain \a d remains in \a B for times up to \a h. The maximum allowable \a h and maximum //! allowable diameter of \a B are given. virtual Pair - flow_bounds(const VectorFunctionType& vf, + flow_bounds(const VectorMultivariateFunctionType& vf, const BoxType& d, const RealType& maximum_step_size, const RealType& maximum_bound_diameter) const = 0; @@ -203,7 +203,7 @@ class CalculusBase //! \brief Computed a pair \f$(h,B)\f$ such that the flow of the vector_field \a vf starting in //! domain \a d remains in \a B for times up to \a h. The maximum allowable \a h is given. virtual Pair - flow_bounds(const VectorFunctionType& vf, + flow_bounds(const VectorMultivariateFunctionType& vf, const BoxType& d, const RealType& maximum_step_size) const { @@ -215,15 +215,15 @@ class CalculusBase //@{ \name Constructing models for functions //! \brief A model for the map \a f over the domain \a d. - virtual MapModelType map_model(const VectorFunctionType& f, const BoxType& d) const = 0; + virtual MapModelType map_model(const VectorMultivariateFunctionType& f, const BoxType& d) const = 0; //! \brief A model for the flow determined by the vector field \a vf over the initial domain \a d, //! valid for times up to \a h, assuming that the state remains in the bounding box \a b. - virtual FlowModelType flow_model(const VectorFunctionType& vf, const BoxType& d, + virtual FlowModelType flow_model(const VectorMultivariateFunctionType& vf, const BoxType& d, const TimeType& h, const BoxType& b) const = 0; //! \brief A model for the real-valued function \a g over the domain \a d. - virtual PredicateModelType predicate_model(const ScalarFunctionType& g, const BoxType& d) const = 0; + virtual PredicateModelType predicate_model(const ScalarMultivariateFunctionType& g, const BoxType& d) const = 0; //! \brief A model for the constant time \a t over the box \a d. virtual TimeModelType time_model(const FloatDP& t, const BoxType& d) const = 0; @@ -248,18 +248,18 @@ class CalculusBase //! \brief Test if a box satisfies the constraint given by the guard. Returns \a true is all points //! in the box satisfy the constraint, \a false if all points do not satisfy the constraint, and //! indeterminate otherwise. - ValidatedKleenean active(const ScalarFunctionType& guard, const BoxType& box) const { + ValidatedKleenean active(const ScalarMultivariateFunctionType& guard, const BoxType& box) const { return this->_tribool(guard.evaluate(box)); } - ValidatedKleenean active(const VectorFunctionType& guard, const BoxType& box) const { + ValidatedKleenean active(const VectorMultivariateFunctionType& guard, const BoxType& box) const { BoxType range=guard.evaluate(box); return this->_tribool(range[0]); } //! \brief Test if a set satisfied the constraint given by the guard. Returns \a true is all points //! in the set satisfy the constraint, \a false if all points do not satisfy the constraint, and //! indeterminate otherwise. - ValidatedKleenean active(const ScalarFunctionType& guard, const SetModelType& set_model) const { + ValidatedKleenean active(const ScalarMultivariateFunctionType& guard, const SetModelType& set_model) const { return this->active(this->predicate_model(guard,set_model.bounding_box()),set_model); } - ValidatedKleenean active(const VectorFunctionType& guard, const SetModelType& set_model) const { + ValidatedKleenean active(const VectorMultivariateFunctionType& guard, const SetModelType& set_model) const { TimeModelType guard_set_model = apply(guard,set_model)[0]; IntervalDomainType guard_range=guard_set_model.range(); ValidatedKleenean guard_active=guard_range.lower()>0 ? ValidatedKleenean(true) : guard_range.upper()<0 ? ValidatedKleenean(false) : indeterminate; @@ -267,7 +267,7 @@ class CalculusBase } //! \brief Computes the image of the set defined by \a set_model under the \a map. - SetModelType reset_step(const VectorFunctionType& map, + SetModelType reset_step(const VectorMultivariateFunctionType& map, const SetModelType& set_model) const { return this->reset_step(this->map_model(map,set_model.range()),set_model); } diff --git a/source/function/constraint.hpp b/source/function/constraint.hpp index b95cfa9a6..8c05520d3 100644 --- a/source/function/constraint.hpp +++ b/source/function/constraint.hpp @@ -78,44 +78,44 @@ class Constraint { R _upper_bound; }; -typedef Constraint RealConstraint; -typedef Constraint EffectiveConstraint; -typedef Constraint ValidatedConstraint; -typedef Constraint ValidatedExactConstraint; +typedef Constraint RealConstraint; +typedef Constraint EffectiveConstraint; +typedef Constraint ValidatedConstraint; +typedef Constraint ValidatedExactConstraint; template OutputStream& operator<<(OutputStream& os, const Constraint& c) { return os << c.lower_bound() << "<=" << c.function() << "<=" << c.upper_bound(); } -inline EffectiveConstraint operator<=(const EffectiveNumber& c, const EffectiveScalarFunction& f) { +inline EffectiveConstraint operator<=(const EffectiveNumber& c, const EffectiveScalarMultivariateFunction& f) { return EffectiveConstraint(c,f,infinity); } -inline EffectiveConstraint operator>=(const EffectiveNumber& c, const EffectiveScalarFunction& f) { +inline EffectiveConstraint operator>=(const EffectiveNumber& c, const EffectiveScalarMultivariateFunction& f) { return EffectiveConstraint(-infinity,f,c); } -inline EffectiveConstraint operator<=(const EffectiveScalarFunction& f, const EffectiveNumber& c) { +inline EffectiveConstraint operator<=(const EffectiveScalarMultivariateFunction& f, const EffectiveNumber& c) { return EffectiveConstraint(-infinity,f,c); } -inline EffectiveConstraint operator>=(const EffectiveScalarFunction& f, const EffectiveNumber& c) { +inline EffectiveConstraint operator>=(const EffectiveScalarMultivariateFunction& f, const EffectiveNumber& c) { return EffectiveConstraint(c,f,infinity); } -inline EffectiveConstraint operator==(const EffectiveScalarFunction& f, const EffectiveNumber& c) { +inline EffectiveConstraint operator==(const EffectiveScalarMultivariateFunction& f, const EffectiveNumber& c) { return EffectiveConstraint(f,c); } -inline EffectiveConstraint operator<=(const EffectiveScalarFunction& f, double c) { +inline EffectiveConstraint operator<=(const EffectiveScalarMultivariateFunction& f, double c) { return f <= Dyadic(c); } -inline EffectiveConstraint operator>=(const EffectiveScalarFunction& f, double c) { +inline EffectiveConstraint operator>=(const EffectiveScalarMultivariateFunction& f, double c) { return f >= Dyadic(c); } -inline EffectiveConstraint operator==(const EffectiveScalarFunction& f, double c) { +inline EffectiveConstraint operator==(const EffectiveScalarMultivariateFunction& f, double c) { return f == Dyadic(c); } @@ -125,19 +125,19 @@ inline EffectiveConstraint operator<=(const EffectiveConstraint& nc, const Effec } -inline ValidatedExactConstraint operator<=(const ExactNumber& c, const ValidatedScalarFunction& f) { +inline ValidatedExactConstraint operator<=(const ExactNumber& c, const ValidatedScalarMultivariateFunction& f) { return ValidatedExactConstraint(c,f,ExactNumber(+infty)); } -inline ValidatedExactConstraint operator<=(const ValidatedScalarFunction& f, const ExactNumber& c) { +inline ValidatedExactConstraint operator<=(const ValidatedScalarMultivariateFunction& f, const ExactNumber& c) { return ValidatedExactConstraint(-infty,f,c); } -inline ValidatedExactConstraint operator>=(const ValidatedScalarFunction& f, const ExactNumber& c) { +inline ValidatedExactConstraint operator>=(const ValidatedScalarMultivariateFunction& f, const ExactNumber& c) { return ValidatedExactConstraint(c,f,+infty); } -inline ValidatedExactConstraint operator==(const ValidatedScalarFunction& f, const ExactNumber& c) { +inline ValidatedExactConstraint operator==(const ValidatedScalarMultivariateFunction& f, const ExactNumber& c) { return ValidatedExactConstraint(c,f,c); } @@ -147,16 +147,16 @@ inline ValidatedExactConstraint operator<=(const ValidatedExactConstraint& nc, c } -inline ValidatedExactConstraint operator<=(const ValidatedScalarFunction& f1, const ValidatedScalarFunction& f2) { +inline ValidatedExactConstraint operator<=(const ValidatedScalarMultivariateFunction& f1, const ValidatedScalarMultivariateFunction& f2) { return (f1-f2) <= ExactNumber(0); } -inline ValidatedExactConstraint operator>=(const ValidatedScalarFunction& f1, const ValidatedScalarFunction& f2) { +inline ValidatedExactConstraint operator>=(const ValidatedScalarMultivariateFunction& f1, const ValidatedScalarMultivariateFunction& f2) { return (f1-f2) >= ExactNumber(0); } -inline ValidatedConstraint operator<=(const ValidatedNumber& c, const ValidatedScalarFunction& f) { +inline ValidatedConstraint operator<=(const ValidatedNumber& c, const ValidatedScalarMultivariateFunction& f) { return ValidatedConstraint(c,f,ExactNumber(+infty)); } diff --git a/source/function/function.cpp b/source/function/function.cpp index 660ca3750..77e113d68 100644 --- a/source/function/function.cpp +++ b/source/function/function.cpp @@ -132,18 +132,18 @@ template Function::Function(DomainType dom, Re *this = make_formula_function

(dom,e); } -template struct MakeVectorFunction; -template struct MakeVectorFunction { +template struct MakeVectorMultivariateFunction; +template struct MakeVectorMultivariateFunction { Function create(Vector> const& lsf) { ARIADNE_FAIL_MSG("Cannot construct scalar function from list."); } }; -template struct MakeVectorFunction { +template struct MakeVectorMultivariateFunction { Function create(Vector> const& lsf) { return Function(std::make_shared>(lsf)); } }; template Function make_vector_function(Vector> const& lsf) { - return MakeVectorFunction().create(lsf); + return MakeVectorMultivariateFunction().create(lsf); } template Function::Function(Vector> const& vsf) @@ -153,37 +153,37 @@ template Function::Function(Vector ScalarFunction

FunctionConstructors

::zero(BoxDomainType dom) { - return ConstantFunction(dom, Y(0)); +template ScalarMultivariateFunction

FunctionConstructors

::zero(BoxDomainType dom) { + return ConstantFunction(dom, Y(0)); } -template ScalarFunction

FunctionConstructors

::constant(BoxDomainType dom, NumericType c) { - return ConstantFunction(dom, c); +template ScalarMultivariateFunction

FunctionConstructors

::constant(BoxDomainType dom, NumericType c) { + return ConstantFunction(dom, c); } -template ScalarFunction

FunctionConstructors

::coordinate(BoxDomainType dom, SizeType j) { - return CoordinateFunction

(dom, j); +template ScalarMultivariateFunction

FunctionConstructors

::coordinate(BoxDomainType dom, SizeType j) { + return CoordinateFunction(dom, j); } -template List> FunctionConstructors

::coordinates(BoxDomainType dom) { - List> r; r.reserve(dom.dimension()); +template List> FunctionConstructors

::coordinates(BoxDomainType dom) { + List> r; r.reserve(dom.dimension()); for(SizeType j=0; j!=dom.dimension(); ++j) { r.append(coordinate(dom,j)); } return std::move(r); } -template VectorFunction

FunctionConstructors

::zeros(SizeType rs, BoxDomainType dom) { - return VectorFunction

(new VectorOfScalarFunction

(rs,zero(dom))); +template VectorMultivariateFunction

FunctionConstructors

::zeros(SizeType rs, BoxDomainType dom) { + return VectorMultivariateFunction

(new VectorOfScalarMultivariateFunction

(rs,zero(dom))); } -template VectorFunction

FunctionConstructors

::identity(BoxDomainType dom) { +template VectorMultivariateFunction

FunctionConstructors

::identity(BoxDomainType dom) { SizeType n=dom.dimension(); - ScalarFunction

z=ScalarFunction::zero(dom); - VectorOfScalarFunction

* res = new VectorOfScalarFunction

(n,z); + ScalarMultivariateFunction

z=ScalarMultivariateFunction

::zero(dom); + VectorOfScalarMultivariateFunction

* res = new VectorOfScalarMultivariateFunction

(n,z); for(SizeType i=0; i!=n; ++i) { - res->_vec[i]=ScalarFunction

::coordinate(dom,i); + res->_vec[i]=ScalarMultivariateFunction

::coordinate(dom,i); } - return VectorFunction

(res); + return VectorMultivariateFunction

(res); } @@ -235,51 +235,51 @@ template ScalarUnivariateFunction

FunctionConstructors

::identity( } -template ScalarFunction

FunctionConstructors

::zero(SizeType as) { - ScalarFunction

sf(new ScalarFormulaFunction(as,Formula::zero())); +template ScalarMultivariateFunction

FunctionConstructors

::zero(SizeType as) { + ScalarMultivariateFunction

sf(new ScalarFormulaFunction(as,Formula::zero())); return sf; } -template ScalarFunction

FunctionConstructors

::constant(SizeType as, NumericType c) { - return ScalarFunction

(new ScalarFormulaFunction(as,Formula::constant(c))); +template ScalarMultivariateFunction

FunctionConstructors

::constant(SizeType as, NumericType c) { + return ScalarMultivariateFunction

(new ScalarFormulaFunction(as,Formula::constant(c))); } -template ScalarFunction

FunctionConstructors

::coordinate(SizeType as, SizeType j) { +template ScalarMultivariateFunction

FunctionConstructors

::coordinate(SizeType as, SizeType j) { ARIADNE_ASSERT(j(new ScalarFormulaFunction(as,Formula::coordinate(j))); + return ScalarMultivariateFunction

(new ScalarFormulaFunction(as,Formula::coordinate(j))); } -template VectorFunction

FunctionConstructors

::zeros(SizeType rs, SizeType as) { - VectorOfScalarFunction

* res = new VectorOfScalarFunction

(rs,as); +template VectorMultivariateFunction

FunctionConstructors

::zeros(SizeType rs, SizeType as) { + VectorOfScalarFunction* res = new VectorOfScalarFunction(rs,as); for(SizeType i=0; i!=rs; ++i) { - res->_vec[i]=ScalarFunction

::zero(as); + res->_vec[i]=ScalarMultivariateFunction

::zero(as); } - return VectorFunction

(res); + return VectorMultivariateFunction

(res); } -template List> FunctionConstructors

::coordinates(SizeType as) { - List> r; r.reserve(as); +template List> FunctionConstructors

::coordinates(SizeType as) { + List> r; r.reserve(as); for(SizeType j=0; j!=as; ++j) { r.append(coordinate(as,j)); } return std::move(r); } -template VectorFunction

FunctionConstructors

::identity(SizeType n) { - ScalarFunction

z=ScalarFunction::zero(n); - VectorOfScalarFunction

* res = new VectorOfScalarFunction

(n,n); +template VectorMultivariateFunction

FunctionConstructors

::identity(SizeType n) { + ScalarMultivariateFunction

z=ScalarMultivariateFunction

::zero(n); + VectorOfScalarFunction* res = new VectorOfScalarFunction(n,n); for(SizeType i=0; i!=n; ++i) { - res->_vec[i]=ScalarFunction

::coordinate(n,i); + res->_vec[i]=ScalarMultivariateFunction

::coordinate(n,i); } - return VectorFunction

(res); + return VectorMultivariateFunction

(res); } template VectorFunction FunctionConstructors

::constant(BoxDomainType dom, Vector c) { SizeType n=c.size(); - ScalarFunction

z=ScalarFunction::zero(dom); - VectorOfScalarFunction

* res = new VectorOfScalarFunction

(n,z); + ScalarFunction z=ScalarFunction::zero(dom); + VectorOfScalarFunction* res = new VectorOfScalarFunction(n,z); for(SizeType i=0; i!=n; ++i) { - res->_vec[i]=ScalarFunction

::constant(dom,c[i]); + res->_vec[i]=ScalarMultivariateFunction

::constant(dom,c[i]); } - return VectorFunction

(res); + return VectorMultivariateFunction

(res); } template VectorFunction FunctionConstructors

::constant(IntervalDomainType dom, Vector c) { @@ -312,16 +312,16 @@ SizeType dimension(const Space& spc); inline EffectiveScalarUnivariateFunction make_formula_function(SizeOne as, const Formula& fm) { return EffectiveScalarUnivariateFunction(RealDomain(),fm); } -inline EffectiveScalarFunction make_formula_function(SizeType as, const Formula& fm) { - return EffectiveScalarFunction(EuclideanDomain(as),fm); } -inline EffectiveVectorFunction make_formula_function(SizeType as, const Vector>& fm) { - return EffectiveVectorFunction(EuclideanDomain(as),fm); } +inline EffectiveScalarMultivariateFunction make_formula_function(SizeType as, const Formula& fm) { + return EffectiveScalarMultivariateFunction(EuclideanDomain(as),fm); } +inline EffectiveVectorMultivariateFunction make_formula_function(SizeType as, const Vector>& fm) { + return EffectiveVectorMultivariateFunction(EuclideanDomain(as),fm); } EffectiveScalarUnivariateFunction make_function(const Variable& var, const Expression& expr) { return make_formula_function(SizeOne(),make_formula(expr,var)); } -EffectiveScalarFunction make_function(const Space& spc, const Expression& expr) { +EffectiveScalarMultivariateFunction make_function(const Space& spc, const Expression& expr) { return make_formula_function(dimension(spc),make_formula(expr,spc)); } -EffectiveVectorFunction make_function(const Space& spc, const Vector>& expr) { +EffectiveVectorMultivariateFunction make_function(const Space& spc, const Vector>& expr) { return make_formula_function(dimension(spc),make_formula(expr,spc)); } template Function make_composed_function(const Function& f, const Function& g) { @@ -329,10 +329,10 @@ template Function make_composed_funct return Function(new ComposedFunction(f,g)); } [[deprecated]] -EffectiveScalarFunction make_function(const Expression& expr, const Space& spc) { +EffectiveScalarMultivariateFunction make_function(const Expression& expr, const Space& spc) { return make_function(spc,expr); } -Formula make_formula(const EffectiveScalarFunction& f) { +Formula make_formula(const EffectiveScalarMultivariateFunction& f) { Vector> x(f.argument_size()); for(SizeType i=0; i!=x.size(); ++i) { x[i]=Formula::coordinate(i); @@ -340,11 +340,11 @@ Formula make_formula(const EffectiveScalarFunction& f) { return f(x); } -Vector> make_formula(const EffectiveVectorFunction& f) { - const VectorFunctionInterface& fi=f; +Vector> make_formula(const EffectiveVectorMultivariateFunction& f) { + const VectorMultivariateFunctionInterface& fi=f; const VectorFormulaFunction* ff; - const VectorOfScalarFunction* vf; - if( (vf=dynamic_cast*>(&fi)) ) { + const VectorOfScalarFunction* vf; + if( (vf=dynamic_cast*>(&fi)) ) { Vector< Formula > r(vf->result_size()); for(SizeType i=0; i!=r.size(); ++i) { r[i]=make_formula((*vf)[i]); } return r; @@ -374,20 +374,20 @@ template Void Function::set(SizeType i, Scalar } /* -template VectorFunction::VectorFunction() +template VectorFunction::VectorMultivariateFunction() : Function(new VectorOfScalarFunction(0u,ScalarFunction())) { } -template VectorFunction::VectorFunction(SizeType rs, SizeType as) +template VectorFunction::VectorMultivariateFunction(SizeType rs, SizeType as) : Function(new VectorOfScalarFunction(rs,ScalarFunction::zero(as))) { } -template VectorFunction::VectorFunction(const InitializerList>& lsf) +template VectorFunction::VectorMultivariateFunction(const InitializerList>& lsf) : VectorFunction(List>(lsf)) { } -template VectorFunction::VectorFunction(const List>& lsf) { +template VectorFunction::VectorMultivariateFunction(const List>& lsf) { ARIADNE_ASSERT(lsf.size()>0); SizeType as=lsf[0].argument_size(); VectorOfScalarFunction* new_ptr=new VectorOfScalarFunction(lsf.size(),as); @@ -397,12 +397,12 @@ template VectorFunction::VectorFunction(const List_ptr=std::shared_ptr< const VectorFunctionInterface >(new_ptr); } -template VectorFunction::VectorFunction(const Vector>& vsf) { +template VectorFunction::VectorMultivariateFunction(const Vector>& vsf) { VectorOfScalarFunction* new_ptr=new VectorOfScalarFunction(vsf); this->_ptr=std::shared_ptr< const VectorFunctionInterface >(new_ptr); } -template VectorFunction::VectorFunction(SizeType as, const List>& le) { +template VectorFunction::VectorMultivariateFunction(SizeType as, const List>& le) { ARIADNE_ASSERT(le.size()>0); VectorOfScalarFunction* new_ptr=new VectorOfScalarFunction(le.size(),as); for(SizeType i=0; i!=le.size(); ++i) { @@ -411,7 +411,7 @@ template VectorFunction::VectorFunction(SizeType as, cons this->_ptr=std::shared_ptr< const VectorFunctionInterface >(new_ptr); } -template VectorFunction::VectorFunction(SizeType rs, ScalarFunction const& sf) +template VectorFunction::VectorMultivariateFunction(SizeType rs, ScalarFunction const& sf) : Function(new VectorOfScalarFunction(rs,sf)) { } @@ -430,9 +430,9 @@ template Void VectorFunction::set(SizeType i, ScalarFunct vfi->_set(i,sf); } -template class VectorFunction; -template class VectorFunction; -template class VectorFunction; +template class VectorMultivariateFunction; +template class VectorMultivariateFunction; +template class VectorMultivariateFunction; */ @@ -459,72 +459,72 @@ template class Function; //------------------------ Vector function operators -------------------------------// -EffectiveVectorFunction operator*(const EffectiveScalarFunction& f, const Vector& e) { +EffectiveVectorMultivariateFunction operator*(const EffectiveScalarMultivariateFunction& f, const Vector& e) { for(SizeType i=0; i!=e.size(); ++i) { ARIADNE_ASSERT(decide(e[i]==EffectiveNumber(0)) || decide(e[i]==EffectiveNumber(1))); } - VectorFunction r(e.size(),f.domain()); + VectorMultivariateFunction r(e.size(),f.domain()); for(SizeType i=0; i!=e.size(); ++i) { if(decide(e[i]==EffectiveNumber(1))) { r.set(i,f); } } return r; } -EffectiveVectorFunction operator+(const EffectiveVectorFunction& f) { - EffectiveVectorFunction r(f.result_size(),f.domain()); +EffectiveVectorMultivariateFunction operator+(const EffectiveVectorMultivariateFunction& f) { + EffectiveVectorMultivariateFunction r(f.result_size(),f.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,+f[i]); } return r; } -EffectiveVectorFunction operator-(const EffectiveVectorFunction& f) { - EffectiveVectorFunction r(f.result_size(),f.domain()); +EffectiveVectorMultivariateFunction operator-(const EffectiveVectorMultivariateFunction& f) { + EffectiveVectorMultivariateFunction r(f.result_size(),f.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,-f[i]); } return r; } -EffectiveVectorFunction operator+(const EffectiveVectorFunction& f1, const EffectiveVectorFunction& f2) { +EffectiveVectorMultivariateFunction operator+(const EffectiveVectorMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.result_size()==f2.result_size()); ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(f1.result_size(),f1.domain()); + EffectiveVectorMultivariateFunction r(f1.result_size(),f1.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,f1[i]+f2[i]); } return r; } -EffectiveVectorFunction operator-(const EffectiveVectorFunction& f1, const EffectiveVectorFunction& f2) { +EffectiveVectorMultivariateFunction operator-(const EffectiveVectorMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.result_size()==f2.result_size()); ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(f1.result_size(),f1.domain()); + EffectiveVectorMultivariateFunction r(f1.result_size(),f1.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,f1[i]-f2[i]); } return r; } -EffectiveVectorFunction operator*(const EffectiveScalarFunction& sf, const EffectiveVectorFunction& vf) { +EffectiveVectorMultivariateFunction operator*(const EffectiveScalarMultivariateFunction& sf, const EffectiveVectorMultivariateFunction& vf) { ARIADNE_ASSERT(sf.argument_size()==vf.argument_size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,sf*vf[i]); } return r; } -EffectiveVectorFunction operator*(const EffectiveVectorFunction& vf, const EffectiveScalarFunction& sf) { +EffectiveVectorMultivariateFunction operator*(const EffectiveVectorMultivariateFunction& vf, const EffectiveScalarMultivariateFunction& sf) { ARIADNE_ASSERT(vf.argument_size()==sf.argument_size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]*sf); } return r; } -EffectiveVectorFunction operator/(const EffectiveVectorFunction& vf, const EffectiveScalarFunction& sf) { +EffectiveVectorMultivariateFunction operator/(const EffectiveVectorMultivariateFunction& vf, const EffectiveScalarMultivariateFunction& sf) { ARIADNE_ASSERT(vf.argument_size()==sf.argument_size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]/sf); } @@ -532,60 +532,60 @@ EffectiveVectorFunction operator/(const EffectiveVectorFunction& vf, const Effec } -EffectiveVectorFunction operator+(const Vector& vc, const EffectiveVectorFunction& vf) { +EffectiveVectorMultivariateFunction operator+(const Vector& vc, const EffectiveVectorMultivariateFunction& vf) { ARIADNE_ASSERT(vc.size()==vf.result_size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vc[i]+vf[i]); } return r; } -EffectiveVectorFunction operator+(const EffectiveVectorFunction& vf, const Vector& vc) { +EffectiveVectorMultivariateFunction operator+(const EffectiveVectorMultivariateFunction& vf, const Vector& vc) { ARIADNE_ASSERT(vf.result_size()==vc.size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]+vc[i]); } return r; } -EffectiveVectorFunction operator-(const Vector& vc, const EffectiveVectorFunction& vf) { +EffectiveVectorMultivariateFunction operator-(const Vector& vc, const EffectiveVectorMultivariateFunction& vf) { ARIADNE_ASSERT(vc.size()==vf.result_size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vc[i]-vf[i]); } return r; } -EffectiveVectorFunction operator-(const EffectiveVectorFunction& vf, const Vector& vc) { +EffectiveVectorMultivariateFunction operator-(const EffectiveVectorMultivariateFunction& vf, const Vector& vc) { ARIADNE_ASSERT(vf.result_size()==vc.size()); - EffectiveVectorFunction r(vf.result_size(),vf.domain()); + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]-vc[i]); } return r; } -EffectiveVectorFunction operator*(const EffectiveNumber& c, const EffectiveVectorFunction& vf) { - EffectiveVectorFunction r(vf.result_size(),vf.domain()); +EffectiveVectorMultivariateFunction operator*(const EffectiveNumber& c, const EffectiveVectorMultivariateFunction& vf) { + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,c*vf[i]); } return r; } -EffectiveVectorFunction operator*(const EffectiveVectorFunction& vf, const EffectiveNumber& c) { - EffectiveVectorFunction r(vf.result_size(),vf.domain()); +EffectiveVectorMultivariateFunction operator*(const EffectiveVectorMultivariateFunction& vf, const EffectiveNumber& c) { + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]*c); } return r; } -EffectiveVectorFunction operator/(const EffectiveVectorFunction& vf, const EffectiveNumber& c) { - EffectiveVectorFunction r(vf.result_size(),vf.domain()); +EffectiveVectorMultivariateFunction operator/(const EffectiveVectorMultivariateFunction& vf, const EffectiveNumber& c) { + EffectiveVectorMultivariateFunction r(vf.result_size(),vf.domain()); for(SizeType i=0; i!=r.result_size(); ++i) { r.set(i,vf[i]/c); } @@ -594,17 +594,17 @@ EffectiveVectorFunction operator/(const EffectiveVectorFunction& vf, const Effec -EffectiveVectorFunction join(const EffectiveScalarFunction& f1, const EffectiveScalarFunction& f2) { +EffectiveVectorMultivariateFunction join(const EffectiveScalarMultivariateFunction& f1, const EffectiveScalarMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(2,f1.domain()); + EffectiveVectorMultivariateFunction r(2,f1.domain()); r.set(0,f1); r.set(1,f2); return r; } -EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveScalarFunction& f2) { +EffectiveVectorMultivariateFunction join(const EffectiveVectorMultivariateFunction& f1, const EffectiveScalarMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(f1.result_size()+1u,f1.domain()); + EffectiveVectorMultivariateFunction r(f1.result_size()+1u,f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -612,9 +612,9 @@ EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveS return r; } -EffectiveVectorFunction join(const EffectiveScalarFunction& f1, const EffectiveVectorFunction& f2) { +EffectiveVectorMultivariateFunction join(const EffectiveScalarMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(f2.result_size()+1u,f1.domain()); + EffectiveVectorMultivariateFunction r(f2.result_size()+1u,f1.domain()); r.set(0u,f1); for(SizeType i=0u; i!=f2.result_size(); ++i) { r.set(i+1u,f2.get(i)); @@ -622,9 +622,9 @@ EffectiveVectorFunction join(const EffectiveScalarFunction& f1, const EffectiveV return r; } -EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveVectorFunction& f2) { +EffectiveVectorMultivariateFunction join(const EffectiveVectorMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - EffectiveVectorFunction r(f1.result_size()+f2.result_size(),f1.domain()); + EffectiveVectorMultivariateFunction r(f1.result_size()+f2.result_size(),f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -635,31 +635,31 @@ EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveV } -EffectiveScalarFunction embed(SizeType as1, const EffectiveScalarFunction& f2, SizeType as3) { +EffectiveScalarMultivariateFunction embed(SizeType as1, const EffectiveScalarMultivariateFunction& f2, SizeType as3) { typedef BoxDomainType D; typedef IntervalDomainType C; - return EffectiveScalarFunction(new EmbeddedFunction(as1,f2,as3)); + return EffectiveScalarMultivariateFunction(new EmbeddedFunction(as1,f2,as3)); } -EffectiveVectorFunction embed(SizeType as1, const EffectiveVectorFunction& f2, SizeType as3) { +EffectiveVectorMultivariateFunction embed(SizeType as1, const EffectiveVectorMultivariateFunction& f2, SizeType as3) { typedef BoxDomainType D; typedef BoxDomainType C; - return EffectiveVectorFunction(new EmbeddedFunction(as1,f2,as3)); + return EffectiveVectorMultivariateFunction(new EmbeddedFunction(as1,f2,as3)); } -EffectiveScalarFunction compose(const EffectiveScalarFunction& f, const EffectiveVectorFunction& g) { +EffectiveScalarMultivariateFunction compose(const EffectiveScalarMultivariateFunction& f, const EffectiveVectorMultivariateFunction& g) { return make_composed_function(f,g); } -EffectiveVectorFunction compose(const EffectiveVectorFunction& f, const EffectiveVectorFunction& g) { +EffectiveVectorMultivariateFunction compose(const EffectiveVectorMultivariateFunction& f, const EffectiveVectorMultivariateFunction& g) { return make_composed_function(f,g); } -EffectiveScalarFunction lie_derivative(const EffectiveScalarFunction& g, const EffectiveVectorFunction& f) { +EffectiveScalarMultivariateFunction lie_derivative(const EffectiveScalarMultivariateFunction& g, const EffectiveVectorMultivariateFunction& f) { ARIADNE_ASSERT_MSG(g.argument_size()==f.result_size(),"f="<0,"f="<0,"f="< f1p=std::dynamic_pointer_cast(f1.managed_pointer()); - std::shared_ptr f2p=std::dynamic_pointer_cast(f2.managed_pointer()); +ValidatedVectorMultivariateFunction operator-(ValidatedVectorMultivariateFunction const& f1, ValidatedVectorMultivariateFunction const& f2) { + std::shared_ptr f1p=std::dynamic_pointer_cast(f1.managed_pointer()); + std::shared_ptr f2p=std::dynamic_pointer_cast(f2.managed_pointer()); if(f1p && f2p) { - return ValidatedVectorFunctionModelDP(*f1p) - ValidatedVectorFunctionModelDP(*f2p); + return ValidatedVectorMultivariateFunctionModelDP(*f1p) - ValidatedVectorMultivariateFunctionModelDP(*f2p); } else if(f1p) { - return ValidatedVectorFunctionModelDP(*f1p) - f2.reference(); + return ValidatedVectorMultivariateFunctionModelDP(*f1p) - f2.reference(); } else if(f2p) { - return f1.reference() - ValidatedVectorFunctionModelDP(*f2p); + return f1.reference() - ValidatedVectorMultivariateFunctionModelDP(*f2p); } else { - VectorOfScalarFunction r(f1.result_size(),ValidatedScalarFunction(f1.argument_size())); + VectorOfScalarFunction r(f1.result_size(),ValidatedScalarMultivariateFunction(f1.argument_size())); for(SizeType i=0; i!=r.result_size(); ++i) { r[i]=f1[i]-f2[i]; } @@ -710,95 +710,97 @@ ValidatedVectorFunction operator-(ValidatedVectorFunction const& f1, ValidatedVe } -ValidatedScalarFunction compose(const ValidatedScalarFunction& f, const ValidatedVectorFunction& g) { +ValidatedScalarMultivariateFunction compose(const ValidatedScalarMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g) { ARIADNE_ASSERT(f.argument_size()==g.result_size()); - std::shared_ptr - gp=std::dynamic_pointer_cast(g.managed_pointer()); + std::shared_ptr + gp=std::dynamic_pointer_cast(g.managed_pointer()); if(gp) { - return compose(f,ValidatedVectorFunctionModelDP(gp->_clone())); + return compose(f,ValidatedVectorMultivariateFunctionModelDP(gp->_clone())); } else { return make_composed_function(f,g); } } -ValidatedVectorFunction compose(const ValidatedVectorFunction& f, const ValidatedVectorFunction& g) { +ValidatedVectorMultivariateFunction compose(const ValidatedVectorMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g) { ARIADNE_ASSERT(f.argument_size()==g.result_size()); - std::shared_ptr - gp=std::dynamic_pointer_cast(g.managed_pointer()); + std::shared_ptr + gp=std::dynamic_pointer_cast(g.managed_pointer()); if(gp) { - return compose(f,ValidatedVectorFunctionModelDP(gp->_clone())); + return compose(f,ValidatedVectorMultivariateFunctionModelDP(gp->_clone())); } else { return make_composed_function(f,g); } } -ValidatedVectorFunction join(ValidatedVectorFunction const& f1, const ValidatedVectorFunction& f2) { - std::shared_ptr - f1p=std::dynamic_pointer_cast(f1.managed_pointer()); - std::shared_ptr - f2p=std::dynamic_pointer_cast(f2.managed_pointer()); +ValidatedVectorMultivariateFunction join(ValidatedVectorMultivariateFunction const& f1, const ValidatedVectorMultivariateFunction& f2) { + std::shared_ptr + f1p=std::dynamic_pointer_cast(f1.managed_pointer()); + std::shared_ptr + f2p=std::dynamic_pointer_cast(f2.managed_pointer()); if(f1p && f2p) { - ValidatedVectorFunctionModelDP f1m(f1p); ValidatedVectorFunctionModelDP f2m(f2p); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f1m(f1p); ValidatedVectorMultivariateFunctionModelDP f2m(f2p); return join(f1m,f2m); } else if(f1p) { - ValidatedVectorFunctionModelDP f1m(f1p); ValidatedVectorFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f1m(f1p); ValidatedVectorMultivariateFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); } else if(f2p) { - ValidatedVectorFunctionModelDP f2m(f2p); ValidatedVectorFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f2m(f2p); ValidatedVectorMultivariateFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); } else { - return ValidatedVectorFunction(new JoinedFunction(f1,f2)); + typedef ValidatedVectorMultivariateFunction::DomainType DomainType; + typedef ValidatedVectorMultivariateFunction::CodomainType CodomainType; + return ValidatedVectorMultivariateFunction(new JoinedFunction(f1,f2)); } } -ValidatedVectorFunction join(ValidatedVectorFunction const& f1, const ValidatedScalarFunction& f2) { - std::shared_ptr - f1p=std::dynamic_pointer_cast(f1.managed_pointer()); - std::shared_ptr - f2p=std::dynamic_pointer_cast(f2.managed_pointer()); +ValidatedVectorMultivariateFunction join(ValidatedVectorMultivariateFunction const& f1, const ValidatedScalarMultivariateFunction& f2) { + std::shared_ptr + f1p=std::dynamic_pointer_cast(f1.managed_pointer()); + std::shared_ptr + f2p=std::dynamic_pointer_cast(f2.managed_pointer()); if(f1p && f2p) { - ValidatedVectorFunctionModelDP f1m(f1p); ValidatedScalarFunctionModelDP f2m(f2p); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f1m(f1p); ValidatedScalarMultivariateFunctionModelDP f2m(f2p); return join(f1m,f2m); } else if(f1p) { - ValidatedVectorFunctionModelDP f1m(f1p); ValidatedScalarFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f1m(f1p); ValidatedScalarMultivariateFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); } else if(f2p) { - ValidatedScalarFunctionModelDP f2m(f2p); ValidatedVectorFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f2m(f2p); ValidatedVectorMultivariateFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); } else { - VectorOfScalarFunction r(f1.result_size()+1u,f1.domain()); + VectorOfScalarFunction r(f1.result_size()+1u,f1.domain()); for(SizeType i=0; i!=f1.result_size(); ++i) { r[i]=f1[i]; } r[f1.result_size()]=f2; return r; } } -ValidatedVectorFunction join(ValidatedScalarFunction const& f1, const ValidatedVectorFunction& f2) { - std::shared_ptr - f1p=std::dynamic_pointer_cast(f1.managed_pointer()); - std::shared_ptr - f2p=std::dynamic_pointer_cast(f2.managed_pointer()); +ValidatedVectorMultivariateFunction join(ValidatedScalarMultivariateFunction const& f1, const ValidatedVectorMultivariateFunction& f2) { + std::shared_ptr + f1p=std::dynamic_pointer_cast(f1.managed_pointer()); + std::shared_ptr + f2p=std::dynamic_pointer_cast(f2.managed_pointer()); if(f1p && f2p) { - ValidatedScalarFunctionModelDP f1m(f1p); ValidatedVectorFunctionModelDP f2m(f2p); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f1m(f1p); ValidatedVectorMultivariateFunctionModelDP f2m(f2p); return join(f1m,f2m); } else if(f1p) { - ValidatedScalarFunctionModelDP f1m(f1p); ValidatedVectorFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f1m(f1p); ValidatedVectorMultivariateFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); } else if(f2p) { - ValidatedVectorFunctionModelDP f2m(f2p); ValidatedScalarFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); + ValidatedVectorMultivariateFunctionModelDP f2m(f2p); ValidatedScalarMultivariateFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); } else { - VectorOfScalarFunction r(f1.result_size()+1u,f1.domain()); + VectorOfScalarFunction r(f1.result_size()+1u,f1.domain()); r[0u]=f1; for(SizeType i=0; i!=f1.result_size(); ++i) { r[i+1]=f2[i]; } return r; } } -ValidatedVectorFunction join(ValidatedScalarFunction const& f1, const ValidatedScalarFunction& f2) { - std::shared_ptr - f1p=std::dynamic_pointer_cast(f1.managed_pointer()); - std::shared_ptr - f2p=std::dynamic_pointer_cast(f2.managed_pointer()); +ValidatedVectorMultivariateFunction join(ValidatedScalarMultivariateFunction const& f1, const ValidatedScalarMultivariateFunction& f2) { + std::shared_ptr + f1p=std::dynamic_pointer_cast(f1.managed_pointer()); + std::shared_ptr + f2p=std::dynamic_pointer_cast(f2.managed_pointer()); if(f1p && f2p) { - ValidatedScalarFunctionModelDP f1m(f1p); ValidatedScalarFunctionModelDP f2m(f2p); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f1m(f1p); ValidatedScalarMultivariateFunctionModelDP f2m(f2p); return join(f1m,f2m); } else if(f1p) { - ValidatedScalarFunctionModelDP f1m(f1p); ValidatedScalarFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f1m(f1p); ValidatedScalarMultivariateFunctionModelDP f2m=factory(f1m).create(f2); return join(f1m,f2m); } else if(f2p) { - ValidatedScalarFunctionModelDP f2m(f2p); ValidatedScalarFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); + ValidatedScalarMultivariateFunctionModelDP f2m(f2p); ValidatedScalarMultivariateFunctionModelDP f1m=factory(f2m).create(f1); return join(f1m,f2m); } else { - VectorOfScalarFunction r(2u,f1.domain()); + VectorOfScalarFunction r(2u,f1.domain()); r[0u]=f1; r[1u]=f2; return r; @@ -806,30 +808,30 @@ ValidatedVectorFunction join(ValidatedScalarFunction const& f1, const ValidatedS } -UpperIntervalType evaluate_range(ScalarFunctionconst& f, const Vector& x) { +UpperIntervalType evaluate_range(ScalarMultivariateFunctionconst& f, const Vector& x) { return static_cast(f(reinterpret_castconst&>(x))); } -Vector evaluate_range(VectorFunctionconst& f, const Vector& x) { +Vector evaluate_range(VectorMultivariateFunctionconst& f, const Vector& x) { return static_cast>(f(reinterpret_castconst&>(x))); } -Vector> derivative_range(VectorFunctionconst& f, const Vector>& x) { +Vector> derivative_range(VectorMultivariateFunctionconst& f, const Vector>& x) { return static_cast>>(f(reinterpret_cast>const&>(x))); } -Covector gradient_range(ValidatedScalarFunction const& f, const Vector& x) { +Covector gradient_range(ValidatedScalarMultivariateFunction const& f, const Vector& x) { return static_cast>(static_cast>(gradient(f,reinterpret_castconst&>(x)))); } -Matrix jacobian_range(ValidatedVectorFunction const& f, const Vector& x) { +Matrix jacobian_range(ValidatedVectorMultivariateFunction const& f, const Vector& x) { return static_cast>(static_cast>(jacobian(f,reinterpret_castconst&>(x)))); } //------------------------ Function operators -------------------------------// -template VectorFunction

join(const ScalarFunction

& f1, const ScalarFunction

& f2) { +template VectorMultivariateFunction

join(const ScalarMultivariateFunction

& f1, const ScalarMultivariateFunction

& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - VectorFunction

r(2,f1.domain()); + VectorMultivariateFunction

r(2,f1.domain()); r.set(0,f1); r.set(1,f2); return r; } -template VectorFunction

join(const VectorFunction

& f1, const ScalarFunction

& f2) { +template VectorMultivariateFunction

join(const VectorMultivariateFunction

& f1, const ScalarMultivariateFunction

& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - VectorFunction

r(f1.result_size()+1u,f1.domain()); + VectorMultivariateFunction

r(f1.result_size()+1u,f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -837,9 +839,9 @@ template VectorFunction

join(const VectorFunction

& f1, const Scal return r; } -template VectorFunction

join(const ScalarFunction

& f1, const VectorFunction

& f2) { +template VectorMultivariateFunction

join(const ScalarMultivariateFunction

& f1, const VectorMultivariateFunction

& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - VectorFunction

r(f2.result_size()+1u,f1.domain()); + VectorMultivariateFunction

r(f2.result_size()+1u,f1.domain()); r.set(0u,f1); for(SizeType i=0u; i!=f2.result_size(); ++i) { r.set(i+1u,f2.get(i)); @@ -847,9 +849,9 @@ template VectorFunction

join(const ScalarFunction

& f1, const Vect return r; } -template VectorFunction

join(const VectorFunction

& f1, const VectorFunction

& f2) { +template VectorMultivariateFunction

join(const VectorMultivariateFunction

& f1, const VectorMultivariateFunction

& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - VectorFunction

r(f1.result_size()+f2.result_size(),f1.domain()); + VectorMultivariateFunction

r(f1.result_size()+f2.result_size(),f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -859,17 +861,17 @@ template VectorFunction

join(const VectorFunction

& f1, const Vect return r; } -ApproximateVectorFunction join(const ApproximateScalarFunction& f1, const ApproximateScalarFunction& f2) { +ApproximateVectorMultivariateFunction join(const ApproximateScalarMultivariateFunction& f1, const ApproximateScalarMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - ApproximateVectorFunction r(2,f1.domain()); + ApproximateVectorMultivariateFunction r(2,f1.domain()); r.set(0,f1); r.set(1,f2); return r; } -ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const ApproximateScalarFunction& f2) { +ApproximateVectorMultivariateFunction join(const ApproximateVectorMultivariateFunction& f1, const ApproximateScalarMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - ApproximateVectorFunction r(f1.result_size()+1u,f1.domain()); + ApproximateVectorMultivariateFunction r(f1.result_size()+1u,f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -877,9 +879,9 @@ ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const Approx return r; } -ApproximateVectorFunction join(const ApproximateScalarFunction& f1, const ApproximateVectorFunction& f2) { +ApproximateVectorMultivariateFunction join(const ApproximateScalarMultivariateFunction& f1, const ApproximateVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - ApproximateVectorFunction r(f2.result_size()+1u,f1.domain()); + ApproximateVectorMultivariateFunction r(f2.result_size()+1u,f1.domain()); r.set(0u,f1); for(SizeType i=0u; i!=f2.result_size(); ++i) { r.set(i+1u,f2.get(i)); @@ -887,9 +889,9 @@ ApproximateVectorFunction join(const ApproximateScalarFunction& f1, const Approx return r; } -ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const ApproximateVectorFunction& f2) { +ApproximateVectorMultivariateFunction join(const ApproximateVectorMultivariateFunction& f1, const ApproximateVectorMultivariateFunction& f2) { ARIADNE_ASSERT(f1.argument_size()==f2.argument_size()); - ApproximateVectorFunction r(f1.result_size()+f2.result_size(),f1.domain()); + ApproximateVectorMultivariateFunction r(f1.result_size()+f2.result_size(),f1.domain()); for(SizeType i=0u; i!=f1.result_size(); ++i) { r.set(i,f1.get(i)); } @@ -900,12 +902,12 @@ ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const Approx } -ApproximateScalarFunction compose(const ApproximateScalarFunction& f, const ApproximateVectorFunction& g) { +ApproximateScalarMultivariateFunction compose(const ApproximateScalarMultivariateFunction& f, const ApproximateVectorMultivariateFunction& g) { return make_composed_function(f,g); } -ApproximateVectorFunction compose(const ApproximateVectorFunction& f, const ApproximateVectorFunction& g) { +ApproximateVectorMultivariateFunction compose(const ApproximateVectorMultivariateFunction& f, const ApproximateVectorMultivariateFunction& g) { return make_composed_function(f,g); } @@ -914,83 +916,83 @@ using std::dynamic_pointer_cast; template struct AlgebraOperationsBase; -template<> struct AlgebraOperationsBase> { +template<> struct AlgebraOperationsBase> { typedef EffectiveTag P; - template static EffectiveScalarFunction apply(OP op, EffectiveScalarFunction const& f) { + template static EffectiveScalarMultivariateFunction apply(OP op, EffectiveScalarMultivariateFunction const& f) { auto e=dynamic_pointer_cast(f.managed_pointer()); if(e) { return make_formula_function(e->_argument_size,op(e->_formula)); } - else { return EffectiveScalarFunction(new UnaryFunction(op.code(),f)); } + else { return EffectiveScalarMultivariateFunction(new UnaryMultivaluedFunction(op.code(),f)); } } - template static EffectiveScalarFunction apply(OP op, EffectiveScalarFunction const& f1, EffectiveScalarFunction const& f2) { + template static EffectiveScalarMultivariateFunction apply(OP op, EffectiveScalarMultivariateFunction const& f1, EffectiveScalarMultivariateFunction const& f2) { auto e1=dynamic_pointer_cast(f1.managed_pointer()); auto e2=dynamic_pointer_cast(f2.managed_pointer()); if(e1 && e2 && e1->_argument_size==e2->_argument_size) { return make_formula_function(e1->_argument_size,op(e1->_formula,e2->_formula)); } - else { return EffectiveScalarFunction(new BinaryFunction(op.code(),f1,f2)); } + else { return EffectiveScalarMultivariateFunction(new BinaryMultivaluedFunction(op.code(),f1,f2)); } } - template static EffectiveScalarFunction apply(OP op, EffectiveScalarFunction const& f1, Number

const& c2) { + template static EffectiveScalarMultivariateFunction apply(OP op, EffectiveScalarMultivariateFunction const& f1, Number

const& c2) { auto e1=dynamic_pointer_cast(f1.managed_pointer()); if(e1) { return make_formula_function(e1->_argument_size,op(e1->_formula,c2)); } - else { return op(f1,EffectiveScalarFunction::constant(f1.argument_size(),c2)); } + else { return op(f1,EffectiveScalarMultivariateFunction::constant(f1.argument_size(),c2)); } } - template static EffectiveScalarFunction apply(OP op, Number

const& c1, EffectiveScalarFunction const& f2) { + template static EffectiveScalarMultivariateFunction apply(OP op, Number

const& c1, EffectiveScalarMultivariateFunction const& f2) { auto e2=dynamic_pointer_cast(f2.managed_pointer()); if(e2) { return make_formula_function(e2->_argument_size,op(c1,e2->_formula)); } - else { return op(EffectiveScalarFunction::constant(f2.argument_size(),c1),f2); } + else { return op(EffectiveScalarMultivariateFunction::constant(f2.argument_size(),c1),f2); } } - template static EffectiveScalarFunction apply(OP op, EffectiveScalarFunction const& f, Int n) { - return EffectiveScalarFunction(new GradedFunction

(op.code(),f,n)); + template static EffectiveScalarMultivariateFunction apply(OP op, EffectiveScalarMultivariateFunction const& f, Int n) { + return EffectiveScalarMultivariateFunction(new GradedMultivaluedFunction

(op.code(),f,n)); } }; -template<> struct AlgebraOperationsBase> { - template static ValidatedScalarFunction apply(OP op, ValidatedScalarFunction const& f) { - auto fp=dynamic_pointer_cast(f.managed_pointer()); - if(fp) { ValidatedScalarFunctionModelDP fm(fp); return op(fm); } - else { return ValidatedScalarFunction(new UnaryFunction(op.code(),f)); } +template<> struct AlgebraOperationsBase> { + template static ValidatedScalarMultivariateFunction apply(OP op, ValidatedScalarMultivariateFunction const& f) { + auto fp=dynamic_pointer_cast(f.managed_pointer()); + if(fp) { ValidatedScalarMultivariateFunctionModelDP fm(fp); return op(fm); } + else { return ValidatedScalarMultivariateFunction(new UnaryMultivaluedFunction(op.code(),f)); } } - template static ValidatedScalarFunction apply(OP op, ValidatedScalarFunction const& f1, ValidatedScalarFunction const& f2) { - auto f1p=dynamic_pointer_cast(f1.managed_pointer()); - auto f2p=dynamic_pointer_cast(f2.managed_pointer()); - if(f1p && f2p) { ValidatedScalarFunctionModelDP f1m(f1p); ValidatedScalarFunctionModelDP f2m(f2p); return op(f1m,f2m); } - else if(f1p) { ValidatedScalarFunctionModelDP f1m(f1p); return op(f1m,factory(f1m).create(f2)); } - else if(f2p) { ValidatedScalarFunctionModelDP f2m(f2p); return op(factory(f2m).create(f1),f2m); } - else { return ValidatedScalarFunction(new BinaryFunction(op.code(),f1,f2)); } + template static ValidatedScalarMultivariateFunction apply(OP op, ValidatedScalarMultivariateFunction const& f1, ValidatedScalarMultivariateFunction const& f2) { + auto f1p=dynamic_pointer_cast(f1.managed_pointer()); + auto f2p=dynamic_pointer_cast(f2.managed_pointer()); + if(f1p && f2p) { ValidatedScalarMultivariateFunctionModelDP f1m(f1p); ValidatedScalarMultivariateFunctionModelDP f2m(f2p); return op(f1m,f2m); } + else if(f1p) { ValidatedScalarMultivariateFunctionModelDP f1m(f1p); return op(f1m,factory(f1m).create(f2)); } + else if(f2p) { ValidatedScalarMultivariateFunctionModelDP f2m(f2p); return op(factory(f2m).create(f1),f2m); } + else { return ValidatedScalarMultivariateFunction(new BinaryMultivaluedFunction(op.code(),f1,f2)); } } - template static ValidatedScalarFunction apply(OP op, ValidatedScalarFunction const& f1, ValidatedNumber const& c2) { - auto f1p=dynamic_pointer_cast(f1.managed_pointer()); - if(f1p) { ValidatedScalarFunctionModelDP f1m=f1p; return op(f1,c2); } - else { return ValidatedScalarFunction(new BinaryFunction(op.code(),f1,f1.create_constant(c2))); } + template static ValidatedScalarMultivariateFunction apply(OP op, ValidatedScalarMultivariateFunction const& f1, ValidatedNumber const& c2) { + auto f1p=dynamic_pointer_cast(f1.managed_pointer()); + if(f1p) { ValidatedScalarMultivariateFunctionModelDP f1m=f1p; return op(f1,c2); } + else { return ValidatedScalarMultivariateFunction(new BinaryMultivaluedFunction(op.code(),f1,f1.create_constant(c2))); } } - template static ValidatedScalarFunction apply(OP op, ValidatedNumber const& c1, ValidatedScalarFunction const& f2) { - auto f2p=dynamic_pointer_cast(f2.managed_pointer()); - if(f2p) { ValidatedScalarFunctionModelDP f2m=f2p; return op(c1,f2m); } - else { return ValidatedScalarFunction(new BinaryFunction(op.code(),f2.create_constant(c1),f2)); } + template static ValidatedScalarMultivariateFunction apply(OP op, ValidatedNumber const& c1, ValidatedScalarMultivariateFunction const& f2) { + auto f2p=dynamic_pointer_cast(f2.managed_pointer()); + if(f2p) { ValidatedScalarMultivariateFunctionModelDP f2m=f2p; return op(c1,f2m); } + else { return ValidatedScalarMultivariateFunction(new BinaryMultivaluedFunction(op.code(),f2.create_constant(c1),f2)); } } - static ValidatedScalarFunction apply(Pow op, ValidatedScalarFunction const& f, Int n) { - auto fp=dynamic_pointer_cast(f.managed_pointer()); - if(fp) { ValidatedScalarFunctionModelDP fm=fp; return op(fm,n); } - else { return ValidatedScalarFunction(new GradedFunction(op.code(),f,n)); } + static ValidatedScalarMultivariateFunction apply(Pow op, ValidatedScalarMultivariateFunction const& f, Int n) { + auto fp=dynamic_pointer_cast(f.managed_pointer()); + if(fp) { ValidatedScalarMultivariateFunctionModelDP fm=fp; return op(fm,n); } + else { return ValidatedScalarMultivariateFunction(new GradedMultivaluedFunction(op.code(),f,n)); } } }; -template<> struct AlgebraOperationsBase> { +template<> struct AlgebraOperationsBase> { typedef ApproximateTag P; - template static ScalarFunction

apply(OP op, ScalarFunction

const& f) { - return ScalarFunction

(new UnaryFunction

(op.code(),f)); } - template static ScalarFunction

apply(OP op, ScalarFunction

const& f1, ScalarFunction

const& f2) { - return ScalarFunction

(new BinaryFunction

(op.code(),f1,f2)); } - template static ScalarFunction

apply(OP op, ScalarFunction

const& f1, Number

const& c2) { - return ScalarFunction

(new BinaryFunction

(op.code(),f1,f1.create_constant(c2))); } - template static ScalarFunction

apply(OP op, Number

const& c1, ScalarFunction

const& f2) { - return ScalarFunction

(new BinaryFunction

(op.code(),f2.create_constant(c1),f2)); } - template static ScalarFunction

apply(OP op, ScalarFunction

const& f, Int n) { - return ScalarFunction

(new GradedFunction

(op.code(),f,n)); } + template static ScalarMultivariateFunction

apply(OP op, ScalarMultivariateFunction

const& f) { + return ScalarMultivariateFunction

(new UnaryMultivaluedFunction

(op.code(),f)); } + template static ScalarMultivariateFunction

apply(OP op, ScalarMultivariateFunction

const& f1, ScalarMultivariateFunction

const& f2) { + return ScalarMultivariateFunction

(new BinaryMultivaluedFunction

(op.code(),f1,f2)); } + template static ScalarMultivariateFunction

apply(OP op, ScalarMultivariateFunction

const& f1, Number

const& c2) { + return ScalarMultivariateFunction

(new BinaryMultivaluedFunction

(op.code(),f1,f1.create_constant(c2))); } + template static ScalarMultivariateFunction

apply(OP op, Number

const& c1, ScalarMultivariateFunction

const& f2) { + return ScalarMultivariateFunction

(new BinaryMultivaluedFunction

(op.code(),f2.create_constant(c1),f2)); } + template static ScalarMultivariateFunction

apply(OP op, ScalarMultivariateFunction

const& f, Int n) { + return ScalarMultivariateFunction

(new GradedMultivaluedFunction

(op.code(),f,n)); } }; template struct AlgebraOperationsBase> { @@ -1028,9 +1030,9 @@ template auto FunctionAlgebraOperations::apply(Cos op, F template auto FunctionAlgebraOperations::apply(Tan op, F const& f) -> F { return Base::apply(op,f); } template auto FunctionAlgebraOperations::apply(Atan op, F const& f) -> F { return Base::apply(op,f); } -template struct AlgebraOperations,Number>; -template struct AlgebraOperations,Number>; -template struct AlgebraOperations,Number>; +template struct AlgebraOperations,Number>; +template struct AlgebraOperations,Number>; +template struct AlgebraOperations,Number>; template struct AlgebraOperations,Number>; template struct AlgebraOperations,Number>; diff --git a/source/function/function.decl.hpp b/source/function/function.decl.hpp index 10bd4587c..acbfb6a4b 100644 --- a/source/function/function.decl.hpp +++ b/source/function/function.decl.hpp @@ -40,8 +40,8 @@ using BoxDomainType = ExactBoxType; // Function declarations template class Function; -template using ScalarFunction = Function; -template using VectorFunction = Function; +template using ScalarFunction = Function; +template using VectorFunction = Function; template using UnivariateFunction = Function; template using MultivariateFunction = Function; @@ -55,39 +55,41 @@ typedef ScalarUnivariateFunction ValidatedScalarUnivariateFunction typedef ScalarUnivariateFunction EffectiveScalarUnivariateFunction; typedef EffectiveScalarUnivariateFunction RealScalarUnivariateFunction; -typedef ScalarFunction ApproximateScalarFunction; -typedef ScalarFunction ValidatedScalarFunction; -typedef ScalarFunction EffectiveScalarFunction; -typedef EffectiveScalarFunction RealScalarFunction; - -typedef VectorFunction ApproximateVectorFunction; -typedef VectorFunction ValidatedVectorFunction; -typedef VectorFunction EffectiveVectorFunction; -typedef EffectiveVectorFunction RealVectorFunction; +typedef ScalarMultivariateFunction ApproximateScalarMultivariateFunction; +typedef ScalarMultivariateFunction ValidatedScalarMultivariateFunction; +typedef ScalarMultivariateFunction EffectiveScalarMultivariateFunction; +typedef EffectiveScalarMultivariateFunction RealScalarMultivariateFunction; typedef VectorUnivariateFunction ApproximateVectorUnivariateFunction; typedef VectorUnivariateFunction ValidatedVectorUnivariateFunction; typedef VectorUnivariateFunction EffectiveVectorUnivariateFunction; +typedef EffectiveVectorUnivariateFunction RealVectorUnivariateFunction; + +typedef VectorMultivariateFunction ApproximateVectorMultivariateFunction; +typedef VectorMultivariateFunction ValidatedVectorMultivariateFunction; +typedef VectorMultivariateFunction EffectiveVectorMultivariateFunction; +typedef EffectiveVectorMultivariateFunction RealVectorMultivariateFunction; + // Function interface declarations template class FunctionInterface; -template using ScalarFunctionInterface = FunctionInterface; -template using VectorFunctionInterface = FunctionInterface; +template using ScalarFunctionInterface = FunctionInterface; +template using VectorFunctionInterface = FunctionInterface; +template using ScalarMultivariateFunctionInterface = FunctionInterface; +template using VectorMultivariateFunctionInterface = FunctionInterface; -typedef ScalarFunctionInterface ApproximateScalarFunctionInterface; -typedef ScalarFunctionInterface ValidatedScalarFunctionInterface; -typedef ScalarFunctionInterface EffectiveScalarFunctionInterface; +typedef ScalarMultivariateFunctionInterface ApproximateScalarMultivariateFunctionInterface; +typedef ScalarMultivariateFunctionInterface ValidatedScalarMultivariateFunctionInterface; +typedef ScalarMultivariateFunctionInterface EffectiveScalarMultivariateFunctionInterface; -typedef VectorFunctionInterface ApproximateVectorFunctionInterface; -typedef VectorFunctionInterface ValidatedVectorFunctionInterface; -typedef VectorFunctionInterface EffectiveVectorFunctionInterface; +typedef VectorMultivariateFunctionInterface ApproximateVectorMultivariateFunctionInterface; +typedef VectorMultivariateFunctionInterface ValidatedVectorMultivariateFunctionInterface; +typedef VectorMultivariateFunctionInterface EffectiveVectorMultivariateFunctionInterface; -using ValidatedScalarFunctionPatch = Function; -using ValidatedVectorFunctionPatch = Function; -using ValidatedUnivariateScalarFunctionPatch = Function; -using ValidatedUnivariateVectorFunctionPatch = Function; -using ValidatedMultivariateScalarFunctionPatch = Function; -using ValidatedMultivariateVectorFunctionPatch = Function; +using ValidatedScalarUnivariateFunctionPatch = Function; +using ValidatedVectorUnivariateFunctionPatch = Function; +using ValidatedScalarMultivariateFunctionPatch = Function; +using ValidatedVectorMultivariateFunctionPatch = Function; // Function models declarations @@ -100,13 +102,13 @@ template using VectorFunctionModelInte template class FunctionModel; template using ScalarFunctionModel = FunctionModel; template using VectorFunctionModel = FunctionModel; +template using ScalarUnivariateFunctionModel = FunctionModel; +template using VectorUnivariateFunctionModel = FunctionModel; +template using ScalarMultivariateFunctionModel = FunctionModel; +template using VectorMultivariateFunctionModel = FunctionModel; template struct FunctionModelTraits; -template using ScalarFunctionModelDPInterface = ScalarFunctionModelInterface; -template using VectorFunctionModelDPInterface = VectorFunctionModelInterface; -template using ScalarFunctionModelDP = ScalarFunctionModel; -template using VectorFunctionModelDP = VectorFunctionModel; template struct FunctionModelTraits { static_assert(IsSame::value or IsSame::value,""); @@ -133,17 +135,23 @@ template using CanonicalError64Type = typename FunctionModelTraits using PrecisionType = typename X::PrecisionType; template using ErrorPrecisionType = typename X::ErrorPrecisionType; -using ValidatedScalarFunctionModelDPInterface = ScalarFunctionModelInterface; -using ValidatedVectorFunctionModelDPInterface = VectorFunctionModelInterface; +template using ScalarMultivariateFunctionModelDP = ScalarFunctionModel; +template using VectorMultivariateFunctionModelDP = VectorFunctionModel; + +template using ScalarMultivariateFunctionModelDPInterface = ScalarFunctionModelInterface; +template using VectorMultivariateFunctionModelDPInterface = VectorFunctionModelInterface; + +using ValidatedScalarMultivariateFunctionModelDPInterface = ScalarFunctionModelInterface; +using ValidatedVectorMultivariateFunctionModelDPInterface = VectorFunctionModelInterface; -using ValidatedScalarFunctionModelDP = ScalarFunctionModel; -using ValidatedVectorFunctionModelDP = VectorFunctionModel; +using ValidatedScalarMultivariateFunctionModelDP = ScalarFunctionModel; +using ValidatedVectorMultivariateFunctionModelDP = VectorFunctionModel; -using ApproximateScalarFunctionModelDPInterface = ScalarFunctionModelInterface; -using ApproximateVectorFunctionModelDPInterface = VectorFunctionModelInterface; +using ApproximateScalarMultivariateFunctionModelDPInterface = ScalarFunctionModelInterface; +using ApproximateVectorMultivariateFunctionModelDPInterface = VectorFunctionModelInterface; -using ApproximateScalarFunctionModelDP = ScalarFunctionModel; -using ApproximateVectorFunctionModelDP = VectorFunctionModel; +using ApproximateScalarMultivariateFunctionModelDP = ScalarFunctionModel; +using ApproximateVectorMultivariateFunctionModelDP = VectorFunctionModel; template class FunctionModelFactoryInterface; typedef FunctionModelFactoryInterface ValidatedFunctionModelDPFactoryInterface; diff --git a/source/function/function.hpp b/source/function/function.hpp index 146c478c1..d371b3b30 100644 --- a/source/function/function.hpp +++ b/source/function/function.hpp @@ -51,7 +51,7 @@ namespace Ariadne { -template struct VectorFunctionElementReference; +template struct VectorFunctionElementReference; template class Variable; typedef Variable RealVariable; @@ -99,7 +99,7 @@ class FunctionConstructors { }; -template using EvaluateType = decltype(declval>()._evaluate(declval>())); +template using EvaluateType = decltype(declval>()._evaluate(declval>())); template class FunctionFacade { }; @@ -333,43 +333,43 @@ FunctionFacade::jacobian(Vector const& x) cons } -ValidatedScalarFunction& operator*=(ValidatedScalarFunction& sf, const ExactNumber& c); -EffectiveVectorFunction operator*(const EffectiveNumericType& c, const EffectiveVectorFunction& vf); +ValidatedScalarMultivariateFunction& operator*=(ValidatedScalarMultivariateFunction& sf, const ExactNumber& c); +EffectiveVectorMultivariateFunction operator*(const EffectiveNumericType& c, const EffectiveVectorMultivariateFunction& vf); -EffectiveScalarFunction embed(SizeType as1, const EffectiveScalarFunction& f2, SizeType as3); -EffectiveVectorFunction embed(SizeType as1, const EffectiveVectorFunction& f2, SizeType as3); +EffectiveScalarMultivariateFunction embed(SizeType as1, const EffectiveScalarMultivariateFunction& f2, SizeType as3); +EffectiveVectorMultivariateFunction embed(SizeType as1, const EffectiveVectorMultivariateFunction& f2, SizeType as3); -EffectiveVectorFunction join(const EffectiveScalarFunction& f1, const EffectiveScalarFunction& f2); -EffectiveVectorFunction join(const EffectiveScalarFunction& f1, const EffectiveVectorFunction& f2); -EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveScalarFunction& f2); -EffectiveVectorFunction join(const EffectiveVectorFunction& f1, const EffectiveVectorFunction& f2); +EffectiveVectorMultivariateFunction join(const EffectiveScalarMultivariateFunction& f1, const EffectiveScalarMultivariateFunction& f2); +EffectiveVectorMultivariateFunction join(const EffectiveScalarMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2); +EffectiveVectorMultivariateFunction join(const EffectiveVectorMultivariateFunction& f1, const EffectiveScalarMultivariateFunction& f2); +EffectiveVectorMultivariateFunction join(const EffectiveVectorMultivariateFunction& f1, const EffectiveVectorMultivariateFunction& f2); -EffectiveScalarFunction compose(const EffectiveScalarFunction& f, const EffectiveVectorFunction& g); -EffectiveVectorFunction compose(const EffectiveVectorFunction& f, const EffectiveVectorFunction& g); +EffectiveScalarMultivariateFunction compose(const EffectiveScalarMultivariateFunction& f, const EffectiveVectorMultivariateFunction& g); +EffectiveVectorMultivariateFunction compose(const EffectiveVectorMultivariateFunction& f, const EffectiveVectorMultivariateFunction& g); -EffectiveScalarFunction lie_derivative(const EffectiveScalarFunction& g, const EffectiveVectorFunction& f); -EffectiveVectorFunction lie_derivative(const EffectiveVectorFunction& g, const EffectiveVectorFunction& f); +EffectiveScalarMultivariateFunction lie_derivative(const EffectiveScalarMultivariateFunction& g, const EffectiveVectorMultivariateFunction& f); +EffectiveVectorMultivariateFunction lie_derivative(const EffectiveVectorMultivariateFunction& g, const EffectiveVectorMultivariateFunction& f); -Formula make_formula(const EffectiveScalarFunction& f); -Vector> make_formula(const EffectiveVectorFunction& f); -//RealExpression evaluate(EffectiveScalarFunction const& f, Vector const& vars); +Formula make_formula(const EffectiveScalarMultivariateFunction& f); +Vector> make_formula(const EffectiveVectorMultivariateFunction& f); +//RealExpression evaluate(EffectiveScalarMultivariateFunction const& f, Vector const& vars); -ValidatedVectorFunction join(const ValidatedScalarFunction& f1, const ValidatedScalarFunction& f2); -ValidatedVectorFunction join(const ValidatedScalarFunction& f1, const ValidatedVectorFunction& f2); -ValidatedVectorFunction join(const ValidatedVectorFunction& f1, const ValidatedScalarFunction& f2); -ValidatedVectorFunction join(const ValidatedVectorFunction& f1, const ValidatedVectorFunction& f2); -ValidatedScalarFunction compose(const ValidatedScalarFunction& f, const ValidatedVectorFunction& g); -ValidatedVectorFunction compose(const ValidatedVectorFunction& f, const ValidatedVectorFunction& g); +ValidatedVectorMultivariateFunction join(const ValidatedScalarMultivariateFunction& f1, const ValidatedScalarMultivariateFunction& f2); +ValidatedVectorMultivariateFunction join(const ValidatedScalarMultivariateFunction& f1, const ValidatedVectorMultivariateFunction& f2); +ValidatedVectorMultivariateFunction join(const ValidatedVectorMultivariateFunction& f1, const ValidatedScalarMultivariateFunction& f2); +ValidatedVectorMultivariateFunction join(const ValidatedVectorMultivariateFunction& f1, const ValidatedVectorMultivariateFunction& f2); +ValidatedScalarMultivariateFunction compose(const ValidatedScalarMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g); +ValidatedVectorMultivariateFunction compose(const ValidatedVectorMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g); -ApproximateVectorFunction join(const ApproximateScalarFunction& f1, const ApproximateScalarFunction& f2); -ApproximateVectorFunction join(const ApproximateScalarFunction& f1, const ApproximateVectorFunction& f2); -ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const ApproximateScalarFunction& f2); -ApproximateVectorFunction join(const ApproximateVectorFunction& f1, const ApproximateVectorFunction& f2); -ApproximateScalarFunction compose(const ApproximateScalarFunction& f, const ApproximateVectorFunction& g); -ApproximateVectorFunction compose(const ApproximateVectorFunction& f, const ApproximateVectorFunction& g); +ApproximateVectorMultivariateFunction join(const ApproximateScalarMultivariateFunction& f1, const ApproximateScalarMultivariateFunction& f2); +ApproximateVectorMultivariateFunction join(const ApproximateScalarMultivariateFunction& f1, const ApproximateVectorMultivariateFunction& f2); +ApproximateVectorMultivariateFunction join(const ApproximateVectorMultivariateFunction& f1, const ApproximateScalarMultivariateFunction& f2); +ApproximateVectorMultivariateFunction join(const ApproximateVectorMultivariateFunction& f1, const ApproximateVectorMultivariateFunction& f2); +ApproximateScalarMultivariateFunction compose(const ApproximateScalarMultivariateFunction& f, const ApproximateVectorMultivariateFunction& g); +ApproximateVectorMultivariateFunction compose(const ApproximateVectorMultivariateFunction& f, const ApproximateVectorMultivariateFunction& g); @@ -424,30 +424,30 @@ template template inline XX VectorFunctionElementRef -UpperIntervalType evaluate_range(ScalarFunctionconst& f, const Vector& x); -Vector evaluate_range(VectorFunctionconst& f, const Vector& x); -Vector> derivative_range(VectorFunctionconst& f, const Vector>& x); -Covector gradient_range(ValidatedScalarFunction const& f, const Vector& x); -Matrix jacobian_range(ValidatedVectorFunction const& f, const Vector& x); +UpperIntervalType evaluate_range(ScalarMultivariateFunctionconst& f, const Vector& x); +Vector evaluate_range(VectorMultivariateFunctionconst& f, const Vector& x); +Vector> derivative_range(VectorMultivariateFunctionconst& f, const Vector>& x); +Covector gradient_range(ValidatedScalarMultivariateFunction const& f, const Vector& x); +Matrix jacobian_range(ValidatedVectorMultivariateFunction const& f, const Vector& x); /* -inline Matrix jacobian(VectorFunctionconst& f, const Vector& x) { +inline Matrix jacobian(VectorMultivariateFunctionconst& f, const Vector& x) { return static_cast>(f.jacobian(reinterpret_castconst&>(x))); } -inline Matrix jacobian(VectorFunctionconst& f, const Vector& x) { +inline Matrix jacobian(VectorMultivariateFunctionconst& f, const Vector& x) { return static_cast>(f.jacobian(reinterpret_castconst&>(x))); } -inline Matrix jacobian_range(VectorFunctionconst& f, const Vector& x) { +inline Matrix jacobian_range(VectorMultivariateFunctionconst& f, const Vector& x) { return static_cast>(f.jacobian(reinterpret_castconst&>(x))); } // FIXME: Needed to override templated gradient and jacobian -inline Covector gradient(ScalarFunctionconst& f, const Vector& x) { +inline Covector gradient(ScalarMultivariateFunctionconst& f, const Vector& x) { return static_cast>(gradient(f,reinterpret_castconst&>(x))); } -inline Covector gradient(ScalarFunctionconst& f, const Vector& x) { +inline Covector gradient(ScalarMultivariateFunctionconst& f, const Vector& x) { return gradient(f,static_cast>(x)); } -inline Matrix jacobian(VectorFunctionconst& f, const Vector& x) { +inline Matrix jacobian(VectorMultivariateFunctionconst& f, const Vector& x) { return static_cast>(f.jacobian(reinterpret_castconst&>(x))); } -inline Matrix jacobian(VectorFunctionconst& f, const Vector& x) { +inline Matrix jacobian(VectorMultivariateFunctionconst& f, const Vector& x) { return jacobian(f,static_cast>(x)); } */ @@ -462,29 +462,29 @@ class FunctionFactory FunctionFactory(const FunctionFactoryInterface& ref) : _ptr(ref.clone()) { } FunctionFactory(const FunctionFactoryInterface* ptr) : _ptr(ptr) { } FunctionFactory(SharedPointer< const FunctionFactoryInterface > ptr) : _ptr(ptr) { } - inline ValidatedScalarFunction create(const BoxDomainType& d, const ValidatedScalarFunctionInterface& f) const; - inline ValidatedVectorFunction create(const BoxDomainType& d, const ValidatedVectorFunctionInterface& f) const; - inline ValidatedScalarFunction create_zero(const BoxDomainType& d) const; - inline ValidatedVectorFunction create_identity(const BoxDomainType& d) const; + inline ValidatedScalarMultivariateFunction create(const BoxDomainType& d, const ValidatedScalarMultivariateFunctionInterface& f) const; + inline ValidatedVectorMultivariateFunction create(const BoxDomainType& d, const ValidatedVectorMultivariateFunctionInterface& f) const; + inline ValidatedScalarMultivariateFunction create_zero(const BoxDomainType& d) const; + inline ValidatedVectorMultivariateFunction create_identity(const BoxDomainType& d) const; friend OutputStream& operator<<(OutputStream& os, const FunctionFactory& factory); }; -inline ValidatedScalarFunction FunctionFactoryInterface::create(const BoxDomainType& domain, const ValidatedScalarFunctionInterface& function) const { - return ValidatedScalarFunction(SharedPointer(this->_create(domain,function))); } -inline ValidatedVectorFunction FunctionFactoryInterface::create(const BoxDomainType& domain, const ValidatedVectorFunctionInterface& function) const { - return ValidatedVectorFunction(SharedPointer(this->_create(domain,function))); } -inline ValidatedScalarFunction FunctionFactoryInterface::create_zero(const BoxDomainType& domain) const { - return this->create(domain,EffectiveScalarFunction::zero(domain.dimension())); } -inline ValidatedVectorFunction FunctionFactoryInterface::create_identity(const BoxDomainType& domain) const { - return this->create(domain,EffectiveVectorFunction::identity(domain.dimension())); } +inline ValidatedScalarMultivariateFunction FunctionFactoryInterface::create(const BoxDomainType& domain, const ValidatedScalarMultivariateFunctionInterface& function) const { + return ValidatedScalarMultivariateFunction(SharedPointer(this->_create(domain,function))); } +inline ValidatedVectorMultivariateFunction FunctionFactoryInterface::create(const BoxDomainType& domain, const ValidatedVectorMultivariateFunctionInterface& function) const { + return ValidatedVectorMultivariateFunction(SharedPointer(this->_create(domain,function))); } +inline ValidatedScalarMultivariateFunction FunctionFactoryInterface::create_zero(const BoxDomainType& domain) const { + return this->create(domain,EffectiveScalarMultivariateFunction::zero(domain.dimension())); } +inline ValidatedVectorMultivariateFunction FunctionFactoryInterface::create_identity(const BoxDomainType& domain) const { + return this->create(domain,EffectiveVectorMultivariateFunction::identity(domain.dimension())); } -inline ValidatedScalarFunction FunctionFactory::create(const BoxDomainType& domain, const ValidatedScalarFunctionInterface& function) const { +inline ValidatedScalarMultivariateFunction FunctionFactory::create(const BoxDomainType& domain, const ValidatedScalarMultivariateFunctionInterface& function) const { return this->_ptr->create(domain,function); } -inline ValidatedVectorFunction FunctionFactory::create(const BoxDomainType& domain, const ValidatedVectorFunctionInterface& function) const { +inline ValidatedVectorMultivariateFunction FunctionFactory::create(const BoxDomainType& domain, const ValidatedVectorMultivariateFunctionInterface& function) const { return this->_ptr->create(domain,function); } -inline ValidatedScalarFunction FunctionFactory::create_zero(const BoxDomainType& domain) const { +inline ValidatedScalarMultivariateFunction FunctionFactory::create_zero(const BoxDomainType& domain) const { return this->_ptr->create_zero(domain); } -inline ValidatedVectorFunction FunctionFactory::create_identity(const BoxDomainType& domain) const { +inline ValidatedVectorMultivariateFunction FunctionFactory::create_identity(const BoxDomainType& domain) const { return this->_ptr->create_identity(domain); } inline OutputStream& operator<<(OutputStream& os, const ValidatedFunctionFactory& factory) { diff --git a/source/function/function_interface.hpp b/source/function/function_interface.hpp index 4805113f6..b0652af6d 100644 --- a/source/function/function_interface.hpp +++ b/source/function/function_interface.hpp @@ -48,26 +48,26 @@ template class FunctionInterface; //! \ingroup FunctionModule //! \brief Interface for vector functions \f$\F^n\rightarrow\F^m\f$ whose derivatives can be computed. -//! \sa \ref ScalarFunctionInterface -template +//! \sa \ref ScalarMultivariateFunctionInterface +template class VectorOfFunctionInterface { }; -template class VectorOfFunctionInterface { +template class VectorOfFunctionInterface { public: virtual ~VectorOfFunctionInterface() = default; virtual ScalarFunctionInterface* _get(SizeType i) const = 0; }; -template class VectorOfFunctionInterface +template class VectorOfFunctionInterface : public virtual VectorOfFunctionInterface { public: virtual ScalarFunctionInterface* _get(SizeType i) const override = 0; }; -template class VectorOfFunctionInterface +template class VectorOfFunctionInterface : public virtual VectorOfFunctionInterface { public: @@ -103,7 +103,7 @@ class FunctionInterface //! \ingroup FunctionModule //! \brief Interface for scalar functions \f$\mathbb{F}^n\rightarrow\mathbb{F}\f$ which can only be evaluated approximately. -//! \sa \ref VectorFunctionInterface. +//! \sa \ref VectorMultivariateFunctionInterface. template class FunctionInterface : public virtual FunctionInterface @@ -128,7 +128,7 @@ class FunctionInterface //! \ingroup FunctionModule //! \brief Interface for scalar functions \f$\mathbb{I}^n\rightarrow\mathbb{I}\f$ which can be evaluated over intervals. -//! \sa \ref VectorFunctionInterface. +//! \sa \ref VectorMultivariateFunctionInterface. template class FunctionInterface : public virtual FunctionInterface @@ -149,7 +149,7 @@ class FunctionInterface virtual Result> _evaluate(const Argument< Formula >& x) const = 0; virtual Result> _evaluate(const Argument< Algebra >& x) const = 0; - virtual Result> _evaluate(const Argument< ScalarFunction >& x) const = 0; + virtual Result> _evaluate(const Argument< ScalarMultivariateFunction >& x) const = 0; inline Result _evaluate(const Argument& x) const { return this->_evaluate(Argument(x)); } @@ -162,7 +162,7 @@ class FunctionInterface //! \ingroup FunctionModule //! \brief Interface for scalar functions \f$\R^n\rightarrow\R\f$ which can be evaluated exactly. -//! \sa \ref VectorFunctionInterface. +//! \sa \ref VectorMultivariateFunctionInterface. template class FunctionInterface : public virtual FunctionInterface @@ -194,22 +194,23 @@ template class FunctionFactoryInterface; template<> class FunctionFactoryInterface { + using P = ValidatedTag; typedef BoxDomainType DomainType; public: virtual FunctionFactoryInterface* clone() const = 0; virtual OutputStream& write(OutputStream& os) const = 0; - inline ValidatedScalarFunction create(const BoxDomainType& domain, const ScalarFunctionInterface& function) const; - inline ValidatedVectorFunction create(const BoxDomainType& domain, const VectorFunctionInterface& function) const; - inline ValidatedScalarFunction create_zero(const BoxDomainType& domain) const; - inline ValidatedVectorFunction create_identity(const BoxDomainType& domain) const; + inline ScalarMultivariateFunction

create(const BoxDomainType& domain, const ScalarMultivariateFunctionInterface

& function) const; + inline VectorMultivariateFunction

create(const BoxDomainType& domain, const VectorMultivariateFunctionInterface

& function) const; + inline ScalarMultivariateFunction

create_zero(const BoxDomainType& domain) const; + inline VectorMultivariateFunction

create_identity(const BoxDomainType& domain) const; private: - virtual ScalarFunctionInterface* _create(const BoxDomainType& domain, const ScalarFunctionInterface& function) const = 0; - virtual VectorFunctionInterface* _create(const BoxDomainType& domain, const VectorFunctionInterface& function) const = 0; + virtual ScalarMultivariateFunctionInterface

* _create(const BoxDomainType& domain, const ScalarMultivariateFunctionInterface

& function) const = 0; + virtual VectorMultivariateFunctionInterface

* _create(const BoxDomainType& domain, const VectorMultivariateFunctionInterface

& function) const = 0; public: - friend inline OutputStream& operator<<(OutputStream& os, const FunctionFactoryInterface& factory) { + friend inline OutputStream& operator<<(OutputStream& os, const FunctionFactoryInterface

& factory) { return factory.write(os); } public: - virtual ~FunctionFactoryInterface() = default; + virtual ~FunctionFactoryInterface

() = default; }; diff --git a/source/function/function_mixin.hpp b/source/function/function_mixin.hpp index 624d8ec9c..87aefca6c 100644 --- a/source/function/function_mixin.hpp +++ b/source/function/function_mixin.hpp @@ -46,8 +46,10 @@ typedef Algebra ValidatedAlgebra; typedef Algebra EffectiveAlgebra; template class FunctionMixin { }; -template class ScalarFunctionMixin; -template class VectorFunctionMixin; +template class ScalarFunctionMixin; +template class VectorFunctionMixin; +template using ScalarMultivariateFunctionMixin = ScalarFunctionMixin; +template using VectorMultivariateFunctionMixin = VectorFunctionMixin; template T* heap_copy(const T& t) { return new T(t); } template T* heap_move(T&& t) { return new T(std::move(t)); } @@ -123,7 +125,7 @@ class FunctionMixin virtual Result> _evaluate(const Argument>& x) const override; virtual Result> _evaluate(const Argument>& x) const override; - virtual Result _evaluate(const Argument& x) const override; + virtual Result _evaluate(const Argument& x) const override; }; diff --git a/source/function/function_mixin.tpl.hpp b/source/function/function_mixin.tpl.hpp index 42b545fdb..c1ba8e5ce 100644 --- a/source/function/function_mixin.tpl.hpp +++ b/source/function/function_mixin.tpl.hpp @@ -104,7 +104,7 @@ FunctionMixin::_evaluate(const Argument_base_evaluate(x); } template auto -FunctionMixin::_evaluate(const Argument& x) const -> Result { +FunctionMixin::_evaluate(const Argument& x) const -> Result { return this->_base_evaluate(x); } template auto diff --git a/source/function/function_model.hpp b/source/function/function_model.hpp index e5c89eaa5..4c5c071b9 100644 --- a/source/function/function_model.hpp +++ b/source/function/function_model.hpp @@ -103,13 +103,10 @@ template auto inline FunctionModelFactoryInterface::create_identity(IntervalDomainType const& dom) const -> ScalarFunctionModel { return ScalarFunctionModel(this->create_coordinate(BoxDomainType(1u,dom),0u)); } -template class FunctionModelCreator; - -template class FunctionModelCreator { +template class FunctionModelCreator { typedef typename FCTRY::Paradigm P; typedef typename FCTRY::PrecisionType PR; typedef typename FCTRY::ErrorPrecisionType PRE; - typedef BoxDomainType D; public: typedef FCTRY FactoryType; typedef D DomainType; @@ -162,7 +159,7 @@ template class FunctionModelCreator { template class FunctionModel // : public DispatchTranscendentalAlgebraOperations, CanonicalNumericType> : public DispatchTranscendentalAlgebraOperations, CanonicalNumericType> - , public ProvideConcreteGenericArithmeticOperators,ScalarFunction

> + , public ProvideConcreteGenericArithmeticOperators,ScalarMultivariateFunction

> , public ProvideConcreteGenericArithmeticOperators,Number

> { static_assert(IsSame::value or IsSame::value,""); @@ -266,7 +263,7 @@ template class FunctionModel_refines(f2); } public: friend OutputStream& operator<<(OutputStream& os, const ScalarFunctionModel& f) { - return os << f.operator ScalarFunction

(); } + return os << f.operator ScalarMultivariateFunction

(); } }; template struct AlgebraOperations> { @@ -339,9 +336,9 @@ template inline Boolean refines(const ScalarFunctionModel& f1, const ScalarFunctionModel& f2) { return f1._ptr->_refines(f2); } */ - // FIXME: Should not be needed since ScalarFunctionModel has a representation -template inline ScalarFunctionModelDP embed(const ScalarFunction

& f, const IntervalDomainType& d) { - return embed(ScalarFunctionModelDP(f),d); } + // FIXME: Should not be needed since ScalarMultivariateFunctionModel has a representation +template inline ScalarMultivariateFunctionModel embed(const ScalarMultivariateFunction

& f, const IntervalDomainType& d) { + return embed(ScalarMultivariateFunctionModel(f),d); } template inline ScalarFunctionModel& ScalarFunctionModel::operator=(const CanonicalNumericType& c) { @@ -456,11 +453,11 @@ template class FunctionModel,D> factory(VectorFunctionModel const& f) { FunctionModelFactory factory(f._ptr->_factory()); return FunctionModelCreator,D>(f.domain(),factory); } public: - friend inline ScalarFunctionModel compose(const ScalarFunction

& f, const VectorFunctionModel& g) { + friend inline ScalarFunctionModel compose(const ScalarMultivariateFunction

& f, const VectorFunctionModel& g) { return ScalarFunctionModel(g._ptr->_compose(f)); } friend inline ScalarFunctionModel compose(const ScalarFunctionModel& f, const VectorFunctionModel& g) { return ScalarFunctionModel(g._ptr->_compose(f)); } - friend inline VectorFunctionModel compose(const VectorFunction

& f, const VectorFunctionModel& g) { + friend inline VectorFunctionModel compose(const VectorMultivariateFunction

& f, const VectorFunctionModel& g) { return VectorFunctionModel(g._ptr->_compose(f)); } friend inline VectorFunctionModel compose(const VectorFunctionModel& f, const VectorFunctionModel& g) { return VectorFunctionModel(g._ptr->_compose(f)); } @@ -489,13 +486,13 @@ template class FunctionModel operator*(const CanonicalNumericType& c1, const VectorFunctionModel& f2) { VectorFunctionModel r=f2; for(SizeType i=0; i!=r.size(); ++i) { r[i]=c1*f2[i]; } return r; } - friend inline VectorFunctionModel operator+(const VectorFunctionModel& f1, const VectorFunction

& f2) { + friend inline VectorFunctionModel operator+(const VectorFunctionModel& f1, const VectorMultivariateFunction

& f2) { return f1+factory(f1).create(f2); } - friend inline VectorFunctionModel operator-(const VectorFunctionModel& f1, const VectorFunction

& f2) { + friend inline VectorFunctionModel operator-(const VectorFunctionModel& f1, const VectorMultivariateFunction

& f2) { return f1-factory(f1).create(f2); } - friend inline VectorFunctionModel operator+(const VectorFunction

& f1, const VectorFunctionModel& f2) { + friend inline VectorFunctionModel operator+(const VectorMultivariateFunction

& f1, const VectorFunctionModel& f2) { return factory(f2).create(f1)+f2; } - friend inline VectorFunctionModel operator-(const VectorFunction

& f1, const VectorFunctionModel& f2) { + friend inline VectorFunctionModel operator-(const VectorMultivariateFunction

& f1, const VectorFunctionModel& f2) { return factory(f2).create(f1)-f2; } @@ -518,10 +515,10 @@ template class FunctionModel> unchecked_evaluate(const VectorFunctionModel& f, const Vector>& x) { return f._ptr->_unchecked_evaluate(x); } - friend ScalarFunctionModel unchecked_compose(const ScalarFunction

& f, const VectorFunctionModel& g) { + friend ScalarFunctionModel unchecked_compose(const ScalarMultivariateFunction

& f, const VectorFunctionModel& g) { ScalarFunctionModelInterface const* fptr = dynamic_cast const*>(f.raw_pointer()); if(fptr) { return unchecked_compose(ScalarFunctionModel(*fptr),g); } else { return compose(f,g); } } - friend VectorFunctionModel unchecked_compose(const VectorFunction

& f, const VectorFunctionModel& g) { + friend VectorFunctionModel unchecked_compose(const VectorMultivariateFunction

& f, const VectorFunctionModel& g) { VectorFunctionModelInterface const* fptr = dynamic_cast const*>(f.raw_pointer()); if(fptr) { return unchecked_compose(VectorFunctionModel(*fptr),g); } else { return compose(f,g); } } @@ -568,7 +565,7 @@ template class FunctionModel(c,f.precision())); } friend OutputStream& operator<<(OutputStream& os, const VectorFunctionModel& f) { - return os << f.operator VectorFunction

(); } + return os << f.operator VectorMultivariateFunction

(); } }; @@ -578,25 +575,25 @@ template inline CanonicalNumericType_unchecked_evaluate(x); } // FIXME: Implement for Multiple-Precision versions -template inline CanonicalNumeric64Type

unchecked_evaluate(const ScalarFunction

& f, const Vector>& x) { - ScalarFunctionModelDPInterface

const* fptr = dynamic_cast const*>(f.raw_pointer()); - if(fptr) { return unchecked_evaluate(ScalarFunctionModelDP

(*fptr),x); } else { return evaluate(f,x); } } +template inline CanonicalNumeric64Type

unchecked_evaluate(const ScalarMultivariateFunction

& f, const Vector>& x) { + ScalarMultivariateFunctionModelDPInterface

const* fptr = dynamic_cast const*>(f.raw_pointer()); + if(fptr) { return unchecked_evaluate(ScalarMultivariateFunctionModelDP

(*fptr),x); } else { return evaluate(f,x); } } -template inline Vector> unchecked_evaluate(const VectorFunction

& f, const Vector>& x) { - VectorFunctionModelDPInterface

const* fptr = dynamic_cast const*>(f.raw_pointer()); - if(fptr) { return unchecked_evaluate(VectorFunctionModelDP

(*fptr),x); } else { return evaluate(f,x); } } +template inline Vector> unchecked_evaluate(const VectorMultivariateFunction

& f, const Vector>& x) { + VectorMultivariateFunctionModelDPInterface

const* fptr = dynamic_cast const*>(f.raw_pointer()); + if(fptr) { return unchecked_evaluate(VectorMultivariateFunctionModelDP

(*fptr),x); } else { return evaluate(f,x); } } -template inline ScalarFunctionModel unchecked_compose(const ScalarFunction

& f, const VectorFunctionModel& g) { +template inline ScalarFunctionModel unchecked_compose(const ScalarMultivariateFunction

& f, const VectorFunctionModel& g) { ScalarFunctionModelInterface const* fptr = dynamic_cast const*>(f.raw_pointer()); if(fptr) { return unchecked_compose(ScalarFunctionModel(*fptr),g); } else { return compose(f,g); } } -template inline VectorFunctionModel unchecked_compose(const VectorFunction

& f, const VectorFunctionModel& g) { +template inline VectorFunctionModel unchecked_compose(const VectorMultivariateFunction

& f, const VectorFunctionModel& g) { VectorFunctionModelInterface const* fptr = dynamic_cast const*>(f.raw_pointer()); if(fptr) { return unchecked_compose(VectorFunctionModel(*fptr),g); } else { return compose(f,g); } } // FIXME: Should be unneeded -template ScalarFunctionModel unchecked_compose(const ScalarFunctionModel& f, const VectorFunctionModel& g) { +template ScalarFunctionModel unchecked_compose(const ScalarMultivariateFunctionModel& f, const VectorFunctionModel& g) { return VectorFunctionModel(g._ptr->_unchecked_compose(f)); } -template VectorFunctionModel unchecked_compose(const VectorFunctionModel& f, const VectorFunctionModel& g) { +template VectorFunctionModel unchecked_compose(const VectorMultivariateFunctionModel& f, const VectorFunctionModel& g) { return VectorFunctionModel(g._ptr->_unchecked_compose(f)); } template ScalarFunctionModel restrict(const ScalarFunctionModel& f, const D& dom) { return ScalarFunctionModel(f._ptr->_restriction(dom)); } diff --git a/source/function/function_model.tpl.hpp b/source/function/function_model.tpl.hpp index 7bcf0bf1d..5d2486014 100644 --- a/source/function/function_model.tpl.hpp +++ b/source/function/function_model.tpl.hpp @@ -43,43 +43,43 @@ namespace Ariadne { /* -template ScalarFunctionModel FunctionModelFactory::create_constant(const DomainType& domain, const CanonicalNumericType& value) const { - return ScalarFunctionModel(this->_ptr->_create(domain,EffectiveScalarFunction::zero(domain.size())))+value; }; -template VectorFunctionModel FunctionModelFactory::create_constants(const DomainType& domain, const Vector>& values) const { +template ScalarMultivariateFunctionModel FunctionModelFactory::create_constant(const DomainType& domain, const CanonicalNumericType& value) const { + return ScalarMultivariateFunctionModel(this->_ptr->_create(domain,EffectiveScalarMultivariateFunction::zero(domain.size())))+value; }; +template VectorMultivariateFunctionModel FunctionModelFactory::create_constants(const DomainType& domain, const Vector>& values) const { typename CanonicalNumericType::PrecisionType pr=this->_ptr->create_number(0).precision(); Vector> concrete_values(values,pr); return this->_ptr->create_constants(domain,concrete_values); } -template VectorFunctionModel FunctionModelFactory::create_constants(const DomainType& domain, const Vector>& values) const { - return VectorFunctionModel(this->_ptr->_create(domain,EffectiveVectorFunction::zeros(values.size(),domain.size())))+values; }; +template VectorMultivariateFunctionModel FunctionModelFactory::create_constants(const DomainType& domain, const Vector>& values) const { + return VectorMultivariateFunctionModel(this->_ptr->_create(domain,EffectiveVectorMultivariateFunction::zeros(values.size(),domain.size())))+values; }; */ /* -template ScalarFunctionModel FunctionModelFactoryInterface::create(const DomainType& domain, const ScalarFunctionInterface

& function) const { +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create(const DomainType& domain, const ScalarMultivariateFunctionInterface

& function) const { return this->_create(domain,function); } -template VectorFunctionModel FunctionModelFactoryInterface::create(const DomainType& domain, const VectorFunctionInterface

& function) const { +template VectorMultivariateFunctionModel FunctionModelFactoryInterface::create(const DomainType& domain, const VectorMultivariateFunctionInterface

& function) const { return this->_create(domain,function); } -template ScalarFunctionModel FunctionModelFactoryInterface::create_zero(const DomainType& domain) const { - return this->_create(domain,EffectiveScalarFunction::zero(domain.size())); } -template VectorFunctionModel FunctionModelFactoryInterface::create_zeros(SizeType result_size, const DomainType& domain) const { - return this->_create(domain,EffectiveVectorFunction::zeros(result_size,domain.size())); } -template ScalarFunctionModel FunctionModelFactoryInterface::create_constant(const DomainType& domain, const Number

& value) const { +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create_zero(const DomainType& domain) const { + return this->_create(domain,EffectiveScalarMultivariateFunction::zero(domain.size())); } +template VectorMultivariateFunctionModel FunctionModelFactoryInterface::create_zeros(SizeType result_size, const DomainType& domain) const { + return this->_create(domain,EffectiveVectorMultivariateFunction::zeros(result_size,domain.size())); } +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create_constant(const DomainType& domain, const Number

& value) const { CanonicalNumericType concrete_value=this->create_number(value); return this->create_constant(domain,concrete_value); } -template ScalarFunctionModel FunctionModelFactoryInterface::create_constant(const DomainType& domain, const CanonicalNumericType& value) const { - return ScalarFunctionModel(this->_create(domain,EffectiveScalarFunction::zero(domain.size())))+value; }; -template VectorFunctionModel FunctionModelFactoryInterface::create_constants(const DomainType& domain, const Vector>& values) const { +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create_constant(const DomainType& domain, const CanonicalNumericType& value) const { + return ScalarMultivariateFunctionModel(this->_create(domain,EffectiveScalarMultivariateFunction::zero(domain.size())))+value; }; +template VectorMultivariateFunctionModel FunctionModelFactoryInterface::create_constants(const DomainType& domain, const Vector>& values) const { typename CanonicalNumericType::PrecisionType pr=this->create_number(0).precision(); Vector> concrete_values(values,pr); return this->create_constants(domain,concrete_values); } -template VectorFunctionModel FunctionModelFactoryInterface::create_constants(const DomainType& domain, const Vector>& values) const { - return VectorFunctionModel(this->_create(domain,EffectiveVectorFunction::zeros(values.size(),domain.size())))+values; }; -template ScalarFunctionModel FunctionModelFactoryInterface::create_coordinate(const DomainType& domain, SizeType index) const { - return ScalarFunctionModel(this->_create(domain,EffectiveScalarFunction::coordinate(domain.size(),index))); }; -template ScalarFunctionModel FunctionModelFactoryInterface::create_identity(const IntervalDomainType& domain) const { - return this->_create(DomainType(1,domain),EffectiveScalarFunction::coordinate(1,0)); }; -template VectorFunctionModel FunctionModelFactoryInterface::create_identity(const DomainType& domain) const { - return this->_create(domain,EffectiveVectorFunction::identity(domain.size())); }; +template VectorMultivariateFunctionModel FunctionModelFactoryInterface::create_constants(const DomainType& domain, const Vector>& values) const { + return VectorMultivariateFunctionModel(this->_create(domain,EffectiveVectorMultivariateFunction::zeros(values.size(),domain.size())))+values; }; +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create_coordinate(const DomainType& domain, SizeType index) const { + return ScalarMultivariateFunctionModel(this->_create(domain,EffectiveScalarMultivariateFunction::coordinate(domain.size(),index))); }; +template ScalarMultivariateFunctionModel FunctionModelFactoryInterface::create_identity(const IntervalDomainType& domain) const { + return this->_create(DomainType(1,domain),EffectiveScalarMultivariateFunction::coordinate(1,0)); }; +template VectorMultivariateFunctionModel FunctionModelFactoryInterface::create_identity(const DomainType& domain) const { + return this->_create(domain,EffectiveVectorMultivariateFunction::identity(domain.size())); }; template CanonicalNumericType FunctionModelFactoryInterface::create_number(const Number

& number) const { return this->_create(number); } */ diff --git a/source/function/function_model_interface.hpp b/source/function/function_model_interface.hpp index 7d6876720..d329a9d91 100644 --- a/source/function/function_model_interface.hpp +++ b/source/function/function_model_interface.hpp @@ -116,10 +116,10 @@ template class FunctionModelInterface* _combine(const VectorFunctionModelInterface& f2) const = 0; virtual Void _adjoin(const ScalarFunctionModelInterface& f2) = 0; virtual Vector> _unchecked_evaluate(const Vector>& x) const = 0; - virtual ScalarFunctionModelInterface* _compose(const ScalarFunctionInterface

& f) const = 0; - virtual VectorFunctionModelInterface* _compose(const VectorFunctionInterface

& f) const = 0; - virtual ScalarFunctionModelInterface* _unchecked_compose(const ScalarFunctionInterface

& f) const = 0; - virtual VectorFunctionModelInterface* _unchecked_compose(const VectorFunctionInterface

& f) const = 0; + virtual ScalarFunctionModelInterface* _compose(const ScalarMultivariateFunctionInterface

& f) const = 0; + virtual VectorFunctionModelInterface* _compose(const VectorMultivariateFunctionInterface

& f) const = 0; + virtual ScalarFunctionModelInterface* _unchecked_compose(const ScalarMultivariateFunctionInterface

& f) const = 0; + virtual VectorFunctionModelInterface* _unchecked_compose(const VectorMultivariateFunctionInterface

& f) const = 0; virtual VectorFunctionModelInterface* _partial_evaluate(SizeType j, const CanonicalNumericType& c) const = 0; virtual Void restrict(const DomainType& d) = 0; }; diff --git a/source/function/function_model_mixin.hpp b/source/function/function_model_mixin.hpp index 8ced99497..d80b906d4 100644 --- a/source/function/function_model_mixin.hpp +++ b/source/function/function_model_mixin.hpp @@ -50,8 +50,8 @@ namespace Ariadne { template class FunctionModelMixin; -template using ScalarFunctionModelMixin = FunctionModelMixin; -template using VectorFunctionModelMixin = FunctionModelMixin; +template using ScalarMultivariateFunctionModelMixin = FunctionModelMixin; +template using VectorMultivariateFunctionModelMixin = FunctionModelMixin; template class FunctionModelMixin : public virtual ScalarFunctionModelInterface @@ -95,7 +95,7 @@ template class FunctionModelMix static_cast(*this)+=dynamic_cast(f1)*dynamic_cast(f2); } }; -template FM ScalarFunctionModelMixin::apply(OperatorCode op) const { +template FM ScalarMultivariateFunctionModelMixin::apply(OperatorCode op) const { const FM& f=static_cast(*this); switch(op) { case OperatorCode::NEG: return neg(f); @@ -110,14 +110,14 @@ template class FunctionModelMix : public virtual VectorFunctionModelInterface , public VectorFunctionMixin { - typedef typename Element::Type ScalarFunctionType; + typedef typename Element::Type ScalarMultivariateFunctionType; typedef FloatError NormType; public: virtual VectorFunctionModelInterface* _clone() const override { return new FM(static_cast(*this)); } virtual Void _set(SizeType i, const ScalarFunctionModelInterface& sf) override { - if(!dynamic_cast(&sf)) { - ARIADNE_FAIL_MSG("Cannot set element of VectorFunctionModel "<<*this<<" to "<(*this).FM::set(i,dynamic_cast(sf)); } + if(!dynamic_cast(&sf)) { + ARIADNE_FAIL_MSG("Cannot set element of VectorMultivariateFunctionModel "<<*this<<" to "<(*this).FM::set(i,dynamic_cast(sf)); } virtual VectorFunctionModelInterface* _derivative(SizeType j) const override { ARIADNE_NOT_IMPLEMENTED; } NormType const _norm() const override { @@ -127,20 +127,20 @@ template class FunctionModelMix VectorFunctionModelInterface* _restriction(const BoxDomainType& d) const override { return new FM(restriction(static_cast(*this),d)); } Void _adjoin(const ScalarFunctionModelInterface& f) override { - static_cast(*this).FM::adjoin(dynamic_cast(f)); } + static_cast(*this).FM::adjoin(dynamic_cast(f)); } VectorFunctionModelInterface* _join(const VectorFunctionModelInterface& f) const override { return heap_copy(join(static_cast(*this),dynamic_cast(f))); } VectorFunctionModelInterface* _combine(const VectorFunctionModelInterface& f) const override { return heap_copy(combine(static_cast(*this),dynamic_cast(f))); } Vector> _unchecked_evaluate(const Vector>& x) const override { return unchecked_evaluate(static_cast(*this),x); } - ScalarFunctionModelInterface* _compose(const ScalarFunctionInterface

& f) const override { + ScalarFunctionModelInterface* _compose(const ScalarMultivariateFunctionInterface

& f) const override { return heap_copy(compose(f,static_cast(*this))); } - VectorFunctionModelInterface* _compose(const VectorFunctionInterface

& f) const override { + VectorFunctionModelInterface* _compose(const VectorMultivariateFunctionInterface

& f) const override { return heap_copy(compose(f,static_cast(*this))); } - ScalarFunctionModelInterface* _unchecked_compose(const ScalarFunctionInterface

& f) const override { - return heap_copy(unchecked_compose(dynamic_cast(f),static_cast(*this))); } - VectorFunctionModelInterface* _unchecked_compose(const VectorFunctionInterface

& f) const override { + ScalarFunctionModelInterface* _unchecked_compose(const ScalarMultivariateFunctionInterface

& f) const override { + return heap_copy(unchecked_compose(dynamic_cast(f),static_cast(*this))); } + VectorFunctionModelInterface* _unchecked_compose(const VectorMultivariateFunctionInterface

& f) const override { return heap_copy(unchecked_compose(dynamic_cast(f),static_cast(*this))); } VectorFunctionModelInterface* _partial_evaluate(SizeType j, const CanonicalNumericType& c) const override { return heap_copy(partial_evaluate(static_cast(*this),j,c)); } @@ -161,8 +161,8 @@ template class FunctionModelFactoryMi virtual OutputStream& _write(OutputStream& os) const override { return os << this->upcast(); } /* CanonicalNumericType create(const Number

& number) const; - ScalarFunctionModel create(const BoxDomainType& domain, const ScalarFunctionInterface

& function) const; - VectorFunctionModel create(const BoxDomainType& domain, const VectorFunctionInterface

& function) const; + ScalarFunctionModel create(const BoxDomainType& domain, const ScalarMultivariateFunctionInterface

& function) const; + VectorFunctionModel create(const BoxDomainType& domain, const VectorMultivariateFunctionInterface

& function) const; ScalarFunctionModel create_zero(const BoxDomainType& domain) const; VectorFunctionModel create_zeros(SizeType result_size, const BoxDomainType& domain) const; ScalarFunctionModel create_constant(const BoxDomainType& domain, const Number

& value) const; diff --git a/source/function/procedure.cpp b/source/function/procedure.cpp index 8f05b98bd..4d1017776 100644 --- a/source/function/procedure.cpp +++ b/source/function/procedure.cpp @@ -38,9 +38,9 @@ template class Procedure; template class Vector>; template class Vector>; -template ApproximateProcedure make_procedure(const ApproximateScalarFunction& f); -template ValidatedProcedure make_procedure(const ValidatedScalarFunction& f); -template EffectiveProcedure make_procedure(const EffectiveScalarFunction& f); +template ApproximateProcedure make_procedure(const ApproximateScalarMultivariateFunction& f); +template ValidatedProcedure make_procedure(const ValidatedScalarMultivariateFunction& f); +template EffectiveProcedure make_procedure(const EffectiveScalarMultivariateFunction& f); template Void _execute(List& v, const List& p, const List& c, const Vector& x); template Void _execute(List>>& v, const List& p, const List& c, const Vector>>& x); diff --git a/source/function/procedure.hpp b/source/function/procedure.hpp index 259a965ab..43df18052 100644 --- a/source/function/procedure.hpp +++ b/source/function/procedure.hpp @@ -185,7 +185,7 @@ template Covector gradient(Procedure const& f, Vector template X hessian(Procedure const& f, Vector const& x, Vector const& s); // \related Convert a function into a procedure. -template Procedure> make_procedure(const ScalarFunction

& f); +template Procedure> make_procedure(const ScalarMultivariateFunction

& f); diff --git a/source/function/procedure.tpl.hpp b/source/function/procedure.tpl.hpp index fc04ab090..c56d2e710 100644 --- a/source/function/procedure.tpl.hpp +++ b/source/function/procedure.tpl.hpp @@ -43,7 +43,7 @@ namespace Ariadne { extern template class Procedure; extern template class Procedure; -template Procedure> make_procedure(ScalarFunction

const& f) { +template Procedure> make_procedure(ScalarMultivariateFunction

const& f) { typedef Number

Y; Formula e=f(Formula::identity(f.argument_size())); return Procedure(e); diff --git a/source/function/scaled_function_patch.hpp b/source/function/scaled_function_patch.hpp index 4aae32e6d..6487dea2b 100644 --- a/source/function/scaled_function_patch.hpp +++ b/source/function/scaled_function_patch.hpp @@ -132,9 +132,9 @@ template struct AlgebraOperations> { * \sa Expansion, TaylorModel, ValidatedVectorTaylorFunctionModelDP, TaylorConstrainedImageSet. */ template class ScaledFunctionPatch - : public ScalarFunctionModelMixin, typename M::Paradigm, BoxDomainType, typename M::PrecisionType, typename M::ErrorPrecisionType> + : public ScalarMultivariateFunctionModelMixin, typename M::Paradigm, BoxDomainType, typename M::PrecisionType, typename M::ErrorPrecisionType> , public DispatchTranscendentalAlgebraOperations, NumericType> - , public ProvideConcreteGenericArithmeticOperators, ScalarFunction> + , public ProvideConcreteGenericArithmeticOperators, ScalarMultivariateFunction> , public DispatchConcreteGenericAlgebraNumberOperations,NumericType,Number> { typedef BoxDomainType D; @@ -156,8 +156,8 @@ template class ScaledFunctionPatch typedef typename ModelType::PrecisionType PrecisionType; typedef typename ModelType::NormType NormType; typedef ScaledFunctionPatch ScaledFunctionPatchType; - typedef ScalarFunction FunctionType; - typedef ScalarFunction GenericType; + typedef ScalarMultivariateFunction FunctionType; + typedef ScalarMultivariateFunction GenericType; typedef Number GenericNumericType; typedef typename M::PropertiesType PropertiesType; private: @@ -355,7 +355,7 @@ template class ScaledFunctionPatch ScaledFunctionPatch* _create() const; virtual ScaledFunctionPatchFactory* _factory() const; public: - using ScalarFunctionModelMixin, typename M::Paradigm, BoxDomainType, typename M::PrecisionType, typename M::ErrorPrecisionType>::_apply; + using ScalarMultivariateFunctionModelMixin, typename M::Paradigm, BoxDomainType, typename M::PrecisionType, typename M::ErrorPrecisionType>::_apply; template static ScaledFunctionPatch _apply(OP op, ScaledFunctionPatch const& f); template static ScaledFunctionPatch _apply(OP op, ScaledFunctionPatch const& f1, ScaledFunctionPatch const& f2); @@ -422,7 +422,7 @@ template class ScaledFunctionPatch return norm(f.model()); } friend NormType distance(const ScaledFunctionPatch& f1, const ScaledFunctionPatch& f2) { return norm(f1-f2); } - friend NormType distance(const ScaledFunctionPatch& f1, const ScalarFunction

& f2) { + friend NormType distance(const ScaledFunctionPatch& f1, const ScalarMultivariateFunction

& f2) { return distance(f1,f1.create(f2)); } friend Polynomial polynomial(const ScaledFunctionPatch& tfn) { return tfn.polynomial(); } @@ -515,7 +515,7 @@ template ScaledFunctionPatch midpoint(const ScaledFunctionPatch& * See also TaylorModel, ScaledFunctionPatch, ValidatedVectorTaylorFunctionModelDP. */ template class VectorScaledFunctionPatch - : public VectorFunctionModelMixin,typename M::Paradigm,BoxDomainType,typename M::PrecisionType,typename M::ErrorPrecisionType> + : public VectorMultivariateFunctionModelMixin,typename M::Paradigm,BoxDomainType,typename M::PrecisionType,typename M::ErrorPrecisionType> { friend class VectorScaledFunctionPatchElementReference; typedef BoxDomainType D; @@ -706,7 +706,7 @@ template class VectorScaledFunctionPatch virtual VectorScaledFunctionPatch* _create() const; virtual ScaledFunctionPatchFactory* _factory() const; private: - friend class VectorFunctionMixin,P>; + friend class VectorFunctionMixin,P,BoxDomainType>; friend class TaylorFunctionFactory; public: template>> =dummy> Void _compute(Vector& r, const Vector& a) const; @@ -856,25 +856,25 @@ template class VectorScaledFunctionPatch ARIADNE_PRECONDITION(A.column_size()==f.size()); return VectorScaledFunctionPatch(f.domain(),A*f.models()); } - friend VectorScaledFunctionPatch operator+(const VectorFunction

& f1, const VectorScaledFunctionPatch& tf2) { + friend VectorScaledFunctionPatch operator+(const VectorMultivariateFunction

& f1, const VectorScaledFunctionPatch& tf2) { return VectorScaledFunctionPatch(tf2.domain(),f1,tf2.properties())+tf2; } - friend VectorScaledFunctionPatch operator-(const VectorFunction

& f1, const VectorScaledFunctionPatch& tf2) { + friend VectorScaledFunctionPatch operator-(const VectorMultivariateFunction

& f1, const VectorScaledFunctionPatch& tf2) { return VectorScaledFunctionPatch(tf2.domain(),f1,tf2.properties())-tf2; } - friend VectorScaledFunctionPatch operator*(const ScalarFunction

& f1, const VectorScaledFunctionPatch& tf2) { + friend VectorScaledFunctionPatch operator*(const ScalarMultivariateFunction

& f1, const VectorScaledFunctionPatch& tf2) { return ScaledFunctionPatch(tf2.domain(),f1,tf2.properties())*tf2; } - friend VectorScaledFunctionPatch operator*(const VectorFunction

& f1, const ScaledFunctionPatch& tf2) { + friend VectorScaledFunctionPatch operator*(const VectorMultivariateFunction

& f1, const ScaledFunctionPatch& tf2) { return VectorScaledFunctionPatch(tf2.domain(),f1,tf2.properties())*tf2; } - friend VectorScaledFunctionPatch operator/(const VectorFunction

& f1, const ScaledFunctionPatch& tf2) { + friend VectorScaledFunctionPatch operator/(const VectorMultivariateFunction

& f1, const ScaledFunctionPatch& tf2) { return VectorScaledFunctionPatch(tf2.domain(),f1,tf2.properties())/tf2; } - friend VectorScaledFunctionPatch operator+(const VectorScaledFunctionPatch& tf1, const VectorFunction

& f2) { + friend VectorScaledFunctionPatch operator+(const VectorScaledFunctionPatch& tf1, const VectorMultivariateFunction

& f2) { return tf1+VectorScaledFunctionPatch(tf1.domain(),f2,tf1.properties()); } - friend VectorScaledFunctionPatch operator-(const VectorScaledFunctionPatch& tf1, const VectorFunction

& f2) { + friend VectorScaledFunctionPatch operator-(const VectorScaledFunctionPatch& tf1, const VectorMultivariateFunction

& f2) { return tf1-VectorScaledFunctionPatch(tf1.domain(),f2,tf1.properties()); } - friend VectorScaledFunctionPatch operator*(const ScaledFunctionPatch& tf1, const VectorFunction

& f2) { + friend VectorScaledFunctionPatch operator*(const ScaledFunctionPatch& tf1, const VectorMultivariateFunction

& f2) { return tf1*VectorScaledFunctionPatch(tf1.domain(),f2,tf1.properties()); } - friend VectorScaledFunctionPatch operator*(const VectorScaledFunctionPatch& tf1, const ScalarFunction

& f2) { + friend VectorScaledFunctionPatch operator*(const VectorScaledFunctionPatch& tf1, const ScalarMultivariateFunction

& f2) { return tf1*ScaledFunctionPatch(tf1.domain(),f2,tf1.properties()); } - friend VectorScaledFunctionPatch operator/(const VectorScaledFunctionPatch& tf1, const ScalarFunction

& f2) { + friend VectorScaledFunctionPatch operator/(const VectorScaledFunctionPatch& tf1, const ScalarMultivariateFunction

& f2) { return tf1/ScaledFunctionPatch(tf1.domain(),f2,tf1.properties()); } friend VectorScaledFunctionPatch partial_evaluate(const VectorScaledFunctionPatch& tf, SizeType k, const NumericType& c) { @@ -891,7 +891,7 @@ template class VectorScaledFunctionPatch return evaluate(f.models(),unscale(x,f.domain())); } - friend ScaledFunctionPatch compose(const ScalarFunction

& g, const VectorScaledFunctionPatch& f) { + friend ScaledFunctionPatch compose(const ScalarMultivariateFunction

& g, const VectorScaledFunctionPatch& f) { return ScaledFunctionPatch(f.domain(),g.evaluate(f.models())); } friend ScaledFunctionPatch compose(const ScaledFunctionPatch& g, const VectorScaledFunctionPatch& f) { @@ -905,10 +905,10 @@ template class VectorScaledFunctionPatch } - friend VectorScaledFunctionPatch compose(const VectorFunction

& g, const VectorScaledFunctionPatch& f) { + friend VectorScaledFunctionPatch compose(const VectorMultivariateFunction

& g, const VectorScaledFunctionPatch& f) { return VectorScaledFunctionPatch(f.domain(),g.evaluate(f.models())); } - friend VectorScaledFunctionPatch compose(const VectorFunctionModel& g, const VectorScaledFunctionPatch& f) { + friend VectorScaledFunctionPatch compose(const VectorMultivariateFunctionModel& g, const VectorScaledFunctionPatch& f) { return VectorScaledFunctionPatch(f.domain(),g.evaluate(f.models())); } friend VectorScaledFunctionPatch compose(const VectorScaledFunctionPatch& g, const VectorScaledFunctionPatch& f) { @@ -958,7 +958,7 @@ template class VectorScaledFunctionPatch NormType distance(const VectorScaledFunctionPatch& f1, const VectorScaledFunctionPatch& f2) { return norm(f1-f2); } - NormType distance(const VectorScaledFunctionPatch& f1, const VectorFunction

& f2) { + NormType distance(const VectorScaledFunctionPatch& f1, const VectorMultivariateFunction

& f2) { return distance(f1,VectorScaledFunctionPatch(f1.domain(),f2,f1.properties())); } @@ -1147,7 +1147,7 @@ template Vector ranges(const Vector class VectorScaledFunctionPatchElementReference : public DispatchTranscendentalAlgebraOperations, NumericType> - , public ProvideConcreteGenericArithmeticOperators, ScalarFunction> + , public ProvideConcreteGenericArithmeticOperators, ScalarMultivariateFunction> , public DispatchConcreteGenericAlgebraNumberOperations,NumericType,Number> { typedef M ModelType; @@ -1225,13 +1225,13 @@ template class ScaledFunctionPatchFactory }; template class ScaledFunctionPatchCreator - : public FunctionModelCreator> + : public FunctionModelCreator,BoxDomainType> { public: typedef BoxDomainType DomainType; typedef typename M::PropertiesType PropertiesType; explicit ScaledFunctionPatchCreator(DomainType domain, PropertiesType properties) - : FunctionModelCreator>(domain,ScaledFunctionPatchFactory(properties)) { } + : FunctionModelCreator,DomainType>(domain,ScaledFunctionPatchFactory(properties)) { } PropertiesType properties() const { return this->_factory.properties(); } }; diff --git a/source/function/scaled_function_patch.tpl.hpp b/source/function/scaled_function_patch.tpl.hpp index 9e47a558e..af7ade633 100644 --- a/source/function/scaled_function_patch.tpl.hpp +++ b/source/function/scaled_function_patch.tpl.hpp @@ -993,10 +993,10 @@ template OutputStream& VectorScaledFunctionPatch::repr(OutputStream& template auto ScaledFunctionPatchFactory::create(const Number

& number) const -> CanonicalNumericType { return CanonicalNumericType(number,this->_properties.precision()); } -template ScaledFunctionPatch ScaledFunctionPatchFactory::create(const DomainType& domain, const ScalarFunctionInterface

& function) const { +template ScaledFunctionPatch ScaledFunctionPatchFactory::create(const DomainType& domain, const ScalarMultivariateFunctionInterface

& function) const { return ScaledFunctionPatch(domain,function,this->_properties); } -template VectorScaledFunctionPatch ScaledFunctionPatchFactory::create(const DomainType& domain, const VectorFunctionInterface

& function) const { +template VectorScaledFunctionPatch ScaledFunctionPatchFactory::create(const DomainType& domain, const VectorMultivariateFunctionInterface

& function) const { return VectorScaledFunctionPatch(domain,function,this->_properties); } template ScaledFunctionPatch ScaledFunctionPatchFactory::create_zero(const DomainType& domain) const { diff --git a/source/function/symbolic_function.hpp b/source/function/symbolic_function.hpp index 5f4f48e88..543bc2304 100644 --- a/source/function/symbolic_function.hpp +++ b/source/function/symbolic_function.hpp @@ -55,7 +55,7 @@ namespace Ariadne { //! A function defined by a formula template struct ScalarFormulaFunction - : ScalarFunctionMixin,InformationTag> + : ScalarMultivariateFunctionMixin,InformationTag> { typedef InformationTag P; SizeType _argument_size; @@ -66,7 +66,7 @@ struct ScalarFormulaFunction virtual SizeType argument_size() const final { return _argument_size; } virtual SizeOne result_size() const final { return SizeOne(); } - virtual ScalarFunctionInterface

* _derivative(SizeType j) const final { return new ScalarFormulaFunction(_argument_size,Ariadne::derivative(_formula,j)); } + virtual ScalarMultivariateFunctionInterface

* _derivative(SizeType j) const final { return new ScalarFormulaFunction(_argument_size,Ariadne::derivative(_formula,j)); } virtual OutputStream& write(OutputStream& os) const final { return os << this->_formula; } virtual OutputStream& repr(OutputStream& os) const final { return os << "FormulaFunction("<_argument_size<<","<_formula<<")"; } template Void _compute(X& r, const Vector& x) const { r=Ariadne::cached_evaluate(_formula,x); } @@ -77,7 +77,7 @@ typedef ScalarFormulaFunction EffectiveScalarFormulaFunction; //! A vector function defined by formulae template struct VectorFormulaFunction - : VectorFunctionMixin,InformationTag> + : VectorMultivariateFunctionMixin,InformationTag> { SizeType _argument_size; Vector< Formula > _formulae; @@ -102,7 +102,7 @@ struct VectorFormulaFunction //! A constant function f(x)=c -template +template struct ConstantFunction : ScalarFunctionMixin,InformationTag,D> { @@ -135,7 +135,7 @@ struct ConstantFunction //! A coordinate function \f$f:\R^n\rightarrow\R\f$ given by \f$f(x)=x_i\f$. -template +template struct CoordinateFunction : ScalarFunctionMixin,P,D> { @@ -166,7 +166,7 @@ struct CoordinateFunction //! \brief The identity function \f$ x\mapsto x\f$ in \f$\R^n\f$. -template +template struct UnaryFunction : ScalarFunctionMixin< UnaryFunction, P,D > { @@ -212,7 +212,7 @@ template ScalarFunction sin(const ScalarFunction& f) template ScalarFunction cos(const ScalarFunction& f) { return ScalarFunction(new UnaryFunction(OperatorCode::COS,f)); } -template +template struct BinaryFunction : ScalarFunctionMixin< BinaryFunction, P,D > { @@ -252,7 +252,7 @@ struct BinaryFunction // \brief The power function \f$(x,n)\mapsto x^n\f$. -template +template class GradedFunction : public ScalarFunctionMixin< GradedFunction, P,D > { @@ -291,17 +291,14 @@ class GradedFunction Int _arg2; }; -typedef ConstantFunction RealConstantFunction; -typedef ConstantFunction EffectiveConstantFunction; -typedef CoordinateFunction EffectiveCoordinateFunction; -typedef UnaryFunction EffectiveUnaryFunction; -typedef BinaryFunction EffectiveBinaryFunction; -typedef GradedFunction EffectiveGradedFunction; - +template using UnaryMultivaluedFunction = UnaryFunction; +template using BinaryMultivaluedFunction = BinaryFunction; +template using GradedMultivaluedFunction = GradedFunction; //------------------------ Vector of Scalar functions -----------------------------------// -template class NonResizableScalarFunction : public ScalarFunction { +template +class NonResizableScalarFunction : public ScalarFunction { public: NonResizableScalarFunction& operator=(const ScalarFunction& f) { ARIADNE_ASSERT_MSG(this->domain()==f.domain(), "this->domain()="<domain()<<", f.domain()="< class NonResizableScalarFunction : publ } }; -template +template struct VectorOfScalarFunction : VectorFunctionMixin,P,D> , public virtual VectorOfFunctionInterface @@ -377,8 +374,9 @@ struct VectorOfScalarFunction }; +template using VectorOfScalarMultivariateFunction = VectorOfScalarFunction; -template +template struct FunctionElement : ScalarFunctionMixin,P,D> { @@ -492,7 +490,7 @@ struct ComposedFunction Function _g; }; -template +template struct JoinedFunction : VectorFunctionMixin,P,D> { @@ -583,15 +581,15 @@ class ProjectedFunction // A Lie deriviative \f$\nabla g\cdot f\f$. template struct LieDerivativeFunction - : ScalarFunctionMixin,P> + : ScalarMultivariateFunctionMixin,P> { //! \brief Construct the identity function in dimension \a n. - LieDerivativeFunction(const ScalarFunction

& g, const VectorFunction

& f) { + LieDerivativeFunction(const ScalarMultivariateFunction

& g, const VectorMultivariateFunction

& f) { ARIADNE_ASSERT(g.argument_size()==f.argument_size()); ARIADNE_ASSERT(f.result_size()==f.argument_size()); _g=g; for(SizeType j=0; j!=g.argument_size(); ++j) { _dg[j]=g.derivative(j); } _f=f; } SizeType argument_size() const { return _g.argument_size(); } - virtual ScalarFunctionInterface

* _derivative(SizeType j) const { ARIADNE_NOT_IMPLEMENTED; } + virtual ScalarMultivariateFunctionInterface

* _derivative(SizeType j) const { ARIADNE_NOT_IMPLEMENTED; } OutputStream& write(OutputStream& os) const { return os << "LieDerivative( g="<<_g<<", f="<<_f<<" )"; } template inline Void _compute(X& r, const Vector& x) const { @@ -603,9 +601,9 @@ struct LieDerivativeFunction } } - ScalarFunction

_g; - List< ScalarFunction

> _dg; - VectorFunction

_f; + ScalarMultivariateFunction

_g; + Vector< ScalarMultivariateFunction

> _dg; + VectorMultivariateFunction

_f; }; diff --git a/source/function/taylor_function.cpp b/source/function/taylor_function.cpp index 1842bc60e..89e57524a 100644 --- a/source/function/taylor_function.cpp +++ b/source/function/taylor_function.cpp @@ -55,7 +55,7 @@ namespace Ariadne { template class ScaledFunctionPatchFactory; -template class FunctionModelCreator>; +template class FunctionModelCreator,BoxDomainType>; template class ScaledFunctionPatch; template class FunctionMixin,ApproximateTag,BoxDomainType,IntervalDomainType>; @@ -65,7 +65,7 @@ template class FunctionMixin,A template class FunctionMixin,ValidatedTag,BoxDomainType,BoxDomainType>; template class ScaledFunctionPatchFactory; -template class FunctionModelCreator>; +template class FunctionModelCreator,BoxDomainType>; template class ScaledFunctionPatch; template class VectorScaledFunctionPatch; diff --git a/source/function/taylor_model.hpp b/source/function/taylor_model.hpp index 50799b7e4..50f8974ed 100644 --- a/source/function/taylor_model.hpp +++ b/source/function/taylor_model.hpp @@ -129,9 +129,9 @@ class TaylorModel typedef FloatBounds ValidatedNumericType; typedef FloatApproximation ApproximateNumericType; - typedef ValidatedScalarFunction FunctionType; - typedef ValidatedScalarFunction ScalarFunctionType; - typedef ValidatedVectorFunction VectorFunctionType; + typedef ValidatedScalarMultivariateFunction FunctionType; + typedef ValidatedScalarMultivariateFunction ScalarFunctionType; + typedef ValidatedVectorMultivariateFunction VectorFunctionType; //! \brief The type used to index the coefficients. typedef MultiIndex IndexType; diff --git a/source/function/user_function.hpp b/source/function/user_function.hpp index bb6cc0c70..a56ecd1f9 100644 --- a/source/function/user_function.hpp +++ b/source/function/user_function.hpp @@ -53,7 +53,7 @@ namespace Ariadne { //! \related ScalarUserFunction //! \brief Template structure containing scalar function meta-information. template -struct ScalarFunctionData +struct ScalarMultivariateFunctionData { static SizeType argument_size() { return AS; } static SizeType parameter_size() { return PS; } @@ -69,15 +69,15 @@ struct ScalarFunctionData //! //! The class F must also define meta-data argument_size(), parameter_size() //! and smoothness(). These are most easily defined by inheriting from the -//! ScalarFunctionData class. +//! ScalarMultivariateFunctionData class. //! //! The constant \a SMOOTH is used for an arbitrarily-differentiable function. template class ScalarUserFunction - : public EffectiveScalarFunction + : public EffectiveScalarMultivariateFunction { private: class Representation - : public ScalarFunctionMixin< Representation, EffectiveTag > + : public ScalarMultivariateFunctionMixin< Representation, EffectiveTag > { private: Vector _p; @@ -92,7 +92,7 @@ template class ScalarUserFunction virtual SizeType parameter_size() const { return F::parameter_size(); } - virtual EffectiveScalarFunction derivative(SizeType j) const { ARIADNE_NOT_IMPLEMENTED; } + virtual EffectiveScalarMultivariateFunction derivative(SizeType j) const { ARIADNE_NOT_IMPLEMENTED; } virtual Covector gradient(const Vector& x) const { return this->evaluate(Differential::variables(1u,x)).gradient(); } @@ -105,9 +105,9 @@ template class ScalarUserFunction return os << "ScalarUserFunction( argument_size="<argument_size()<<" )"; } }; public: - ScalarUserFunction() : EffectiveScalarFunction(new Representation(Vector(this->parameter_size()))) { } - ScalarUserFunction(const Vector& p) : EffectiveScalarFunction(new Representation(Vector(p))) { } - ScalarUserFunction(const Vector& p) : EffectiveScalarFunction(new Representation(p)) { } + ScalarUserFunction() : EffectiveScalarMultivariateFunction(new Representation(Vector(this->parameter_size()))) { } + ScalarUserFunction(const Vector& p) : EffectiveScalarMultivariateFunction(new Representation(Vector(p))) { } + ScalarUserFunction(const Vector& p) : EffectiveScalarMultivariateFunction(new Representation(p)) { } SizeType parameter_size() const { return F().parameter_size(); } //const Vector parameters() const { return _p; } @@ -118,7 +118,7 @@ template class ScalarUserFunction //! \brief A convenience class defining the meta-data of an %Ariadne function. template -class VectorFunctionData +class VectorMultivariateFunctionData { public: //! @@ -143,15 +143,15 @@ class VectorFunctionData //! //! The class F must also define meta-data result_size(), argument_size(), parameter_size() //! and smoothness() as static functions. These are most easily defined by inheriting from the -//! VectorFunctionData class. +//! VectorMultivariateFunctionData class. //! //! The constant \a SMOOTH is used for an arbitrarily-differentiable function. template class VectorUserFunction - : public EffectiveVectorFunction + : public EffectiveVectorMultivariateFunction { private: class Representation - : public VectorFunctionMixin< Representation, EffectiveTag > + : public VectorMultivariateFunctionMixin< Representation, EffectiveTag > { public: Representation(const Vector& p) : _p(p) { } @@ -169,8 +169,8 @@ template class VectorUserFunction virtual Matrix jacobian(const Vector& x) const { return Ariadne::jacobian(this->evaluate(Differential::variables(1u,x))); } - virtual EffectiveScalarFunctionInterface* _get(SizeType i) const { ARIADNE_NOT_IMPLEMENTED; } - virtual EffectiveScalarFunction operator[](SizeType i) const { ARIADNE_NOT_IMPLEMENTED; } + virtual EffectiveScalarMultivariateFunctionInterface* _get(SizeType i) const { ARIADNE_NOT_IMPLEMENTED; } + virtual EffectiveScalarMultivariateFunction operator[](SizeType i) const { ARIADNE_NOT_IMPLEMENTED; } // TODO: Find a better way for writing functions which can handle transformations which may not have a // write() method or operator<<. @@ -180,10 +180,10 @@ template class VectorUserFunction Vector _p; }; public: - //VectorUserFunction() : VectorFunction(new Representation(Vector(this->parameter_size()))) { } - //VectorUserFunction(const Vector& p) : VectorFunction(new Representation(Vector(p))) { } - //VectorUserFunction(const Vector& p) : VectorFunction(new Representation(Vector(p))) { } - VectorUserFunction(const Vector& p) : EffectiveVectorFunction(new Representation(p)) { } + //VectorUserFunction() : VectorMultivariateFunction(new Representation(Vector(this->parameter_size()))) { } + //VectorUserFunction(const Vector& p) : VectorMultivariateFunction(new Representation(Vector(p))) { } + //VectorUserFunction(const Vector& p) : VectorMultivariateFunction(new Representation(Vector(p))) { } + VectorUserFunction(const Vector& p) : EffectiveVectorMultivariateFunction(new Representation(p)) { } const Vector& parameters() const { return dynamic_cast(this->raw_pointer())->_p; } }; diff --git a/source/geometry/affine_set.cpp b/source/geometry/affine_set.cpp index a21fe4ef3..7a2ee7546 100644 --- a/source/geometry/affine_set.cpp +++ b/source/geometry/affine_set.cpp @@ -311,7 +311,7 @@ ValidatedLowerKleenean ValidatedAffineConstrainedImageSet::inside(const ExactBox } -ValidatedAffineConstrainedImageSet image(ValidatedAffineConstrainedImageSet set, ValidatedVectorFunction const& h) { +ValidatedAffineConstrainedImageSet image(ValidatedAffineConstrainedImageSet set, ValidatedVectorMultivariateFunction const& h) { set._space_models=compose(h,set._space_models); return set; } diff --git a/source/geometry/affine_set.hpp b/source/geometry/affine_set.hpp index 1083bd7df..2a14d4e67 100644 --- a/source/geometry/affine_set.hpp +++ b/source/geometry/affine_set.hpp @@ -127,7 +127,7 @@ class ValidatedAffineConstrainedImageSet ValidatedLowerKleenean is_empty() const; //! \brief Compute the image of \f$S\f$ under the function \f$h\f$. - friend ValidatedAffineConstrainedImageSet image(ValidatedAffineConstrainedImageSet set, ValidatedVectorFunction const& h); + friend ValidatedAffineConstrainedImageSet image(ValidatedAffineConstrainedImageSet set, ValidatedVectorMultivariateFunction const& h); Void adjoin_outer_approximation_to(PavingInterface& g, Nat depth) const; GridTreePaving outer_approximation(const Grid& g, Nat depth) const; diff --git a/source/geometry/box.cpp b/source/geometry/box.cpp index ebc0d8087..15809cae8 100644 --- a/source/geometry/box.cpp +++ b/source/geometry/box.cpp @@ -40,11 +40,11 @@ namespace Ariadne { -UpperIntervalType apply(ScalarFunctionconst& f, const Box& bx) { +UpperIntervalType apply(ScalarMultivariateFunctionconst& f, const Box& bx) { return static_cast(f(reinterpret_castconst&>(bx))); } -Box apply(VectorFunctionconst& f, const Box& bx) { +Box apply(VectorMultivariateFunctionconst& f, const Box& bx) { return static_cast>(f(reinterpret_castconst&>(bx))); } -Box image(Box bx, VectorFunctionconst& f) { +Box image(Box bx, VectorMultivariateFunctionconst& f) { return static_cast>(f(reinterpret_castconst&>(bx))); } template class Box>; diff --git a/source/geometry/box.hpp b/source/geometry/box.hpp index 722e5794b..9b8dc63b0 100644 --- a/source/geometry/box.hpp +++ b/source/geometry/box.hpp @@ -207,9 +207,9 @@ template inline decltype(auto) product(S1 const& s template inline Box remove(const Box& bx, SizeType k) { Box rbx(bx.dimension()-1); for(SizeType i=0; i!=k; ++i) { rbx[i]=bx[i]; } for(SizeType i=k; i!=rbx.dimension(); ++i) { rbx[i]=bx[i+1]; } return rbx; } -UpperIntervalType apply(ScalarFunctionconst& f, const Box& x); -Box apply(VectorFunctionconst& f, const Box& x); -UpperBoxType image(UpperBoxType bx, ValidatedVectorFunction const& f); +UpperIntervalType apply(ScalarMultivariateFunctionconst& f, const Box& x); +Box apply(VectorMultivariateFunctionconst& f, const Box& x); +UpperBoxType image(UpperBoxType bx, ValidatedVectorMultivariateFunction const& f); //! \relates Box \brief Project onto the variables \a rng. template inline Box project(const Box & bx, Array const& rng) { return Box::_project(bx,rng); } diff --git a/source/geometry/enclosure.cpp b/source/geometry/enclosure.cpp index d309975b1..803b7731b 100644 --- a/source/geometry/enclosure.cpp +++ b/source/geometry/enclosure.cpp @@ -81,18 +81,18 @@ template StringType str(const T& t) { StringStream ss; ss< RawFloatVector; typedef Vector ExactIntervalVectorType; -inline ValidatedConstraintModel operator>=(ValidatedScalarFunctionModelDP const& f, ValidatedNumericType const& l) { +inline ValidatedConstraintModel operator>=(ValidatedScalarMultivariateFunctionModelDP const& f, ValidatedNumericType const& l) { return ValidatedConstraintModel(l,f,infty); } -inline ValidatedConstraintModel operator<=(ValidatedScalarFunctionModelDP const& f, ValidatedNumericType const& u) { +inline ValidatedConstraintModel operator<=(ValidatedScalarMultivariateFunctionModelDP const& f, ValidatedNumericType const& u) { return ValidatedConstraintModel(-infty,f,u); } -inline ValidatedConstraintModel operator==(ValidatedScalarFunctionModelDP const& f, ValidatedNumericType const& c) { +inline ValidatedConstraintModel operator==(ValidatedScalarMultivariateFunctionModelDP const& f, ValidatedNumericType const& c) { return ValidatedConstraintModel(c,f,c); } Pair,FloatDPError> make_domain(Interval const& ivl); namespace { -ValidatedVectorFunctionModelDP make_identity(const EffectiveBoxType& bx, const EnclosureConfiguration& configuration) { +ValidatedVectorMultivariateFunctionModelDP make_identity(const EffectiveBoxType& bx, const EnclosureConfiguration& configuration) { ExactIntervalVectorType dom(bx.dimension()); Vector errs(bx.dimension()); @@ -100,7 +100,7 @@ ValidatedVectorFunctionModelDP make_identity(const EffectiveBoxType& bx, const E make_lpair(dom[i],errs[i])=make_domain(bx[i]); } - ValidatedVectorFunctionModelDP res=configuration._function_factory.create_identity(dom); + ValidatedVectorMultivariateFunctionModelDP res=configuration._function_factory.create_identity(dom); for(Nat i=0; i!=bx.dimension(); ++i) { res[i]=res[i]+ValidatedNumericType(-errs[i],+errs[i]); } @@ -110,12 +110,12 @@ ValidatedVectorFunctionModelDP make_identity(const EffectiveBoxType& bx, const E } // namespace -inline Pair split(const ValidatedScalarFunctionModelDP& f, Nat k) { +inline Pair split(const ValidatedScalarMultivariateFunctionModelDP& f, Nat k) { Pair domains=split(f.domain(),k); return make_pair(restrict(f,domains.first),restrict(f,domains.second)); } -inline Pair split(const ValidatedVectorFunctionModelDP& f, Nat k) { +inline Pair split(const ValidatedVectorMultivariateFunctionModelDP& f, Nat k) { Pair domains=split(f.domain(),k); return make_pair(restrict(f,domains.first),restrict(f,domains.second)); } @@ -181,7 +181,7 @@ inline Void assign_all_but_last(MultiIndex& r, const MultiIndex& a) { // FIXME: What if solving for constraint leaves domain? Void Enclosure::_solve_zero_constraints() { this->_check(); - for(List::Iterator iter=this->_zero_constraints.begin(); iter!=this->_zero_constraints.end(); ) { + for(List::Iterator iter=this->_zero_constraints.begin(); iter!=this->_zero_constraints.end(); ) { const ExactBoxType& domain=this->domain(); const ValidatedTaylorModelDP& model=iter->model(); const Nat k=model.argument_size()-1u; @@ -207,14 +207,14 @@ Void Enclosure::_solve_zero_constraints() { const ExactBoxType new_domain=project(domain,range(0,k)); ValidatedTaylorModelDP substitution_model=-zeroth_order/first_order; this->_state_function=this->function_factory().create(new_domain,Ariadne::substitute(this->_state_function.models(),k,substitution_model)); - for(List::Iterator constraint_iter=this->_negative_constraints.begin(); + for(List::Iterator constraint_iter=this->_negative_constraints.begin(); constraint_iter!=this->_negative_constraints.end(); ++constraint_iter) { - ValidatedScalarFunctionModelDP& constraint=*constraint_iter; + ValidatedScalarMultivariateFunctionModelDP& constraint=*constraint_iter; constraint=this->function_factory().create(new_domain,Ariadne::substitute(constraint.model(),k,substitution_model)); } - for(List::Iterator constraint_iter=this->_zero_constraints.begin(); + for(List::Iterator constraint_iter=this->_zero_constraints.begin(); constraint_iter!=this->_zero_constraints.end(); ++constraint_iter) { - ValidatedScalarFunctionModelDP& constraint=*constraint_iter; + ValidatedScalarMultivariateFunctionModelDP& constraint=*constraint_iter; constraint=this->function_factory().create(new_domain,Ariadne::substitute(constraint.model(),k,substitution_model)); } // Since we are using an std::vector, assign Iterator to next element @@ -251,7 +251,7 @@ Enclosure::Enclosure(const BoundedConstraintSet& set, const EnclosureConfigurati this->_domain=this->_state_function.domain(); this->_time_function=this->function_factory().create_zero(this->domain()); this->_dwell_time_function=this->function_factory().create_zero(this->domain()); - this->_auxiliary_mapping=EffectiveVectorFunction(0u,EuclideanDomain(this->_state_function.result_size())); + this->_auxiliary_mapping=EffectiveVectorMultivariateFunction(0u,EuclideanDomain(this->_state_function.result_size())); for(Nat i=0; i!=set.number_of_constraints(); ++i) { this->new_state_constraint(set.constraint(i)); } @@ -286,7 +286,7 @@ Enclosure::Enclosure(const ExactBoxType& box, const EnclosureConfiguration& conf this->_state_function=this->function_factory().create_zeros(box.dimension(),this->_domain); this->_time_function=this->function_factory().create_zero(this->_domain); this->_dwell_time_function=this->function_factory().create_zero(this->domain()); - this->_auxiliary_mapping=EffectiveVectorFunction(0u,EuclideanDomain(this->_state_function.result_size())); + this->_auxiliary_mapping=EffectiveVectorMultivariateFunction(0u,EuclideanDomain(this->_state_function.result_size())); Nat j=0; proper_coordinates.append(box.dimension()); for(Nat i=0; i!=box.dimension(); ++i) { @@ -303,7 +303,7 @@ Enclosure::Enclosure(const ExactBoxType& box, const EnclosureConfiguration& conf } -Enclosure::Enclosure(const ExactBoxType& domain, const ValidatedVectorFunction& function, const EnclosureConfiguration& configuration) +Enclosure::Enclosure(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const EnclosureConfiguration& configuration) : _configuration(configuration) { ARIADNE_ASSERT_MSG(domain.size()==function.argument_size(),"domain="<_state_function.result_size()==aux.argument_size()); @@ -437,7 +437,7 @@ Void Enclosure::new_parameter(ExactIntervalType ivl) Void Enclosure::new_variable(ExactIntervalType ivl) { - ValidatedScalarFunctionModelDP variable_function = this->function_factory().create_identity(ivl); + ValidatedScalarMultivariateFunctionModelDP variable_function = this->function_factory().create_identity(ivl); this->_domain=product(this->_domain,ivl); this->_reduced_domain=product(this->_reduced_domain,ivl); this->_state_function=combine(this->_state_function,variable_function); @@ -457,7 +457,7 @@ Void Enclosure::clear_time() this->_check(); } -Void Enclosure::apply_map(ValidatedVectorFunction map) +Void Enclosure::apply_map(ValidatedVectorMultivariateFunction map) { ARIADNE_ASSERT_MSG(map.argument_size()==this->state_dimension(),"state_dimension="<state_dimension()<<", map="<_state_function=compose(map,this->_state_function); @@ -466,53 +466,53 @@ Void Enclosure::apply_map(ValidatedVectorFunction map) } /* -Void Enclosure::apply_flow(ValidatedVectorFunction flow, ExactIntervalType time) +Void Enclosure::apply_flow(ValidatedVectorMultivariateFunction flow, ExactIntervalType time) { ARIADNE_ASSERT_MSG(flow.argument_size()==this->state_dimension()+1u,"state_dimension="<state_dimension()<<", flow="<_state_function=compose(flow,combine(this->_state_function,this->function_factory().create_identity(ExactBoxType(1u,time)))); - for(List::Iterator iter=this->_negative_constraints.begin(); iter!=this->_negative_constraints.end(); ++iter) { + for(List::Iterator iter=this->_negative_constraints.begin(); iter!=this->_negative_constraints.end(); ++iter) { *iter=embed(*iter,time); } - for(List::Iterator iter=this->_zero_constraints.begin(); iter!=this->_zero_constraints.end(); ++iter) { + for(List::Iterator iter=this->_zero_constraints.begin(); iter!=this->_zero_constraints.end(); ++iter) { *iter=embed(*iter,time); } this->_check(); } */ -Void Enclosure::apply_fixed_evolve_step(ValidatedVectorFunction flow, StepSizeType time) +Void Enclosure::apply_fixed_evolve_step(ValidatedVectorMultivariateFunction flow, StepSizeType time) { ARIADNE_ASSERT_MSG(flow.argument_size()==this->state_dimension()+1u,"state_dimension="<state_dimension()<<", flow="<function_factory().create_constant(this->domain(),time); + ValidatedScalarMultivariateFunctionModelDP evolve_time_function=this->function_factory().create_constant(this->domain(),time); this->_state_function=compose(flow,join(this->_state_function,evolve_time_function)); this->_time_function=this->_time_function + evolve_time_function; this->_dwell_time_function=this->_dwell_time_function + evolve_time_function; this->_check(); } -Void Enclosure::apply_space_evolve_step(ValidatedVectorFunction flow, ValidatedScalarFunction time) +Void Enclosure::apply_space_evolve_step(ValidatedVectorMultivariateFunction flow, ValidatedScalarMultivariateFunction time) { ARIADNE_ASSERT_MSG(flow.argument_size()==this->state_dimension()+1u,"state_dimension="<state_dimension()<<", flow="<state_dimension(),"state_dimension="<state_dimension()<<", time="<_state_function); + ValidatedScalarMultivariateFunctionModelDP evolve_time_function=compose(time,this->_state_function); this->_state_function=compose(flow,join(this->_state_function,evolve_time_function)); this->_time_function=this->_time_function + evolve_time_function; this->_dwell_time_function=this->_dwell_time_function + evolve_time_function; this->_check(); } -Void Enclosure::apply_spacetime_evolve_step(ValidatedVectorFunction flow, ValidatedScalarFunction time) +Void Enclosure::apply_spacetime_evolve_step(ValidatedVectorMultivariateFunction flow, ValidatedScalarMultivariateFunction time) { ARIADNE_ASSERT_MSG(flow.argument_size()==this->state_dimension()+1u,"state_dimension="<state_dimension()<<", flow="<state_dimension()+1u,"state_dimension="<state_dimension()<<", time="<_state_function,this->_time_function)); + ValidatedScalarMultivariateFunctionModelDP evolve_time_function=compose(time,join(this->_state_function,this->_time_function)); this->_state_function=compose(flow,join(this->_state_function,evolve_time_function)); this->_time_function=this->_time_function + evolve_time_function; this->_dwell_time_function=this->_dwell_time_function + evolve_time_function; this->_check(); } -Void Enclosure::apply_parameter_evolve_step(ValidatedVectorFunction flow, ValidatedScalarFunction time) +Void Enclosure::apply_parameter_evolve_step(ValidatedVectorMultivariateFunction flow, ValidatedScalarMultivariateFunction time) { ARIADNE_ASSERT_MSG(flow.argument_size()==this->state_dimension()+1u,"state_dimension="<state_dimension()<<", flow="<number_of_parameters(),"number_of_parameters="<number_of_parameters()<<", time="< nonlinearities_first_order(const ValidatedVectorFunction& f, con return nonlinearities; } -Matrix nonlinearities_second_order(const ValidatedVectorFunction& f, const ExactBoxType& dom) +Matrix nonlinearities_second_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom) { //std::cerr<<"\n\nf="<& c) { return as; } -template VectorFunction

make_constraint_function(D dom, const List& c) { - VectorFunction

f(c.size(),dom); +template VectorMultivariateFunction

make_constraint_function(D dom, const List& c) { + VectorMultivariateFunction

f(c.size(),dom); for(Nat i=0; i!=c.size(); ++i) { //f[i]=c[i].function(); f.set(i,c[i].function()); @@ -239,15 +239,15 @@ template VectorFunction

make_constraint_function(D return f; } -EffectiveVectorFunction constraint_function(EuclideanDomain dom, const List& c) { +EffectiveVectorMultivariateFunction constraint_function(EuclideanDomain dom, const List& c) { return make_constraint_function(dom,c); } -EffectiveVectorFunction constraint_function(BoxDomainType dom, const List& c) { +EffectiveVectorMultivariateFunction constraint_function(BoxDomainType dom, const List& c) { return make_constraint_function(dom,c); } -ValidatedVectorFunction constraint_function(BoxDomainType dom, const List& c) { +ValidatedVectorMultivariateFunction constraint_function(BoxDomainType dom, const List& c) { return make_constraint_function(dom,c); } @@ -260,7 +260,7 @@ EffectiveBoxType constraint_bounds(const List& c) { return b; } -List constraints(const EffectiveVectorFunction& f, const EffectiveBoxType& b) { +List constraints(const EffectiveVectorMultivariateFunction& f, const EffectiveBoxType& b) { ARIADNE_ASSERT(f.result_size()==b.size()); List c; c.reserve(b.size()); for(Nat i=0; i!=b.size(); ++i) { @@ -288,7 +288,7 @@ template struct LogicalExpression decltype(auto) make_shared_logical_expression(OP const& op, ARG1 const& arg1, ARG2 const& arg2) { return std::make_shared>(op,arg1,arg2); } -ConstraintSet::ConstraintSet(const EffectiveVectorFunction& f, const EffectiveBoxType& b) +ConstraintSet::ConstraintSet(const EffectiveVectorMultivariateFunction& f, const EffectiveBoxType& b) : _dimension(f.argument_size()), _constraints() { this->_constraints=Ariadne::constraints(f,b); @@ -299,7 +299,7 @@ ConstraintSet::ConstraintSet(const List& c) { } -EffectiveVectorFunction const ConstraintSet::constraint_function() const +EffectiveVectorMultivariateFunction const ConstraintSet::constraint_function() const { return Ariadne::constraint_function(EuclideanDomain(this->dimension()),this->constraints()); } @@ -383,7 +383,7 @@ BoundedConstraintSet::BoundedConstraintSet(const EffectiveBoxType& bx) { } -BoundedConstraintSet::BoundedConstraintSet(const EffectiveBoxType& d, const EffectiveVectorFunction& f, const EffectiveBoxType& b) +BoundedConstraintSet::BoundedConstraintSet(const EffectiveBoxType& d, const EffectiveVectorMultivariateFunction& f, const EffectiveBoxType& b) : _domain(d), _constraints(Ariadne::constraints(f,b)) { ARIADNE_ASSERT(b.size()==f.result_size()); @@ -395,7 +395,7 @@ BoundedConstraintSet::BoundedConstraintSet(const EffectiveBoxType& d, const List { } -EffectiveVectorFunction const BoundedConstraintSet::constraint_function() const +EffectiveVectorMultivariateFunction const BoundedConstraintSet::constraint_function() const { return Ariadne::constraint_function(EuclideanDomain(this->dimension()),this->constraints()); } @@ -550,7 +550,7 @@ intersection(const ConstraintSet& cs,const BoundedConstraintSet& bcs) ConstrainedImageSet::ConstrainedImageSet(const BoundedConstraintSet& set) - : _domain(over_approximation(set.domain())), _function(EffectiveVectorFunction::identity(set.dimension())) + : _domain(over_approximation(set.domain())), _function(EffectiveVectorMultivariateFunction::identity(set.dimension())) { for(Nat i=0; i!=set.number_of_constraints(); ++i) { this->new_parameter_constraint(set.constraint(i)); @@ -558,7 +558,7 @@ ConstrainedImageSet::ConstrainedImageSet(const BoundedConstraintSet& set) } -const EffectiveVectorFunction ConstrainedImageSet::constraint_function() const +const EffectiveVectorMultivariateFunction ConstrainedImageSet::constraint_function() const { return Ariadne::constraint_function(this->function().domain(),this->constraints()); } @@ -614,7 +614,7 @@ ValidatedKleenean ConstrainedImageSet::satisfies(const EffectiveConstraint& nc, ConstraintSolver solver; const EffectiveBoxType& domain=this->_domain; List all_constraints=this->_constraints; - EffectiveScalarFunction composed_function = compose(nc.function(),this->_function); + EffectiveScalarMultivariateFunction composed_function = compose(nc.function(),this->_function); const EffectiveNumber& lower_bound = nc.lower_bound(); const EffectiveNumber& upper_bound = nc.upper_bound(); @@ -659,7 +659,7 @@ ValidatedLowerKleenean ConstrainedImageSet::inside(const ExactBoxType& bx, Effor ValidatedLowerKleenean ConstrainedImageSet::separated(const ExactBoxType& bx, Effort eff) const { UpperBoxType subdomain = over_approximation(this->_domain); - EffectiveVectorFunction function = join(this->function(),this->constraint_function()); + EffectiveVectorMultivariateFunction function = join(this->function(),this->constraint_function()); ExactBoxType codomain = product(bx,ExactBoxType(over_approximation(this->constraint_bounds()))); ConstraintSolver solver; solver.reduce(subdomain,function,codomain); @@ -709,7 +709,7 @@ ConstrainedImageSet::split(Nat j) const } -ConstrainedImageSet image(const BoundedConstraintSet& set, const EffectiveVectorFunction& function) { +ConstrainedImageSet image(const BoundedConstraintSet& set, const EffectiveVectorMultivariateFunction& function) { ARIADNE_ASSERT(set.dimension()==function.argument_size()); ConstrainedImageSet result(set.domain(),function); for(Nat i=0; i!=set.number_of_constraints(); ++i) { @@ -718,19 +718,19 @@ ConstrainedImageSet image(const BoundedConstraintSet& set, const EffectiveVector return result; } -ConstrainedImageSet image(ConstrainedImageSet set, const EffectiveVectorFunction& function) { +ConstrainedImageSet image(ConstrainedImageSet set, const EffectiveVectorMultivariateFunction& function) { set.apply(function); return set; } -Matrix nonlinearities_zeroth_order(const ValidatedVectorFunction& f, const ExactBoxType& dom) +Matrix nonlinearities_zeroth_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom) { ARIADNE_ASSERT(dynamic_cast(f.raw_pointer())); return nonlinearities_zeroth_order(dynamic_cast(*f.raw_pointer()),dom); } /* -Matrix nonlinearities_first_order(const ValidatedVectorFunction& f, const ExactBoxType& dom) +Matrix nonlinearities_first_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom) { //std::cerr<<"\n\nf="< nonlinearities_first_order(const ValidatedVectorFunction& f, con return nonlinearities; } -Matrix nonlinearities_second_order(const ValidatedVectorFunction& f, const ExactBoxType& dom) +Matrix nonlinearities_second_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom) { //std::cerr<<"\n\nf="< nonlinearities_second_order(const ValidatedVectorFunction& f, co } */ -Pair lipschitz_index_and_error(const ValidatedVectorFunction& function, const ExactBoxType& domain) +Pair lipschitz_index_and_error(const ValidatedVectorMultivariateFunction& function, const ExactBoxType& domain) { Matrix jacobian=Ariadne::jacobian_range(function,domain); @@ -823,7 +823,7 @@ Pair lipschitz_index_and_error(const ValidatedVectorFunction& funct return make_pair(jmax,max_column_norm); } -Pair nonlinearity_index_and_error(const ValidatedVectorFunction& function, const ExactBoxType& domain) +Pair nonlinearity_index_and_error(const ValidatedVectorMultivariateFunction& function, const ExactBoxType& domain) { Matrix nonlinearities=Ariadne::nonlinearities_zeroth_order(function,domain); @@ -877,15 +877,15 @@ ConstrainedImageSet::write(OutputStream& os) const template struct FunctionTraits; -template struct FunctionTraits< ScalarFunction > { typedef VectorFunction VectorFunctionType; }; -template<> struct FunctionTraits< ValidatedScalarTaylorFunctionModelDP > { typedef ValidatedVectorTaylorFunctionModelDP VectorFunctionType; }; +template struct FunctionTraits< ScalarMultivariateFunction > { typedef VectorMultivariateFunction VectorMultivariateFunctionType; }; +template<> struct FunctionTraits< ValidatedScalarTaylorFunctionModelDP > { typedef ValidatedVectorTaylorFunctionModelDP VectorMultivariateFunctionType; }; template class TemplatedConstraintSet; template class TemplatedConstrainedImageSet; -ValidatedVectorFunction ValidatedConstrainedImageSet::constraint_function() const +ValidatedVectorMultivariateFunction ValidatedConstrainedImageSet::constraint_function() const { return Ariadne::constraint_function(this->function().domain(),this->constraints()); } @@ -1067,8 +1067,8 @@ ValidatedConstrainedImageSet::split() const } -inline ValidatedScalarFunction const& _restriction(ValidatedScalarFunction const& f, ExactBoxType dom) { return f; } -inline ValidatedVectorFunction const& _restriction(ValidatedVectorFunction const& f, ExactBoxType dom) { return f; } +inline ValidatedScalarMultivariateFunction const& _restriction(ValidatedScalarMultivariateFunction const& f, ExactBoxType dom) { return f; } +inline ValidatedVectorMultivariateFunction const& _restriction(ValidatedVectorMultivariateFunction const& f, ExactBoxType dom) { return f; } ValidatedConstrainedImageSet @@ -1107,10 +1107,10 @@ ValidatedLowerKleenean ValidatedConstrainedImageSet::inside(const ExactBoxType& ValidatedLowerKleenean ValidatedConstrainedImageSet::separated(const ExactBoxType& bx) const { UpperBoxType subdomain = this->_reduced_domain; - ValidatedVectorFunction function(this->dimension()+this->number_of_constraints(),EuclideanDomain(this->number_of_parameters())); + ValidatedVectorMultivariateFunction function(this->dimension()+this->number_of_constraints(),EuclideanDomain(this->number_of_parameters())); for(Nat i=0; i!=this->dimension(); ++i) { function[i]=this->_function[i]; } for(Nat i=0; i!=this->number_of_constraints(); ++i) { function[i+this->dimension()]=this->_constraints[i].function(); } - //ValidatedVectorFunction function = join(this->_function,this->constraint_function()); + //ValidatedVectorMultivariateFunction function = join(this->_function,this->constraint_function()); ExactBoxType codomain = product(bx,this->constraint_bounds()); ConstraintSolver solver; solver.reduce(subdomain,function,codomain); @@ -1123,9 +1123,9 @@ ValidatedLowerKleenean ValidatedConstrainedImageSet::overlaps(const ExactBoxType //std::cerr<<"subdomain="<_reduced_domain<<"\n"; ExactBoxType subdomain = this->_reduced_domain; - ValidatedVectorFunction space_function = this->_function; - ValidatedVectorFunction constraint_function = this->constraint_function(); - ValidatedVectorFunction function = join(space_function,constraint_function); + ValidatedVectorMultivariateFunction space_function = this->_function; + ValidatedVectorMultivariateFunction constraint_function = this->constraint_function(); + ValidatedVectorMultivariateFunction function = join(space_function,constraint_function); //std::cerr<<"function="<constraint_bounds(),cast_exact_box(Ariadne::apply(this->constraint_function(),subdomain))); ExactBoxType codomain = product(bx,constraint_bounds); @@ -1198,7 +1198,7 @@ ValidatedKleenean ValidatedConstrainedImageSet::satisfies(const ValidatedConstra ConstraintSolver solver; const ExactBoxType& domain=this->_domain; List all_constraints=this->constraints(); - ValidatedScalarFunction composed_function = compose(nc.function(),this->_function); + ValidatedScalarMultivariateFunction composed_function = compose(nc.function(),this->_function); const ExactIntervalType& bounds = nc.bounds(); ValidatedKleenean result; @@ -1278,19 +1278,19 @@ join(const ValidatedConstrainedImageSet& set1, const ValidatedConstrainedImageSe ExactBoxType new_domain = hull(domain1,domain2); - ValidatedVectorFunctionModelDP function1 - = ValidatedVectorFunctionModelDP( dynamic_cast const&>(set1.function().reference())); + ValidatedVectorMultivariateFunctionModelDP function1 + = ValidatedVectorMultivariateFunctionModelDP( dynamic_cast const&>(set1.function().reference())); Vector function_error1=function1.errors(); function1.clobber(); function1.restrict(new_domain); - ValidatedVectorFunctionModelDP function2 - = ValidatedVectorFunctionModelDP( dynamic_cast const&>(set2.function().reference())); + ValidatedVectorMultivariateFunctionModelDP function2 + = ValidatedVectorMultivariateFunctionModelDP( dynamic_cast const&>(set2.function().reference())); Vector function_error2=function2.errors(); function2.clobber(); function2.restrict(new_domain); - ValidatedVectorFunctionModelDP new_function=(function1+function2)*FloatDPValue(0.5); + ValidatedVectorMultivariateFunctionModelDP new_function=(function1+function2)*FloatDPValue(0.5); new_function.clobber(); for(Nat i=0; i!=new_function.result_size(); ++i) { function_error1[i]=norm(new_function[i]-function1[i])+function_error1[i]; diff --git a/source/geometry/function_set.hpp b/source/geometry/function_set.hpp index e83f11013..4a9dbd08a 100644 --- a/source/geometry/function_set.hpp +++ b/source/geometry/function_set.hpp @@ -78,13 +78,13 @@ class ConstraintSet List< EffectiveConstraint > _constraints; public: //! \brief Construct the preimage of \a C under \a g. - ConstraintSet(const EffectiveVectorFunction& g, const RealBox& C); + ConstraintSet(const EffectiveVectorMultivariateFunction& g, const RealBox& C); //! \brief Construct the restriction of \a D under the constraints \a c. ConstraintSet(const List& c); //! \brief The codomain of the set. const RealBox codomain() const { return this->constraint_bounds(); } //! \brief The function used to define the constraints. - const EffectiveVectorFunction constraint_function() const; + const EffectiveVectorMultivariateFunction constraint_function() const; //! \brief The bounds of the constraints. const RealBox constraint_bounds() const; //! \brief The number of constraints. @@ -121,7 +121,7 @@ class BoundedConstraintSet List< EffectiveConstraint > _constraints; public: //! \brief Construct the preimage of \a C under \a g. - BoundedConstraintSet(const RealBox& D, const EffectiveVectorFunction& g, const RealBox& C); + BoundedConstraintSet(const RealBox& D, const EffectiveVectorMultivariateFunction& g, const RealBox& C); //! \brief Construct the restriction of \a D under the constraints \a c. BoundedConstraintSet(const RealBox& D, const List& c); //! \brief Construct the box \a D. @@ -131,7 +131,7 @@ class BoundedConstraintSet //! \brief The codomain of the set. const RealBox codomain() const { return this->constraint_bounds(); } //! \brief The function used to define the constraints. - const EffectiveVectorFunction constraint_function() const; + const EffectiveVectorMultivariateFunction constraint_function() const; //! \brief The bounds for the constraints. const RealBox constraint_bounds() const; //! \brief The number of constraints. @@ -160,7 +160,7 @@ class BoundedConstraintSet friend BoundedConstraintSet intersection(const ConstraintSet& cs1, const BoundedConstraintSet& bcs2); friend BoundedConstraintSet intersection(const BoundedConstraintSet& bcs1, const RealBox& bx2); friend BoundedConstraintSet intersection(const RealBox& bx1, const BoundedConstraintSet& bcs2); - friend ConstrainedImageSet image(const BoundedConstraintSet& set, const EffectiveVectorFunction& function); + friend ConstrainedImageSet image(const BoundedConstraintSet& set, const EffectiveVectorMultivariateFunction& function); }; @@ -168,27 +168,27 @@ class ConstrainedImageSet : public virtual LocatedSetInterface, public virtual DrawableInterface { RealBox _domain; - EffectiveVectorFunction _function; + EffectiveVectorMultivariateFunction _function; List< EffectiveConstraint > _constraints; public: //! \brief Construct the set with zero-dimensional parameterisation in zero dimensions with no constraints. ConstrainedImageSet() : _domain(), _function() { } //! \brief Construct the box \a dom. - ConstrainedImageSet(const RealBox& dom) : _domain(dom), _function(EffectiveVectorFunction::identity(dom.size())) { } + ConstrainedImageSet(const RealBox& dom) : _domain(dom), _function(EffectiveVectorMultivariateFunction::identity(dom.size())) { } //! \brief Construct the image of \a dom under \a fn. - ConstrainedImageSet(const RealBox& dom, const EffectiveVectorFunction& fn) : _domain(dom), _function(fn) { + ConstrainedImageSet(const RealBox& dom, const EffectiveVectorMultivariateFunction& fn) : _domain(dom), _function(fn) { ARIADNE_ASSERT_MSG(dom.size()==fn.argument_size(),"dom="<>& af, const Zonotope& z); - friend Zonotope apply(const VectorFunction& f, const Zonotope& z); + friend Zonotope apply(const VectorMultivariateFunction& f, const Zonotope& z); //@} //@{ @@ -241,7 +241,7 @@ Zonotope cascade_over_approximation(const Zonotope& z, Nat b); Zonotope orthogonal_approximation(const Zonotope& z); Zonotope apply(const Affine& af, const Zonotope& z); -Zonotope apply(const VectorFunction& f, const Zonotope& z); +Zonotope apply(const VectorMultivariateFunction& f, const Zonotope& z); OutputStream& operator<<(OutputStream& os, const Zonotope& z); InputStream& operator>>(InputStream& is, Zonotope& z); diff --git a/source/hybrid/hybrid_automaton-composite.cpp b/source/hybrid/hybrid_automaton-composite.cpp index a3e7b6cc1..be3ed9bb1 100644 --- a/source/hybrid/hybrid_automaton-composite.cpp +++ b/source/hybrid/hybrid_automaton-composite.cpp @@ -405,7 +405,7 @@ CompositeHybridAutomaton::guard_predicate(DiscreteLocation location, DiscreteEve -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositeHybridAutomaton::auxiliary_function(DiscreteLocation location) const { RealExpression default_expression; Space space=this->state_variables(location); @@ -415,7 +415,7 @@ CompositeHybridAutomaton::auxiliary_function(DiscreteLocation location) const { return make_function(space,results); } -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositeHybridAutomaton::dynamic_function(DiscreteLocation location) const { RealExpression default_expression; Space space=this->state_variables(location); @@ -426,7 +426,7 @@ CompositeHybridAutomaton::dynamic_function(DiscreteLocation location) const { return make_function(space,results); } -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositeHybridAutomaton::reset_function(DiscreteLocation source, DiscreteEvent event) const { RealExpression default_expression; DiscreteLocation target=this->target(source,event); @@ -439,7 +439,7 @@ CompositeHybridAutomaton::reset_function(DiscreteLocation source, DiscreteEvent return make_function(source_space,results); } -EffectiveScalarFunction +EffectiveScalarMultivariateFunction CompositeHybridAutomaton::invariant_function(DiscreteLocation location, DiscreteEvent event) const { Space space=this->state_variables(location); List algebraic=this->auxiliary_assignments(location); @@ -447,7 +447,7 @@ CompositeHybridAutomaton::invariant_function(DiscreteLocation location, Discrete return make_function(space,substitute(invariant,algebraic)); } -EffectiveScalarFunction +EffectiveScalarMultivariateFunction CompositeHybridAutomaton::guard_function(DiscreteLocation location, DiscreteEvent event) const { Space space=this->state_variables(location); List algebraic=this->auxiliary_assignments(location); diff --git a/source/hybrid/hybrid_automaton-composite.hpp b/source/hybrid/hybrid_automaton-composite.hpp index 8c14994fe..e6fc8e62c 100644 --- a/source/hybrid/hybrid_automaton-composite.hpp +++ b/source/hybrid/hybrid_automaton-composite.hpp @@ -181,15 +181,15 @@ class CompositeHybridAutomaton DiscreteLocation target(DiscreteLocation location, DiscreteEvent event) const; //! \brief The function outputting the auxiliary variables \f$y=h(x)\f$ in the location. - EffectiveVectorFunction auxiliary_function(DiscreteLocation location) const; + EffectiveVectorMultivariateFunction auxiliary_function(DiscreteLocation location) const; //! \brief The function outputting the differential equations \f$dx/dt =f(x)\f$ in the location. - EffectiveVectorFunction dynamic_function(DiscreteLocation location) const; + EffectiveVectorMultivariateFunction dynamic_function(DiscreteLocation location) const; //! \brief The reset function \f$x'=r(x)\f$ for the given event. - EffectiveVectorFunction reset_function(DiscreteLocation location, DiscreteEvent event) const; + EffectiveVectorMultivariateFunction reset_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The invariant function \f$i(x)\leq 0\f$ corresponding to the given event. - EffectiveScalarFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; + EffectiveScalarMultivariateFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The guard function \f$g(x)\geq 0\f$ corresponding to the given event. - EffectiveScalarFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; + EffectiveScalarMultivariateFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The type of the event (urgent, permissive, impact etc). EventKind event_kind(DiscreteLocation location, DiscreteEvent event) const; diff --git a/source/hybrid/hybrid_automaton-restrictive.cpp b/source/hybrid/hybrid_automaton-restrictive.cpp index cee3a6d5d..380dda708 100644 --- a/source/hybrid/hybrid_automaton-restrictive.cpp +++ b/source/hybrid/hybrid_automaton-restrictive.cpp @@ -451,7 +451,7 @@ Void HybridSystem::new_transition(DiscreteLocation s, DiscreteEvent e, DiscreteL -EffectiveVectorFunction +EffectiveVectorMultivariateFunction dynamic_function(Space& space, const List& algebraic, const List& differential) { RealExpression default_expression; @@ -899,26 +899,26 @@ CompositionalHybridAutomaton::dimension(DiscreteLocation location) const { } -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositionalHybridAutomaton::output_function(DiscreteLocation location) const { Space space=this->state_variables(location); List algebraic=this->algebraic_assignments(location); List results(algebraic.size(),RealExpression(0.0)); for(SizeType i=0; i!=algebraic.size(); ++i) { results[i]=algebraic[i].variable(); } - return EffectiveVectorFunction(Ariadne::dimension(space),Ariadne::formula(results,algebraic,space)); + return EffectiveVectorMultivariateFunction(Ariadne::dimension(space),Ariadne::formula(results,algebraic,space)); } -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositionalHybridAutomaton::dynamic_function(DiscreteLocation location) const { Space space=this->state_variables(location); List algebraic=this->algebraic_assignments(location); List differential=this->differential_assignments(location); List results(differential.size(),RealExpression(0.0)); for(SizeType i=0; i!=differential.size(); ++i) { results[space.index(differential[i].variable().base())]=substitute(differential[i].expression(),algebraic); } - return EffectiveVectorFunction(Ariadne::dimension(space),Ariadne::formula(results,algebraic,space)); + return EffectiveVectorMultivariateFunction(Ariadne::dimension(space),Ariadne::formula(results,algebraic,space)); } -EffectiveVectorFunction +EffectiveVectorMultivariateFunction CompositionalHybridAutomaton::reset_function(DiscreteLocation source, DiscreteEvent event) const { DiscreteLocation target=this->target(source,event); Space source_space=this->state_variables(source); @@ -927,23 +927,23 @@ CompositionalHybridAutomaton::reset_function(DiscreteLocation source, DiscreteEv List update=this->update_assignments(source,event); List results(update.size(),RealExpression(0.0)); for(SizeType i=0; i!=update.size(); ++i) { results[target_space.index(update[i].variable().base())]=update[i].expression(); } - return EffectiveVectorFunction(Ariadne::dimension(source_space),Ariadne::formula(results,algebraic,source_space)); + return EffectiveVectorMultivariateFunction(Ariadne::dimension(source_space),Ariadne::formula(results,algebraic,source_space)); } -EffectiveScalarFunction +EffectiveScalarMultivariateFunction CompositionalHybridAutomaton::invariant_function(DiscreteLocation location, DiscreteEvent event) const { Space space=this->state_variables(location); List algebraic=this->algebraic_assignments(location); RealExpression invariant=indicator(invariant_predicate(location,event),Sign::NEGATIVE); - return EffectiveScalarFunction(Ariadne::dimension(space),Ariadne::formula(invariant,algebraic,space)); + return EffectiveScalarMultivariateFunction(Ariadne::dimension(space),Ariadne::formula(invariant,algebraic,space)); } -EffectiveScalarFunction +EffectiveScalarMultivariateFunction CompositionalHybridAutomaton::guard_function(DiscreteLocation location, DiscreteEvent event) const { Space space=this->state_variables(location); List algebraic=this->algebraic_assignments(location); RealExpression guard=indicator(guard_predicate(location,event),Sign::POSITIVE); - return EffectiveScalarFunction(Ariadne::dimension(space),Ariadne::formula(guard,algebraic,space)); + return EffectiveScalarMultivariateFunction(Ariadne::dimension(space),Ariadne::formula(guard,algebraic,space)); } diff --git a/source/hybrid/hybrid_automaton-restrictive.hpp b/source/hybrid/hybrid_automaton-restrictive.hpp index 22aea05eb..ce78c329b 100644 --- a/source/hybrid/hybrid_automaton-restrictive.hpp +++ b/source/hybrid/hybrid_automaton-restrictive.hpp @@ -61,8 +61,8 @@ class DiscreteTransition; typedef ContinuousPredicate RealPredicate; -EffectiveVectorFunction dynamic_function(Space& space, const List& algebraic, const List& differential); -EffectiveScalarFunction constraint_function(Space& space, const List& algebraic, const RealPredicate& constraint); +EffectiveVectorMultivariateFunction dynamic_function(Space& space, const List& algebraic, const List& differential); +EffectiveScalarMultivariateFunction constraint_function(Space& space, const List& algebraic, const RealPredicate& constraint); template class FinitarySet @@ -242,13 +242,13 @@ class HybridSystem HybridSpace state_space() const; DimensionType dimension(DiscreteLocation) const; RealSpace continuous_state_space(DiscreteLocation) const; - EffectiveVectorFunction output_function(DiscreteLocation) const; - EffectiveVectorFunction auxiliary_function(DiscreteLocation) const; - EffectiveVectorFunction dynamic_function(DiscreteLocation) const; - EffectiveVectorFunction reset_function(DiscreteLocation, DiscreteEvent) const; - EffectiveScalarFunction constraint_function(DiscreteLocation, DiscreteEvent) const; - EffectiveScalarFunction invariant_function(DiscreteLocation, DiscreteEvent) const; - EffectiveScalarFunction guard_function(DiscreteLocation, DiscreteEvent) const; + EffectiveVectorMultivariateFunction output_function(DiscreteLocation) const; + EffectiveVectorMultivariateFunction auxiliary_function(DiscreteLocation) const; + EffectiveVectorMultivariateFunction dynamic_function(DiscreteLocation) const; + EffectiveVectorMultivariateFunction reset_function(DiscreteLocation, DiscreteEvent) const; + EffectiveScalarMultivariateFunction constraint_function(DiscreteLocation, DiscreteEvent) const; + EffectiveScalarMultivariateFunction invariant_function(DiscreteLocation, DiscreteEvent) const; + EffectiveScalarMultivariateFunction guard_function(DiscreteLocation, DiscreteEvent) const; //@} @@ -307,15 +307,15 @@ class HybridSystem //! \brief The dimension of the state spacec in the given \a location. virtual DimensionType dimension(DiscreteLocation location) const; //! \brief The output function on Euclidean state space. Used for outputting auxiliary variables. - virtual EffectiveVectorFunction output_function(DiscreteLocation location) const; + virtual EffectiveVectorMultivariateFunction output_function(DiscreteLocation location) const; //! \brief The function defining the differential equation \f$\der{x}=f(x)\f$ valid in the \a location. - virtual EffectiveVectorFunction dynamic_function(DiscreteLocation location) const; + virtual EffectiveVectorMultivariateFunction dynamic_function(DiscreteLocation location) const; //! \brief The function defining the reset \f$x'=r(x)\f$ when the \a event occurs in the \a source location. - virtual EffectiveVectorFunction reset_function(DiscreteLocation source, DiscreteEvent event) const; + virtual EffectiveVectorMultivariateFunction reset_function(DiscreteLocation source, DiscreteEvent event) const; //! \brief The function defining the guard \f$g(x) \geq 0\f$ for the given \a event to occur in \a location. - virtual EffectiveScalarFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; + virtual EffectiveScalarMultivariateFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The function defining the invariant \f$p(x)\leq 0\f$ for continuous evolution to be blocked in \a location. - virtual EffectiveScalarFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; + virtual EffectiveScalarMultivariateFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The grid for the state variables in \a location. virtual Grid grid(DiscreteLocation location) const; diff --git a/source/hybrid/hybrid_automaton.cpp b/source/hybrid/hybrid_automaton.cpp index 1433ab1c0..2d808d67e 100644 --- a/source/hybrid/hybrid_automaton.cpp +++ b/source/hybrid/hybrid_automaton.cpp @@ -40,10 +40,10 @@ namespace Ariadne { -EffectiveVectorFunction auxiliary_function(Space const& space, List const& sorted_algebraic); -EffectiveVectorFunction dynamic_function(Space const& space, List const& algebraic, List const& differential); -EffectiveVectorFunction reset_function(Space const& space, List const& algebraic, List const& primed); -EffectiveScalarFunction constraint_function(Space const& space, List const& algebraic, ContinuousPredicate const& constraint, Sign sign); +EffectiveVectorMultivariateFunction auxiliary_function(Space const& space, List const& sorted_algebraic); +EffectiveVectorMultivariateFunction dynamic_function(Space const& space, List const& algebraic, List const& differential); +EffectiveVectorMultivariateFunction reset_function(Space const& space, List const& algebraic, List const& primed); +EffectiveScalarMultivariateFunction constraint_function(Space const& space, List const& algebraic, ContinuousPredicate const& constraint, Sign sign); List algebraic_sort(const List& auxiliary); @@ -192,7 +192,7 @@ algebraic_sort(const List& auxiliary) { return sorted_auxiliary; } -EffectiveVectorFunction auxiliary_function( +EffectiveVectorMultivariateFunction auxiliary_function( Space const& space, List const& sorted_algebraic) { @@ -202,7 +202,7 @@ EffectiveVectorFunction auxiliary_function( return make_function(space,results); } -EffectiveVectorFunction dynamic_function( +EffectiveVectorMultivariateFunction dynamic_function( Space const& space, List const& algebraic, List const& differential) @@ -214,7 +214,7 @@ EffectiveVectorFunction dynamic_function( return make_function(space,results); } -EffectiveVectorFunction reset_function( +EffectiveVectorMultivariateFunction reset_function( Space const& space, List const& algebraic, List const& primed) @@ -226,7 +226,7 @@ EffectiveVectorFunction reset_function( return make_function(space,results); } -EffectiveScalarFunction constraint_function( +EffectiveScalarMultivariateFunction constraint_function( Space const& space, List const& algebraic, ContinuousPredicate const& constraint, @@ -680,27 +680,27 @@ EventKind HybridAutomaton::event_kind(DiscreteLocation location, DiscreteEvent e return this->mode(location)._kinds[event]; } -EffectiveVectorFunction HybridAutomaton::auxiliary_function(DiscreteLocation location) const { +EffectiveVectorMultivariateFunction HybridAutomaton::auxiliary_function(DiscreteLocation location) const { DiscreteMode const& mode=this->mode(location); return Ariadne::auxiliary_function(this->continuous_state_space(location),mode._sorted_auxiliary); } -EffectiveVectorFunction HybridAutomaton::dynamic_function(DiscreteLocation location) const { +EffectiveVectorMultivariateFunction HybridAutomaton::dynamic_function(DiscreteLocation location) const { DiscreteMode const& mode=this->mode(location); return Ariadne::dynamic_function(this->continuous_state_space(location),mode._sorted_auxiliary,mode._dynamic); } -EffectiveVectorFunction HybridAutomaton::reset_function(DiscreteLocation location, DiscreteEvent event) const { +EffectiveVectorMultivariateFunction HybridAutomaton::reset_function(DiscreteLocation location, DiscreteEvent event) const { DiscreteMode const& mode=this->mode(location); return Ariadne::reset_function(this->continuous_state_space(location),mode._sorted_auxiliary,mode._resets[event]); } -EffectiveScalarFunction HybridAutomaton::invariant_function(DiscreteLocation location, DiscreteEvent event) const { +EffectiveScalarMultivariateFunction HybridAutomaton::invariant_function(DiscreteLocation location, DiscreteEvent event) const { DiscreteMode const& mode=this->mode(location); return Ariadne::constraint_function(this->continuous_state_space(location),mode._auxiliary,mode._invariants[event],Sign::NEGATIVE); } -EffectiveScalarFunction HybridAutomaton::guard_function(DiscreteLocation location, DiscreteEvent event) const { +EffectiveScalarMultivariateFunction HybridAutomaton::guard_function(DiscreteLocation location, DiscreteEvent event) const { DiscreteMode const& mode=this->mode(location); return Ariadne::constraint_function(this->continuous_state_space(location),mode._sorted_auxiliary,mode._guards[event],Sign::POSITIVE); } diff --git a/source/hybrid/hybrid_automaton.hpp b/source/hybrid/hybrid_automaton.hpp index 01efb6f0b..046933811 100644 --- a/source/hybrid/hybrid_automaton.hpp +++ b/source/hybrid/hybrid_automaton.hpp @@ -565,15 +565,15 @@ class HybridAutomaton virtual DiscreteLocation target(DiscreteLocation location, DiscreteEvent event) const; //! \brief The function outputting the auxiliary variables \f$y=h(x)\f$ in the location. - virtual EffectiveVectorFunction auxiliary_function(DiscreteLocation location) const; + virtual EffectiveVectorMultivariateFunction auxiliary_function(DiscreteLocation location) const; //! \brief The function outputting the differential equations \f$\dt{x}=f(x)\f$ in the location. - virtual EffectiveVectorFunction dynamic_function(DiscreteLocation location) const; + virtual EffectiveVectorMultivariateFunction dynamic_function(DiscreteLocation location) const; //! \brief The invariant function \f$i(x)\leq 0\f$ corresponding to the given event. - virtual EffectiveScalarFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; + virtual EffectiveScalarMultivariateFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The guard function \f$g(x)\geq 0\f$ corresponding to the given event. - virtual EffectiveScalarFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; + virtual EffectiveScalarMultivariateFunction guard_function(DiscreteLocation location, DiscreteEvent event) const; //! \brief The reset function \f$x'=r(x)\f$ for the given event. - virtual EffectiveVectorFunction reset_function(DiscreteLocation location, DiscreteEvent event) const; + virtual EffectiveVectorMultivariateFunction reset_function(DiscreteLocation location, DiscreteEvent event) const; //@} diff --git a/source/hybrid/hybrid_automaton_interface.hpp b/source/hybrid/hybrid_automaton_interface.hpp index fd77333a6..23b6772af 100644 --- a/source/hybrid/hybrid_automaton_interface.hpp +++ b/source/hybrid/hybrid_automaton_interface.hpp @@ -198,19 +198,19 @@ class HybridAutomatonInterface { virtual DimensionType dimension(DiscreteLocation location) const = 0; //! \brief The function giving the auxiliary variables in the mode \a location. - virtual EffectiveVectorFunction auxiliary_function(DiscreteLocation location) const = 0; + virtual EffectiveVectorMultivariateFunction auxiliary_function(DiscreteLocation location) const = 0; //! \brief The dynamic valid in the mode \a location. - virtual EffectiveVectorFunction dynamic_function(DiscreteLocation location) const = 0; + virtual EffectiveVectorMultivariateFunction dynamic_function(DiscreteLocation location) const = 0; //! \brief The constraint function defining the invariant or time-can-progress predicate \f$p(x)\leq0\f$. - virtual EffectiveScalarFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const = 0; + virtual EffectiveScalarMultivariateFunction invariant_function(DiscreteLocation location, DiscreteEvent event) const = 0; //! \brief The constraint function defining the condition \f$c(x)\geq0\f$ under which a transition occurs. - virtual EffectiveScalarFunction guard_function(DiscreteLocation location, DiscreteEvent event) const = 0; + virtual EffectiveScalarMultivariateFunction guard_function(DiscreteLocation location, DiscreteEvent event) const = 0; //! \brief The dynamic valid in the mode \a location. - virtual EffectiveVectorFunction reset_function(DiscreteLocation location, DiscreteEvent event) const = 0; + virtual EffectiveVectorMultivariateFunction reset_function(DiscreteLocation location, DiscreteEvent event) const = 0; //! \brief The hybrid state space. virtual HybridSpace state_space() const = 0; diff --git a/source/hybrid/hybrid_enclosure.cpp b/source/hybrid/hybrid_enclosure.cpp index d557f5870..978f45d0e 100644 --- a/source/hybrid/hybrid_enclosure.cpp +++ b/source/hybrid/hybrid_enclosure.cpp @@ -198,7 +198,7 @@ HybridEnclosure::function_factory() const return this->_set.function_factory(); } -ValidatedScalarFunctionModelDP const +ValidatedScalarMultivariateFunctionModelDP const HybridEnclosure::function(RealVariable var) const { if(this->state_space().contains(var)) { @@ -213,38 +213,38 @@ HybridEnclosure::function(RealVariable var) const } } -ValidatedVectorFunctionModelDP const& +ValidatedVectorMultivariateFunctionModelDP const& HybridEnclosure::state_function() const { return this->_set.state_function(); } -ValidatedScalarFunctionModelDP const& +ValidatedScalarMultivariateFunctionModelDP const& HybridEnclosure::time_function() const { return this->_set.time_function(); } -ValidatedScalarFunctionModelDP const& +ValidatedScalarMultivariateFunctionModelDP const& HybridEnclosure::dwell_time_function() const { return this->_set.dwell_time_function(); } -ValidatedVectorFunctionModelDP const +ValidatedVectorMultivariateFunctionModelDP const HybridEnclosure::auxiliary_function() const { return this->_set.auxiliary_function(); } -ValidatedVectorFunctionModelDP const +ValidatedVectorMultivariateFunctionModelDP const HybridEnclosure::state_time_auxiliary_function() const { return this->_set.state_time_auxiliary_function(); } -Void HybridEnclosure::set_time_function(const ValidatedScalarFunctionModelDP& time_function) +Void HybridEnclosure::set_time_function(const ValidatedScalarMultivariateFunctionModelDP& time_function) { ARIADNE_NOT_IMPLEMENTED; ARIADNE_ASSERT_MSG(Ariadne::subset(this->parameter_domain(),time_function.domain()), @@ -263,7 +263,7 @@ HybridEnclosure::state_bounding_box() const } UpperIntervalType -HybridEnclosure::range_of(EffectiveScalarFunction const& g) const +HybridEnclosure::range_of(EffectiveScalarMultivariateFunction const& g) const { return apply(compose(g,this->state_function()),this->_set.reduced_domain()); } @@ -309,7 +309,7 @@ HybridEnclosure::bounding_box() const } -Void HybridEnclosure::set_auxiliary(List vars, EffectiveVectorFunction aux) +Void HybridEnclosure::set_auxiliary(List vars, EffectiveVectorMultivariateFunction aux) { if(vars.size()!=aux.result_size()) { std::cerr<_state_space.size()==aux.argument_size()); @@ -330,19 +330,19 @@ Void HybridEnclosure::new_variable(ExactIntervalType ivl, EnclosureVariableType this->_variables.append(vt); } -Void HybridEnclosure::new_state_time_bound(DiscreteEvent e, ValidatedScalarFunction gamma) { +Void HybridEnclosure::new_state_time_bound(DiscreteEvent e, ValidatedScalarMultivariateFunction gamma) { this->_set.new_state_time_bound(gamma); } -Void HybridEnclosure::new_invariant(DiscreteEvent event, ValidatedScalarFunction constraint_function) { +Void HybridEnclosure::new_invariant(DiscreteEvent event, ValidatedScalarMultivariateFunction constraint_function) { this->_set.new_negative_state_constraint(constraint_function); } -Void HybridEnclosure::new_activation(DiscreteEvent event, ValidatedScalarFunction constraint_function) { +Void HybridEnclosure::new_activation(DiscreteEvent event, ValidatedScalarMultivariateFunction constraint_function) { this->_set.new_positive_state_constraint(constraint_function); } -Void HybridEnclosure::new_guard(DiscreteEvent event, ValidatedScalarFunction constraint_function) { +Void HybridEnclosure::new_guard(DiscreteEvent event, ValidatedScalarMultivariateFunction constraint_function) { this->_set.new_zero_state_constraint(constraint_function); } @@ -374,7 +374,7 @@ Void HybridEnclosure::clear_events() this->_events.clear(); } -Void HybridEnclosure::apply_reset(DiscreteEvent event, DiscreteLocation target, RealSpace state_space, const ValidatedVectorFunction& map) +Void HybridEnclosure::apply_reset(DiscreteEvent event, DiscreteLocation target, RealSpace state_space, const ValidatedVectorMultivariateFunction& map) { ARIADNE_ASSERT_MSG(map.argument_size()==this->state_dimension(),"*this="<<*this<<", event="<system().dynamic_function(location); + const EffectiveVectorMultivariateFunction& dynamic=this->system().dynamic_function(location); Map transitions; Set events = this->system().events(location); @@ -484,15 +484,15 @@ _extract_transitions(DiscreteLocation const& location) const DiscreteEvent event=*event_iter; EventKind event_kind=this->system().event_kind(location,event); ARIADNE_LOG(5,"event="<system().guard_function(location,event); } else { constraint_function=this->system().invariant_function(location,event); } ARIADNE_LOG(5,"constraint_function="<system().reset_function(location,event); target=this->system().target(location,event); @@ -591,9 +591,9 @@ _process_starting_events(EvolutionData& evolution_data, } } -ValidatedVectorFunctionModelDP +ValidatedVectorMultivariateFunctionModelDP HybridEvolverBase:: -_compute_flow(EffectiveVectorFunction dynamic, +_compute_flow(EffectiveVectorMultivariateFunction dynamic, ExactBoxType const& initial_box, const StepSizeType& maximum_step_size) const { @@ -609,7 +609,7 @@ _compute_flow(EffectiveVectorFunction dynamic, // more accurate, and the time domain might be used explicitly for the domain // of the resulting set. StepSizeType step_size=maximum_step_size; - ValidatedVectorFunctionModelDP flow_model=integrator.flow_step(dynamic,initial_box,step_size); + ValidatedVectorMultivariateFunctionModelDP flow_model=integrator.flow_step(dynamic,initial_box,step_size); ARIADNE_LOG(6,"twosided_flow_model="< HybridEvolverBase:: -_compute_active_events(EffectiveVectorFunction const& dynamic, - Map const& guards, - ValidatedVectorFunctionModelDP const& flow, +_compute_active_events(EffectiveVectorMultivariateFunction const& dynamic, + Map const& guards, + ValidatedVectorMultivariateFunctionModelDP const& flow, HybridEnclosure const& starting_set) const { ARIADNE_LOG(7,"HybridEvolverBase::_compute_active_events(...)\n"); @@ -638,8 +638,8 @@ _compute_active_events(EffectiveVectorFunction const& dynamic, ARIADNE_LOG(8,"reach_set="<::Iterator event_iter=events.begin(); event_iter!=events.end(); ++event_iter) { const DiscreteEvent event=*event_iter; - const EffectiveScalarFunction& guard_function=guards[event]; - EffectiveScalarFunction flow_derivative = lie_derivative(guard_function,dynamic); + const EffectiveScalarMultivariateFunction& guard_function=guards[event]; + EffectiveScalarMultivariateFunction flow_derivative = lie_derivative(guard_function,dynamic); ARIADNE_LOG(8,"event="< HybridEvolverBase:: _compute_crossings(Set const& active_events, - EffectiveVectorFunction const& dynamic, - Map const& guards, + EffectiveVectorMultivariateFunction const& dynamic, + Map const& guards, FlowFunctionModel const& flow, HybridEnclosure const& initial_set) const { @@ -684,7 +684,7 @@ _compute_crossings(Set const& active_events, { const DiscreteEvent event=*event_iter; ARIADNE_LOG(8,"\n\nevent="< const& active_events, ARIADNE_LOG(8,"guard_range="<zero)) { @@ -702,7 +702,7 @@ _compute_crossings(Set const& active_events, // crossing must be the time of the event along the trajectory. // The crossing time $\gamma(x_0)$ given the initial state can usually be computed // by solving the equation $g(\phi(x_0,\gamma(x_0))) = 0$ - ValidatedScalarFunctionModelDP crossing_time; + ValidatedScalarMultivariateFunctionModelDP crossing_time; try { crossing_time=solver.implicit(compose(guard,flow),flow_spacial_domain,flow_time_domain); if(decide(crossing_time.error()>1e-8)) { ARIADNE_LOG(2,event<<": crossing_time: error="< const& active_events, // If the derivative of the guard function along flow lines cannot be shown // to have a definite sign over the entire flow box, then try to compute // the sign of the second derivative $L_{f}^{2}g(x)=L_{f}L_{f}g(x)$. - ValidatedScalarFunction guard_second_derivative=lie_derivative(guard_derivative,dynamic); + ValidatedScalarMultivariateFunction guard_second_derivative=lie_derivative(guard_derivative,dynamic); UpperIntervalType guard_second_derivative_bounds_range=apply(guard_second_derivative,flow_bounds); UpperIntervalType guard_second_derivative_flow_range=compose(guard_second_derivative,flow).range(); UpperIntervalType guard_second_derivative_range @@ -785,7 +785,7 @@ _compute_crossings(Set const& active_events, // sufficient condition for no crossing involving the critical // time is $(g(\phi(x_0,t))<=0 /\ t<=\mu(x_0)) \/ g(\phi(x_0,\mu(x_0)))<=0$ try { - ValidatedScalarFunctionModelDP critical_time=solver.implicit(compose(guard_derivative,flow),flow_spacial_domain,flow_time_domain); + ValidatedScalarMultivariateFunctionModelDP critical_time=solver.implicit(compose(guard_derivative,flow),flow_spacial_domain,flow_time_domain); UpperIntervalType critical_time_range=critical_time.range(); ARIADNE_LOG(8,"critical_time_range="<1e-8)) { @@ -793,8 +793,8 @@ _compute_crossings(Set const& active_events, HybridEnclosure evolve_set_at_critical_time=initial_set; evolve_set_at_critical_time.apply_space_evolve_step(flow,critical_time); - ValidatedVectorFunctionModelDP identity = factory(critical_time).create_identity(); - //ValidatedVectorFunctionModelDP::identity(critical_time.domain(),critical_time.sweeper()); + ValidatedVectorMultivariateFunctionModelDP identity = factory(critical_time).create_identity(); + //ValidatedVectorMultivariateFunctionModelDP::identity(critical_time.domain(),critical_time.sweeper()); UpperIntervalType guard_range_at_critical_time=evolve_set_at_critical_time.range_of(guard); ARIADNE_LOG(8,"guard_range_at_critical_time="< const& active_events, // FIXME: Find a more reliable way of solving the implicit equation for the crossing time // which takes into account the fact that the derivative over the domain goes negative static const Rational INTERVAL_REDUCTION_FACTOR(15,16); - ValidatedScalarFunctionModelDP reduced_critical_time=INTERVAL_REDUCTION_FACTOR * critical_time; + ValidatedScalarMultivariateFunctionModelDP reduced_critical_time=INTERVAL_REDUCTION_FACTOR * critical_time; HybridEnclosure evolve_set_at_reduced_critical_time=initial_set; evolve_set_at_reduced_critical_time.apply_space_evolve_step(flow,reduced_critical_time); HybridEnclosure evolve_set_at_upper_reduced_critical_time=initial_set; @@ -823,7 +823,7 @@ _compute_crossings(Set const& active_events, try { //KrawczykSolver solver=KrawczykSolver(1e-10,20); //solver.verbosity=9;//this->verbosity; - ValidatedScalarFunctionModelDP crossing_time=solver.implicit(compose(guard,flow),flow_spacial_domain,crossing_flow_time_domain); + ValidatedScalarMultivariateFunctionModelDP crossing_time=solver.implicit(compose(guard,flow),flow_spacial_domain,crossing_flow_time_domain); UpperIntervalType crossing_time_range=crossing_time.range(); ARIADNE_LOG(8,"crossing_time_range="<& sets, case Semantics::UPPER: for(Nat i=0; i!=n; ++i) { FloatDPBounds alpha=FloatDPValue(i+1)/n; - ValidatedScalarFunctionModelDP intermediate_guard + ValidatedScalarMultivariateFunctionModelDP intermediate_guard = compose( guard_function, unchecked_compose( flow, join(starting_state_function, alpha*elapsed_time_function) ) ); set.new_parameter_constraint(event, intermediate_guard <= zero); } @@ -1202,7 +1202,7 @@ _evolution_in_mode(EvolutionData& evolution_data, const DiscreteLocation location=initial_set.location(); // Cache dynamic and constraint functions - EffectiveVectorFunction dynamic=this->system().dynamic_function(location); + EffectiveVectorMultivariateFunction dynamic=this->system().dynamic_function(location); Map transitions = this->_extract_transitions(location); Set events = transitions.keys(); @@ -1247,7 +1247,7 @@ _evolution_in_mode(EvolutionData& evolution_data, Void HybridEvolverBase:: _evolution_step(EvolutionData& evolution_data, - EffectiveVectorFunction const& dynamic, + EffectiveVectorMultivariateFunction const& dynamic, Map const& transitions, Real const& final_time) const { @@ -1299,7 +1299,7 @@ _evolution_step(EvolutionData& evolution_data, } } - Map guard_functions; + Map guard_functions; for(Map::ConstIterator transition_iter=transitions.begin(); transition_iter!=transitions.end(); ++transition_iter) { @@ -1340,10 +1340,10 @@ _evolution_step(EvolutionData& evolution_data, Void HybridEvolverBase:: _apply_evolution_step(EvolutionData& evolution_data, HybridEnclosure const& starting_set, - ValidatedVectorFunctionModelDP const& flow, + ValidatedVectorMultivariateFunctionModelDP const& flow, TimingData const& timing_data, Map const& crossings, - EffectiveVectorFunction const& dynamic, + EffectiveVectorMultivariateFunction const& dynamic, Map const& transitions) const { ARIADNE_LOG(3,"GeneralHybridEvolver::_apply_evolution_step(...)\n"); @@ -1370,8 +1370,8 @@ _apply_evolution_step(EvolutionData& evolution_data, ARIADNE_LOG(6,"activating_events="<& active_events, ExactIntervalType time_domain = cast_exact_interval(initial_set.time_range()+ExactIntervalType(zero,step_size)); ExactBoxType statetime_domain = join(state_domain,time_domain); - //ValidatedVectorFunctionModelDP space_coordinates=this->function_factory().create_identity(space_domain); - ValidatedScalarFunctionModelDP time_coordinate=this->function_factory().create_coordinate(statetime_domain,n); - ValidatedScalarFunctionModelDP time_identity=this->function_factory().create_identity(time_domain); + //ValidatedVectorMultivariateFunctionModelDP space_coordinates=this->function_factory().create_identity(space_domain); + ValidatedScalarMultivariateFunctionModelDP time_coordinate=this->function_factory().create_coordinate(statetime_domain,n); + ValidatedScalarMultivariateFunctionModelDP time_identity=this->function_factory().create_identity(time_domain); result.evolution_time_domain=ExactIntervalType(zero,step_size); result.evolution_time_coordinate=this->function_factory().create_identity(result.evolution_time_domain); @@ -1698,8 +1698,8 @@ _estimate_timing(Set& active_events, // NOTE: The starting time function may be negative or greater than the final time // over part of the parameter domain. - ValidatedVectorFunctionModelDP const& starting_state_function=initial_set.state_function(); - ValidatedScalarFunctionModelDP const& starting_time_function=initial_set.time_function(); + ValidatedVectorMultivariateFunctionModelDP const& starting_state_function=initial_set.state_function(); + ValidatedScalarMultivariateFunctionModelDP const& starting_time_function=initial_set.time_function(); UpperIntervalType starting_time_range=initial_set.time_range(); UpperIntervalType remaining_time_range=final_time_bounds-starting_time_range; @@ -1707,7 +1707,7 @@ _estimate_timing(Set& active_events, // The time-dependent part of the evolution time - ValidatedScalarFunctionModelDP temporal_evolution_time=this->function_factory().create_zero(ExactIntervalVectorType(1u,time_domain)); + ValidatedScalarMultivariateFunctionModelDP temporal_evolution_time=this->function_factory().create_zero(ExactIntervalVectorType(1u,time_domain)); ARIADNE_LOG(9,std::fixed<<"remaining_time_range="<& active_events, ARIADNE_LOG(7,"temporal_evolution_time="<function_factory().create_constant(state_domain,FloatDPValue(step_size)); + ValidatedScalarMultivariateFunctionModelDP spacial_evolution_time=this->function_factory().create_constant(state_domain,FloatDPValue(step_size)); // Select one of GUARD_CREEP or TIME_CREEP static const Bool GUARD_CREEP=true; @@ -1800,7 +1800,7 @@ _estimate_timing(Set& active_events, && event_kind!=EventKind::PERMISSIVE) { ARIADNE_LOG(6," crossing_time_range="<second.crossing_time.range()<<"\n"); - const ValidatedScalarFunctionModelDP& crossing_time=crossing_iter->second.crossing_time; + const ValidatedScalarMultivariateFunctionModelDP& crossing_time=crossing_iter->second.crossing_time; UpperIntervalType crossing_time_range=crossing_time.range(); if(Ariadne::is_blocking(event_kind) && definitely(crossing_time_range.upper()& active_events, // This event ensures that the evolve set is empty after a full step, so use this. ARIADNE_LOG(6,std::setprecision(18)<<"crossing_time_range="<function_factory().create_identity(crossing_time.domain()); - ValidatedScalarFunctionModelDP step_time=crossing_time*zero+FloatDPValue(step_size); + EffectiveScalarMultivariateFunction guard=transitions[event].guard_function; + ValidatedVectorMultivariateFunctionModelDP identity=this->function_factory().create_identity(crossing_time.domain()); + ValidatedScalarMultivariateFunctionModelDP step_time=crossing_time*zero+FloatDPValue(step_size); ARIADNE_LOG(6,"full flow="<& active_events, ARIADNE_ASSERT(alpha_val.value()==alpha); ARIADNE_LOG(6," step_size: "<0 && alpha<=1) { - ValidatedScalarFunctionModelDP guard_creep_time; + ValidatedScalarMultivariateFunctionModelDP guard_creep_time; Bool sucessfully_computed_guard_creep_time=false; try { guard_creep_time=solver.implicit(compose(guard_function,flow)-alpha*compose(guard_function,space_projection), @@ -1966,8 +1966,8 @@ _estimate_timing(Set& active_events, } - ValidatedScalarFunctionModelDP evolution_time = embed(spacial_evolution_time,time_domain) * embed(state_domain,temporal_evolution_time/FloatDPValue(step_size)); - ValidatedScalarFunctionModelDP finishing_time=evolution_time+time_coordinate; + ValidatedScalarMultivariateFunctionModelDP evolution_time = embed(spacial_evolution_time,time_domain) * embed(state_domain,temporal_evolution_time/FloatDPValue(step_size)); + ValidatedScalarMultivariateFunctionModelDP finishing_time=evolution_time+time_coordinate; ARIADNE_LOG(7,"evolution_time="<<(evolution_time)<<"\n"); ARIADNE_LOG(7,"finishing_time="<<(finishing_time)<<"\n"); diff --git a/source/hybrid/hybrid_evolver.hpp b/source/hybrid/hybrid_evolver.hpp index 1d334afa0..f5c21956c 100644 --- a/source/hybrid/hybrid_evolver.hpp +++ b/source/hybrid/hybrid_evolver.hpp @@ -61,14 +61,14 @@ class GeneralHybridEvolverConfiguration; //! \ingroup FunctionModule //! \brief A class representing the flow \f$\phi(x,t)\f$ of a differential equation \f$\frac{dx}{dt}=f(x)\f$. class FlowFunctionModel - : public ValidatedVectorFunctionModelDP + : public ValidatedVectorMultivariateFunctionModelDP { public: - FlowFunctionModel(const ValidatedVectorFunctionModelDP& f) : ValidatedVectorFunctionModelDP(f) { } + FlowFunctionModel(const ValidatedVectorMultivariateFunctionModelDP& f) : ValidatedVectorMultivariateFunctionModelDP(f) { } StepSizeType step_size() const { return static_cast(this->time_domain().upper()); } ExactIntervalType time_domain() const { return this->domain()[this->domain().size()-1]; } ExactBoxType space_domain() const { return ExactBoxType(project(this->domain(),Ariadne::range(0,this->domain().size()-1))); } - ExactBoxType const codomain() const { return this->ValidatedVectorFunctionModelDP::codomain(); } + ExactBoxType const codomain() const { return this->ValidatedVectorMultivariateFunctionModelDP::codomain(); } }; struct TransitionData; @@ -217,7 +217,7 @@ class HybridEvolverBase virtual Void _evolution_step(EvolutionData& evolution_data, - EffectiveVectorFunction const& dynamic, + EffectiveVectorMultivariateFunction const& dynamic, Map const& transitions, Real const& final_time) const; @@ -235,8 +235,8 @@ class HybridEvolverBase //! defined on a domain \f$B\times [0,h]\f$, where \f$B\f$ is the bounding //! box for the set, and \f$h\f$ is the step size actually used. virtual - ValidatedVectorFunctionModelDP - _compute_flow(EffectiveVectorFunction vector_field, + ValidatedVectorMultivariateFunctionModelDP + _compute_flow(EffectiveVectorMultivariateFunction vector_field, ExactBoxType const& initial_set, const StepSizeType& maximum_step_size) const; @@ -249,9 +249,9 @@ class HybridEvolverBase //! compute. virtual Set - _compute_active_events(EffectiveVectorFunction const& dynamic, - Map const& guards, - ValidatedVectorFunctionModelDP const& flow, + _compute_active_events(EffectiveVectorMultivariateFunction const& dynamic, + Map const& guards, + ValidatedVectorMultivariateFunctionModelDP const& flow, HybridEnclosure const& starting_set) const; //! \brief Compute data on how trajectories of the \a flow @@ -271,8 +271,8 @@ class HybridEvolverBase virtual Map _compute_crossings(Set const& active_events, - EffectiveVectorFunction const& dynamic, - Map const& guards, + EffectiveVectorMultivariateFunction const& dynamic, + Map const& guards, FlowFunctionModel const& flow, HybridEnclosure const& initial_set) const; @@ -338,7 +338,7 @@ class HybridEvolverBase virtual Void _apply_reach_step(HybridEnclosure& set, - ValidatedVectorFunctionModelDP const& flow, + ValidatedVectorMultivariateFunctionModelDP const& flow, TimingData const& timing_data) const; //! \brief Apply the \a flow to the \a set for the time specified by \a timing_data @@ -346,7 +346,7 @@ class HybridEvolverBase virtual Void _apply_evolve_step(HybridEnclosure& set, - ValidatedVectorFunctionModelDP const& flow, + ValidatedVectorMultivariateFunctionModelDP const& flow, TimingData const& timing_data) const; //! \brief Apply the \a flow to the \a set for to reach the @@ -358,8 +358,8 @@ class HybridEvolverBase virtual Void _apply_guard_step(HybridEnclosure& set, - EffectiveVectorFunction const& dynamic, - ValidatedVectorFunctionModelDP const& flow, + EffectiveVectorMultivariateFunction const& dynamic, + ValidatedVectorMultivariateFunctionModelDP const& flow, TimingData const& timing_data, TransitionData const& transition_data, CrossingData const& crossing_data, @@ -382,9 +382,9 @@ class HybridEvolverBase virtual Void _apply_guard(List& sets, - const ValidatedScalarFunctionModelDP& sets_elapsed_time, + const ValidatedScalarMultivariateFunctionModelDP& sets_elapsed_time, const HybridEnclosure& starting_set, - const ValidatedVectorFunctionModelDP& flow, + const ValidatedVectorMultivariateFunctionModelDP& flow, const TransitionData& transition_data, const CrossingData crossing_data, const Semantics semantics) const; @@ -432,10 +432,10 @@ class HybridEvolverBase Void _apply_evolution_step(EvolutionData& evolution_data, HybridEnclosure const& starting_set, - ValidatedVectorFunctionModelDP const& flow, + ValidatedVectorMultivariateFunctionModelDP const& flow, TimingData const& timing_data, Map const& crossing_data, - EffectiveVectorFunction const& dynamic, + EffectiveVectorMultivariateFunction const& dynamic, Map const& transitions) const; //! \brief Output a one-line summary of the current evolution state to the logging stream. @@ -471,17 +471,17 @@ struct TransitionData EventKind event_kind; //! \brief The guard function of the event, the event being active when //! \f$g(x)\geq0\f$. - EffectiveScalarFunction guard_function; + EffectiveScalarMultivariateFunction guard_function; //! \brief The Lie derivative of the guard function along the flow. - EffectiveScalarFunction guard_flow_derivative_function; + EffectiveScalarMultivariateFunction guard_flow_derivative_function; //! \brief The target location of the transition. DiscreteLocation target; //! \brief The reset function \f$x'=r(x)\f$ of the transition. - EffectiveVectorFunction reset_function; + EffectiveVectorMultivariateFunction reset_function; //! \brief The state space in the target location. RealSpace target_space; //TransitionData() { } - //TransitionData(DiscreteLocation t, ValidatedScalarFunction g, ValidatedVectorFunction r) + //TransitionData(DiscreteLocation t, ValidatedScalarMultivariateFunction g, ValidatedVectorMultivariateFunction r) // : target(t), guard_function(g), reset_function(r) { } }; OutputStream& operator<<(OutputStream& os, const TransitionData& transition); @@ -541,7 +541,7 @@ struct CrossingData { CrossingData() : crossing_kind() { } CrossingData(CrossingKind crk) : crossing_kind(crk) { } - CrossingData(CrossingKind crk, const ValidatedScalarFunctionModelDP& crt) + CrossingData(CrossingKind crk, const ValidatedScalarMultivariateFunctionModelDP& crt) : crossing_kind(crk), crossing_time(crt) { } //! \brief The way in which the guard function changes along trajectories DirectionKind direction_kind; @@ -552,10 +552,10 @@ struct CrossingData ExactIntervalType crossing_time_range; //! \brief The time \f$\gamma(x)\f$ at which the crossing occurs, //! as a function of the initial point in space. Satisfies \f$g(\phi(x,\gamma(x)))=0\f$. - ValidatedScalarFunctionModelDP crossing_time; + ValidatedScalarMultivariateFunctionModelDP crossing_time; //! \brief The time \f$\mu(x)\f$ at which the guard function reaches a maximum or minimum //! i.e. \f$L_{f}g(\phi(x,\mu(x))) = 0\f$. - ValidatedScalarFunctionModelDP critical_time; + ValidatedScalarMultivariateFunctionModelDP critical_time; }; OutputStream& operator<<(OutputStream& os, const CrossingData& crk); @@ -608,18 +608,18 @@ struct TimingData FinishingKind finishing_kind; //!< The relationship between the finishing time of the step, and the final time of the evolution trace. Real final_time; //!< The time \f$t_{\max}\f$ specified as the final time of the evolution trace. FloatDPValue step_size; //!< The maximum step size \f$h\f$ allowed by the computed flow function. - ValidatedScalarFunctionModelDP spacetime_dependent_evolution_time; + ValidatedScalarMultivariateFunctionModelDP spacetime_dependent_evolution_time; //!< The evolution time \f$\varepsilon(x,t)\f$ used in a \a SPACETIME_DEPENDENT_EVOLUTION_TIME step. - ValidatedScalarFunctionModelDP spacetime_dependent_finishing_time; + ValidatedScalarMultivariateFunctionModelDP spacetime_dependent_finishing_time; //!< The final time \f$\omega(x,t)\f$ used in a \a SPACETIME_DEPENDENT_FINISHING_TIME step. - ValidatedScalarFunctionModelDP parameter_dependent_finishing_time; + ValidatedScalarMultivariateFunctionModelDP parameter_dependent_finishing_time; //!< The time \f$\omega(s)\f$ reached after an \a PARAMETER_DEPENDENT_FINISHING_TIME as a function of the parameters. - ValidatedScalarFunctionModelDP parameter_dependent_evolution_time; + ValidatedScalarMultivariateFunctionModelDP parameter_dependent_evolution_time; //!< The time \f$\delta(s)\f$ used in a \a PARAMETER_DEPENDENT_EVOLUTION_TIME step. //! Set equal to \f$\varepsilon(\xi(s))\f$ for a \a SPACE_DEPENDENT_EVOLUTION_TIME //! and \f$\omega(s)-\varepsilon(s)\f$ for an \a PARAMETER_DEPENDENT_FINISHING_TIME. ExactIntervalType evolution_time_domain; //!< The time domain of the flow function, equal to \f$[0,h]\f$. - ValidatedScalarFunctionModelDP evolution_time_coordinate; //!< The time coordinate of the flow function, equal to the identity on \f$[0,h]\f$. + ValidatedScalarMultivariateFunctionModelDP evolution_time_coordinate; //!< The time coordinate of the flow function, equal to the identity on \f$[0,h]\f$. }; OutputStream& operator<<(OutputStream& os, const TimingData& timing); diff --git a/source/hybrid/hybrid_simulator.cpp b/source/hybrid/hybrid_simulator.cpp index 34036806e..a5c076426 100644 --- a/source/hybrid/hybrid_simulator.cpp +++ b/source/hybrid/hybrid_simulator.cpp @@ -68,9 +68,9 @@ Void HybridSimulator::set_step_size(double h) namespace { -Map guard_functions(const HybridAutomatonInterface& system, const DiscreteLocation& location) { +Map guard_functions(const HybridAutomatonInterface& system, const DiscreteLocation& location) { Set events=system.events(location); - Map guards; + Map guards; for(Set::ConstIterator iter=events.begin(); iter!=events.end(); ++iter) { guards.insert(*iter,system.guard_function(location,*iter)); } @@ -89,8 +89,8 @@ ApproximatePoint make_point(const HybridApproximatePoint& hpt, const RealSpace& } -inline FloatDPApproximation evaluate(const EffectiveScalarFunction& f, const Vector& x) { return f(x); } -inline Vector evaluate(const EffectiveVectorFunction& f, const Vector& x) { return f(x); } +inline FloatDPApproximation evaluate(const EffectiveScalarMultivariateFunction& f, const Vector& x) { return f(x); } +inline Vector evaluate(const EffectiveVectorMultivariateFunction& f, const Vector& x) { return f(x); } Orbit HybridSimulator::orbit(const HybridAutomatonInterface& system, const HybridRealPoint& init_pt, const HybridTime& tmax) const @@ -112,14 +112,14 @@ HybridSimulator::orbit(const HybridAutomatonInterface& system, const HybridAppro Orbit orbit(HybridApproximatePoint(location,space,cast_exact(point))); - EffectiveVectorFunction dynamic=system.dynamic_function(location); - Map guards=guard_functions(system,location); + EffectiveVectorMultivariateFunction dynamic=system.dynamic_function(location); + Map guards=guard_functions(system,location); while(possibly(check(t::ConstIterator guard_iter=guards.begin(); guard_iter!=guards.end(); ++guard_iter) { + for(Map::ConstIterator guard_iter=guards.begin(); guard_iter!=guards.end(); ++guard_iter) { if(probably(evaluate(guard_iter->second,point)>0)) { enabled=true; event=guard_iter->first; @@ -129,7 +129,7 @@ HybridSimulator::orbit(const HybridAutomatonInterface& system, const HybridAppro if(enabled) { DiscreteLocation target=system.target(location,event); - EffectiveVectorFunction reset=system.reset_function(location,event); + EffectiveVectorMultivariateFunction reset=system.reset_function(location,event); location=target; space=system.continuous_state_space(location); next_point=reset(point); diff --git a/source/output/drawer.cpp b/source/output/drawer.cpp index df5c85e40..129b99ea8 100644 --- a/source/output/drawer.cpp +++ b/source/output/drawer.cpp @@ -40,7 +40,7 @@ namespace Ariadne { Void box_draw(CanvasInterface& cnvs, const Projection2d& proj, const ValidatedConstrainedImageSet& set); Void affine_draw(CanvasInterface& cnvs, const Projection2d& proj, const ValidatedConstrainedImageSet& set, Nat splittings_remaining); -Pair nonlinearity_index_and_error(const ValidatedVectorFunction& function, const ExactBoxType& domain); +Pair nonlinearity_index_and_error(const ValidatedVectorMultivariateFunction& function, const ExactBoxType& domain); Void SubdivisionDrawer::draw(CanvasInterface& cnvs, const Projection2d& proj, const ValidatedConstrainedImageSet& set) const { ARIADNE_NOT_IMPLEMENTED; } @@ -82,12 +82,12 @@ Void EnclosureAffineDrawer::draw(CanvasInterface& canvas, const Projection2d& pr return; } - ValidatedVectorFunction fg(2u+set.number_of_constraints(),set.domain()); + ValidatedVectorMultivariateFunction fg(2u+set.number_of_constraints(),set.domain()); fg[0]=set.function()[projection.i]; fg[1]=set.function()[projection.i]; for(Nat i=0; i!=set.constraints().size(); ++i) { fg[i+2u]=set.constraints()[i].function(); } Projection2d identity(2, 0,1); -// ValidatedVectorFunctionModelDP fg=join(set.state_function(),set.time_function(),set.constraint_function()); +// ValidatedVectorMultivariateFunctionModelDP fg=join(set.state_function(),set.time_function(),set.constraint_function()); List subdomains; List unsplitdomains; diff --git a/source/solvers/constraint_solver.cpp b/source/solvers/constraint_solver.cpp index 39ac07a7c..26dabd2d3 100644 --- a/source/solvers/constraint_solver.cpp +++ b/source/solvers/constraint_solver.cpp @@ -79,7 +79,7 @@ Pair ConstraintSolver::feasible(const ExactBoxType { if(constraints.empty()) { return make_pair(!domain.is_empty(),domain.midpoint()); } - ValidatedVectorFunction function(constraints.size(),constraints[0].function().domain()); + ValidatedVectorMultivariateFunction function(constraints.size(),constraints[0].function().domain()); ExactBoxType bounds(constraints.size()); for(Nat i=0; i!=constraints.size(); ++i) { @@ -90,7 +90,7 @@ Pair ConstraintSolver::feasible(const ExactBoxType } -Pair ConstraintSolver::feasible(const ExactBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const +Pair ConstraintSolver::feasible(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const { static const FloatDPValue XSIGMA=0.125_exact; @@ -125,7 +125,7 @@ Pair ConstraintSolver::feasible(const ExactBoxType FloatApproximationVector slack(l); // The slack between the test point and the violated constraints FloatDPApproximation& t=violation; FloatApproximationVector& x=multipliers; FloatApproximationVector& y=point; FloatApproximationVector& z=slack; // Aliases for the main quantities used - const ExactBoxType& d=domain; const ValidatedVectorFunction& fn=function; const ExactBoxType& c=codomain; // Aliases for the main quantities used + const ExactBoxType& d=domain; const ValidatedVectorMultivariateFunction& fn=function; const ExactBoxType& c=codomain; // Aliases for the main quantities used ValidatedVectorTaylorFunctionModelDP tfn(d,fn,default_sweeper()); point=static_cast(midpoint(d)); @@ -201,7 +201,7 @@ Pair ConstraintSolver::feasible(const ExactBoxType } -Bool ConstraintSolver::reduce(UpperBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const +Bool ConstraintSolver::reduce(UpperBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const { const FloatDP MINIMUM_REDUCTION = 0.75; ARIADNE_ASSERT(function.argument_size()==domain.size()); @@ -302,9 +302,9 @@ Bool ConstraintSolver::hull_reduce(UpperBoxType& domain, const Vector formula=function.evaluate(Formula::identity(function.argument_size())); @@ -312,9 +312,9 @@ Bool ConstraintSolver::hull_reduce(UpperBoxType& domain, const ValidatedScalarFu return this->hull_reduce(domain,procedure,bounds); } -Bool ConstraintSolver::hull_reduce(UpperBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& bounds) const +Bool ConstraintSolver::hull_reduce(UpperBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& bounds) const { - ARIADNE_LOG(2,"ConstraintSolver::hull_reduce(ExactBoxType domain, ValidatedScalarFunction function, ExactIntervalType bounds): " + ARIADNE_LOG(2,"ConstraintSolver::hull_reduce(ExactBoxType domain, ValidatedScalarMultivariateFunction function, ExactIntervalType bounds): " "function="< > formula=function.evaluate(Formula::identity(function.argument_size())); @@ -322,9 +322,9 @@ Bool ConstraintSolver::hull_reduce(UpperBoxType& domain, const ValidatedVectorFu return this->hull_reduce(domain,procedure,bounds); } -Bool ConstraintSolver::monotone_reduce(UpperBoxType& domain, const ValidatedScalarFunction& function, const ExactIntervalType& bounds, Nat variable) const +Bool ConstraintSolver::monotone_reduce(UpperBoxType& domain, const ValidatedScalarMultivariateFunction& function, const ExactIntervalType& bounds, Nat variable) const { - ValidatedScalarFunction derivative=function.derivative(variable); + ValidatedScalarMultivariateFunction derivative=function.derivative(variable); ARIADNE_LOG(2,"ConstraintSolver::monotone_reduce(ExactBoxType domain): function="< ConstraintSolver::split(const UpperBoxType& d, const ValidatedVectorFunction& f, const ExactBoxType& c) const +Pair ConstraintSolver::split(const UpperBoxType& d, const ValidatedVectorMultivariateFunction& f, const ExactBoxType& c) const { return d.split(); } -ValidatedKleenean ConstraintSolver::check_feasibility(const ExactBoxType& d, const ValidatedVectorFunction& f, const ExactBoxType& c, const ExactPoint& y) const +ValidatedKleenean ConstraintSolver::check_feasibility(const ExactBoxType& d, const ValidatedVectorMultivariateFunction& f, const ExactBoxType& c, const ExactPoint& y) const { for(Nat i=0; i!=y.size(); ++i) { if(y[i]d[i].upper()) { return false; } diff --git a/source/solvers/constraint_solver.hpp b/source/solvers/constraint_solver.hpp index 4f8c4f46a..90c54af3d 100644 --- a/source/solvers/constraint_solver.hpp +++ b/source/solvers/constraint_solver.hpp @@ -63,11 +63,11 @@ template struct FeasibilityState { class ConstraintSolverInterface { public: //! \brief Test if the image of the box \a domain under the function \a function intersects \a codomain. - virtual Pair feasible(const ExactBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const = 0; + virtual Pair feasible(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const = 0; //! \brief Test if \a point is in \a domain and the image of \a point under the function \a function lies in \a codomain. - virtual ValidatedKleenean check_feasibility(const ExactBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain, const ExactPoint& point) const = 0; + virtual ValidatedKleenean check_feasibility(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain, const ExactPoint& point) const = 0; //! \brief Try to reduce the size of the domain by propagating interval constraints. Returns \c true if the reduced domain is empty. - virtual Bool reduce(UpperBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const = 0; + virtual Bool reduce(UpperBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const = 0; }; @@ -80,11 +80,11 @@ class ConstraintSolver { public: //! \brief Test if the image of the box \a domain under the function \a function intersects \a codomain. - virtual Pair feasible(const ExactBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const; + virtual Pair feasible(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const; //! \brief Test if \a point is in \a domain and the image of \a point under the function \a function lies in \a codomain. - virtual ValidatedKleenean check_feasibility(const ExactBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain, const ExactPoint& point) const; + virtual ValidatedKleenean check_feasibility(const ExactBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain, const ExactPoint& point) const; //! \brief Try to reduce the size of the domain by propagating interval constraints. - virtual Bool reduce(UpperBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const; + virtual Bool reduce(UpperBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const; //! \brief Test if the constraints are solvable using a nonlinear feasibility test. Returns an approximate feasible point if the result is true. (Deprecated) @@ -94,11 +94,11 @@ class ConstraintSolver //! \brief Try to enforce hull consistency by propagating several interval constraints at once. //! This method is sharp if each variable occurs at most once in the constraint. - Bool hull_reduce(UpperBoxType& bx, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const; + Bool hull_reduce(UpperBoxType& bx, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const; Bool hull_reduce(UpperBoxType& bx, const Vector& procedure, const ExactBoxType& codomain) const; //! \brief Try to enforce hull consistency by propagating an interval constraint. //! This method is sharp if each variable occurs at most once in the constraint. - Bool hull_reduce(UpperBoxType& bx, const ValidatedScalarFunction& function, const ExactIntervalType& codomain) const; + Bool hull_reduce(UpperBoxType& bx, const ValidatedScalarMultivariateFunction& function, const ExactIntervalType& codomain) const; Bool hull_reduce(UpperBoxType& bx, const ValidatedProcedure& procedure, const ExactIntervalType& codomain) const; //! \brief Reduce the \a domain by testing intersection of \a multipliers inner product \a function(\a domain) @@ -109,13 +109,13 @@ class ConstraintSolver Bool lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType& codomain, Vector centre, Vector multpliers) const; //! \brief Try to enforce hull consistency by reducing a constraint with respect to one variable. - Bool box_reduce(UpperBoxType& bx, const ValidatedScalarFunction& function, const ExactIntervalType&, Nat j) const; + Bool box_reduce(UpperBoxType& bx, const ValidatedScalarMultivariateFunction& function, const ExactIntervalType&, Nat j) const; //! \brief Try to enforce hull consistency by reducing an a monotone dimension. //! This method is sharp if each variable occurs at most once in the constraint. - Bool monotone_reduce(UpperBoxType& bx, const ValidatedScalarFunction& function, const ExactIntervalType&, Nat j) const; + Bool monotone_reduce(UpperBoxType& bx, const ValidatedScalarMultivariateFunction& function, const ExactIntervalType&, Nat j) const; //! Split the domain into two pieces to help try to solve the constraints. - Pair split(const UpperBoxType& domain, const ValidatedVectorFunction& function, const ExactBoxType& codomain) const; + Pair split(const UpperBoxType& domain, const ValidatedVectorMultivariateFunction& function, const ExactBoxType& codomain) const; // Deprecated functions. Bool hull_reduce(UpperBoxType& bx, const ValidatedConstraint& constraint) const { diff --git a/source/solvers/integrator.cpp b/source/solvers/integrator.cpp index c38cf14a0..2e1623ccd 100644 --- a/source/solvers/integrator.cpp +++ b/source/solvers/integrator.cpp @@ -92,9 +92,9 @@ IntegratorBase::function_factory() const } Pair -IntegratorBase::flow_bounds(const ValidatedVectorFunction& vf, const ExactBoxType& domx, const StepSizeType& hsug) const +IntegratorBase::flow_bounds(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& domx, const StepSizeType& hsug) const { - ARIADNE_LOG(3,"IntegratorBase::flow_bounds(ValidatedVectorFunction vf, ExactBoxType domx, StepSizeType hmax)\n"); + ARIADNE_LOG(3,"IntegratorBase::flow_bounds(ValidatedVectorMultivariateFunction vf, ExactBoxType domx, StepSizeType hmax)\n"); ARIADNE_ASSERT_MSG(vf.result_size()==domx.size(),"vector_field="<function_factory().create_identity(dx0); + ValidatedVectorMultivariateFunctionModelDP flow_function=this->function_factory().create_identity(dx0); StepSizeType t=0; - ValidatedVectorFunctionModelDP step_function; + ValidatedVectorMultivariateFunctionModelDP step_function; StepSizeType tmaxu = tmax.compute(Effort(0)).get().upper_raw(); while(t -IntegratorBase::flow(const ValidatedVectorFunction& vf, const ExactBoxType& dx0, const Real& tmin, const Real& tmax) const +List +IntegratorBase::flow(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& dx0, const Real& tmin, const Real& tmax) const { - ARIADNE_LOG(1,"IntegratorBase::flow(ValidatedVectorFunction vf, ExactBoxType dx0, Real tmin, Real tmax)\n"); + ARIADNE_LOG(1,"IntegratorBase::flow(ValidatedVectorMultivariateFunction vf, ExactBoxType dx0, Real tmin, Real tmax)\n"); StepSizeType tminl = tmin.compute(Effort(0)).get().lower_raw(); StepSizeType tmaxu = tmax.compute(Effort(0)).get().upper_raw(); - ValidatedVectorFunctionModelDP evolve_function=this->flow_to(vf,dx0,tmin); + ValidatedVectorMultivariateFunctionModelDP evolve_function=this->flow_to(vf,dx0,tmin); StepSizeType t=tminl; - List result; + List result; while(possibly(tflow_bounds(vf,dx,h); - ValidatedVectorFunctionModelDP flow_step_function=this->flow_step(vf,dx,h,bx); + ValidatedVectorMultivariateFunctionModelDP flow_step_function=this->flow_step(vf,dx,h,bx); StepSizeType new_t=t+h; ExactIntervalType dt(t,new_t); - ValidatedScalarFunctionModelDP step_time_function=this->function_factory().create_identity(dt)-t; - ValidatedVectorFunctionModelDP flow_function=compose(flow_step_function,combine(evolve_function,step_time_function)); + ValidatedScalarMultivariateFunctionModelDP step_time_function=this->function_factory().create_identity(dt)-t; + ValidatedVectorMultivariateFunctionModelDP flow_function=compose(flow_step_function,combine(evolve_function,step_time_function)); ARIADNE_ASSERT(flow_function.domain()[dx0.size()].upper()==new_t); result.append(flow_function); // FIXME: @@ -248,18 +248,18 @@ IntegratorBase::flow(const ValidatedVectorFunction& vf, const ExactBoxType& dx0, return result; } -List -IntegratorBase::flow(const ValidatedVectorFunction& vf, const ExactBoxType& dx0, const Real& tmax) const +List +IntegratorBase::flow(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& dx0, const Real& tmax) const { return flow(vf,dx0,Real(0),tmax); } -ValidatedVectorFunctionModelDP -IntegratorBase::flow_step(const ValidatedVectorFunction& vf, const ExactBoxType& dx, StepSizeType& hmax) const +ValidatedVectorMultivariateFunctionModelDP +IntegratorBase::flow_step(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& dx, StepSizeType& hmax) const { - ARIADNE_LOG(3,"IntegratorBase::flow_step(ValidatedVectorFunction vf, ExactBoxType dx, StepSizeType hmax)\n"); + ARIADNE_LOG(3,"IntegratorBase::flow_step(ValidatedVectorMultivariateFunction vf, ExactBoxType dx, StepSizeType hmax)\n"); StepSizeType& h=hmax; UpperBoxType bx; make_lpair(h,bx)=this->flow_bounds(vf,dx,hmax); @@ -272,10 +272,10 @@ IntegratorBase::flow_step(const ValidatedVectorFunction& vf, const ExactBoxType& } } -ValidatedVectorFunctionModelDP -TaylorPicardIntegrator::flow_step(const ValidatedVectorFunction& f, const ExactBoxType& dx, const StepSizeType& h, const UpperBoxType& bx) const +ValidatedVectorMultivariateFunctionModelDP +TaylorPicardIntegrator::flow_step(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dx, const StepSizeType& h, const UpperBoxType& bx) const { - ARIADNE_LOG(3,"TaylorPicardIntegrator::flow_step(ValidatedVectorFunction vf, ExactBoxType dx, StepSizeType h, UpperBoxType bx)\n"); + ARIADNE_LOG(3,"TaylorPicardIntegrator::flow_step(ValidatedVectorMultivariateFunction vf, ExactBoxType dx, StepSizeType h, UpperBoxType bx)\n"); ARIADNE_LOG(3," dx="< sweeper(new ThresholdSweeper(dp,this->_step_sweep_threshold)); @@ -283,17 +283,17 @@ TaylorPicardIntegrator::flow_step(const ValidatedVectorFunction& f, const ExactB ExactBoxType dom=join(dx,ExactIntervalType(-h,h)); ARIADNE_LOG(7,"dom="<function_factory().create_zeros(nx,dom); + ValidatedVectorMultivariateFunctionModelDP phi0=this->function_factory().create_zeros(nx,dom); for(Nat i=0; i!=nx; ++i) { phi0[i]=this->function_factory().create_coordinate(dom,i); } ARIADNE_LOG(5,"phi0="<function_factory().create_zeros(nx,dom); + ValidatedVectorMultivariateFunctionModelDP phi=this->function_factory().create_zeros(nx,dom); for(Nat i=0; i!=nx; ++i) { phi[i]=this->function_factory().create_constant(dom,cast_singleton(bx[i])); } ARIADNE_LOG(5,"phi="<_maximum_temporal_order; ++k) { Bool last_step=(phi.error().raw()maximum_error()); - ValidatedVectorFunctionModelDP fphi=compose(f,phi); + ValidatedVectorMultivariateFunctionModelDP fphi=compose(f,phi); ARIADNE_LOG(5,"fphi="<_maximum_temporal_order<<" iterations, which exceeds maximum error "<maximum_error()<<"\n"); } - ValidatedVectorFunctionModelDP res=this->function_factory().create_zeros(nx,dom); + ValidatedVectorMultivariateFunctionModelDP res=this->function_factory().create_zeros(nx,dom); ARIADNE_LOG(4,"res_init="< Void append_join(Expansion& e, const MultiIndex& } -inline Vector formula(const ValidatedVectorFunction& f) { +inline Vector formula(const ValidatedVectorMultivariateFunction& f) { return f.evaluate(ValidatedFormula::identity(f.argument_size())); } @@ -483,8 +483,8 @@ ValidatedVectorTaylorFunctionModelDP flow_function(const Vectorstep_maximum_error(),this->step_sweep_threshold(), this->minimum_spacial_order(),this->minimum_temporal_order(), this->maximum_spacial_order(),this->maximum_temporal_order(),this->verbosity); -// ValidatedVectorFunctionModelDP tphi=Ariadne::differential_space_time_flow_step(f,dx,h,bx, +// ValidatedVectorMultivariateFunctionModelDP tphi=Ariadne::differential_space_time_flow_step(f,dx,h,bx, // this->step_sweep_threshold(),6,4,this->verbosity); if(tphi.error().raw()>this->step_maximum_error()) { @@ -628,7 +628,7 @@ TaylorSeriesIntegrator::flow_step(const ValidatedVectorFunction& f, const ExactB } Pair -TaylorSeriesIntegrator::flow_bounds(const ValidatedVectorFunction& vf, const ExactBoxType& dx, const StepSizeType& hmax) const +TaylorSeriesIntegrator::flow_bounds(const ValidatedVectorMultivariateFunction& vf, const ExactBoxType& dx, const StepSizeType& hmax) const { return this->IntegratorBase::flow_bounds(vf,dx,hmax); } @@ -676,9 +676,9 @@ AffineIntegrator::AffineIntegrator(MaximumError maximum_error_, SpacialOrder spa : IntegratorBase(maximum_error_,lipschitz_constant=0.5), _spacial_order(spacial_order_), _temporal_order(temporal_order_) { } Vector -AffineIntegrator::flow_derivative(const ValidatedVectorFunction& f, const Vector& dom) const +AffineIntegrator::flow_derivative(const ValidatedVectorMultivariateFunction& f, const Vector& dom) const { - ARIADNE_LOG(5,"AffineIntegrator::flow_derivative(ValidatedVectorFunction f, ValidatedBoxType dom)\n"); + ARIADNE_LOG(5,"AffineIntegrator::flow_derivative(ValidatedVectorMultivariateFunction f, ValidatedBoxType dom)\n"); Vector dx= ValidatedDifferential::variables(this->_spacial_order+this->_temporal_order, join(dom,zero)); @@ -691,10 +691,10 @@ AffineIntegrator::flow_derivative(const ValidatedVectorFunction& f, const Vector return dphi; } -ValidatedVectorFunctionModelDP -AffineIntegrator::flow_step(const ValidatedVectorFunction& f, const ExactBoxType& dom, const StepSizeType& h, const UpperBoxType& bbox) const +ValidatedVectorMultivariateFunctionModelDP +AffineIntegrator::flow_step(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom, const StepSizeType& h, const UpperBoxType& bbox) const { - ARIADNE_LOG(3,"AffineIntegrator::flow_step(ValidatedVectorFunction f, ExactBoxType dom, StepSizeType h, UpperBoxType bbox)\n"); + ARIADNE_LOG(3,"AffineIntegrator::flow_step(ValidatedVectorMultivariateFunction f, ExactBoxType dom, StepSizeType h, UpperBoxType bbox)\n"); Vector dmid = Vector(midpoint(dom)); Vector mdphi = this->flow_derivative(f,dmid); @@ -730,10 +730,10 @@ AffineIntegrator::flow_step(const ValidatedVectorFunction& f, const ExactBoxType ExactBoxType flow_domain = join(dom,ExactIntervalType(0,h)); - ValidatedVectorFunctionModelDP id = this->function_factory().create_identity(flow_domain); - ValidatedVectorFunctionModelDP res = this->function_factory().create_zeros(n,flow_domain); + ValidatedVectorMultivariateFunctionModelDP id = this->function_factory().create_identity(flow_domain); + ValidatedVectorMultivariateFunctionModelDP res = this->function_factory().create_zeros(n,flow_domain); for(Nat i=0; i!=n; ++i) { - ValidatedScalarFunctionModelDP res_model = res[i] + mdphi[i].expansion()[MultiIndex::zero(n+1)]; + ValidatedScalarMultivariateFunctionModelDP res_model = res[i] + mdphi[i].expansion()[MultiIndex::zero(n+1)]; for(Nat j=0; j!=mdphi[i].argument_size()-1; ++j) { res_model+=mdphi[i].expansion()[MultiIndex::unit(n+1,j)]*(id[j]-ValidatedNumericType(midpoint(flow_domain[j]))); } Nat j=mdphi[i].argument_size()-1; { res_model+=mdphi[i].expansion()[MultiIndex::unit(n+1,j)]*id[j]; } res_model += FloatDPBounds(-err[i],+err[i]); diff --git a/source/solvers/integrator.hpp b/source/solvers/integrator.hpp index 58a0a4d0c..0d77b5ab7 100644 --- a/source/solvers/integrator.hpp +++ b/source/solvers/integrator.hpp @@ -102,35 +102,35 @@ class IntegratorBase virtual Pair - flow_bounds(const ValidatedVectorFunction& vector_field, + flow_bounds(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& maximum_time_step) const; - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, StepSizeType& suggested_time_step) const; - virtual ValidatedVectorFunctionModelDP - flow_to(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_to(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& time) const; //! \brief Solve \f$\der{\phi}(x,t)=f(\phi(x,t))\f$ for \f$t\in[0,T_{\max}]\f$. - virtual List - flow(const ValidatedVectorFunction& vector_field, + virtual List + flow(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& minimum_time, const Real& maximum_time) const; //! \brief Solve \f$\der{\phi}(x,t)=f(\phi(x,t))\f$ for \f$t\in[0,T_{\max}]\f$. - virtual List - flow(const ValidatedVectorFunction& vector_field, + virtual List + flow(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& maximum_time) const; - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& suggested_time_step, const UpperBoxType& bounding_box) const = 0; @@ -173,8 +173,8 @@ class TaylorPicardIntegrator virtual TaylorPicardIntegrator* clone() const { return new TaylorPicardIntegrator(*this); } virtual Void write(OutputStream& os) const; - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& time_step, const UpperBoxType& bounding_box) const; @@ -232,12 +232,12 @@ class TaylorSeriesIntegrator virtual Void write(OutputStream& os) const; virtual Pair - flow_bounds(const ValidatedVectorFunction& vector_field, + flow_bounds(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& suggested_time_step) const; - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& time_step, const UpperBoxType& bounding_box) const; @@ -267,8 +267,8 @@ class AffineIntegrator virtual AffineIntegrator* clone() const { return new AffineIntegrator(*this); } virtual Void write(OutputStream& os) const; - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& time_step, const UpperBoxType& bounding_box) const; @@ -277,7 +277,7 @@ class AffineIntegrator //! \brief Compute the derivative of the flow of f at time zero within \a dom. Vector - flow_derivative(const ValidatedVectorFunction& f, + flow_derivative(const ValidatedVectorMultivariateFunction& f, const Vector& dom) const; }; diff --git a/source/solvers/integrator_interface.hpp b/source/solvers/integrator_interface.hpp index 4e8f841dc..7979e6e42 100644 --- a/source/solvers/integrator_interface.hpp +++ b/source/solvers/integrator_interface.hpp @@ -74,7 +74,7 @@ class IntegratorInterface //!
//! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain and \f$h_{\max}\f$ is the \a maximum_time_step. virtual Pair - flow_bounds(const ValidatedVectorFunction& vector_field, + flow_bounds(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& maximum_time_step) const = 0; @@ -83,8 +83,8 @@ class IntegratorInterface //! Returns: A validated version \f$\hat{\phi}\f$ of the flow over a short step represented as a single function over a box. //!
//! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain, and \f$h_\mathrm{sug}\f$ is the \a suggested_time_step. - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, StepSizeType& suggested_time_step) const = 0; @@ -97,8 +97,8 @@ class IntegratorInterface //! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain, \f$h\f$ is the \a time_step, and \f$B\f$ is the \a state_bounding_box. //!
//! Throws: A FlowTimeStepException if the flow cannot be computed sufficiently accurately for the given time step. - virtual ValidatedVectorFunctionModelDP - flow_step(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_step(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const StepSizeType& time_step, const UpperBoxType& state_bounding_box) const = 0; @@ -110,8 +110,8 @@ class IntegratorInterface //! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain, and \f$t_f\f$ is the \a final_time. //!
//! Throws: A FlowTimeStepException if the flow cannot be represented as a single function to sufficiently accurately for the given time interval. - virtual ValidatedVectorFunctionModelDP - flow_to(const ValidatedVectorFunction& vector_field, + virtual ValidatedVectorMultivariateFunctionModelDP + flow_to(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& final_time) const = 0; @@ -120,8 +120,8 @@ class IntegratorInterface //! Returns: A validated version of the flow represented as a list of functions whose spacial domains are all \f$D\f$ and whose time domains have union \f$[t_b,t_f]\f$. //!
//! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain, \f$t_b\f$ is the \a beginning_time, and \f$t_f\f$ is the \a final_time. - virtual List - flow(const ValidatedVectorFunction& vector_field, + virtual List + flow(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& beginning_time, const Real& final_time) const = 0; @@ -129,8 +129,8 @@ class IntegratorInterface //! \brief Solve \f$\dt{\phi}(x,t)=f(\phi(x,t))\f$ for initial conditions in \f$x\in D\f$ over the interval \f$[0,t_f]\f$.. //!
//! Arguments: \f$f\f$ is the \a vector_field, \f$D\f$ is the \a state_domain, and \f$t_f\f$ is the \a final_time. - virtual List - flow(const ValidatedVectorFunction& vector_field, + virtual List + flow(const ValidatedVectorMultivariateFunction& vector_field, const ExactBoxType& state_domain, const Real& final_time) const = 0; diff --git a/source/solvers/nonlinear_programming.cpp b/source/solvers/nonlinear_programming.cpp index 206e01e55..59ef8a2b2 100644 --- a/source/solvers/nonlinear_programming.cpp +++ b/source/solvers/nonlinear_programming.cpp @@ -281,7 +281,7 @@ template inline Bool all_greater(const Vector& x, const X& e) { -template Vector< Differential > second_derivative(const ValidatedVectorFunction& f, const Vector& x) { +template Vector< Differential > second_derivative(const ValidatedVectorMultivariateFunction& f, const Vector& x) { Vector< Differential > d=Differential::variables(f.result_size(),f.argument_size(),2); return f.evaluate(d); } @@ -467,7 +467,7 @@ const FloatDPValue OptimiserBase::zero = FloatDPValue(0,dp); const FloatDPValue OptimiserBase::one = FloatDPValue(1,dp); Bool OptimiserBase:: -almost_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, ApproximateVector ax, FloatDPApproximation error) const +almost_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ApproximateVector ax, FloatDPApproximation error) const { ExactVector ex=cast_exact(ax); if(!contains(D,ex)) { return false; } @@ -477,7 +477,7 @@ almost_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, Bool OptimiserBase:: -is_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, ExactVector x) const +is_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x) const { if(!contains(D,x)) { return false; } Vector gx=g(x); @@ -486,7 +486,7 @@ is_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, Exa ValidatedKleenean OptimiserBase:: -contains_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, ValidatedVector X) const +contains_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ValidatedVector X) const { ARIADNE_LOG(4,"OptimiserBase::contains_feasible_point(D,g,C,X):\n"); ARIADNE_LOG(5," D="<0); - ValidatedVectorFunction ge(equality_constraints.size(),g.domain()); + ValidatedVectorMultivariateFunction ge(equality_constraints.size(),g.domain()); ExactIntervalVectorType ce(equality_constraints.size()); for(Nat i=0; i!=ge.result_size(); ++i) { ge[i]=g[equality_constraints[i]]; @@ -572,14 +572,14 @@ contains_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType Bool OptimiserBase:: -validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, +validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x0, ExactVector y0) const { return this->validate_feasibility(D,g,C,x0); } Bool OptimiserBase:: -validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, +validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x0) const { ARIADNE_PRECONDITION(D.size()==g.argument_size()); @@ -611,7 +611,7 @@ validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, Nat k=equalities.size(); Nat n=D.size(); - ValidatedVectorFunction h(equalities.size(),g.domain()); + ValidatedVectorMultivariateFunction h(equalities.size(),g.domain()); ExactFloatVector c(equalities.size()); for(Nat i=0; i!=equalities.size(); ++i) { h[i] = g[equalities[i]]; @@ -684,7 +684,7 @@ validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, Bool OptimiserBase:: -validate_infeasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, +validate_infeasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const { ARIADNE_PRECONDITION(D.size()==g.argument_size()); @@ -723,7 +723,7 @@ validate_infeasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C // FIXME: Look at this code again, especially relating to generalised Lagrange multipliers Bool OptimiserBase:: -is_infeasibility_certificate(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, ExactFloatVector y) const +is_infeasibility_certificate(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactFloatVector y) const { ARIADNE_LOG(2,"OptimiserBase::is_infeasibility_certificate(D,g,C,y)\n"); ARIADNE_LOG(2," D="<minimise(f,D,gh,C); @@ -769,10 +769,10 @@ minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, V ValidatedKleenean OptimiserBase:: -feasible(ExactBoxType D, ValidatedVectorFunction g, ValidatedVectorFunction h) const +feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ValidatedVectorMultivariateFunction h) const { ARIADNE_LOG(2,"OptimiserBase::feasible(D,g,h)\n"); - ValidatedVectorFunction gh=join(g,h); + ValidatedVectorMultivariateFunction gh=join(g,h); ExactBoxType C(gh.result_size(),ExactIntervalType(0,0)); for(Nat i=0; i!=g.result_size(); ++i) { C[i]=ExactIntervalType(-inf,0); } return this->feasible(D,gh,C); @@ -790,7 +790,7 @@ struct NonlinearInfeasibleInteriorPointOptimiser::StepData : public PrimalDualDa }; ValidatedVector NonlinearInfeasibleInteriorPointOptimiser:: -minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const +minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const { ARIADNE_LOG(2,"NonlinearInfeasibleInteriorPointOptimiser::minimise(f,D,g,C)\n"); ARIADNE_LOG(2," f="<setup_feasibility(D,g,R,v); @@ -884,7 +884,7 @@ feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const } Void NonlinearInfeasibleInteriorPointOptimiser:: -setup_feasibility(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, +setup_feasibility(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, StepData& v) const { ExactIntervalType I(-1,+1); @@ -910,7 +910,7 @@ setup_feasibility(const ExactBoxType& D, const ApproximateVectorFunction& g, con Void NonlinearInfeasibleInteriorPointOptimiser::step( - const ApproximateScalarFunction& f, const ExactBoxType& d, const ApproximateVectorFunction& g, const ExactBoxType& c, + const ApproximateScalarMultivariateFunction& f, const ExactBoxType& d, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& c, StepData& v) const { RawFloatVector& w=v.w; RawFloatVector& x=v.x; RawFloatVector& y=v.y; FloatDP& mu=v.mu; @@ -1162,11 +1162,11 @@ NonlinearInfeasibleInteriorPointOptimiser::step( //------- NonlinearInteriorPointOptimiser -----------------------------------// ValidatedVector NonlinearInteriorPointOptimiser:: -minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const +minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const { ARIADNE_LOG(2,"NonlinearInteriorPointOptimiser::minimise(f,D,g,C)\n"); ARIADNE_LOG(3,"f="<::infinity(); @@ -1540,7 +1540,7 @@ NonlinearInteriorPointOptimiser::feasibility_step( /* Void NonlinearInteriorPointOptimiser::linearised_feasibility_step( - const ExactBoxType& d, const ApproximateVectorFunction& g, const ExactBoxType& c, + const ExactBoxType& d, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& c, FloatDP& t, RawFloatVector& x, RawFloatVector& y) const { static const double gamma=1.0/1024; @@ -1660,7 +1660,7 @@ Void NonlinearInteriorPointOptimiser::linearised_feasibility_step( FloatDPApproximation NonlinearInteriorPointOptimiser:: -compute_mu(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, +compute_mu(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, const FloatApproximationVector& x, const FloatApproximationVector& lambda) const { // Compute the relaxation parameter mu as the average of the product of the Lyapunov exponents and constraint satisfactions @@ -1682,7 +1682,7 @@ compute_mu(const ExactBoxType& D, const ApproximateVectorFunction& g, const Exac Void NonlinearInteriorPointOptimiser:: -setup_feasibility(const ExactBoxType& d, const ApproximateVectorFunction& g, const ExactBoxType& c, +setup_feasibility(const ExactBoxType& d, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& c, FloatApproximationVector& x, FloatApproximationVector& y) const { const Nat l=2*(d.size()+c.size()); @@ -1703,13 +1703,13 @@ clone() const } ValidatedVector PenaltyFunctionOptimiser:: -minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const +minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const { ARIADNE_NOT_IMPLEMENTED; } ValidatedKleenean PenaltyFunctionOptimiser:: -feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const +feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const { ARIADNE_LOG(2,"PenaltyFunctionOptimiser::feasible(D,g,C)\n"); ARIADNE_LOG(3,"D="< +struct KuhnTuckerFunctionBody : VectorMultivariateFunctionMixin { - ValidatedScalarFunction f; - Array g; - Array df; - Array > dg; + ValidatedScalarMultivariateFunction f; + Array g; + Array df; + Array > dg; - KuhnTuckerFunctionBody(ValidatedScalarFunction _f, ValidatedVectorFunction _g) { + KuhnTuckerFunctionBody(ValidatedScalarMultivariateFunction _f, ValidatedVectorMultivariateFunction _g) { ARIADNE_ASSERT(_f.argument_size()==_g.argument_size()); const Nat m=_g.argument_size(); const Nat n=_g.result_size(); @@ -2418,7 +2418,7 @@ struct KuhnTuckerFunctionBody : VectorFunctionMixin Void _compute(Vector& res, const Vector& arg) const { @@ -2437,12 +2437,12 @@ struct KuhnTuckerFunctionBody : VectorFunctionMixin +struct FeasibilityKuhnTuckerFunctionBody : VectorMultivariateFunctionMixin { - Array g; - Array > dg; + Array g; + Array > dg; - FeasibilityKuhnTuckerFunctionBody(ValidatedVectorFunction _g) { + FeasibilityKuhnTuckerFunctionBody(ValidatedVectorMultivariateFunction _g) { const Nat m=_g.argument_size(); const Nat n=_g.result_size(); g.resize(n); dg.resize(n); for(Nat j=0; j!=n; ++j) { dg[j].resize(m); } @@ -2451,7 +2451,7 @@ struct FeasibilityKuhnTuckerFunctionBody : VectorFunctionMixin Void _compute(Vector& res, const Vector& arg) const { @@ -2475,16 +2475,16 @@ struct FeasibilityKuhnTuckerFunctionBody : VectorFunctionMixin +struct ConstrainedFeasibilityKuhnTuckerFunctionBody : VectorMultivariateFunctionMixin { Nat m; Nat n; ExactIntervalVectorType d; - Array g; + Array g; ExactIntervalVectorType c; - Array > dg; + Array > dg; - ConstrainedFeasibilityKuhnTuckerFunctionBody(ExactBoxType D, ValidatedVectorFunction _g, ExactBoxType C) { + ConstrainedFeasibilityKuhnTuckerFunctionBody(ExactBoxType D, ValidatedVectorMultivariateFunction _g, ExactBoxType C) { m=_g.argument_size(); n=_g.result_size(); d=D; c=C; @@ -2494,7 +2494,7 @@ struct ConstrainedFeasibilityKuhnTuckerFunctionBody : VectorFunctionMixin Void _compute(Vector& res, const Vector& arg) const { @@ -2529,16 +2529,16 @@ struct ConstrainedFeasibilityKuhnTuckerFunctionBody : VectorFunctionMixin0u); @@ -2669,7 +2669,7 @@ Void KrawczykOptimiser::compute_tz(const ExactBoxType& d, const ValidatedVectorF Void KrawczykOptimiser:: -minimisation_step(const ValidatedScalarFunction& f, const ValidatedVectorFunction& g, +minimisation_step(const ValidatedScalarMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g, ExactIntervalVectorType& x, ExactIntervalVectorType& y, ExactIntervalVectorType& z) const { const Nat m=f.argument_size(); @@ -2694,7 +2694,7 @@ minimisation_step(const ValidatedScalarFunction& f, const ValidatedVectorFunctio -Void KrawczykOptimiser::feasibility_step(const ValidatedVectorFunction& g, +Void KrawczykOptimiser::feasibility_step(const ValidatedVectorMultivariateFunction& g, ExactIntervalVectorType& x, ExactIntervalVectorType& y, ExactIntervalVectorType& z, ExactIntervalType& t) const { ARIADNE_NOT_IMPLEMENTED; @@ -2738,7 +2738,7 @@ Void KrawczykOptimiser::feasibility_step(const ValidatedVectorFunction& g, // Feasibility step for dual (inequality constrained) problem without using slack variables // FIXME: Do we need a slackness parameter mu? Probably not; hopefully the infinities are kept in check... // This method has the advantage of not needing to update the primal variables -Void KrawczykOptimiser::feasibility_step(const ExactBoxType& d, const ValidatedVectorFunction& g, const ExactBoxType& c, +Void KrawczykOptimiser::feasibility_step(const ExactBoxType& d, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& c, ExactIntervalVectorType& y, ExactIntervalType& t) const { const Nat m=d.size(); @@ -2817,7 +2817,7 @@ Void KrawczykOptimiser::feasibility_step(const ExactBoxType& d, const ValidatedV -Void KrawczykOptimiser::feasibility_step(const ExactBoxType& d, const ValidatedVectorFunction& g, const ExactBoxType& c, +Void KrawczykOptimiser::feasibility_step(const ExactBoxType& d, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& c, ExactIntervalVectorType& x, ExactIntervalVectorType& y, ExactIntervalVectorType& z, ExactIntervalType& t) const { const Nat m=d.size(); diff --git a/source/solvers/nonlinear_programming.hpp b/source/solvers/nonlinear_programming.hpp index b9d1c4396..20aa2864a 100644 --- a/source/solvers/nonlinear_programming.hpp +++ b/source/solvers/nonlinear_programming.hpp @@ -63,36 +63,36 @@ class OptimiserInterface { virtual OptimiserInterface* clone() const = 0; //! \brief Solve the general nonlinear programming problem \f$\min f(x) \text{ such that } x\in D \text{ and } g(x)\in C\f$. - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const = 0; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const = 0; //! \brief Solve the standard nonlinear programming problem \f$\min f(x) \text{ such that } x\in ,D\ g(x)\leq 0 \text{ and } h(x) = 0\f$. - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ValidatedVectorFunction h) const = 0; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ValidatedVectorMultivariateFunction h) const = 0; //! \brief Tests is the general nonlinear feasibility problem \f$x\in D \text{ and } g(x)\in C\f$ is feasible. - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const = 0; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const = 0; //! \brief Tests is the standard nonlinear feasibility problem \f$x\in D,\ g(x)\leq 0 \text{ and } h(x) = 0\f$ is feasible. Assumes \fD\f$ is singleton with nonempty interior. //! \internal This is one of the simplest nonlinear programming problems, and is a good test case for new algorithms. - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ValidatedVectorFunction h) const = 0; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ValidatedVectorMultivariateFunction h) const = 0; //! \brief Tests if the point \a x is feasible, in that \f$x\in D\f$ and \f$g(x)\in N_\epsilon(C)\f$. - virtual Bool almost_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool almost_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, FloatApproximationVector x, FloatDPApproximation eps) const = 0; //! \brief Tests if the point \a x is feasible. - virtual Bool is_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool is_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactFloatVector x) const = 0; //! \brief Tests if the point \a x is near feasible. - virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x) const = 0; //! \brief Tests if the point \a x is near feasible, using approximate multipliers \a y to guide the search. - virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const = 0; //! \brief Tests if the feasibility problem is definitely unsolvable, using multipliers \a y and local centering point \a x. - virtual Bool validate_infeasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_infeasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const = 0; //! \brief Tests if the box \a X definitely containss a feasible point. - virtual ValidatedKleenean contains_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual ValidatedKleenean contains_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, FloatBoundsVector X) const = 0; //! \brief Tests if the Lagrange multipliers \a y are a certificate of infeasiblity. - virtual Bool is_infeasibility_certificate(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool is_infeasibility_certificate(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector y) const = 0; }; @@ -106,25 +106,25 @@ class OptimiserBase static const FloatDPValue zero; static const FloatDPValue one; public: - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const = 0; - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ValidatedVectorFunction h) const; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const = 0; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ValidatedVectorMultivariateFunction h) const; - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const = 0; - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ValidatedVectorFunction h) const; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const = 0; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ValidatedVectorMultivariateFunction h) const; - virtual Bool almost_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool almost_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ApproximateVector x, FloatDPApproximation error) const; - virtual Bool is_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool is_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x) const; - virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x) const; - virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const; - virtual Bool validate_infeasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool validate_infeasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const; - virtual ValidatedKleenean contains_feasible_point(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual ValidatedKleenean contains_feasible_point(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ValidatedVector X) const; - virtual Bool is_infeasibility_certificate(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + virtual Bool is_infeasibility_certificate(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector lambda) const; }; @@ -143,14 +143,14 @@ class PenaltyFunctionOptimiser using OptimiserBase::feasible; public: virtual PenaltyFunctionOptimiser* clone() const; - virtual ValidatedKleenean check_feasibility(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, ExactVector x, ExactVector y) const; - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; - virtual Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + virtual ValidatedKleenean check_feasibility(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, ExactVector x, ExactVector y) const; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; + virtual Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& w, FloatDPApproximation& mu) const; - virtual Void feasibility_step(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + virtual Void feasibility_step(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, FloatBoundsVector& x, FloatBoundsVector& w) const; - virtual Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + virtual Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& y, FloatApproximationVector& z) const; }; @@ -176,20 +176,20 @@ class NonlinearInfeasibleInteriorPointOptimiser //! \brief Compute a \em local optimum of linear programming problem \f$\max f(x) \text{ such that } x\in D, g(x)\in C \text{ and } h(x)=0.\f$. //! \precondition The domain \f$D\f$ is singleton and has nonempty interior, and the codomain \f$C\f$ is nonempty. //! \return A box \f$X\f$ which definitely contains a feasible point, and contains a local optimum. - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; //! \brief Tests is the nonlinear programming problem \f$x\in D \text{ and } g(x)\in C\f$ is feasible. - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; //! \brief Test if the constraints \f$g(x)\in C\f$ are solvable for \f$x\in D\f$ using a nonlinear feasibility test, //! hotstarting the method with the overall primal and dual variables. - Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, const PrimalDualData& wxy0) const; - Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, StepData& stp) const; - Void step(const ApproximateScalarFunction& f, const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void step(const ApproximateScalarMultivariateFunction& f, const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, StepData& stp) const; -// FloatDPApproximation compute_mu(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, +// FloatDPApproximation compute_mu(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, // FloatApproximationVector& w, FloatApproximationVector& x, FloatApproximationVector& y) const; }; @@ -208,48 +208,48 @@ class NonlinearInteriorPointOptimiser //! \brief Compute a \em local optimum of linear programming problem \f$\max f(x) \text{ such that } x\in D, g(x)\in C \text{ and } h(x)=0.\f$. //! \precondition The domain \f$D\f$ is singleton and has nonempty interior, and the codomain \f$C\f$ is nonempty. //! \return A box \f$X\f$ which definitely contains a feasible point, and contains a local optimum. - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; //! \brief Tests is the nonlinear programming problem \f$x\in D, g(x)\in C \text{ and } h(x)= 0 \f$ is feasible. - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; //! \brief Test if the constraints \f$g(y)\in C\f$ are solvable for \f$y\in D\f$ using a nonlinear feasibility test, //! hotstarting the method with the overall constraint violation, primal and dual variables. - Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, const FloatApproximationVector& x0, const FloatApproximationVector& lambda0, const FloatDPApproximation& violation0) const; //! \brief Test if the constraints \f$g(y)\in C\f$ are solvable for \f$y\in D\f$ using a nonlinear feasibility test, //! hotstarting the method with the primal and dual. - Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + Pair feasible_hotstarted(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, const FloatApproximationVector& x0, const FloatApproximationVector& lambda0) const; - Void minimisation_step(const ApproximateScalarFunction& f, const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, const ApproximateVectorFunction& h, + Void minimisation_step(const ApproximateScalarMultivariateFunction& f, const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, const ApproximateVectorMultivariateFunction& h, FloatApproximationVector& x, FloatApproximationVector& w, FloatApproximationVector& kappa, FloatApproximationVector& lambda, const FloatDPApproximation& mu) const; - Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& lambda) const; - Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void setup_feasibility(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& lambda, FloatDPApproximation& t) const; - Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& lambda) const; - Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& lambda, FloatDPApproximation& violation) const; - Void initialise_lagrange_multipliers(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void initialise_lagrange_multipliers(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, const FloatApproximationVector& x, FloatApproximationVector& lambda) const; - FloatDPApproximation compute_mu(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + FloatDPApproximation compute_mu(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, const FloatApproximationVector& x, const FloatApproximationVector& lambda) const; public: // Deprecated - Void compute_tz(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void compute_tz(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatDPApproximation& t, FloatApproximationVector& z) const { } - Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& y, FloatApproximationVector& z, FloatDPApproximation& violation) const { }; - Void linearised_feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void linearised_feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatDPApproximation& slack, FloatApproximationVector& x, FloatApproximationVector& lambda) const { }; - Void linearised_feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void linearised_feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatApproximationVector& y, FloatApproximationVector& z, FloatDPApproximation& t) const { }; private: - FloatDPApproximation compute_mu(const ApproximateScalarFunction& f, const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + FloatDPApproximation compute_mu(const ApproximateScalarMultivariateFunction& f, const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, const FloatApproximationVector& x, const FloatApproximationVector& y) const; - Void compute_violation(const ExactBoxType& D, const ApproximateVectorFunction& g, const ExactBoxType& C, + Void compute_violation(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& g, const ExactBoxType& C, FloatApproximationVector& x, FloatDPApproximation& t) const; }; @@ -260,8 +260,8 @@ class IntervalOptimiser : public NonlinearInteriorPointOptimiser { virtual IntervalOptimiser* clone() const { return new IntervalOptimiser(*this); } - virtual ValidatedKleenean feasible_zero(ExactBoxType D, ValidatedVectorFunction h) const; - Void feasibility_step(const ExactFloatVector& xl, const ExactFloatVector& xu, const ValidatedVectorFunction& h, + virtual ValidatedKleenean feasible_zero(ExactBoxType D, ValidatedVectorMultivariateFunction h) const; + Void feasibility_step(const ExactFloatVector& xl, const ExactFloatVector& xu, const ValidatedVectorMultivariateFunction& h, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& zl, FloatBoundsVector zu, FloatDPBounds& mu) const; }; @@ -270,8 +270,8 @@ class ApproximateOptimiser : public NonlinearInteriorPointOptimiser { virtual ApproximateOptimiser* clone() const { return new ApproximateOptimiser(*this); } - virtual ValidatedKleenean feasible_zero(ExactBoxType D, ValidatedVectorFunction h) const; - Void feasibility_step(const ExactBoxType& D, const ApproximateVectorFunction& h, + virtual ValidatedKleenean feasible_zero(ExactBoxType D, ValidatedVectorMultivariateFunction h) const; + Void feasibility_step(const ExactBoxType& D, const ApproximateVectorMultivariateFunction& h, FloatApproximationVector& X, FloatApproximationVector& Lambda) const; }; @@ -287,37 +287,37 @@ class KrawczykOptimiser virtual KrawczykOptimiser* clone() const { return new KrawczykOptimiser(*this); } //! \brief Solve the linear programming problem \f$\max f(x) \text{ such that } x\in D \text{ and } g(x)\in C\f$. - virtual Vector minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual Vector minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; //! \brief Tests is the nonlinear programming problem \f$x\in D \text{ and } g(x)\in C\f$ is feasible. - virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C) const; + virtual ValidatedKleenean feasible(ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C) const; public: //! \brief Try to solve the nonlinear constraint problem by applying the Krawczyk contractor to the Kuhn-Tucker conditions, //! hotstarting the iteration with the primal and dual variables. - ValidatedKleenean minimise(ValidatedScalarFunction f, ExactBoxType D, ValidatedVectorFunction g, ExactBoxType C, + ValidatedKleenean minimise(ValidatedScalarMultivariateFunction f, ExactBoxType D, ValidatedVectorMultivariateFunction g, ExactBoxType C, const FloatDPBounds& t0, const FloatBoundsVector& x0, const FloatBoundsVector& y0, const FloatBoundsVector& z0) const; //! \brief A primal-dual feasibility step for the problem \f$g(y)\in C;\ y\in D\f$. - Void minimisation_step(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + Void minimisation_step(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& z, FloatDPBounds& t) const; //! \brief A primal-dual feasibility step for the problem \f$g(y)\in C;\ y\in D\f$. - Void feasibility_step(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + Void feasibility_step(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& z, FloatDPBounds& t) const; //! \brief A primal feasibility step for the problem \f$g(y)\in C;\ y\in D\f$. \deprecated - Void feasibility_step(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + Void feasibility_step(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, FloatBoundsVector& y, FloatDPBounds& t) const; //! \brief A feasibility step for the problem \f$g(y)\leq 0\f$. \deprecated - Void feasibility_step(const ValidatedVectorFunction& g, + Void feasibility_step(const ValidatedVectorMultivariateFunction& g, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& z, FloatDPBounds& t) const; //! \brief An optimization step for the problem \f$\max f(y) \text{ s.t. } g(y)\leq 0\f$. \deprecated - Void minimisation_step(const ValidatedScalarFunction& f, const ValidatedVectorFunction& g, + Void minimisation_step(const ValidatedScalarMultivariateFunction& f, const ValidatedVectorMultivariateFunction& g, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& z) const; protected: - Void setup_feasibility(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, + Void setup_feasibility(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, FloatBoundsVector& x, FloatBoundsVector& y, FloatBoundsVector& z, FloatDPBounds& t) const; protected: - Void compute_tz(const ExactBoxType& D, const ValidatedVectorFunction& g, const ExactBoxType& C, const FloatBoundsVector& y, FloatDPBounds& t, FloatBoundsVector& z) const; + Void compute_tz(const ExactBoxType& D, const ValidatedVectorMultivariateFunction& g, const ExactBoxType& C, const FloatBoundsVector& y, FloatDPBounds& t, FloatBoundsVector& z) const; }; */ diff --git a/source/solvers/runge_kutta_integrator.cpp b/source/solvers/runge_kutta_integrator.cpp index 876431947..4dc6ba25e 100644 --- a/source/solvers/runge_kutta_integrator.cpp +++ b/source/solvers/runge_kutta_integrator.cpp @@ -47,7 +47,7 @@ RungeKutta4Integrator::RungeKutta4Integrator(double step_size) } FloatApproximationVector -RungeKutta4Integrator::step(const ApproximateVectorFunction& f, const FloatApproximationVector& x, const FloatDPApproximation& h) const +RungeKutta4Integrator::step(const ApproximateVectorMultivariateFunction& f, const FloatApproximationVector& x, const FloatDPApproximation& h) const { FloatApproximationVector k1=f(x); FloatApproximationVector k2=f(FloatApproximationVector(x+(h/2)*k1)); @@ -58,7 +58,7 @@ RungeKutta4Integrator::step(const ApproximateVectorFunction& f, const FloatAppro } List< Pair > -RungeKutta4Integrator::evolve(const ApproximateVectorFunction& f, const FloatApproximationVector& x0, const FloatDPApproximation& tmax) const +RungeKutta4Integrator::evolve(const ApproximateVectorMultivariateFunction& f, const FloatApproximationVector& x0, const FloatDPApproximation& tmax) const { static const FloatDPApproximation h(this->_step_size,dp); diff --git a/source/solvers/runge_kutta_integrator.hpp b/source/solvers/runge_kutta_integrator.hpp index ffb2d020f..2e0a32141 100644 --- a/source/solvers/runge_kutta_integrator.hpp +++ b/source/solvers/runge_kutta_integrator.hpp @@ -46,10 +46,10 @@ class RungeKutta4Integrator RungeKutta4Integrator(double step_size); FloatApproximationVector - step(const ApproximateVectorFunction& f, const FloatApproximationVector& x, const FloatDPApproximation& h) const; + step(const ApproximateVectorMultivariateFunction& f, const FloatApproximationVector& x, const FloatDPApproximation& h) const; List< Pair > - evolve(const ApproximateVectorFunction& f, const FloatApproximationVector& x0, const FloatDPApproximation& tmax) const; + evolve(const ApproximateVectorMultivariateFunction& f, const FloatApproximationVector& x0, const FloatDPApproximation& tmax) const; private: double _step_size; }; diff --git a/source/solvers/solver.cpp b/source/solvers/solver.cpp index 8c107f60a..9681ecec3 100644 --- a/source/solvers/solver.cpp +++ b/source/solvers/solver.cpp @@ -49,11 +49,11 @@ namespace Ariadne { namespace { -ValidatedVectorFunctionModelDP operator*(const Matrix& A,const ValidatedVectorFunctionModelDP& v) { +ValidatedVectorMultivariateFunctionModelDP operator*(const Matrix& A,const ValidatedVectorMultivariateFunctionModelDP& v) { ARIADNE_ASSERT(v.size()!=0); - ValidatedVectorFunctionModelDP r(A.row_size(),factory(v).create_zero()); + ValidatedVectorMultivariateFunctionModelDP r(A.row_size(),factory(v).create_zero()); for(Nat i=0; i!=r.size(); ++i) { - ValidatedScalarFunctionModelDP t=r[i]; + ValidatedScalarMultivariateFunctionModelDP t=r[i]; for(Nat j=0; j!=v.size(); ++j) { t+=A[i][j]*v[j]; } @@ -62,7 +62,7 @@ ValidatedVectorFunctionModelDP operator*(const Matrix& A,c return r; } -FloatDPError sup_error(const ValidatedVectorFunctionModelDP& x) { +FloatDPError sup_error(const ValidatedVectorMultivariateFunctionModelDP& x) { FloatDPError r; r=0u; for(Nat i=0; i!=x.size(); ++i) { r=max(r,x[i].error()); } return r; @@ -96,7 +96,7 @@ SolverBase::function_factory() const Vector -SolverBase::solve(const ValidatedVectorFunction& f, +SolverBase::solve(const ValidatedVectorMultivariateFunction& f, const Vector& ix) const { ExactBoxType bx=cast_exact_box(ix); @@ -104,7 +104,7 @@ SolverBase::solve(const ValidatedVectorFunction& f, } Vector -SolverBase::solve(const ValidatedVectorFunction& f, +SolverBase::solve(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { Set< Vector > r = this->solve_all(f,bx); @@ -116,11 +116,11 @@ SolverBase::solve(const ValidatedVectorFunction& f, Void solve_all(Set< Vector >& r, const SolverInterface& s, - const ValidatedVectorFunction& f, + const ValidatedVectorMultivariateFunction& f, const ExactBoxType& ix); Set< Vector > -SolverBase::solve_all(const ValidatedVectorFunction& f, +SolverBase::solve_all(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { ARIADNE_LOG(5,"SolverBase::solve_all(f,bx): f="< -SolverBase::zero(const ValidatedVectorFunction& f, +SolverBase::zero(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { const FloatDPValue e=this->maximum_error(); @@ -247,19 +247,19 @@ SolverBase::zero(const ValidatedVectorFunction& f, Vector -SolverBase::fixed_point(const ValidatedVectorFunction& f, const ExactBoxType& bx) const +SolverBase::fixed_point(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& bx) const { - ValidatedVectorFunction id=ValidatedVectorFunction::identity(f.argument_size()); + ValidatedVectorMultivariateFunction id=ValidatedVectorMultivariateFunction::identity(f.argument_size()); return this->solve(f-id,bx); } -ValidatedVectorFunctionModelDP -SolverBase::implicit(const ValidatedVectorFunction& f, +ValidatedVectorMultivariateFunctionModelDP +SolverBase::implicit(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& ip, const ExactBoxType& ix) const { - ARIADNE_LOG(4,"SolverBase::implicit(ValidatedVectorFunction f, ExactIntervalVectorType ip, ExactIntervalVectorType ix)\n"); + ARIADNE_LOG(4,"SolverBase::implicit(ValidatedVectorMultivariateFunction f, ExactIntervalVectorType ip, ExactIntervalVectorType ix)\n"); ARIADNE_LOG(5,"f="<maximum_error(); - ValidatedVectorFunctionModelDP id(this->function_factory().create_identity(ip)); - ValidatedVectorFunctionModelDP h(this->function_factory().create_constants(ip,cast_singleton(ix))); - ValidatedVectorFunctionModelDP nh(this->function_factory().create_zeros(n,ip)); - ValidatedVectorFunctionModelDP fnh(this->function_factory().create_zeros(n,ip)); + ValidatedVectorMultivariateFunctionModelDP id(this->function_factory().create_identity(ip)); + ValidatedVectorMultivariateFunctionModelDP h(this->function_factory().create_constants(ip,cast_singleton(ix))); + ValidatedVectorMultivariateFunctionModelDP nh(this->function_factory().create_zeros(n,ip)); + ValidatedVectorMultivariateFunctionModelDP fnh(this->function_factory().create_zeros(n,ip)); Nat steps_remaining=this->maximum_number_of_steps(); Nat number_unrefined=n; @@ -291,7 +291,7 @@ SolverBase::implicit(const ValidatedVectorFunction& f, if(refines(nh[i],h[i])) { is_refinement[i]=true; --number_unrefined; - } else if(definitely(disjoint(ValidatedScalarFunctionModelDP(nh[i]).range(),ix[i]))) { + } else if(definitely(disjoint(ValidatedScalarMultivariateFunctionModelDP(nh[i]).range(),ix[i]))) { ARIADNE_THROW(NoSolutionException,"SolverBase::implicit","No result found in "<implicit(ValidatedVectorFunction(List(1u,f)),ip,ExactBoxType(1u,ix)); + ValidatedVectorMultivariateFunctionModelDP res=this->implicit(ValidatedVectorMultivariateFunction(List(1u,f)),ip,ExactBoxType(1u,ix)); return res[0]; } -ValidatedVectorFunctionModelDP -SolverBase::continuation(const ValidatedVectorFunction& f, +ValidatedVectorMultivariateFunctionModelDP +SolverBase::continuation(const ValidatedVectorMultivariateFunction& f, const Vector& p, const ExactBoxType& ix, const ExactBoxType& ip) const @@ -354,7 +354,7 @@ SolverBase::continuation(const ValidatedVectorFunction& f, Vector -IntervalNewtonSolver::step(const ValidatedVectorFunction& f, +IntervalNewtonSolver::step(const ValidatedVectorMultivariateFunction& f, const Vector& x) const { ARIADNE_LOG(4,"Testing for root in "< -KrawczykSolver::step(const ValidatedVectorFunction& f, +KrawczykSolver::step(const ValidatedVectorMultivariateFunction& f, const Vector& x) const { Matrix I=Matrix::identity(x.size()); @@ -402,7 +402,7 @@ KrawczykSolver::step(const ValidatedVectorFunction& f, Vector -FactoredKrawczykSolver::step(const ValidatedVectorFunction& f, +FactoredKrawczykSolver::step(const ValidatedVectorMultivariateFunction& f, const Vector& x) const { Matrix I=Matrix::identity(x.size()); @@ -428,23 +428,23 @@ FactoredKrawczykSolver::step(const ValidatedVectorFunction& f, } -ValidatedVectorFunctionModelDP -IntervalNewtonSolver::implicit_step(const ValidatedVectorFunction& f, - const ValidatedVectorFunctionModelDP& id, - const ValidatedVectorFunctionModelDP& h) const +ValidatedVectorMultivariateFunctionModelDP +IntervalNewtonSolver::implicit_step(const ValidatedVectorMultivariateFunction& f, + const ValidatedVectorMultivariateFunctionModelDP& id, + const ValidatedVectorMultivariateFunctionModelDP& h) const { const Nat m=id.size(); const Nat n=h.size(); - ARIADNE_LOG(6,"IntervalNewtonSolver::implicit_step(ValidatedVectorFunction f, ValidatedVectorFunctionModelDP id, ValidatedVectorFunctionModelDP h)\n"); + ARIADNE_LOG(6,"IntervalNewtonSolver::implicit_step(ValidatedVectorMultivariateFunction f, ValidatedVectorMultivariateFunctionModelDP id, ValidatedVectorMultivariateFunctionModelDP h)\n"); ARIADNE_LOG(7,"f="< D2f(n,n,zero_function); + ValidatedScalarMultivariateFunction zero_function(f.domain()); + Matrix D2f(n,n,zero_function); for(Nat i=0; i!=n; ++i) { for(Nat j=0; j!=n; ++j) { D2f[i][j]=f[i].derivative(m+j); @@ -453,10 +453,10 @@ IntervalNewtonSolver::implicit_step(const ValidatedVectorFunction& f, ARIADNE_LOG(7,"D2f="< J(n,n,z); + Matrix J(n,n,z); for(Nat i=0; i!=n; ++i) { for(Nat j=0; j!=n; ++j) { J[i][j]=compose(D2f[i][j],idh); @@ -473,10 +473,10 @@ IntervalNewtonSolver::implicit_step(const ValidatedVectorFunction& f, } ARIADNE_LOG(7,"rngJ="< ex(nx); for(Nat i=0; i!=nx; ++i) { ex[i]=x[i].error(); } Vector eix=make_bounds(ex); ARIADNE_LOG(5," ex="< rp(np); for(Nat i=0; i!=np; ++i) { rp[i]=cast_singleton(p[i].range()); } @@ -529,28 +529,28 @@ KrawczykSolver::implicit_step(const ValidatedVectorFunction& f, ARIADNE_LOG(5," M*f(p,mx)="<SolverBase::implicit(f,ip,ix); - ARIADNE_LOG(4,"IntervalNewtonSolver::implicit(ValidatedScalarFunction f, ExactIntervalVectorType P, ExactIntervalType X)\n"); + ARIADNE_LOG(4,"IntervalNewtonSolver::implicit(ValidatedScalarMultivariateFunction f, ExactIntervalVectorType P, ExactIntervalType X)\n"); ARIADNE_LOG(5,"f="<function_factory().create_constant(ip,ix); - ValidatedVectorFunctionModelDP id=this->function_factory().create_identity(ip); - ValidatedScalarFunctionModelDP dh=this->function_factory().create_zero(ip); - ValidatedScalarFunctionModelDP mh=this->function_factory().create_zero(ip); - ValidatedScalarFunctionModelDP nh=this->function_factory().create_zero(ip); - ValidatedScalarFunctionModelDP dfidh=this->function_factory().create_zero(ip); - ValidatedScalarFunctionModelDP fidmh=this->function_factory().create_zero(ip); + ValidatedScalarMultivariateFunctionModelDP h=this->function_factory().create_constant(ip,ix); + ValidatedVectorMultivariateFunctionModelDP id=this->function_factory().create_identity(ip); + ValidatedScalarMultivariateFunctionModelDP dh=this->function_factory().create_zero(ip); + ValidatedScalarMultivariateFunctionModelDP mh=this->function_factory().create_zero(ip); + ValidatedScalarMultivariateFunctionModelDP nh=this->function_factory().create_zero(ip); + ValidatedScalarMultivariateFunctionModelDP dfidh=this->function_factory().create_zero(ip); + ValidatedScalarMultivariateFunctionModelDP fidmh=this->function_factory().create_zero(ip); ARIADNE_LOG(5,"f="<& factory); /*! \brief Solve \f$f(x)=0\f$, starting in the box \a bx. */ - virtual Vector zero(const ValidatedVectorFunction& f,const ExactBoxType& bx) const; + virtual Vector zero(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const; /*! \brief Solve \f$f(x)=0\f$, starting in the box \a bx. */ - virtual Vector fixed_point(const ValidatedVectorFunction& f,const ExactBoxType& bx) const; + virtual Vector fixed_point(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const; /*! \brief Solve \f$f(x)=0\f$, starting in the box \a bx. */ - virtual Vector solve(const ValidatedVectorFunction& f,const ExactBoxType& bx) const; - virtual Vector solve(const ValidatedVectorFunction& f,const Vector& ipt) const; + virtual Vector solve(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const; + virtual Vector solve(const ValidatedVectorMultivariateFunction& f,const Vector& ipt) const; /*! \brief Solve \f$f(a,x)=0\f$ for a in \a par, looking for a solution with x in \a ix. */ - virtual ValidatedVectorFunctionModelDP implicit(const ValidatedVectorFunction& f, const ExactBoxType& par, const ExactBoxType& ix) const; + virtual ValidatedVectorMultivariateFunctionModelDP implicit(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& par, const ExactBoxType& ix) const; /*! \brief Solve \f$f(a,x)=0\f$ for a in \a par, looking for a solution with x in \a ix. */ - virtual ValidatedScalarFunctionModelDP implicit(const ValidatedScalarFunction& f, const ExactBoxType& par, const ExactIntervalType& ix) const; + virtual ValidatedScalarMultivariateFunctionModelDP implicit(const ValidatedScalarMultivariateFunction& f, const ExactBoxType& par, const ExactIntervalType& ix) const; //! \brief Solve \f$f(a,x)=0\f$ yielding a function \f$x=h(a)\f$ for a in \a A, looking for a solution with \f$h(A) \subset X\f$ and $h(a)\in x\f$. - virtual ValidatedVectorFunctionModelDP continuation(const ValidatedVectorFunction& f, const Vector& a, const ExactBoxType& X, const ExactBoxType& A) const; + virtual ValidatedVectorMultivariateFunctionModelDP continuation(const ValidatedVectorMultivariateFunction& f, const Vector& a, const ExactBoxType& X, const ExactBoxType& A) const; /*! \brief Solve \f$f(x)=0\f$, starting in the interval point \a pt. */ - virtual Set< Vector > solve_all(const ValidatedVectorFunction& f,const ExactBoxType& bx) const; + virtual Set< Vector > solve_all(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const; protected: /*! \brief Perform one iterative step of the contractor. */ - virtual Vector step(const ValidatedVectorFunction& f,const Vector& pt) const = 0; + virtual Vector step(const ValidatedVectorMultivariateFunction& f,const Vector& pt) const = 0; /*! \brief Perform one iterative step of the contractor. */ - virtual ValidatedVectorFunctionModelDP implicit_step(const ValidatedVectorFunction& f,const ValidatedVectorFunctionModelDP& p,const ValidatedVectorFunctionModelDP& x) const = 0; + virtual ValidatedVectorMultivariateFunctionModelDP implicit_step(const ValidatedVectorMultivariateFunction& f,const ValidatedVectorMultivariateFunctionModelDP& p,const ValidatedVectorMultivariateFunctionModelDP& x) const = 0; private: FloatDPValue _max_error; Nat _max_steps; @@ -118,9 +118,9 @@ class IntervalNewtonSolver using SolverBase::implicit; public: - virtual ValidatedVectorFunctionModelDP implicit_step(const ValidatedVectorFunction& f, const ValidatedVectorFunctionModelDP& p, const ValidatedVectorFunctionModelDP& x) const; + virtual ValidatedVectorMultivariateFunctionModelDP implicit_step(const ValidatedVectorMultivariateFunction& f, const ValidatedVectorMultivariateFunctionModelDP& p, const ValidatedVectorMultivariateFunctionModelDP& x) const; - virtual Vector step(const ValidatedVectorFunction& f, const Vector& pt) const; + virtual Vector step(const ValidatedVectorMultivariateFunction& f, const Vector& pt) const; }; @@ -141,12 +141,12 @@ class KrawczykSolver virtual Void write(OutputStream& os) const; /*! \brief Solve \f$f(a,x)=0\f$ for a in \a par, looking for solutions with x in \a ix. */ - virtual ValidatedVectorFunctionModelDP implicit_step(const ValidatedVectorFunction& f, const ValidatedVectorFunctionModelDP& p, const ValidatedVectorFunctionModelDP& x) const; + virtual ValidatedVectorMultivariateFunctionModelDP implicit_step(const ValidatedVectorMultivariateFunction& f, const ValidatedVectorMultivariateFunctionModelDP& p, const ValidatedVectorMultivariateFunctionModelDP& x) const; public: /*! \brief A single step of the Krawczyk contractor. */ virtual Vector - step(const ValidatedVectorFunction& f, + step(const ValidatedVectorMultivariateFunction& f, const Vector& pt) const; }; @@ -169,7 +169,7 @@ class FactoredKrawczykSolver public: /*! \brief A single step of the modified Krawczyk contractor. */ virtual Vector - step(const ValidatedVectorFunction& f, + step(const ValidatedVectorMultivariateFunction& f, const Vector& pt) const; }; diff --git a/source/solvers/solver_interface.hpp b/source/solvers/solver_interface.hpp index 7fe1ed7df..fc733ef47 100644 --- a/source/solvers/solver_interface.hpp +++ b/source/solvers/solver_interface.hpp @@ -102,30 +102,30 @@ class SolverInterface virtual Void set_maximum_number_of_steps(Nat max_steps) = 0; //! \brief Solve \f$f(x)=0\f$, starting in the box \a bx. - virtual Vector zero(const ValidatedVectorFunction& f,const ExactBoxType& pt) const = 0; + virtual Vector zero(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& pt) const = 0; //! \brief Solve \f$f(x)=x\f$, starting in the box \a bx. - virtual Vector fixed_point(const ValidatedVectorFunction& f,const ExactBoxType& pt) const = 0; + virtual Vector fixed_point(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& pt) const = 0; //! \brief Solve \f$f(x)=0\f$, starting in the box \a bx. Throws a SolverException if there is not a unique solution. - virtual Vector solve(const ValidatedVectorFunction& f,const ExactBoxType& bx) const = 0; - virtual Vector solve(const ValidatedVectorFunction& f,const Vector& ipt) const = 0; + virtual Vector solve(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const = 0; + virtual Vector solve(const ValidatedVectorMultivariateFunction& f,const Vector& ipt) const = 0; //! \brief Solve \f$f(a,x)=0\f$ for \f$a\f$ in \f$A\f$, looking for a solution with \f$x\f$ in \f$X\f$. The result is a function \f$h\f$ with domain \f$A\f$ such that \f$f(a,h(a))=0\f$ for all \f$a\in A\f$. //! \details A strong solution to the problem exists if for every \f$a\in A\f$, there is a unique solution \f$x\in X\f$ to the equation \f$f(a,x)=0\f$, and this solution varies continuously in \f$a\f$. A weak solution is a function \f$h\f$ with domain \f$A\f$ such that \f$f(a,h(a))=0\f$ for all \f$a\in A\f$, if \f$f(a,x)=0\f$ for \f$x\in X\f$ then \f$h(a)=x\f$, and there exists \f$(a,x)\in A\times X\f$ such that \f$f(a,x)=0\f$. //! If \f$D_2f(a,x)\f$ is nonsingular for all \f$(a,x)\in A\times X\f$, then any solution is guaranteed to be unique. //! May throw a NoSolutionException, but \em only if there are no solutions to \f$f(a,x)=0\f$ in \f$A\times X\f$. //! If there is a continuous branch of solutions \f$x=h(a)\f$ such that \f$h(a)\in X\f$ for some parameter values, //! but \f$h(a)\not\in X\f$ for others, then \f$h\f$ is a valid result for the function. - virtual ValidatedVectorFunctionModelDP implicit(const ValidatedVectorFunction& f, const ExactBoxType& A, const ExactBoxType& X) const = 0; + virtual ValidatedVectorMultivariateFunctionModelDP implicit(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& A, const ExactBoxType& X) const = 0; //! \brief Solve \f$f(a,x)=0\f$ for a in \a A, looking for a solution with x in \a X. - virtual ValidatedScalarFunctionModelDP implicit(const ValidatedScalarFunction& f, const ExactBoxType& A, const ExactIntervalType& X) const = 0; + virtual ValidatedScalarMultivariateFunctionModelDP implicit(const ValidatedScalarMultivariateFunction& f, const ExactBoxType& A, const ExactIntervalType& X) const = 0; //! \brief Solve \f$f(a,x)=0\f$ for x in \a X, and continue to a function \f$h\f$ solving \f$f(a,h(a))=0\f$ over \f$A\f$. - virtual ValidatedVectorFunctionModelDP continuation(const ValidatedVectorFunction& f, const Vector& a, const ExactBoxType& X, const ExactBoxType& A) const = 0; + virtual ValidatedVectorMultivariateFunctionModelDP continuation(const ValidatedVectorMultivariateFunction& f, const Vector& a, const ExactBoxType& X, const ExactBoxType& A) const = 0; //! \brief Solve \f$f(x)=0\f$, starting in the interval point \a pt. Returns a set of boxes for which it can be proved that //! a solution exists in the box. This means that some solutions may be omitted if they are not sufficiently robust. //! - virtual Set< Vector > solve_all(const ValidatedVectorFunction& f,const ExactBoxType& bx) const = 0; + virtual Set< Vector > solve_all(const ValidatedVectorMultivariateFunction& f,const ExactBoxType& bx) const = 0; }; inline OutputStream& operator<<(OutputStream& os, const SolverInterface& solver) { diff --git a/source/symbolic/expression.cpp b/source/symbolic/expression.cpp index 8851de8b0..fd5c3540f 100644 --- a/source/symbolic/expression.cpp +++ b/source/symbolic/expression.cpp @@ -536,8 +536,8 @@ Expression make_expression(const Formula& f, const Space& s) { return fa.template extract(); } -Formula make_formula(const EffectiveScalarFunction& f); -Expression make_expression(const ScalarFunction& f, const Space& s) { +Formula make_formula(const EffectiveScalarMultivariateFunction& f); +Expression make_expression(const ScalarMultivariateFunction& f, const Space& s) { return make_expression(make_formula(f),s); } } // namespace Ariadne diff --git a/source/symbolic/expression.hpp b/source/symbolic/expression.hpp index a5c603cef..742e5d12a 100644 --- a/source/symbolic/expression.hpp +++ b/source/symbolic/expression.hpp @@ -201,15 +201,15 @@ const Formula& cached_make_formula(const Expression& e, c //! \brief Make a function on the real line given an expression in a single argument variable. ScalarUnivariateFunction make_function(const Variable& v, const Expression& e); //! \brief Make a function on a Euclidean domain given an ordered list including all argument variables. -ScalarFunction make_function(const Space& s, const Expression& e); +ScalarMultivariateFunction make_function(const Space& s, const Expression& e); //! \brief Make a function on a Euclidean domain given an ordered list including all argument variables. -VectorFunction make_function(const Space& s, const Vector>& e); +VectorMultivariateFunction make_function(const Space& s, const Vector>& e); //! \brief Make a function on a Euclidean domain given an ordered list including all argument variables. // DEPRECATED -ScalarFunction make_function(const Expression& e, const Space& s); +ScalarMultivariateFunction make_function(const Expression& e, const Space& s); //! \brief Make a function on a Euclidean domain given an ordered list including all argument variables. -Expression make_expression(const ScalarFunction& f, const Space& s); +Expression make_expression(const ScalarMultivariateFunction& f, const Space& s); Expression make_expression(const Formula& f, const Space& s); diff --git a/source/symbolic/expression_set.cpp b/source/symbolic/expression_set.cpp index 2541083e5..df1355a8e 100644 --- a/source/symbolic/expression_set.cpp +++ b/source/symbolic/expression_set.cpp @@ -154,7 +154,7 @@ ConstraintSet RealExpressionConstraintSet::euclidean_set(const RealSpace& space) List constraints; for(Nat i=0; i!=set.constraints().size(); ++i) { RealExpression constraint_expression=indicator(set.constraints()[i],Sign::NEGATIVE); - EffectiveScalarFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); + EffectiveScalarMultivariateFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); constraints.append( constraint_function <= Real(0) ); } return ConstraintSet(constraints); @@ -205,7 +205,7 @@ BoundedConstraintSet RealExpressionBoundedConstraintSet::euclidean_set(const Rea List constraints; for(Nat i=0; i!=set.constraints().size(); ++i) { RealExpression constraint_expression=indicator(set.constraints()[i],Sign::NEGATIVE); - EffectiveScalarFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); + EffectiveScalarMultivariateFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); constraints.append( constraint_function <= Real(0) ); } return BoundedConstraintSet(domain,constraints);} @@ -228,13 +228,13 @@ RealExpressionBoundedConstraintSet intersection(RealVariablesBox const& bx, Real ValidatedConstrainedImageSet approximate_euclidean_set(const RealExpressionBoundedConstraintSet& set, const RealSpace& space) { RealBox real_domain = RealVariablesBox(set.bounds()).euclidean_set(space); ExactBoxType domain=cast_exact_box(ApproximateBoxType(real_domain,dp)); - ValidatedVectorFunction identity=ValidatedVectorFunction::identity(domain.size()); + ValidatedVectorMultivariateFunction identity=ValidatedVectorMultivariateFunction::identity(domain.size()); ValidatedConstrainedImageSet result(domain,identity); //List constraints; for(Nat i=0; i!=set.constraints().size(); ++i) { RealExpression constraint_expression=indicator(set.constraints()[i],Sign::NEGATIVE); - ValidatedScalarFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); + ValidatedScalarMultivariateFunction constraint_function( Ariadne::make_function(constraint_expression,space) ); result.new_parameter_constraint(constraint_function <= ExactNumericType(0) ); //constraints.append( constraint_function <= 0.0 ); } diff --git a/source/symbolic/function_expression.hpp b/source/symbolic/function_expression.hpp index abc7cd1ca..f21591124 100644 --- a/source/symbolic/function_expression.hpp +++ b/source/symbolic/function_expression.hpp @@ -41,8 +41,10 @@ namespace Ariadne { template class FunctionExpression; -template using ScalarFunctionExpression = FunctionExpression; -template using VectorFunctionExpression = FunctionExpression; +template using ScalarFunctionExpression = FunctionExpression; +template using VectorFunctionExpression = FunctionExpression; +template using ScalarMultivariateFunctionExpression = FunctionExpression; +template using VectorMultivariateFunctionExpression = FunctionExpression; using ValidatedScalarFunctionExpression = FunctionExpression; using ValidatedVectorFunctionExpression = FunctionExpression; @@ -82,22 +84,22 @@ template class FunctionExpression { Argument const& variables() const { return this->_vars; } Set arguments() const { Set args; for(SizeType i=0; i!=_vars.size(); ++i) { args.insert(_vars[i]); } return args; } auto domain() const -> decltype(_make_domain(_vars,_f.domain())) { return _make_domain(_vars,_f.domain()); } - template friend OutputStream& operator<<(OutputStream& os, ScalarFunctionExpression const& sfe); + template friend OutputStream& operator<<(OutputStream& os, ScalarFunctionExpression const& sfe); }; -template OutputStream& operator<<(OutputStream& os, ScalarFunctionExpression

const& e) { +template OutputStream& operator<<(OutputStream& os, ScalarMultivariateFunctionExpression

const& e) { os << e._f; for(SizeType i=0; i!=e._vars.size(); ++i) { os << (i==0?'[':',') << "x[" << i << "]=" << e._vars[i]; } return os << "]"; } -template ScalarFunctionExpression

FunctionFacade::operator() (Vector const& vars) const { - return ScalarFunctionExpression

(static_castconst&>(*this),vars); +template ScalarMultivariateFunctionExpression

FunctionFacade::operator() (Vector const& vars) const { + return ScalarMultivariateFunctionExpression

(static_castconst&>(*this),vars); } -template ScalarFunctionExpression

evaluate(ScalarFunction

const& f, Vector const& vars) { - return ScalarFunctionExpression

(f,vars); +template ScalarMultivariateFunctionExpression

evaluate(ScalarMultivariateFunction

const& f, Vector const& vars) { + return ScalarMultivariateFunctionExpression

(f,vars); } template TaylorModel compose(const TaylorModel& x, Projection const& prj) { @@ -146,9 +148,9 @@ template ScalarFunctionModel compose(Sca } template ScalarFunction compose(ScalarFunction const& f, Projection const& prj) { - auto fmp = std::dynamic_pointer_cast>(f.managed_pointer()); + auto fmp = std::dynamic_pointer_cast>(f.managed_pointer()); if(fmp) { - return compose(ScalarFunctionModelDP

(fmp),prj); + return compose(ScalarMultivariateFunctionModelDP

(fmp),prj); } auto f_dom=f.domain(); BoxDomainType dom=preimage(prj,f_dom); @@ -165,16 +167,16 @@ template ScalarFunction compose(ScalarFunction id(RealScalarFunction::coordinates(dom)); - RealVectorFunction pid=prj(id); + Vector id(RealScalarMultivariateFunction::coordinates(dom)); + RealVectorMultivariateFunction pid=prj(id); return compose(f,pid); } -template ScalarFunction

make_function(RealSpace args, ScalarFunctionExpression

const& expr) { +template ScalarMultivariateFunction

make_function(RealSpace args, ScalarMultivariateFunctionExpression

const& expr) { ARIADNE_PRECONDITION(subset(expr.arguments(),args.variables())); auto expr_vars=expr.variables(); auto expr_func=expr.function(); diff --git a/source/symbolic/predicate.hpp b/source/symbolic/predicate.hpp index e04e5d8bf..a2ae91245 100644 --- a/source/symbolic/predicate.hpp +++ b/source/symbolic/predicate.hpp @@ -59,9 +59,9 @@ class ExpressionPredicate { friend ExpressionPredicate operator!(const ExpressionPredicate&); public: - ExpressionPredicate(const EffectiveScalarFunction& expression) + ExpressionPredicate(const EffectiveScalarMultivariateFunction& expression) : _expression(expression), _sign(+1) { } - const EffectiveScalarFunction& expression() const { return _expression; } + const EffectiveScalarMultivariateFunction& expression() const { return _expression; } Int sign() const { return _sign; } Bool same(const ExpressionPredicate& ep2) const { @@ -84,7 +84,7 @@ class ExpressionPredicate else if(range.lower()>0) { return false; } else { return indeterminate; } } private: - EffectiveScalarFunction _expression; + EffectiveScalarMultivariateFunction _expression; Int _sign; }; diff --git a/tests/algebra/check_algebra.hpp b/tests/algebra/check_algebra.hpp index 7a08a7463..bf888522e 100644 --- a/tests/algebra/check_algebra.hpp +++ b/tests/algebra/check_algebra.hpp @@ -141,7 +141,7 @@ template bool CheckAlgebraConcept::has_numeric_type() ARIADNE_TEST_STATIC_ASSERT(HasNumericType); return HasNumericType::value; } -namespace Ariadne { template<> String class_name() { return "EffectiveScalarFunction"; } } +namespace Ariadne { template<> String class_name() { return "EffectiveScalarMultivariateFunction"; } } template void CheckAlgebraConcept::check_algebra_concept() { typedef typename A::NumericType X; diff --git a/tests/dynamics/test_continuous_evolution.cpp b/tests/dynamics/test_continuous_evolution.cpp index 62acfdff4..5bff81059 100644 --- a/tests/dynamics/test_continuous_evolution.cpp +++ b/tests/dynamics/test_continuous_evolution.cpp @@ -50,7 +50,7 @@ using namespace Ariadne; using namespace std; /// This function diverges heavily -struct FailOne : VectorFunctionData<2,2,1> { +struct FailOne : VectorMultivariateFunctionData<2,2,1> { template static Void compute(R& r, const A& x, const P& p) { r[0] = 1; @@ -59,7 +59,7 @@ struct FailOne : VectorFunctionData<2,2,1> { }; /// This function diverges heavily -struct FailTwo : VectorFunctionData<3,3,1> { +struct FailTwo : VectorMultivariateFunctionData<3,3,1> { template static Void compute(R& r, const A& x, const P& p) { r[0] = 1; @@ -118,9 +118,9 @@ Void TestContinuousEvolution::test() const // Set up the vector field Real mu=Dyadic(0.5); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction xp=EffectiveScalarFunction::coordinate(2,1); - EffectiveVectorFunction vdp={x,mu*(1-x*x)*xp-x}; + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction xp=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveVectorMultivariateFunction vdp={x,mu*(1-x*x)*xp-x}; VectorField vanderpol(vdp); ARIADNE_TEST_PRINT(vanderpol); @@ -178,10 +178,10 @@ Void TestContinuousEvolution::failure_test() const // Set up the vector field for the first test Real p = 200; - EffectiveScalarFunction o=EffectiveScalarFunction::constant(2,1.0_q); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction y=EffectiveScalarFunction::coordinate(2,1); - EffectiveVectorFunction failone={o,-p*y+p}; + EffectiveScalarMultivariateFunction o=EffectiveScalarMultivariateFunction::constant(2,1.0_q); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction y=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveVectorMultivariateFunction failone={o,-p*y+p}; VectorField failone_vf(failone); VectorFieldEvolver evolverone(failone_vf,integrator); @@ -216,12 +216,12 @@ Void TestContinuousEvolution::failure_test() const // Set up the vector field for the second test p = Rational(1,10); - EffectiveScalarFunction z3=EffectiveScalarFunction::zero(3); - EffectiveScalarFunction o3=EffectiveScalarFunction::constant(3,1.0_q); - EffectiveScalarFunction x0=EffectiveScalarFunction::coordinate(3,0); - EffectiveScalarFunction x1=EffectiveScalarFunction::coordinate(3,1); - EffectiveScalarFunction x2=EffectiveScalarFunction::coordinate(3,1); - EffectiveVectorFunction failtwo={o3,x1*x2/p,z3}; + EffectiveScalarMultivariateFunction z3=EffectiveScalarMultivariateFunction::zero(3); + EffectiveScalarMultivariateFunction o3=EffectiveScalarMultivariateFunction::constant(3,1.0_q); + EffectiveScalarMultivariateFunction x0=EffectiveScalarMultivariateFunction::coordinate(3,0); + EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(3,1); + EffectiveScalarMultivariateFunction x2=EffectiveScalarMultivariateFunction::coordinate(3,1); + EffectiveVectorMultivariateFunction failtwo={o3,x1*x2/p,z3}; VectorField failtwo_vf(failtwo); VectorFieldEvolver evolvertwo(failtwo_vf,integrator); diff --git a/tests/dynamics/test_differential_inclusion.cpp b/tests/dynamics/test_differential_inclusion.cpp index 82ddb107b..383b5c37f 100644 --- a/tests/dynamics/test_differential_inclusion.cpp +++ b/tests/dynamics/test_differential_inclusion.cpp @@ -54,7 +54,7 @@ class TestInclusionIntegrator { { auto integrator = InclusionIntegrator(approximations,sweeper,step_size=step,number_of_steps_between_simplifications=freq,number_of_variables_to_keep=20000); integrator.verbosity = verbosity; - List flow_functions = integrator.flow(ivp,evolution_time); + List flow_functions = integrator.flow(ivp,evolution_time); } Void run_test(String name, const DottedRealAssignments& dynamics, const RealVariablesBox& inputs, diff --git a/tests/dynamics/test_discrete_evolution.cpp b/tests/dynamics/test_discrete_evolution.cpp index 02f7fac8e..45e7540e6 100644 --- a/tests/dynamics/test_discrete_evolution.cpp +++ b/tests/dynamics/test_discrete_evolution.cpp @@ -77,10 +77,10 @@ Void TestMapEvolver::test() const // Set up the map field // The Henon map \f$(x,y)\mapsto(a-x^2+by,x) Real a=Dyadic(1.5); Real b=Dyadic(0.375); - EffectiveVectorFunction henon; + EffectiveVectorMultivariateFunction henon; { - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction y=EffectiveScalarFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction y=EffectiveScalarMultivariateFunction::coordinate(2,1); henon = { a-x*x+b*y, x }; } ARIADNE_TEST_PRINT(henon); diff --git a/tests/function/check_function.hpp b/tests/function/check_function.hpp index fb9c19593..4ae14a6d4 100644 --- a/tests/function/check_function.hpp +++ b/tests/function/check_function.hpp @@ -101,7 +101,7 @@ template void CheckFunctionConcept::check() ARIADNE_TEST_CALL(check_integrable_concept()); ARIADNE_TEST_CALL(check_composable_concept()); - ARIADNE_TEST_STATIC_ASSERT(HasOperator); + ARIADNE_TEST_STATIC_ASSERT(HasOperator); } @@ -213,7 +213,7 @@ template void CheckFunctionConcept::check_composable_concept() -template class CheckVectorFunctionConcept : CheckVectorConcept +template class CheckVectorMultivariateFunctionConcept : CheckVectorConcept { typedef VF FunctionType; void check(); @@ -223,13 +223,13 @@ template class CheckVectorFunctionConcept : CheckVectorConcept }; -template void CheckVectorFunctionConcept::test() +template void CheckVectorMultivariateFunctionConcept::test() { ARIADNE_TEST_CALL(check_vector_concept()); ARIADNE_TEST_CALL(check_evaluable_concept()); } -template void CheckVectorFunctionConcept::check_evaluable_concept() +template void CheckVectorMultivariateFunctionConcept::check_evaluable_concept() { ARIADNE_TEST_STATIC_ASSERT(HasParadigm); ARIADNE_TEST_STATIC_ASSERT(HasDomainType); @@ -744,23 +744,23 @@ void CheckFunctionConcept::check_scalar_function() void CheckFunctionConcept::check_vector_function() { - ARIADNE_TEST_NAMED_CONSTRUCT(ExactVectorFunction,f,identity(3)); + ARIADNE_TEST_NAMED_CONSTRUCT(ExactVectorMultivariateFunction,f,identity(3)); ARIADNE_TEST_CONSTRUCT(ExactFunction,fa0,(f.get(0))); ARIADNE_TEST_CONSTRUCT(ExactFunction,fa1,(f[1])); // Regression tests for element ARIADNE_TEST_PRINT(f[0]); - const ExactVectorFunction& fcr=f; + const ExactVectorMultivariateFunction& fcr=f; ARIADNE_TEST_PRINT(fcr[0]); - ExactVectorFunction& fr=f; + ExactVectorMultivariateFunction& fr=f; ARIADNE_TEST_PRINT(fr[0]); ARIADNE_TEST_EQUAL(f[0](Vector{2.0,3.0,5.0}),2.0); ARIADNE_TEST_EXECUTE(f[0]=f[1]); ARIADNE_TEST_EQUAL(f[0](Vector{2.0,3.0,5.0}),3.0); - ExactVectorFunction x=ExactVectorFunction::identity(2); + ExactVectorMultivariateFunction x=ExactVectorMultivariateFunction::identity(2); ExactFunction x0=x[0]; //ExactFunction fvi=(1-x[0]*x[0]-x[1]/2); diff --git a/tests/function/test_function.cpp b/tests/function/test_function.cpp index 5906b5d5a..17c1330a3 100644 --- a/tests/function/test_function.cpp +++ b/tests/function/test_function.cpp @@ -71,21 +71,21 @@ Void TestFunction::test() Void TestFunction::test_concept() { - EffectiveScalarFunction sf1(3); - EffectiveScalarFunction sf2(3); - EffectiveScalarFunction sf3(3); - //Vector ve=join(3,*e1,*e2,*e3); + EffectiveScalarMultivariateFunction sf1(3); + EffectiveScalarMultivariateFunction sf2(3); + EffectiveScalarMultivariateFunction sf3(3); + //Vector ve=join(3,*e1,*e2,*e3); - EffectiveVectorFunction vf=join(sf1,sf2); + EffectiveVectorMultivariateFunction vf=join(sf1,sf2); - EffectiveScalarFunction g(2); - EffectiveScalarFunction h=compose(g,vf); + EffectiveScalarMultivariateFunction g(2); + EffectiveScalarMultivariateFunction h=compose(g,vf); - EffectiveVectorFunction jf=join(sf1,sf2); - //EffectiveScalarFunction cf=combine(sf1,sf2); + EffectiveVectorMultivariateFunction jf=join(sf1,sf2); + //EffectiveScalarMultivariateFunction cf=combine(sf1,sf2); //Polynomial p; - //EffectiveScalarFunction pf(p); + //EffectiveScalarMultivariateFunction pf(p); //Vector b; Matrix A; //VectorAffineFunction aff(A,b); @@ -128,36 +128,36 @@ Void TestFunction::test_vector_univariate_function() Void TestFunction::test_scalar_function() { - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarFunction,o,constant(3,1)); - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarFunction,x,coordinate(3,0)); - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarFunction,y,coordinate(3,1)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarMultivariateFunction,o,constant(3,1)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarMultivariateFunction,x,coordinate(3,0)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarMultivariateFunction,y,coordinate(3,1)); - ARIADNE_TEST_CONSTRUCT(EffectiveScalarFunction,f,(o+x*y)); + ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,f,(o+x*y)); ARIADNE_TEST_CONSTRUCT(Vector,p,({2.0_approx,3.0_approx,5.0_approx})); ARIADNE_TEST_EQUAL(f(p),7.0_approx); ARIADNE_TEST_PRINT(cos(f)); - EffectiveScalarFunction df=f.derivative(1); + EffectiveScalarMultivariateFunction df=f.derivative(1); ARIADNE_TEST_PRINT(df); ARIADNE_TEST_EQUAL(df(p),2.0_approx); } Void TestFunction::test_vector_function() { - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveVectorFunction,id,identity(3)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveVectorMultivariateFunction,id,identity(3)); // Regression tests for element ARIADNE_TEST_PRINT(id[0]); - const EffectiveVectorFunction& id_const_ref=id; + const EffectiveVectorMultivariateFunction& id_const_ref=id; ARIADNE_TEST_PRINT(id_const_ref[0]); - EffectiveVectorFunction& id_ref=id; + EffectiveVectorMultivariateFunction& id_ref=id; ARIADNE_TEST_PRINT(id_ref[0]); Vector v={2.0_approx,3.0_approx,5.0_approx}; - ARIADNE_TEST_CONSTRUCT(EffectiveVectorFunction,f,(id)); + ARIADNE_TEST_CONSTRUCT(EffectiveVectorMultivariateFunction,f,(id)); ARIADNE_TEST_EQUAL(f(v),v); ARIADNE_TEST_EQUAL(f[0](v),v[0]); ARIADNE_TEST_EXECUTE(f[0]=f[1]); @@ -165,7 +165,7 @@ Void TestFunction::test_vector_function() ARIADNE_TEST_EQUAL(f(v)[0],v[1]); // Regression test for function - vector product - EffectiveScalarFunction x1=EffectiveScalarFunction::coordinate(3,1); + EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(3,1); // EffectiveVector e0={1,0}; Vector e0={1,0}; ARIADNE_TEST_EQUAL((x1*e0)(v)[0],v[1]); @@ -186,14 +186,14 @@ Void TestFunction::test_differentiation() EuclideanDomain dom(2); DegreeType deg(3); - EffectiveScalarFunction z=EffectiveScalarFunction::constant(dom,0); - EffectiveScalarFunction o=EffectiveScalarFunction::constant(dom,1); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(dom,0); - EffectiveScalarFunction y=EffectiveScalarFunction::coordinate(dom,1); + EffectiveScalarMultivariateFunction z=EffectiveScalarMultivariateFunction::constant(dom,0); + EffectiveScalarMultivariateFunction o=EffectiveScalarMultivariateFunction::constant(dom,1); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(dom,0); + EffectiveScalarMultivariateFunction y=EffectiveScalarMultivariateFunction::coordinate(dom,1); - ARIADNE_TEST_CONSTRUCT(EffectiveScalarFunction,f,(3*x-2*y+1)); - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarFunction,df0,constant(dom,3)); - ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarFunction,df1,constant(dom,-2)); + ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,f,(3*x-2*y+1)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarMultivariateFunction,df0,constant(dom,3)); + ARIADNE_TEST_NAMED_CONSTRUCT(EffectiveScalarMultivariateFunction,df1,constant(dom,-2)); ARIADNE_TEST_CONSTRUCT(Vector,v,({2.25_exact,1.375_exact})); ARIADNE_TEST_CONSTRUCT(Vector,va,(v)); diff --git a/tests/function/test_procedure.cpp b/tests/function/test_procedure.cpp index 7dfadbbf6..ca6d37df4 100644 --- a/tests/function/test_procedure.cpp +++ b/tests/function/test_procedure.cpp @@ -221,7 +221,7 @@ Void TestProcedure::test_derivative() auto xs=sqr(x); auto ys=sqr(y); Formula e=sqrt(xs+c*ys)+sin(y/x)*xs*c-ys; ARIADNE_TEST_PRINT(e); - ScalarFunction

f(EuclideanDomain(2),e); + ScalarMultivariateFunction

f(EuclideanDomain(2),e); ARIADNE_TEST_PRINT(f); Procedure p(e); ARIADNE_TEST_PRINT(p); diff --git a/tests/function/test_taylor_function.cpp b/tests/function/test_taylor_function.cpp index 6cd6edee4..9f0f21119 100644 --- a/tests/function/test_taylor_function.cpp +++ b/tests/function/test_taylor_function.cpp @@ -162,9 +162,9 @@ Void TestScalarTaylorFunction::test_create() FloatDPValue c2={1,pr}; ValidatedScalarTaylorFunctionModelDP pf1=ValidatedScalarTaylorFunctionModelDP::constant(D,c1,swp); ValidatedScalarTaylorFunctionModelDP pf2=ValidatedScalarTaylorFunctionModelDP::constant(D,c2,swp); - ValidatedScalarFunctionModelDP fm1=pf1; - ValidatedScalarFunctionModelDP fm2=pf2; - ValidatedScalarFunction f2=fm2; + ValidatedScalarMultivariateFunctionModelDP fm1=pf1; + ValidatedScalarMultivariateFunctionModelDP fm2=pf2; + ValidatedScalarMultivariateFunction f2=fm2; ARIADNE_TEST_EQUAL(factory(pf1).create(pf2).range(),c2); ARIADNE_TEST_EQUAL(factory(pf1).create(fm2).range(),c2); ARIADNE_TEST_EQUAL(factory(pf1).create(f2).range(),c2); @@ -200,9 +200,9 @@ Void TestScalarTaylorFunction::test_evaluate() Void TestScalarTaylorFunction::test_gradient() { - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); Real a(1.5); Real b(0.25); - EffectiveScalarFunction quadratic = a-x[0]*x[0]+b*x[1]; + EffectiveScalarMultivariateFunction quadratic = a-x[0]*x[0]+b*x[1]; ExactBoxType domain1={{-1.0,+1.0},{-1.0,+1.0}}; ExactBoxType domain2={{-0.5,+0.5},{-0.25,+0.25}}; @@ -309,13 +309,13 @@ Void TestScalarTaylorFunction::test_conversion() { ExactBoxType D={{-0.5,0.5},{-1.0,2.0}}; Vector pt={-0.25_exact,0.25_exact}; Vector ipt(pt); - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); ARIADNE_TEST_PRINT(x); ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,tx,(D,x,swp)); - ARIADNE_TEST_CONSTRUCT(EffectiveScalarFunction,f,(1-x[0]*x[0]-x[1]/2)); + ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,f,(1-x[0]*x[0]-x[1]/2)); ARIADNE_TEST_PRINT(compose(f,tx)); - ARIADNE_TEST_CONSTRUCT(EffectiveScalarFunction,y,(x[1]/2)); + ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,y,(x[1]/2)); ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,ty,(D,x[1]/2,swp)); ARIADNE_TEST_PRINT(ValidatedScalarTaylorFunctionModelDP(D,x[1],swp)/2); ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,tf,(D,f,swp)); @@ -333,11 +333,11 @@ Void TestScalarTaylorFunction::test_generic() { ValidatedScalarTaylorFunctionModelDP pf0=ValidatedScalarTaylorFunctionModelDP::constant(D,c0,swp); ValidatedScalarTaylorFunctionModelDP pf1=ValidatedScalarTaylorFunctionModelDP::constant(D,c1,swp); ValidatedScalarTaylorFunctionModelDP pf2=ValidatedScalarTaylorFunctionModelDP::constant(D,c2,swp); - ValidatedScalarFunctionModelDP fm1=pf1; - ValidatedScalarFunctionModelDP fm2=pf2; - ValidatedScalarFunctionModelDP fm4=pf0; - ValidatedScalarFunction f1=fm1; - ValidatedScalarFunction f2=fm2; + ValidatedScalarMultivariateFunctionModelDP fm1=pf1; + ValidatedScalarMultivariateFunctionModelDP fm2=pf2; + ValidatedScalarMultivariateFunctionModelDP fm4=pf0; + ValidatedScalarMultivariateFunction f1=fm1; + ValidatedScalarMultivariateFunction f2=fm2; ARIADNE_TEST_EQUAL((pf1+pf2).range(),c1+c2); // ARIADNE_TEST_EQUAL((pf1+fm2).range(),c1+c2); ARIADNE_TEST_EQUAL((pf1+ f2).range(),c1+c2); @@ -411,9 +411,9 @@ Void TestVectorTaylorFunction::test_constructors() Vector< RawFloatDP > errors(2); ExactBoxType domain={{0.25,1.25},{0.5,1.0}}; - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); Real a(1.5); Real b(0.25); - EffectiveVectorFunction henon_function={a-x[0]*x[0]+b*x[1], x[0]*1}; + EffectiveVectorMultivariateFunction henon_function={a-x[0]*x[0]+b*x[1], x[0]*1}; ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,henon_model,(domain,henon_function,swp)); ARIADNE_TEST_EQUAL(henon_model.models()[0].expansion(),expansion[0]) ARIADNE_TEST_EQUAL(henon_model.models()[1].expansion(),expansion[1]) @@ -458,9 +458,9 @@ Void TestVectorTaylorFunction::test_restrict() Void TestVectorTaylorFunction::test_jacobian() { - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); Real a(1.5); Real b(0.25); - EffectiveVectorFunction henon={a-x[0]*x[0]+b*x[1], x[0]*1}; + EffectiveVectorMultivariateFunction henon={a-x[0]*x[0]+b*x[1], x[0]*1}; ExactBoxType domain1={{-1.0,+1.0},{-1.0,+1.0}}; ExactBoxType domain2={{-0.5,+0.5},{-0.25,+0.25}}; ExactBoxType domain3={{-0.25,+0.75},{0.0,+0.50}}; @@ -481,10 +481,10 @@ Void TestVectorTaylorFunction::test_jacobian() Void TestVectorTaylorFunction::test_compose() { Real a(1.5); Real b(0.25); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction y=EffectiveScalarFunction::coordinate(2,1); - EffectiveVectorFunction henon_polynomial=(a-x*x+b*y)*e(2,0)+x*e(2,1); - EffectiveVectorFunction henon_square_polynomial= + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction y=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveVectorMultivariateFunction henon_polynomial=(a-x*x+b*y)*e(2,0)+x*e(2,1); + EffectiveVectorMultivariateFunction henon_square_polynomial= {a*(1-a)+b*x-2*a*b*y+2*a*x*x-b*b*y*y+2*b*x*x*y-x*x*x*x, a-x*x+b*y}; // compose(henon_polynomial,henon_polynomial); ExactBoxType domain1={{0.25,1.25},{0.5,1.0}}; @@ -537,10 +537,10 @@ Void TestVectorTaylorFunction::test_antiderivative() Void TestVectorTaylorFunction::test_join() { ExactBoxType domain={{-0.25,+0.25},{-0.5,+0.5}}; - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); - EffectiveVectorFunction function1 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(1,0); - EffectiveVectorFunction function2 = (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[1])*e(2,1); - EffectiveVectorFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); + EffectiveVectorMultivariateFunction function1 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(1,0); + EffectiveVectorMultivariateFunction function2 = (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[1])*e(2,1); + EffectiveVectorMultivariateFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[1])*e(3,2); ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction1,(domain,function1,swp)); @@ -556,13 +556,13 @@ Void TestVectorTaylorFunction::test_combine() ExactBoxType domain1={{-0.25,+0.25},{-0.5,+0.5}}; ExactBoxType domain2={{-0.75,+0.75},{-1.0,+1.0},{-1.25,+1.25}}; ExactBoxType domain3={{-0.25,+0.25},{-0.5,+0.5},{-0.75,+0.75},{-1.0,+1.0},{-1.25,+1.25}}; - EffectiveVectorFunction x; - x=EffectiveVectorFunction::identity(2); - EffectiveVectorFunction function1 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(1,0); - x=EffectiveVectorFunction::identity(3); - EffectiveVectorFunction function2 = (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[2])*e(2,1); - x=EffectiveVectorFunction::identity(5); - EffectiveVectorFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + EffectiveVectorMultivariateFunction x; + x=EffectiveVectorMultivariateFunction::identity(2); + EffectiveVectorMultivariateFunction function1 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(1,0); + x=EffectiveVectorMultivariateFunction::identity(3); + EffectiveVectorMultivariateFunction function2 = (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[2])*e(2,1); + x=EffectiveVectorMultivariateFunction::identity(5); + EffectiveVectorMultivariateFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + (4*x[2]*x[2]+5*x[2]*x[3]+6*x[3]*x[4])*e(3,2); ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction1,(domain1,function1,swp)); ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction2,(domain2,function2,swp)); @@ -578,9 +578,9 @@ Void TestVectorTaylorFunction::test_conversion() Vector pt={-0.25,0.25}; Vector ipt(pt); Vector apt(pt); - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); - EffectiveVectorFunction h={1-x[0]*x[0]-x[1]/2,x[0]+Real(0)}; + EffectiveVectorMultivariateFunction h={1-x[0]*x[0]-x[1]/2,x[0]+Real(0)}; ValidatedVectorTaylorFunctionModelDP th(D,h,swp); ARIADNE_TEST_PRINT(h); @@ -597,10 +597,10 @@ Void TestVectorTaylorFunction::test_conversion() // Regression test for domain with empty interior Void TestVectorTaylorFunction::test_domain() { - EffectiveScalarFunction z=EffectiveScalarFunction::constant(2,0); - EffectiveScalarFunction o=EffectiveScalarFunction::constant(2,1); - EffectiveScalarFunction x0=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction x1=EffectiveScalarFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction z=EffectiveScalarMultivariateFunction::constant(2,0); + EffectiveScalarMultivariateFunction o=EffectiveScalarMultivariateFunction::constant(2,1); + EffectiveScalarMultivariateFunction x0=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(2,1); ExactBoxType D1={{-1.0,1.0},{-1.0,1.0}}; ValidatedVectorTaylorFunctionModelDP t1(D1, {o,x0+x1}, swp); @@ -674,13 +674,13 @@ Void TestTaylorFunctionFactory::test_create() Vector dom={{-1,+1},{0.5,3.5}}; Vector args=reinterpret_castconst&>(dom); - ValidatedScalarTaylorFunctionModelDP stf=factory.create(dom, EffectiveScalarFunction::zero(dom.size()) ); + ValidatedScalarTaylorFunctionModelDP stf=factory.create(dom, EffectiveScalarMultivariateFunction::zero(dom.size()) ); ARIADNE_TEST_PRINT(stf); ARIADNE_TEST_EQUALS(&stf.properties(),&sweeper); ARIADNE_TEST_EQUALS(stf(args),FloatDPBounds(0.0)); ARIADNE_TEST_EQUALS(evaluate(stf,args),FloatDPBounds(0.0)); - ValidatedVectorTaylorFunctionModelDP vtf=factory.create(dom, EffectiveVectorFunction::identity(dom.size()) ); + ValidatedVectorTaylorFunctionModelDP vtf=factory.create(dom, EffectiveVectorMultivariateFunction::identity(dom.size()) ); ARIADNE_TEST_PRINT(vtf); // Test evaluation gives a superset with small additional error diff --git a/tests/geometry/test_function_sets.cpp b/tests/geometry/test_function_sets.cpp index ddee8b404..73a48f18e 100644 --- a/tests/geometry/test_function_sets.cpp +++ b/tests/geometry/test_function_sets.cpp @@ -58,8 +58,8 @@ class TestConstrainedImageSet } Void test_constructor() { - List s=EffectiveScalarFunction::coordinates(3); - List x=EffectiveScalarFunction::coordinates(2); + List s=EffectiveScalarMultivariateFunction::coordinates(3); + List x=EffectiveScalarMultivariateFunction::coordinates(2); EffectiveBoxType d(3,EffectiveIntervalType(-1,+2)); EffectiveConstrainedImageSet set(d,{s[0],s[0]*s[0]/4+s[1]+s[2]/2}); @@ -69,7 +69,7 @@ class TestConstrainedImageSet } Void test_domain() { - List s=EffectiveScalarFunction::coordinates(3); + List s=EffectiveScalarMultivariateFunction::coordinates(3); EffectiveBoxType d(3,EffectiveIntervalType(Decimal(-1.1),Decimal(+2.1))); EffectiveConstrainedImageSet set(d,{s[0],s[0]*s[0]/4+s[1]+s[2]/2}); set.new_parameter_constraint(0<=s[0]+s[1]<=1); @@ -84,9 +84,9 @@ class TestConstrainedImageSet } Void test_geometry() { - List p=EffectiveScalarFunction::coordinates(1); - List s=EffectiveScalarFunction::coordinates(3); - List x=EffectiveScalarFunction::coordinates(2); + List p=EffectiveScalarMultivariateFunction::coordinates(1); + List s=EffectiveScalarMultivariateFunction::coordinates(3); + List x=EffectiveScalarMultivariateFunction::coordinates(2); ExactBoxType box1(2); ExactBoxType box2(2); ExactBoxType box3(2); @@ -130,8 +130,8 @@ class TestConstrainedImageSet Real half(0.5); EffectiveBoxType d(2,EffectiveIntervalType(-half,+half)); Real a(1.5); Real b(0.375); - EffectiveVectorFunction h={a-x[0]*x[0]-b*x[1],x[0]}; - EffectiveVectorFunction f=compose(h,h); + EffectiveVectorMultivariateFunction h={a-x[0]*x[0]-b*x[1],x[0]}; + EffectiveVectorMultivariateFunction f=compose(h,h); EffectiveConstrainedImageSet set(d,f); set.new_parameter_constraint(0<=x[0]+x[1]<=1); @@ -156,8 +156,8 @@ class TestConstrainedImageSet } Void test_separated() { - List s=EffectiveScalarFunction::coordinates(3); - List x=EffectiveScalarFunction::coordinates(2); + List s=EffectiveScalarMultivariateFunction::coordinates(3); + List x=EffectiveScalarMultivariateFunction::coordinates(2); EffectiveBoxType d(3,EffectiveIntervalType(Decimal(-1.1),Decimal(+2.1))); // EffectiveBoxType d(3,EffectiveIntervalType(Decimal(-0.1015625),Decimal(+2.1015625))); @@ -202,8 +202,8 @@ class TestConstrainedImageSet } Void test_approximation() { - List s=EffectiveScalarFunction::coordinates(3); - List x=EffectiveScalarFunction::coordinates(2); + List s=EffectiveScalarMultivariateFunction::coordinates(3); + List x=EffectiveScalarMultivariateFunction::coordinates(2); EffectiveBoxType d(3,EffectiveIntervalType(-1,+2)); EffectiveConstrainedImageSet set(d,{s[0],s[0]*s[0]/4+s[1]+s[2]/2}); @@ -219,13 +219,13 @@ class TestConstrainedImageSet Void test_split() { - EffectiveScalarFunction o=EffectiveScalarFunction::constant(3,1); - EffectiveScalarFunction s0=EffectiveScalarFunction::coordinate(3,0); - EffectiveScalarFunction s1=EffectiveScalarFunction::coordinate(3,1); - EffectiveScalarFunction s2=EffectiveScalarFunction::coordinate(3,2); - EffectiveScalarFunction x0=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction x1=EffectiveScalarFunction::coordinate(2,1); - EffectiveVectorFunction translation; + EffectiveScalarMultivariateFunction o=EffectiveScalarMultivariateFunction::constant(3,1); + EffectiveScalarMultivariateFunction s0=EffectiveScalarMultivariateFunction::coordinate(3,0); + EffectiveScalarMultivariateFunction s1=EffectiveScalarMultivariateFunction::coordinate(3,1); + EffectiveScalarMultivariateFunction s2=EffectiveScalarMultivariateFunction::coordinate(3,2); + EffectiveScalarMultivariateFunction x0=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveVectorMultivariateFunction translation; EffectiveBoxType d(3,EffectiveIntervalType(-1,+1)); EffectiveConstrainedImageSet set(d,{s0,s1+s2*s2/2}); set.new_parameter_constraint(s0+Real(0.75)*s1+s2<=Real(0)); @@ -266,7 +266,7 @@ class TestConstrainedImageSet Void test_affine_approximation() { // Test conversionn is exact for the affine set -2 s=EffectiveScalarFunction::coordinates(2); + List s=EffectiveScalarMultivariateFunction::coordinates(2); EffectiveBoxType d={EffectiveIntervalType(-2,1),EffectiveIntervalType(0,2)}; EffectiveConstrainedImageSet set(d,{s[0],s[1]}); set.new_parameter_constraint(3*s[0]+s[1]<=1); @@ -329,10 +329,10 @@ class TestConstrainedImageSet } Void test_draw() { - EffectiveScalarFunction s=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction t=EffectiveScalarFunction::coordinate(2,1); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction y=EffectiveScalarFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction s=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction t=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction y=EffectiveScalarMultivariateFunction::coordinate(2,1); Nat acc = 2u; test_draw("ellipse",EffectiveConstrainedImageSet(EffectiveBoxType(2,EffectiveIntervalType(-1,1)),{2*s+t,s+t},{s*s+t*t<=0.75}),acc+1u); diff --git a/tests/geometry/test_paving.cpp b/tests/geometry/test_paving.cpp index a17115013..851704665 100644 --- a/tests/geometry/test_paving.cpp +++ b/tests/geometry/test_paving.cpp @@ -215,7 +215,7 @@ Void TestPaving::test_approximation() const { GridTreePaving grid_set(grid); PavingInterface& paving = grid_set; - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); EffectiveConstrainedImageSet set(EffectiveBoxType(ExactIntervalVectorType({{-1.0,1.0},{-1.0,1.0}}))); set.apply( {2*x[0]+x[1]+x[0]*x[0]/4,x[0]+x[1]} ); Nat depth = 2; diff --git a/tests/hybrid/test_hybrid_evolution.cpp b/tests/hybrid/test_hybrid_evolution.cpp index 9c314a5a3..9ed8029d4 100644 --- a/tests/hybrid/test_hybrid_evolution.cpp +++ b/tests/hybrid/test_hybrid_evolution.cpp @@ -49,9 +49,9 @@ using namespace Ariadne; using namespace std; -EffectiveScalarFunction c=EffectiveScalarFunction::constant(2,1); -EffectiveScalarFunction x0=EffectiveScalarFunction::coordinate(2,0); -EffectiveScalarFunction x1=EffectiveScalarFunction::coordinate(2,1); +EffectiveScalarMultivariateFunction c=EffectiveScalarMultivariateFunction::constant(2,1); +EffectiveScalarMultivariateFunction x0=EffectiveScalarMultivariateFunction::coordinate(2,0); +EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(2,1); Colour reach_set_colour(0.25,0.25,0.50); Colour intermediate_set_colour(0.50,0.50,0.75); diff --git a/tests/hybrid/test_hybrid_evolver.cpp b/tests/hybrid/test_hybrid_evolver.cpp index ca03fed99..247e866a6 100644 --- a/tests/hybrid/test_hybrid_evolver.cpp +++ b/tests/hybrid/test_hybrid_evolver.cpp @@ -825,8 +825,8 @@ Void TestHybridEvolver::test_transverse_linear_crossing() const RealSpace final_space=system.continuous_state_space(q2); RealExpression ct=-guard; // Crossing time - //EffectiveVectorFunction function=make_function((x+ct,y+2-ct),final_space); - EffectiveVectorFunction function=join(make_function(x+ct,final_space),make_function(y+2-ct,final_space)); + //EffectiveVectorMultivariateFunction function=make_function((x+ct,y+2-ct),final_space); + EffectiveVectorMultivariateFunction function=join(make_function(x+ct,final_space),make_function(y+2-ct,final_space)); Enclosure expected_final_enclosure(initial_set.euclidean_set(q1,final_space),evolver_ptr->function_factory()); expected_final_enclosure.apply_map(function); diff --git a/tests/output/test_graphics.cpp b/tests/output/test_graphics.cpp index a321442f6..eee01cfe6 100644 --- a/tests/output/test_graphics.cpp +++ b/tests/output/test_graphics.cpp @@ -36,8 +36,8 @@ using namespace Ariadne; -inline EffectiveScalarFunction operator+(EffectiveScalarFunction f, double c) { return f+Real(c); } -inline EffectiveScalarFunction operator*(double c, EffectiveScalarFunction f) { return Real(c)*f; } +inline EffectiveScalarMultivariateFunction operator+(EffectiveScalarMultivariateFunction f, double c) { return f+Real(c); } +inline EffectiveScalarMultivariateFunction operator*(double c, EffectiveScalarMultivariateFunction f) { return Real(c)*f; } Int main(Int argc, char **argv) @@ -52,12 +52,12 @@ Int main(Int argc, char **argv) //Zonotope z1(z1c,z1g); //Polytope p1=polytope(z1); Real p(0.5); - EffectiveVectorFunction x=EffectiveVectorFunction::identity(3); - EffectiveVectorFunction afn1={0.05*x[0]+0.05*x[2]+0.15,0.05*x[1]+0.05*x[2]+0.6}; + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(3); + EffectiveVectorMultivariateFunction afn1={0.05*x[0]+0.05*x[2]+0.15,0.05*x[1]+0.05*x[2]+0.6}; ValidatedConstrainedImageSet s1(ExactBoxType::unit_box(3),afn1); ApproximateBoxType bbx1=widen(s1.bounding_box(),0.25_x); - EffectiveVectorFunction rf(1u, sqr(x[0])+sqr(x[1])-sqr(p)); + EffectiveVectorMultivariateFunction rf(1u, sqr(x[0])+sqr(x[1])-sqr(p)); ConstraintSet cs1(rf,EffectiveBoxType(1u,EffectiveIntervalType(-1,0))); { diff --git a/tests/solvers/test_constraint_solver.cpp b/tests/solvers/test_constraint_solver.cpp index 6adc4d9ab..7dba18df7 100644 --- a/tests/solvers/test_constraint_solver.cpp +++ b/tests/solvers/test_constraint_solver.cpp @@ -61,7 +61,7 @@ class TestConstraintSolver } Void test_empty_reduce_inequality() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,1.0},{0.0,1.0}}; List c = {4<=2*x[0]+x[1]}; @@ -74,7 +74,7 @@ class TestConstraintSolver } Void test_empty_reduce_equality() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,1.0},{0.0,1.0}}; List c = {2*x[0]+x[1]==4}; @@ -87,7 +87,7 @@ class TestConstraintSolver } Void test_empty_reduce_mixed() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,0.25},{0.0, 2.0}}; List c = {x[1]<=1,x[0]+x[1]==2}; @@ -100,7 +100,7 @@ class TestConstraintSolver } Void test_empty_hull_reduce() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,0.25},{0.0,2.0}}; List c = {x[1]<=1, x[0]+x[1]==2}; @@ -114,7 +114,7 @@ class TestConstraintSolver } Void test_empty_box_reduce() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,0.25},{0.0, 2.0}}; List c = {x[1]<=1,x[0]+x[1]==2}; @@ -132,7 +132,7 @@ class TestConstraintSolver } Void test_hull_reduce() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; List c = {-2<=2*x[0]+x[1]<=1}; @@ -144,7 +144,7 @@ class TestConstraintSolver } Void test_box_reduce() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; EffectiveConstraint c = (-2<=2*x[0]+x[1]<=1); @@ -159,7 +159,7 @@ class TestConstraintSolver Void test_monotone_reduce() { - List x=EffectiveScalarFunction::coordinates(2); + List x=EffectiveScalarMultivariateFunction::coordinates(2); UpperBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; EffectiveConstraint c = (-2<=2*x[0]+x[1]<=1); @@ -178,7 +178,7 @@ class TestConstraintSolver Void test_feasible() { - List x=EffectiveScalarFunction::coordinates(1); + List x=EffectiveScalarMultivariateFunction::coordinates(1); EffectiveConstraint c = (x[0]-2<=0); List constraints; diff --git a/tests/solvers/test_integrator.cpp b/tests/solvers/test_integrator.cpp index a5fb0448b..ee0bf1178 100644 --- a/tests/solvers/test_integrator.cpp +++ b/tests/solvers/test_integrator.cpp @@ -42,8 +42,8 @@ using namespace Ariadne; using namespace std; -inline EffectiveScalarFunction operator^(EffectiveScalarFunction f, Int m) { return pow(f,m); } -inline EffectiveScalarFunction operator*(double c, EffectiveScalarFunction f) { return Real(c)*f; } +inline EffectiveScalarMultivariateFunction operator^(EffectiveScalarMultivariateFunction f, Int m) { return pow(f,m); } +inline EffectiveScalarMultivariateFunction operator*(double c, EffectiveScalarMultivariateFunction f) { return Real(c)*f; } struct UnsafeReal : Real { UnsafeReal(double d) : Real(d) { } }; @@ -52,17 +52,17 @@ class TestIntegrator typedef Vector ExactIntervalVectorType; private: std::unique_ptr integrator_ptr; - EffectiveScalarFunction o,x,y,x0,y0,t; + EffectiveScalarMultivariateFunction o,x,y,x0,y0,t; public: TestIntegrator(const IntegratorInterface& i) : integrator_ptr(i.clone()) { - o=EffectiveScalarFunction::constant(2,1); - x=EffectiveScalarFunction::coordinate(2,0); - y=EffectiveScalarFunction::coordinate(2,1); - x0=EffectiveScalarFunction::coordinate(3,0); - y0=EffectiveScalarFunction::coordinate(3,1); - t=EffectiveScalarFunction::coordinate(3,2); + o=EffectiveScalarMultivariateFunction::constant(2,1); + x=EffectiveScalarMultivariateFunction::coordinate(2,0); + y=EffectiveScalarMultivariateFunction::coordinate(2,1); + x0=EffectiveScalarMultivariateFunction::coordinate(3,0); + y0=EffectiveScalarMultivariateFunction::coordinate(3,1); + t=EffectiveScalarMultivariateFunction::coordinate(3,2); } Int test() { @@ -85,12 +85,12 @@ class TestIntegrator } Void test_constant_derivative() { - EffectiveVectorFunction f={o*2,o*3}; + EffectiveVectorMultivariateFunction f={o*2,o*3}; ARIADNE_TEST_PRINT(f); ExactBoxType d={ExactIntervalType(0.0,1.0),ExactIntervalType(-0.5,1.5)}; StepSizeType h=0.25_x; - ValidatedVectorFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); - EffectiveVectorFunction expected_flow={x0+2*t,y0+3*t}; + ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); + EffectiveVectorMultivariateFunction expected_flow={x0+2*t,y0+3*t}; ARIADNE_TEST_PRINT(flow); ARIADNE_TEST_PRINT(expected_flow); ARIADNE_TEST_PRINT(flow.errors()); @@ -98,11 +98,11 @@ class TestIntegrator } Void test_quadratic_flow() { - EffectiveVectorFunction f={o,x}; + EffectiveVectorMultivariateFunction f={o,x}; ExactBoxType d={ExactIntervalType(0.0,1.0),ExactIntervalType(-0.5,1.5)}; StepSizeType h=0.25_x; - ValidatedVectorFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); - EffectiveVectorFunction expected_flow={x0+t,y0+x0*t+t*t/2}; + ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); + EffectiveVectorMultivariateFunction expected_flow={x0+t,y0+x0*t+t*t/2}; ARIADNE_TEST_PRINT(f); ARIADNE_TEST_PRINT(flow); ARIADNE_TEST_PRINT(expected_flow); @@ -111,11 +111,11 @@ class TestIntegrator } Void test_linear() { - EffectiveVectorFunction f={x,-y}; + EffectiveVectorMultivariateFunction f={x,-y}; ExactBoxType d={ExactIntervalType(-0.25,0.25),ExactIntervalType(-0.25,0.25)}; StepSizeType h=0.25_x; - ValidatedVectorFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); - EffectiveVectorFunction expected_flow={x0*(1+t+t*t/2+t*t*t/6+t*t*t*t/24),y0*(1-t+t*t/2-t*t*t/6+t*t*t*t/24)}; + ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); + EffectiveVectorMultivariateFunction expected_flow={x0*(1+t+t*t/2+t*t*t/6+t*t*t*t/24),y0*(1-t+t*t/2-t*t*t/6+t*t*t*t/24)}; ARIADNE_TEST_PRINT(f); ARIADNE_TEST_PRINT(flow); ARIADNE_TEST_PRINT(expected_flow); @@ -125,11 +125,11 @@ class TestIntegrator Void test_spiral() { Real half(0.5); - EffectiveVectorFunction f={-half*x-y,x-half*y}; + EffectiveVectorMultivariateFunction f={-half*x-y,x-half*y}; ExactBoxType d={ExactIntervalType(0.75,1.25),ExactIntervalType(-0.25,0.25)}; StepSizeType h=0.25_x; - ValidatedVectorFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); - EffectiveVectorFunction expected_flow={exp(-half*t)*(x0*cos(t)-y0*sin(t)),exp(-half*t)*(x0*sin(t)+y0*cos(t))}; + ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); + EffectiveVectorMultivariateFunction expected_flow={exp(-half*t)*(x0*cos(t)-y0*sin(t)),exp(-half*t)*(x0*sin(t)+y0*cos(t))}; ARIADNE_TEST_PRINT(f); ARIADNE_TEST_PRINT(flow); ARIADNE_TEST_PRINT(expected_flow); @@ -140,12 +140,12 @@ class TestIntegrator }; Void test_logistic() { - o=EffectiveScalarFunction::constant(1,1); - x=EffectiveScalarFunction::coordinate(1,0); - x0=EffectiveScalarFunction::coordinate(2,0); - t=EffectiveScalarFunction::coordinate(2,1); + o=EffectiveScalarMultivariateFunction::constant(1,1); + x=EffectiveScalarMultivariateFunction::coordinate(1,0); + x0=EffectiveScalarMultivariateFunction::coordinate(2,0); + t=EffectiveScalarMultivariateFunction::coordinate(2,1); - EffectiveScalarFunction flowf= + EffectiveScalarMultivariateFunction flowf= -1.9364*(x0^6)*(t^12)+0.30657*(x0^5)*(t^12)-18.4777*(x0^8)*(t^11)+10.4865*(x0^7)*(t^11)-3.65151*(x0^6)*(t^11) +0.74626*(x0^5)*(t^11)-0.0792375*(x0^4)*(t^11)+0.00334345*(x0^3)*(t^11) -15.9276*(x0^8)*(t^10)+12.2428*(x0^7)*(t^10)-5.69044*(x0^6)*(t^10)+1.54717*(x0^5)*(t^10)-0.223181*(x0^4)*(t^10)+0.0136828*(x0^3)*(t^10) @@ -158,18 +158,18 @@ class TestIntegrator -2.5*(x0^4)*(t^4)+2.08333*(x0^3)*(t^4)-0.625*(x0^2)*(t^4)+0.0416667*x0*(t^4)-(x0^4)*(t^3) +2*(x0^3)*(t^3)-1.16667*(x0^2)*(t^3)+0.166667*x0*(t^3)+(x0^3)*(t^2)-1.5*(x0^2)*(t^2)+0.5*x0*(t^2)-(x0^2)*t+x0*t+x0; - //EffectiveVectorFunction f=(x*(o-x),o); - EffectiveVectorFunction f={x*(o-x)}; + //EffectiveVectorMultivariateFunction f=(x*(o-x),o); + EffectiveVectorMultivariateFunction f={x*(o-x)}; //ExactIntervalVectorType d=(ExactIntervalType(0.25,0.5),ExactIntervalType(-0.25,0.25)); ExactBoxType d={ExactIntervalType(0.25,0.5)}; StepSizeType h=0.5_x; //ExactIntervalVectorType d(1u,ExactIntervalType(-0.125,+0.125)); //StepSizeType h=0.125_x; - ValidatedVectorFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); + ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); ValidatedVectorTaylorFunctionModelDP taylor_flow=dynamic_cast(flow.reference()); - //EffectiveVectorFunction expected_flow( (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t, y0+t) ); - //EffectiveVectorFunction expected_flow(1u, (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t) ); - EffectiveVectorFunction expected_flow(1u, flowf ); + //EffectiveVectorMultivariateFunction expected_flow( (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t, y0+t) ); + //EffectiveVectorMultivariateFunction expected_flow(1u, (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t) ); + EffectiveVectorMultivariateFunction expected_flow(1u, flowf ); ARIADNE_TEST_PRINT(*integrator_ptr); ARIADNE_TEST_PRINT(f); ARIADNE_TEST_PRINT(flow); diff --git a/tests/solvers/test_nonlinear_programming.cpp b/tests/solvers/test_nonlinear_programming.cpp index 5f69de605..e0301f999 100644 --- a/tests/solvers/test_nonlinear_programming.cpp +++ b/tests/solvers/test_nonlinear_programming.cpp @@ -63,11 +63,11 @@ class TestOptimiser Void test_unconstrained_optimisation() { // Test the feasibility of x0>0, x1>0, 2x1+x2<1 using box [0,2]x[0,2] - List x=EffectiveScalarFunction::coordinates(2); - EffectiveScalarFunction x0s = sqr(x[0]); - EffectiveScalarFunction f(x0s*(12+x0s*(Decimal(6.3)+x0s))+6*x[1]*(x[1]-x[0])); + List x=EffectiveScalarMultivariateFunction::coordinates(2); + EffectiveScalarMultivariateFunction x0s = sqr(x[0]); + EffectiveScalarMultivariateFunction f(x0s*(12+x0s*(Decimal(6.3)+x0s))+6*x[1]*(x[1]-x[0])); ARIADNE_TEST_PRINT(f); - EffectiveVectorFunction g(0u,2u); + EffectiveVectorMultivariateFunction g(0u,2u); ARIADNE_TEST_PRINT(g); ExactBoxType D=ExactBoxType{{-1.0,2.0},{-3.0,5.0}}; ExactBoxType C=ExactBoxType{}; @@ -81,11 +81,11 @@ class TestOptimiser } Void test_equality_constrained_optimisation() { - List x=EffectiveScalarFunction::coordinates(2); - EffectiveScalarFunction f=(sqr(x[0])+sqr(x[1])); + List x=EffectiveScalarMultivariateFunction::coordinates(2); + EffectiveScalarMultivariateFunction f=(sqr(x[0])+sqr(x[1])); ARIADNE_TEST_PRINT(f); Real a(1.5); Real b(0.25); - EffectiveVectorFunction g={a+x[0]+2*x[1]+b*x[0]*x[1]}; + EffectiveVectorMultivariateFunction g={a+x[0]+2*x[1]+b*x[0]*x[1]}; ARIADNE_TEST_PRINT(g); ExactIntervalVectorType C={{0.0,0.0}}; ExactBoxType D=ExactBoxType{{-1.0,2.0},{-3.0,5.0}}; @@ -98,14 +98,14 @@ class TestOptimiser } Void test_constrained_optimisation() { - List x=EffectiveScalarFunction::coordinates(3); - EffectiveScalarFunction x0s = sqr(x[0]); - EffectiveScalarFunction f = x0s*(12+x0s*(Decimal(6.3)+x0s))+6*x[1]*(x[1]-x[0])+x[2]; + List x=EffectiveScalarMultivariateFunction::coordinates(3); + EffectiveScalarMultivariateFunction x0s = sqr(x[0]); + EffectiveScalarMultivariateFunction f = x0s*(12+x0s*(Decimal(6.3)+x0s))+6*x[1]*(x[1]-x[0])+x[2]; ARIADNE_TEST_PRINT(f); - //EffectiveVectorFunction g( (x[0]-1, x[0]+x[1]*x[1], x[1]*x[1]) ); + //EffectiveVectorMultivariateFunction g( (x[0]-1, x[0]+x[1]*x[1], x[1]*x[1]) ); ExactBoxType D = ExactBoxType{{-1.0,2.0},{-3.0,5.0},{-3.0,5.0}}; ARIADNE_TEST_PRINT(D); - EffectiveVectorFunction g = {2*x[1]+x[0], x[0]+x[1]*x[1]-Real(0.875)}; + EffectiveVectorMultivariateFunction g = {2*x[1]+x[0], x[0]+x[1]*x[1]-Real(0.875)}; ARIADNE_TEST_PRINT(g); ExactBoxType C = ExactBoxType{{0.0,inf},{0.0,inf}}; ARIADNE_TEST_PRINT(C); @@ -118,14 +118,14 @@ class TestOptimiser } Void test_mixed_constrained_optimisation() { - List x=EffectiveScalarFunction::coordinates(3); - EffectiveScalarFunction f(+(sqr(x[0])+sqr(x[1])+x[1]*x[2])); + List x=EffectiveScalarMultivariateFunction::coordinates(3); + EffectiveScalarMultivariateFunction f(+(sqr(x[0])+sqr(x[1])+x[1]*x[2])); ARIADNE_TEST_PRINT(f); ExactBoxType D = ExactBoxType{{-1.0,2.0},{-3.0,5.0},{1.25,2.25}}; ARIADNE_TEST_PRINT(D); - EffectiveScalarFunction g = x[0]*x[1]-x[0]*Real(1.25); - EffectiveVectorFunction h = {Real(1.5)+x[0]+2*x[1]+Real(0.25)*x[0]*x[1]}; - EffectiveVectorFunction gh=join(g,h); + EffectiveScalarMultivariateFunction g = x[0]*x[1]-x[0]*Real(1.25); + EffectiveVectorMultivariateFunction h = {Real(1.5)+x[0]+2*x[1]+Real(0.25)*x[0]*x[1]}; + EffectiveVectorMultivariateFunction gh=join(g,h); ARIADNE_TEST_PRINT(gh); ExactBoxType C = ExactBoxType {{-1.0,-0.5},{0.0,0.0}}; ARIADNE_TEST_PRINT(C); @@ -137,8 +137,8 @@ class TestOptimiser Void test_linear_feasibility() { // Test the feasibility of x0>0, x1>0, 2x1+x2<1 using box [0,2]x[0,2] - List x=EffectiveScalarFunction::coordinates(2); - EffectiveVectorFunction g=EffectiveVectorFunction(1u, 2*x[0]+x[1]); + List x=EffectiveScalarMultivariateFunction::coordinates(2); + EffectiveVectorMultivariateFunction g=EffectiveVectorMultivariateFunction(1u, 2*x[0]+x[1]); ARIADNE_TEST_PRINT(g); ExactBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; ExactBoxType C = ExactBoxType{{-2.0,1.0}}; @@ -152,8 +152,8 @@ class TestOptimiser Void test_nonlinear_feasibility() { // Test the feasibility of x0>0, x1>0, 2x1+x2<1 using box [0,2]x[0,2] - List x=EffectiveScalarFunction::coordinates(2); - EffectiveVectorFunction g = {2*x[0]+x[1]+x[0]*x[1]/8}; + List x=EffectiveScalarMultivariateFunction::coordinates(2); + EffectiveVectorMultivariateFunction g = {2*x[0]+x[1]+x[0]*x[1]/8}; ARIADNE_TEST_PRINT(g); ExactBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; ExactBoxType C = ExactBoxType{{-2.0,1.0}}; @@ -167,8 +167,8 @@ class TestOptimiser Void test_nonlinear_equality_feasibility() { // Test the feasibility of x0>0, x1>0, 2x1+x2<1 using box [0,2]x[0,2] - List x=EffectiveScalarFunction::coordinates(2); - EffectiveVectorFunction h = { 2*x[0]-x[1]+x[0]*x[1]/8 }; + List x=EffectiveScalarMultivariateFunction::coordinates(2); + EffectiveVectorMultivariateFunction h = { 2*x[0]-x[1]+x[0]*x[1]/8 }; ARIADNE_TEST_PRINT(h); ExactBoxType D = ExactBoxType{{0.0,2.0},{0.0,2.0}}; ExactBoxType C = ExactBoxType{{0.0,0.0}}; @@ -177,8 +177,8 @@ class TestOptimiser } Void test_feasibility_check() { - EffectiveVectorFunction x=EffectiveVectorFunction::identity(2); - ARIADNE_TEST_CONSTRUCT( EffectiveVectorFunction, g, ({sqr(x[0])+2*sqr(x[1])-1}) ); + EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); + ARIADNE_TEST_CONSTRUCT( EffectiveVectorMultivariateFunction, g, ({sqr(x[0])+2*sqr(x[1])-1}) ); ARIADNE_TEST_CONSTRUCT( ExactIntervalVectorType, D, ({{-1.0, 1.0},{-1.0,1.0}}) ); ARIADNE_TEST_CONSTRUCT( ExactIntervalVectorType, C, ({{0.0,0.0}}) ); diff --git a/tests/solvers/test_solvers.cpp b/tests/solvers/test_solvers.cpp index 74a909e6a..8e4f681b2 100644 --- a/tests/solvers/test_solvers.cpp +++ b/tests/solvers/test_solvers.cpp @@ -63,9 +63,9 @@ class TestSolver } Void test_solve() { - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(1,0); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(1,0); ExactIntervalVectorType d({ExactIntervalType(0.0,1.0)}); - EffectiveVectorFunction f({(x*x+1)*x-1}); + EffectiveVectorMultivariateFunction f({(x*x+1)*x-1}); FloatBoundsVector p=solver->solve(f,d); ARIADNE_TEST_BINARY_PREDICATE(contains,ExactIntervalType(0.6823,0.6824),p[0]); } @@ -74,50 +74,50 @@ class TestSolver //TaylorModelAccuracy::set_default_sweep_threshold(1e-12); // FIXME: Should be able to use numbers yielding exact results for p,r - EffectiveScalarFunction aa=EffectiveScalarFunction::coordinate(1,0); - EffectiveScalarFunction a=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,1); - EffectiveScalarFunction bb; + EffectiveScalarMultivariateFunction aa=EffectiveScalarMultivariateFunction::coordinate(1,0); + EffectiveScalarMultivariateFunction a=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction bb; ExactIntervalVectorType p,r; - EffectiveVectorFunction f; - ValidatedVectorFunctionModelDP h; - EffectiveVectorFunction e; + EffectiveVectorMultivariateFunction f; + ValidatedVectorMultivariateFunctionModelDP h; + EffectiveVectorMultivariateFunction e; FloatDPValue tol; // Test solution of x-a=0. This should be very easy to solve. p=ExactIntervalVectorType({ExactIntervalType(-0.25,0.25)}); r=ExactIntervalVectorType({ExactIntervalType(-2.0,2.0)}); - f=EffectiveVectorFunction({x-a}); + f=EffectiveVectorMultivariateFunction({x-a}); ARIADNE_TEST_PRINT(f); h=solver->implicit(f,p,r); ARIADNE_TEST_PRINT(h); - e=EffectiveVectorFunction(1u,aa); + e=EffectiveVectorMultivariateFunction(1u,aa); ARIADNE_TEST_PRINT(e); ARIADNE_TEST_COMPARE(norm(h-e),<,1e-8); // Test solution of 4x^2+x-4-a=0 on [0.875,1.125]. There is a unique solution with positive derivative. p=ExactIntervalVectorType({ExactIntervalType(0.875,1.125)}); r=ExactIntervalVectorType({ExactIntervalType(0.25,1.25)}); - f=EffectiveVectorFunction({(x*x+1)*x-a}); + f=EffectiveVectorMultivariateFunction({(x*x+1)*x-a}); ARIADNE_TEST_PRINT(f); h=solver->implicit(f,p,r); ARIADNE_TEST_PRINT(h); - bb=EffectiveScalarFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); + bb=EffectiveScalarMultivariateFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); Decimal a0(0.682328), a1(0.0521547), a2(-0.0023232), a3(0.000147778); - e=EffectiveVectorFunction( { a0+bb*(a1+bb*(a2+bb*a3)) } ); + e=EffectiveVectorMultivariateFunction( { a0+bb*(a1+bb*(a2+bb*a3)) } ); ARIADNE_TEST_PRINT(e); ARIADNE_TEST_COMPARE(norm(h-e),<,1e-4); // Test solution of 4x^2+x-4-a=0 on [-0.25,0.25]. There is a unique solution with positive derivative. p=ExactIntervalVectorType({ExactIntervalType(-0.25,0.25)}); r=ExactIntervalVectorType({ExactIntervalType(0.25,2.0)}); - f=EffectiveVectorFunction({4*x+x*x-a-4}); + f=EffectiveVectorMultivariateFunction({4*x+x*x-a-4}); ARIADNE_TEST_PRINT(f); h=solver->implicit(f,p,r); ARIADNE_TEST_PRINT(h); - bb=EffectiveScalarFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); + bb=EffectiveScalarMultivariateFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); Decimal c0(0.828427), c1(0.0441942), c2(-0.000345267), c3(0.00000539468); - e=EffectiveVectorFunction( { c0+bb*(c1+bb*(c2+bb*c3)) } ); + e=EffectiveVectorMultivariateFunction( { c0+bb*(c1+bb*(c2+bb*c3)) } ); ARIADNE_TEST_PRINT(e); ARIADNE_TEST_COMPARE(norm(h-e),<,1e-4); @@ -126,7 +126,7 @@ class TestSolver // Should obtain PartialSolutionException p=ExactIntervalVectorType({ExactIntervalType(-1,1)}); r=ExactIntervalVectorType({ExactIntervalType(-1,1)}); - f=EffectiveVectorFunction({x-2*a}); + f=EffectiveVectorMultivariateFunction({x-2*a}); ARIADNE_TEST_PRINT(f); try { h=solver->implicit(f,p,r); @@ -142,27 +142,27 @@ class TestSolver Void test_scalar_implicit() { //TaylorModelAccuracy::set_default_sweep_threshold(1e-12); - EffectiveScalarFunction aa=EffectiveScalarFunction::coordinate(1,0); - EffectiveScalarFunction a=EffectiveScalarFunction::coordinate(2,0); - EffectiveScalarFunction x=EffectiveScalarFunction::coordinate(2,1); + EffectiveScalarMultivariateFunction aa=EffectiveScalarMultivariateFunction::coordinate(1,0); + EffectiveScalarMultivariateFunction a=EffectiveScalarMultivariateFunction::coordinate(2,0); + EffectiveScalarMultivariateFunction x=EffectiveScalarMultivariateFunction::coordinate(2,1); // Test solution of x-2*a=0 on [-1,+1], taking values in [-1,+1]. There is at most one solution. // Uses scalar implicit ExactIntervalVectorType p; ExactIntervalType r; - EffectiveScalarFunction e,f,s; // s is unscaling functions - ValidatedScalarFunctionModelDP h; + EffectiveScalarMultivariateFunction e,f,s; // s is unscaling functions + ValidatedScalarMultivariateFunctionModelDP h; ARIADNE_TEST_PRINT(*solver); // Test solution of 4x^2+x-4-a=0 on [0.875,1.125]. There is a unique solution with positive derivative. p=ExactIntervalVectorType({ExactIntervalType(0.875,1.125)}); r=ExactIntervalType(0.25,1.25); - f=EffectiveScalarFunction((x*x+1)*x-a); + f=EffectiveScalarMultivariateFunction((x*x+1)*x-a); ARIADNE_TEST_PRINT(f); h=solver->implicit(f,p,r); ARIADNE_TEST_PRINT(h); - s=EffectiveScalarFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); + s=EffectiveScalarMultivariateFunction(aa-DyadicInterval(p[0]).midpoint())/DyadicInterval(p[0]).radius(); Decimal a0(0.682328), a1(0.0521547), a2(-0.0023232), a3(0.000147778); - e=EffectiveScalarFunction( a0+s*(a1+s*(a2+s*a3)) ); + e=EffectiveScalarMultivariateFunction( a0+s*(a1+s*(a2+s*a3)) ); ARIADNE_TEST_PRINT(e); ARIADNE_TEST_COMPARE(mag((h-e).range()),<,1e-4); @@ -171,9 +171,9 @@ class TestSolver // Should obtain PartialSolutionException p=ExactIntervalVectorType({ExactIntervalType(-1,1)}); r=ExactIntervalType(-1,1); - f=EffectiveScalarFunction(x-2*a); + f=EffectiveScalarMultivariateFunction(x-2*a); ARIADNE_TEST_PRINT(f); - ValidatedScalarFunctionModelDP g=ValidatedScalarTaylorFunctionModelDP(join(p,r),f,ThresholdSweeper(dp,1e-12)); + ValidatedScalarMultivariateFunctionModelDP g=ValidatedScalarTaylorFunctionModelDP(join(p,r),f,ThresholdSweeper(dp,1e-12)); ARIADNE_TEST_PRINT(g); try { h=solver->implicit(g,p,r); diff --git a/tests/symbolic/test_expression.cpp b/tests/symbolic/test_expression.cpp index 059e4b62a..544270a3e 100644 --- a/tests/symbolic/test_expression.cpp +++ b/tests/symbolic/test_expression.cpp @@ -200,30 +200,30 @@ class TestExpression { RealConstant c("5",tc); RealExpression e1=c; - EffectiveScalarFunction f1=make_function(e1,RealSpace(List({x,y,z}))); + EffectiveScalarMultivariateFunction f1=make_function(e1,RealSpace(List({x,y,z}))); ARIADNE_TEST_PRINT(f1); ARIADNE_TEST_EQUAL(f1.evaluate(tv), tc); RealExpression e2=c+x; - EffectiveScalarFunction f2=make_function(e2,RealSpace(List({x,y,z}))); + EffectiveScalarMultivariateFunction f2=make_function(e2,RealSpace(List({x,y,z}))); ARIADNE_TEST_PRINT(f2); ARIADNE_TEST_EQUAL(f2.evaluate(tv), tc+tx); RealExpression e3=c+x+c*y; - EffectiveScalarFunction f3=make_function(e3,{x,y,z}); + EffectiveScalarMultivariateFunction f3=make_function(e3,{x,y,z}); ARIADNE_TEST_PRINT(f3); ARIADNE_TEST_EQUAL(f3.evaluate(tv), tc+tx+tc*ty); RealExpression e4=exp(c+x); - EffectiveScalarFunction f4=make_function(e4,{x,y,z}); + EffectiveScalarMultivariateFunction f4=make_function(e4,{x,y,z}); ARIADNE_TEST_PRINT(f4); ARIADNE_TEST_ASSERT(possibly((f4.evaluate(tv) == exp(tc+tx)).check(Effort(0)))); - //ARIADNE_TEST_EVALUATE(EffectiveVectorFunction((x+y,y+z*z),(x,y,z))[0]); - //ARIADNE_TEST_EQUAL(EffectiveVectorFunction((x+y,y+z*z),(x,y,z))[0],EffectiveScalarFunction(x+y,(x,y,z))); + //ARIADNE_TEST_EVALUATE(EffectiveVectorMultivariateFunction((x+y,y+z*z),(x,y,z))[0]); + //ARIADNE_TEST_EQUAL(EffectiveVectorMultivariateFunction((x+y,y+z*z),(x,y,z))[0],EffectiveScalarMultivariateFunction(x+y,(x,y,z))); - //ARIADNE_TEST_EVALUATE(EffectiveVectorFunction((dot(x),dot(y)),(dot(x)=x+y,dot(y)=y+z*z),(x,y,z))[0]); - //ARIADNE_TEST_EQUAL(EffectiveVectorFunction((x+y,y+z*z),(x,y,z))[0],EffectiveScalarFunction(x+y,(x,y,z))); + //ARIADNE_TEST_EVALUATE(EffectiveVectorMultivariateFunction((dot(x),dot(y)),(dot(x)=x+y,dot(y)=y+z*z),(x,y,z))[0]); + //ARIADNE_TEST_EQUAL(EffectiveVectorMultivariateFunction((x+y,y+z*z),(x,y,z))[0],EffectiveScalarMultivariateFunction(x+y,(x,y,z))); EffectiveAlgebra ax=RealExpression(x); EffectiveAlgebra ay=RealExpression(y); diff --git a/tutorials/rigorous_numerics/rigorous_numerics_tutorial.cpp b/tutorials/rigorous_numerics/rigorous_numerics_tutorial.cpp index e4c3f1507..792b7ecae 100644 --- a/tutorials/rigorous_numerics/rigorous_numerics_tutorial.cpp +++ b/tutorials/rigorous_numerics/rigorous_numerics_tutorial.cpp @@ -88,9 +88,9 @@ int main() { //! [function_demonstration] { Real a(1.875_dy), b(0.3_dec); - auto id=EffectiveVectorFunction::identity(EuclideanDomain(2)); + auto id=EffectiveVectorMultivariateFunction::identity(EuclideanDomain(2)); auto x=id[0]; auto y=id[1]; - auto h = EffectiveVectorFunction{a-x*x-b*y,x}; + auto h = EffectiveVectorMultivariateFunction{a-x*x-b*y,x}; // Vector v({0.5_x,1.0_x},double_precision); Vector v({0.5,1.0},double_precision); print(v); @@ -115,10 +115,10 @@ int main() { //! [geometry_demonstration] { - auto x=EffectiveScalarFunction::coordinate(EuclideanDomain(2),0); - auto y=EffectiveScalarFunction::coordinate(EuclideanDomain(2),1); + auto x=EffectiveScalarMultivariateFunction::coordinate(EuclideanDomain(2),0); + auto y=EffectiveScalarMultivariateFunction::coordinate(EuclideanDomain(2),1); auto g = sqr(x)+4*sqr(y); - auto h = EffectiveVectorFunction{1+x+y*y,2+x-y}; + auto h = EffectiveVectorMultivariateFunction{1+x+y*y,2+x-y}; EffectiveConstraint c=(g<=1); ConstraintSet cs={c}; RealBox bx={{-2,+2},{-2,+2}}; From 7d0fe4adeb81287294c7e79a0fa525e73d07b88a Mon Sep 17 00:00:00 2001 From: Pieter Collins Date: Tue, 25 Sep 2018 17:31:29 +0200 Subject: [PATCH 6/8] Changed TaylorFunctionModel typedefs to include 'Multivariate' explicitly. --- python/source/calculus_submodule.cpp | 138 ++++++------ python/source/function_submodule.cpp | 2 +- source/dynamics/differential_inclusion.cpp | 50 ++--- source/function/affine_model.tpl.hpp | 2 +- source/function/function_model.hpp | 4 +- source/function/scaled_function_patch.hpp | 8 +- source/function/taylor_function.hpp | 23 +- source/function/taylor_model.hpp | 2 +- source/geometry/enclosure.cpp | 18 +- source/geometry/function_set.cpp | 30 +-- source/geometry/paver.cpp | 28 +-- source/hybrid/hybrid_enclosure.cpp | 2 +- source/solvers/constraint_solver.cpp | 12 +- source/solvers/constraint_solver.hpp | 6 +- source/solvers/integrator.cpp | 8 +- source/solvers/nonlinear_programming.cpp | 12 +- source/symbolic/function_expression.hpp | 4 +- tests/function/test_taylor_function.cpp | 200 +++++++++--------- tests/solvers/test_integrator.cpp | 2 +- tests/solvers/test_solvers.cpp | 21 +- .../rigorous_numerics_tutorial.cpp | 2 +- 21 files changed, 274 insertions(+), 300 deletions(-) diff --git a/python/source/calculus_submodule.cpp b/python/source/calculus_submodule.cpp index 16c8186cc..685dfe13e 100644 --- a/python/source/calculus_submodule.cpp +++ b/python/source/calculus_submodule.cpp @@ -67,13 +67,13 @@ template OutputStream& operator< static_cast&>(frepr.reference()).repr(os); return os; } -ValidatedVectorTaylorFunctionModelDP __getslice__(const ValidatedVectorTaylorFunctionModelDP& tf, Int start, Int stop) { +ValidatedVectorMultivariateTaylorFunctionModelDP __getslice__(const ValidatedVectorMultivariateTaylorFunctionModelDP& tf, Int start, Int stop) { Int rs = tf.result_size(); if(start<0) { start+=rs; } if(stop<0) { stop+=rs; } ARIADNE_ASSERT_MSG(0<=start&&start<=stop&&stop<=rs, "result_size="<& repr) { - const ValidatedVectorTaylorFunctionModelDP& vtf=repr.reference(); +OutputStream& operator<<(OutputStream& os, const PythonRepresentation& repr) { + const ValidatedVectorMultivariateTaylorFunctionModelDP& vtf=repr.reference(); os << std::setprecision(17); os << "ValidatedVectorMultivariateTaylorFunctionModelDP" << "(" << python_representation(vtf.domain()) @@ -317,7 +317,7 @@ Void export_scalar_function_model(pybind11::module& module) { pybind11::class_ scalar_function_model_class(module,"ValidatedScalarMultivariateFunctionModel"); scalar_function_model_class.def(pybind11::init()); - scalar_function_model_class.def(pybind11::init()); + scalar_function_model_class.def(pybind11::init()); scalar_function_model_class.def("argument_size", &ValidatedScalarMultivariateFunctionModelDP::argument_size); scalar_function_model_class.def("domain", &ValidatedScalarMultivariateFunctionModelDP::domain); scalar_function_model_class.def("codomain", &ValidatedScalarMultivariateFunctionModelDP::codomain); @@ -360,13 +360,13 @@ Void export_vector_function_model(pybind11::module& module) pybind11::class_ vector_function_model_class(module,"ValidatedVectorMultivariateFunctionModel"); vector_function_model_class.def(pybind11::init()); // vector_function_model_class.def(pybind11::init([](Array ary){return ValidatedVectorMultivariateFunctionModelDP(Vector(ary));})); - vector_function_model_class.def(pybind11::init()); + vector_function_model_class.def(pybind11::init()); vector_function_model_class.def("result_size", &ValidatedVectorMultivariateFunctionModelDP::result_size); vector_function_model_class.def("argument_size", &ValidatedVectorMultivariateFunctionModelDP::argument_size); vector_function_model_class.def("domain", &ValidatedVectorMultivariateFunctionModelDP::domain); vector_function_model_class.def("codomain", &ValidatedVectorMultivariateFunctionModelDP::codomain); vector_function_model_class.def("range", &ValidatedVectorMultivariateFunctionModelDP::range); - //vector_function_model_class.def("__getslice__", (ValidatedVectorTaylorFunctionModelDP(*)(const ValidatedVectorTaylorFunctionModelDP&,Int,Int))&__getslice__); + //vector_function_model_class.def("__getslice__", (ValidatedVectorMultivariateTaylorFunctionModelDP(*)(const ValidatedVectorMultivariateTaylorFunctionModelDP&,Int,Int))&__getslice__); vector_function_model_class.def("__getitem__", &__getitem__); vector_function_model_class.def("__setitem__",&__setitem__); //vector_function_model_class.def("__setitem__",&__setitem__); @@ -406,14 +406,14 @@ Void export_vector_function_model(pybind11::module& module) Void export_scalar_taylor_function(pybind11::module& module) { - using FunctionModelType = ValidatedScalarTaylorFunctionModelDP; + using FunctionModelType = ValidatedScalarMultivariateTaylorFunctionModelDP; // using FunctionType = ScalarMultivariateFunction>; using GenericFunctionType = ScalarMultivariateFunction; using NumericType = NumericType; using GenericNumericType = GenericType; - typedef ValidatedScalarTaylorFunctionModelDP F; - typedef ValidatedVectorTaylorFunctionModelDP VF; + typedef ValidatedScalarMultivariateTaylorFunctionModelDP F; + typedef ValidatedVectorMultivariateTaylorFunctionModelDP VF; typedef typename F::DomainType D; typedef typename F::NumericType X; typedef Vector VX; @@ -422,23 +422,23 @@ Void export_scalar_taylor_function(pybind11::module& module) Tag generic_number_tag; Tag generic_function_tag; - pybind11::class_ scalar_taylor_function_class(module,"ValidatedScalarMultivariateTaylorFunctionModel"); - scalar_taylor_function_class.def(pybind11::init()); + pybind11::class_ scalar_taylor_function_class(module,"ValidatedScalarMultivariateTaylorFunctionModel"); + scalar_taylor_function_class.def(pybind11::init()); scalar_taylor_function_class.def(pybind11::init()); scalar_taylor_function_class.def(pybind11::init< ExactBoxType,SweeperDP >()); scalar_taylor_function_class.def(pybind11::init< ExactBoxType, const EffectiveScalarMultivariateFunction&,SweeperDP >()); scalar_taylor_function_class.def(pybind11::init< ExactBoxType, Expansion, FloatDPError, SweeperDP >()); - scalar_taylor_function_class.def("error", (const FloatDPError&(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::error); - scalar_taylor_function_class.def("set_error", (Void(ValidatedScalarTaylorFunctionModelDP::*)(const FloatDPError&)) &ValidatedScalarTaylorFunctionModelDP::set_error); + scalar_taylor_function_class.def("error", (const FloatDPError&(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const) &ValidatedScalarMultivariateTaylorFunctionModelDP::error); + scalar_taylor_function_class.def("set_error", (Void(ValidatedScalarMultivariateTaylorFunctionModelDP::*)(const FloatDPError&)) &ValidatedScalarMultivariateTaylorFunctionModelDP::set_error); scalar_taylor_function_class.def("argument_size", &F::argument_size); scalar_taylor_function_class.def("domain", &F::domain); scalar_taylor_function_class.def("codomain", &F::codomain); scalar_taylor_function_class.def("range", &F::range); - scalar_taylor_function_class.def("model", (const ValidatedTaylorModelDP&(ValidatedScalarTaylorFunctionModelDP::*)()const)&ValidatedScalarTaylorFunctionModelDP::model); - scalar_taylor_function_class.def("polynomial", (Polynomial(ValidatedScalarTaylorFunctionModelDP::*)()const)&ValidatedScalarTaylorFunctionModelDP::polynomial); - scalar_taylor_function_class.def("number_of_nonzeros", (SizeType(ValidatedScalarTaylorFunctionModelDP::*)()const)&ValidatedScalarTaylorFunctionModelDP::number_of_nonzeros); - scalar_taylor_function_class.def("__getitem__", &__getitem__); - scalar_taylor_function_class.def("__setitem__",&__setitem__); + scalar_taylor_function_class.def("model", (const ValidatedTaylorModelDP&(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const)&ValidatedScalarMultivariateTaylorFunctionModelDP::model); + scalar_taylor_function_class.def("polynomial", (Polynomial(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const)&ValidatedScalarMultivariateTaylorFunctionModelDP::polynomial); + scalar_taylor_function_class.def("number_of_nonzeros", (SizeType(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const)&ValidatedScalarMultivariateTaylorFunctionModelDP::number_of_nonzeros); + scalar_taylor_function_class.def("__getitem__", &__getitem__); + scalar_taylor_function_class.def("__setitem__",&__setitem__); define_elementary_algebra(module,scalar_taylor_function_class); define_inplace_algebra(module,scalar_taylor_function_class); @@ -450,23 +450,23 @@ Void export_scalar_taylor_function(pybind11::module& module) scalar_taylor_function_class.def("__str__", &__cstr__); scalar_taylor_function_class.def("__repr__", &__crepr__); - scalar_taylor_function_class.def("value", (const FloatDPValue&(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::value); - scalar_taylor_function_class.def("clobber", (Void(ValidatedScalarTaylorFunctionModelDP::*)()) &ValidatedScalarTaylorFunctionModelDP::clobber); - scalar_taylor_function_class.def("set_properties",&ValidatedScalarTaylorFunctionModelDP::set_properties); - scalar_taylor_function_class.def("properties",&ValidatedScalarTaylorFunctionModelDP::properties); - scalar_taylor_function_class.def("__call__", (FloatDPApproximation(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::operator()); - scalar_taylor_function_class.def("__call__", (FloatDPBounds(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::operator()); - scalar_taylor_function_class.def("gradient", (Covector(ValidatedScalarTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarTaylorFunctionModelDP::gradient); - scalar_taylor_function_class.def("function", (ValidatedScalarMultivariateFunction(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::function); - scalar_taylor_function_class.def("polynomial", (Polynomial(ValidatedScalarTaylorFunctionModelDP::*)()const) &ValidatedScalarTaylorFunctionModelDP::polynomial); + scalar_taylor_function_class.def("value", (const FloatDPValue&(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const) &ValidatedScalarMultivariateTaylorFunctionModelDP::value); + scalar_taylor_function_class.def("clobber", (Void(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()) &ValidatedScalarMultivariateTaylorFunctionModelDP::clobber); + scalar_taylor_function_class.def("set_properties",&ValidatedScalarMultivariateTaylorFunctionModelDP::set_properties); + scalar_taylor_function_class.def("properties",&ValidatedScalarMultivariateTaylorFunctionModelDP::properties); + scalar_taylor_function_class.def("__call__", (FloatDPApproximation(ValidatedScalarMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarMultivariateTaylorFunctionModelDP::operator()); + scalar_taylor_function_class.def("__call__", (FloatDPBounds(ValidatedScalarMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarMultivariateTaylorFunctionModelDP::operator()); + scalar_taylor_function_class.def("gradient", (Covector(ValidatedScalarMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedScalarMultivariateTaylorFunctionModelDP::gradient); + scalar_taylor_function_class.def("function", (ValidatedScalarMultivariateFunction(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const) &ValidatedScalarMultivariateTaylorFunctionModelDP::function); + scalar_taylor_function_class.def("polynomial", (Polynomial(ValidatedScalarMultivariateTaylorFunctionModelDP::*)()const) &ValidatedScalarMultivariateTaylorFunctionModelDP::polynomial); scalar_taylor_function_class.def("restriction", &_restriction_); module.def("restrict", &_restriction_); // scalar_taylor_function_class.def("extension",&_extension_); - scalar_taylor_function_class.def_static("zero",(ValidatedScalarTaylorFunctionModelDP(*)(const ExactBoxType&,SweeperDP))&ValidatedScalarTaylorFunctionModelDP::zero); - scalar_taylor_function_class.def_static("constant",(ValidatedScalarTaylorFunctionModelDP(*)(const ExactBoxType&,const ValidatedNumericType&,SweeperDP))&ValidatedScalarTaylorFunctionModelDP::constant); - scalar_taylor_function_class.def_static("constant",[](const ExactBoxType& bx, const ValidatedNumber& c,SweeperDP swp){return ValidatedScalarTaylorFunctionModelDP::constant(bx,ValidatedNumericType(c,swp.precision()),swp);}); - scalar_taylor_function_class.def_static("coordinate",(ValidatedScalarTaylorFunctionModelDP(*)(const ExactBoxType&,SizeType,SweeperDP))&ValidatedScalarTaylorFunctionModelDP::coordinate); + scalar_taylor_function_class.def_static("zero",(ValidatedScalarMultivariateTaylorFunctionModelDP(*)(const ExactBoxType&,SweeperDP))&ValidatedScalarMultivariateTaylorFunctionModelDP::zero); + scalar_taylor_function_class.def_static("constant",(ValidatedScalarMultivariateTaylorFunctionModelDP(*)(const ExactBoxType&,const ValidatedNumericType&,SweeperDP))&ValidatedScalarMultivariateTaylorFunctionModelDP::constant); + scalar_taylor_function_class.def_static("constant",[](const ExactBoxType& bx, const ValidatedNumber& c,SweeperDP swp){return ValidatedScalarMultivariateTaylorFunctionModelDP::constant(bx,ValidatedNumericType(c,swp.precision()),swp);}); + scalar_taylor_function_class.def_static("coordinate",(ValidatedScalarMultivariateTaylorFunctionModelDP(*)(const ExactBoxType&,SizeType,SweeperDP))&ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate); module.def("restriction", &_restriction_); @@ -486,7 +486,7 @@ Void export_scalar_taylor_function(pybind11::module& module) module.def("refinement", &_refinement_); -// to_python< Vector >(); +// to_python< Vector >(); } @@ -500,8 +500,8 @@ Void export_vector_taylor_function(pybind11::module& module) typedef SizeType I; typedef ValidatedScalarMultivariateFunction SFN; typedef ValidatedVectorMultivariateFunction VFN; - typedef ValidatedScalarTaylorFunctionModelDP SF; - typedef ValidatedVectorTaylorFunctionModelDP VF; + typedef ValidatedScalarMultivariateTaylorFunctionModelDP SF; + typedef ValidatedVectorMultivariateTaylorFunctionModelDP VF; typedef typename VF::DomainType D; typedef typename D::ScalarType Di; typedef typename VF::NumericType X; @@ -510,49 +510,49 @@ Void export_vector_taylor_function(pybind11::module& module) Tag scalar_taylor_function_tag; Tag> number_vector_tag; - pybind11::class_ vector_taylor_function_class(module,"ValidatedVectorMultivariateTaylorFunctionModel"); - vector_taylor_function_class.def( pybind11::init()); -// vector_taylor_function_class.def( pybind11::init>()); - vector_taylor_function_class.def( pybind11::init([](Array ary){return ValidatedVectorTaylorFunctionModelDP(Vector(ary));})); + pybind11::class_ vector_taylor_function_class(module,"ValidatedVectorMultivariateTaylorFunctionModel"); + vector_taylor_function_class.def( pybind11::init()); +// vector_taylor_function_class.def( pybind11::init>()); + vector_taylor_function_class.def( pybind11::init([](Array ary){return ValidatedVectorMultivariateTaylorFunctionModelDP(Vector(ary));})); vector_taylor_function_class.def( pybind11::init< SizeType, ExactBoxType, SweeperDP >()); vector_taylor_function_class.def( pybind11::init< ExactBoxType,const EffectiveVectorMultivariateFunction&,SweeperDP >()); vector_taylor_function_class.def(pybind11::init< ExactBoxType, Vector< Expansion >, Vector, SweeperDP >()); - vector_taylor_function_class.def( pybind11::init< Vector >()); - vector_taylor_function_class.def("_len_", &ValidatedVectorTaylorFunctionModelDP::result_size); - vector_taylor_function_class.def("result_size", &ValidatedVectorTaylorFunctionModelDP::result_size); - vector_taylor_function_class.def("argument_size", &ValidatedVectorTaylorFunctionModelDP::argument_size); - vector_taylor_function_class.def("domain", &ValidatedVectorTaylorFunctionModelDP::domain); - vector_taylor_function_class.def("codomain", &ValidatedVectorTaylorFunctionModelDP::codomain); + vector_taylor_function_class.def( pybind11::init< Vector >()); + vector_taylor_function_class.def("_len_", &ValidatedVectorMultivariateTaylorFunctionModelDP::result_size); + vector_taylor_function_class.def("result_size", &ValidatedVectorMultivariateTaylorFunctionModelDP::result_size); + vector_taylor_function_class.def("argument_size", &ValidatedVectorMultivariateTaylorFunctionModelDP::argument_size); + vector_taylor_function_class.def("domain", &ValidatedVectorMultivariateTaylorFunctionModelDP::domain); + vector_taylor_function_class.def("codomain", &ValidatedVectorMultivariateTaylorFunctionModelDP::codomain); // FIXME: Omitted since const and non-const versions - // vector_taylor_function_class.def("models", &ValidatedVectorTaylorFunctionModelDP::models); - vector_taylor_function_class.def("centre", &ValidatedVectorTaylorFunctionModelDP::centre); - vector_taylor_function_class.def("range", &ValidatedVectorTaylorFunctionModelDP::range); - vector_taylor_function_class.def("errors", &ValidatedVectorTaylorFunctionModelDP::errors); - vector_taylor_function_class.def("clobber", (Void(ValidatedVectorTaylorFunctionModelDP::*)()) &ValidatedVectorTaylorFunctionModelDP::clobber); - vector_taylor_function_class.def("set_properties",&ValidatedVectorTaylorFunctionModelDP::set_properties); - vector_taylor_function_class.def("properties",&ValidatedVectorTaylorFunctionModelDP::properties); + // vector_taylor_function_class.def("models", &ValidatedVectorMultivariateTaylorFunctionModelDP::models); + vector_taylor_function_class.def("centre", &ValidatedVectorMultivariateTaylorFunctionModelDP::centre); + vector_taylor_function_class.def("range", &ValidatedVectorMultivariateTaylorFunctionModelDP::range); + vector_taylor_function_class.def("errors", &ValidatedVectorMultivariateTaylorFunctionModelDP::errors); + vector_taylor_function_class.def("clobber", (Void(ValidatedVectorMultivariateTaylorFunctionModelDP::*)()) &ValidatedVectorMultivariateTaylorFunctionModelDP::clobber); + vector_taylor_function_class.def("set_properties",&ValidatedVectorMultivariateTaylorFunctionModelDP::set_properties); + vector_taylor_function_class.def("properties",&ValidatedVectorMultivariateTaylorFunctionModelDP::properties); //FIXME: Omitted since project(...) fails - //vector_taylor_function_class.def("__getslice__", &__getslice__); - vector_taylor_function_class.def("__getitem__", &__getitem__); - vector_taylor_function_class.def("__setitem__",&__setitem__); + //vector_taylor_function_class.def("__getslice__", &__getslice__); + vector_taylor_function_class.def("__getitem__", &__getitem__); + vector_taylor_function_class.def("__setitem__",&__setitem__); define_vector_arithmetic(module,vector_taylor_function_class, scalar_taylor_function_tag); //FIXME: Not completely defined in C++ API //define_inplace_vector_arithmetic(module,vector_taylor_function_class, scalar_taylor_function_tag); define_inplace_mixed_vector_arithmetic(module,vector_taylor_function_class, number_vector_tag); - vector_taylor_function_class.def("__str__", &__cstr__); - vector_taylor_function_class.def("__repr__", &__crepr__); - vector_taylor_function_class.def("clobber", (Void(ValidatedVectorTaylorFunctionModelDP::*)()) &ValidatedVectorTaylorFunctionModelDP::clobber); - vector_taylor_function_class.def("__call__", (Vector(ValidatedVectorTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorTaylorFunctionModelDP::operator()); - vector_taylor_function_class.def("__call__", (Vector(ValidatedVectorTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorTaylorFunctionModelDP::operator()); - vector_taylor_function_class.def("jacobian", (Matrix(ValidatedVectorTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorTaylorFunctionModelDP::jacobian); - vector_taylor_function_class.def("polynomials", (Vector< Polynomial >(ValidatedVectorTaylorFunctionModelDP::*)()const) &ValidatedVectorTaylorFunctionModelDP::polynomials); - vector_taylor_function_class.def("function", (ValidatedVectorMultivariateFunction(ValidatedVectorTaylorFunctionModelDP::*)()const) &ValidatedVectorTaylorFunctionModelDP::function); - - vector_taylor_function_class.def_static("constant",(ValidatedVectorTaylorFunctionModelDP(*)(const ExactBoxType&, const Vector&,SweeperDP))&ValidatedVectorTaylorFunctionModelDP::constant); - vector_taylor_function_class.def_static("constant",[](const ExactBoxType& bx, const Vector& c,SweeperDP swp){return ValidatedVectorTaylorFunctionModelDP::constant(bx,Vector(c,swp.precision()),swp);}); - vector_taylor_function_class.def_static("identity",(ValidatedVectorTaylorFunctionModelDP(*)(const ExactBoxType&,SweeperDP))&ValidatedVectorTaylorFunctionModelDP::identity); + vector_taylor_function_class.def("__str__", &__cstr__); + vector_taylor_function_class.def("__repr__", &__crepr__); + vector_taylor_function_class.def("clobber", (Void(ValidatedVectorMultivariateTaylorFunctionModelDP::*)()) &ValidatedVectorMultivariateTaylorFunctionModelDP::clobber); + vector_taylor_function_class.def("__call__", (Vector(ValidatedVectorMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorMultivariateTaylorFunctionModelDP::operator()); + vector_taylor_function_class.def("__call__", (Vector(ValidatedVectorMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorMultivariateTaylorFunctionModelDP::operator()); + vector_taylor_function_class.def("jacobian", (Matrix(ValidatedVectorMultivariateTaylorFunctionModelDP::*)(const Vector&)const) &ValidatedVectorMultivariateTaylorFunctionModelDP::jacobian); + vector_taylor_function_class.def("polynomials", (Vector< Polynomial >(ValidatedVectorMultivariateTaylorFunctionModelDP::*)()const) &ValidatedVectorMultivariateTaylorFunctionModelDP::polynomials); + vector_taylor_function_class.def("function", (ValidatedVectorMultivariateFunction(ValidatedVectorMultivariateTaylorFunctionModelDP::*)()const) &ValidatedVectorMultivariateTaylorFunctionModelDP::function); + + vector_taylor_function_class.def_static("constant",(ValidatedVectorMultivariateTaylorFunctionModelDP(*)(const ExactBoxType&, const Vector&,SweeperDP))&ValidatedVectorMultivariateTaylorFunctionModelDP::constant); + vector_taylor_function_class.def_static("constant",[](const ExactBoxType& bx, const Vector& c,SweeperDP swp){return ValidatedVectorMultivariateTaylorFunctionModelDP::constant(bx,Vector(c,swp.precision()),swp);}); + vector_taylor_function_class.def_static("identity",(ValidatedVectorMultivariateTaylorFunctionModelDP(*)(const ExactBoxType&,SweeperDP))&ValidatedVectorMultivariateTaylorFunctionModelDP::identity); module.def("inconsistent", &_inconsistent_); module.def("refinement", &_refinement_); diff --git a/python/source/function_submodule.cpp b/python/source/function_submodule.cpp index f5d09fd4e..cd375fd70 100644 --- a/python/source/function_submodule.cpp +++ b/python/source/function_submodule.cpp @@ -98,7 +98,7 @@ typedef Matrix IMx; typedef Vector< Differential > FSDV; typedef Vector< Differential > ISDV; typedef Vector TMV; -typedef ValidatedVectorTaylorFunctionModelDP TFM; +typedef ValidatedVectorMultivariateTaylorFunctionModelDP TFM; typedef ValidatedTaylorModelDP TM; diff --git a/source/dynamics/differential_inclusion.cpp b/source/dynamics/differential_inclusion.cpp index 9f5a3c8d3..8a8d7ffb9 100644 --- a/source/dynamics/differential_inclusion.cpp +++ b/source/dynamics/differential_inclusion.cpp @@ -392,7 +392,7 @@ List InclusionIntegrator::flow(Diffe PositiveFloatDPValue hsug(this->_step_size); - ValidatedVectorMultivariateFunctionModelDP evolve_function = ValidatedVectorTaylorFunctionModelDP::identity(X0,this->_sweeper); + ValidatedVectorMultivariateFunctionModelDP evolve_function = ValidatedVectorMultivariateTaylorFunctionModelDP::identity(X0,this->_sweeper); auto t=PositiveFloatDPValue(0.0); Map approximation_global_frequencies, approximation_local_frequencies; @@ -633,14 +633,14 @@ ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::build_secondhalf auto swp=this->_sweeper; auto Tau=IntervalDomainType(t,new_t); BoxDomainType XPT = join(X,PA,PB,PM,Tau); - ValidatedVectorTaylorFunctionModelDP xf=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(0,n),swp); - ValidatedVectorTaylorFunctionModelDP af=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(n,n+a),swp); - ValidatedVectorTaylorFunctionModelDP bf=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(n+a,n+a+b),swp); - ValidatedVectorTaylorFunctionModelDP mf=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(n+a+b,n+a+b+2*m),swp); - ValidatedScalarTaylorFunctionModelDP tf=ValidatedScalarTaylorFunctionModelDP::coordinate(XPT,n+a+b+2*m,swp); - ValidatedScalarTaylorFunctionModelDP hf=tf-t; + ValidatedVectorMultivariateTaylorFunctionModelDP xf=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(0,n),swp); + ValidatedVectorMultivariateTaylorFunctionModelDP af=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(n,n+a),swp); + ValidatedVectorMultivariateTaylorFunctionModelDP bf=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(n+a,n+a+b),swp); + ValidatedVectorMultivariateTaylorFunctionModelDP mf=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(n+a+b,n+a+b+2*m),swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tf=ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(XPT,n+a+b+2*m,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP hf=tf-t; - ValidatedVectorTaylorFunctionModelDP ef=compose(evolve_function,join(xf,af,mf)); + ValidatedVectorMultivariateTaylorFunctionModelDP ef=compose(evolve_function,join(xf,af,mf)); return compose(Phi,join(ef,bf,mf,hf)); } @@ -664,13 +664,13 @@ ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::build_reach_func auto swp=this->_sweeper; auto Tau=IntervalDomainType(t,new_t); BoxDomainType XPT = join(X,PA,PB,Tau); - ValidatedVectorTaylorFunctionModelDP xf=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(0,n),swp); - ValidatedVectorTaylorFunctionModelDP af=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(n,n+a),swp); - ValidatedVectorTaylorFunctionModelDP bf=ValidatedVectorTaylorFunctionModelDP::projection(XPT,range(n+a,n+a+b),swp); - ValidatedScalarTaylorFunctionModelDP tf=ValidatedScalarTaylorFunctionModelDP::coordinate(XPT,n+a+b,swp); - ValidatedScalarTaylorFunctionModelDP hf=tf-t; + ValidatedVectorMultivariateTaylorFunctionModelDP xf=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(0,n),swp); + ValidatedVectorMultivariateTaylorFunctionModelDP af=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(n,n+a),swp); + ValidatedVectorMultivariateTaylorFunctionModelDP bf=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(XPT,range(n+a,n+a+b),swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tf=ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(XPT,n+a+b,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP hf=tf-t; - ValidatedVectorTaylorFunctionModelDP ef=compose(evolve_function,join(xf,af)); + ValidatedVectorMultivariateTaylorFunctionModelDP ef=compose(evolve_function,join(xf,af)); return compose(Phi,join(ef,bf,hf)); } @@ -681,7 +681,7 @@ ValidatedVectorMultivariateFunctionModelDP InclusionIntegrator::evaluate_evolve_ ValidatedVectorMultivariateFunctionModelDP add_errors(ValidatedVectorMultivariateFunctionModelDP phi, Vector const& e) { assert(phi.result_size()==e.size()); - ValidatedVectorTaylorFunctionModelDP& tphi = dynamic_cast(phi.reference()); + ValidatedVectorMultivariateTaylorFunctionModelDP& tphi = dynamic_cast(phi.reference()); for (auto i : range(e.size())) { tphi[i].add_error(e[i]); } @@ -734,10 +734,10 @@ compute_flow_function(ValidatedVectorMultivariateFunction const& dyn, BoxDomainT auto n=dyn.result_size(); auto swp=this->_sweeper; - auto x0f=ValidatedVectorTaylorFunctionModelDP::projection(domain,range(n),swp); - auto af=ValidatedVectorTaylorFunctionModelDP::projection(domain,range(n,dyn.argument_size()),swp); + auto x0f=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(domain,range(n),swp); + auto af=ValidatedVectorMultivariateTaylorFunctionModelDP::projection(domain,range(n,dyn.argument_size()),swp); - auto picardPhi=ValidatedVectorTaylorFunctionModelDP(n,domain,swp); + auto picardPhi=ValidatedVectorMultivariateTaylorFunctionModelDP(n,domain,swp); picardPhi=picardPhi+cast_singleton(B); for(Nat i=0; i_sweeper); + ValidatedVectorMultivariateFunctionModelDP error_function=ValidatedVectorMultivariateTaylorFunctionModelDP::identity(errors,this->_sweeper); return embed(f,errors)+embed(domain,error_function); } @@ -884,7 +884,7 @@ Void LohnerReconditioner::simplify(ValidatedVectorMultivariateFunctionModelDP& f ARIADNE_LOG(6,"num.parameters="<(f.reference()); + ValidatedVectorMultivariateTaylorFunctionModelDP& tf = dynamic_cast(f.reference()); // Compute effect of error terms, but not of original variables; Matrix C(m,n); @@ -969,11 +969,11 @@ Void LohnerReconditioner::simplify(ValidatedVectorMultivariateFunctionModelDP& f auto old_domain=f.domain(); auto new_domain=BoxDomainType(Vector(keep_indices.size(),[&old_domain,&keep_indices](SizeType j){return old_domain[keep_indices[j]];})); - auto projection=ValidatedVectorTaylorFunctionModelDP(m,new_domain,this->_sweeper); - for (auto i : range(new_domain.size())) { projection[keep_indices[i]]=ValidatedScalarTaylorFunctionModelDP::coordinate(new_domain,i,this->_sweeper); } + auto projection=ValidatedVectorMultivariateTaylorFunctionModelDP(m,new_domain,this->_sweeper); + for (auto i : range(new_domain.size())) { projection[keep_indices[i]]=ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(new_domain,i,this->_sweeper); } for (auto i : range(remove_indices.size())) { auto j=remove_indices[i]; auto cj=old_domain[j].midpoint(); - projection[j]=ValidatedScalarTaylorFunctionModelDP::constant(new_domain,cj,this->_sweeper); } + projection[j]=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(new_domain,cj,this->_sweeper); } f=compose(f,projection); } @@ -986,7 +986,7 @@ Void LohnerReconditioner::simplify(ValidatedVectorMultivariateFunctionModelDP& f namespace Ariadne { -ValidatedVectorTaylorFunctionModelDP lohner_approximation(ValidatedVectorTaylorFunctionModelDP f) { +ValidatedVectorMultivariateTaylorFunctionModelDP lohner_approximation(ValidatedVectorMultivariateTaylorFunctionModelDP f) { auto n=f.result_size(); auto models=f.models(); DoublePrecision pr; @@ -1018,7 +1018,7 @@ ValidatedVectorTaylorFunctionModelDP lohner_approximation(ValidatedVectorTaylorF r[i].set_error(e[i]); } - return ValidatedVectorTaylorFunctionModelDP(BoxDomainType(n,IntervalDomainType(-1,+1)),r); + return ValidatedVectorMultivariateTaylorFunctionModelDP(BoxDomainType(n,IntervalDomainType(-1,+1)),r); } diff --git a/source/function/affine_model.tpl.hpp b/source/function/affine_model.tpl.hpp index f7dbf5a74..6614781a9 100644 --- a/source/function/affine_model.tpl.hpp +++ b/source/function/affine_model.tpl.hpp @@ -352,7 +352,7 @@ template AffineModel::AffineModel(const TaylorModel AffineModel> affine_model(const BoxDomainType& domain, const ScalarMultivariateFunction

& function, PR precision) { - ValidatedScalarTaylorFunctionModelDP tf(domain,function,AffineSweeper>(precision)); + ValidatedScalarMultivariateTaylorFunctionModelDP tf(domain,function,AffineSweeper>(precision)); return affine_model(tf.model()); } diff --git a/source/function/function_model.hpp b/source/function/function_model.hpp index 4c5c071b9..8eb70f615 100644 --- a/source/function/function_model.hpp +++ b/source/function/function_model.hpp @@ -194,7 +194,7 @@ template class FunctionModel& operator=(const CanonicalNumericType& c); ScalarFunctionModel& operator=(const ScalarFunction& f); ScalarFunctionModel& operator=(const ScalarFunctionModelInterface& f); -// ScalarFunctionModel& operator=(const ValidatedScalarTaylorFunctionModelDP& f); +// ScalarFunctionModel& operator=(const ValidatedScalarMultivariateTaylorFunctionModelDP& f); inline PrecisionType const precision() const { return this->_ptr->value().precision(); } inline SizeType argument_size() const { return this->_ptr->argument_size(); } @@ -361,7 +361,7 @@ template class ScaledFunctionPatch; template class VectorScaledFunctionPatch; template struct Element> { typedef ScaledFunctionPatch Type; }; -typedef ScaledFunctionPatch ValidatedScalarTaylorFunctionModelDP; +typedef ScaledFunctionPatch ValidatedScalarMultivariateTaylorFunctionModelDP; template class VectorFunctionModelElement : public DispatchTranscendentalAlgebraOperations, CanonicalNumericType> diff --git a/source/function/scaled_function_patch.hpp b/source/function/scaled_function_patch.hpp index 6487dea2b..88c4bf442 100644 --- a/source/function/scaled_function_patch.hpp +++ b/source/function/scaled_function_patch.hpp @@ -111,9 +111,9 @@ template struct AlgebraOperations> { }; /*! \ingroup FunctionModelSubModule - * \brief A ValidatedScalarTaylorFunctionModelDP is a type of FunctionModel in which a the restriction of a scalar function \f$f:\R^n\rightarrow\R\f$ on a domain \f$D\f$ is approximated by polynomial \f$p\f$ with uniform error \f$e\f$. + * \brief A ValidatedScalarMultivariateTaylorFunctionModelDP is a type of FunctionModel in which a the restriction of a scalar function \f$f:\R^n\rightarrow\R\f$ on a domain \f$D\f$ is approximated by polynomial \f$p\f$ with uniform error \f$e\f$. * - * Formally, a ValidatedScalarTaylorFunctionModelDP is a triple \f$(D,p,e)\f$ representing a set of continuous functions \f$\mathrm{T}(D,p,e)\f$ by + * Formally, a ValidatedScalarMultivariateTaylorFunctionModelDP is a triple \f$(D,p,e)\f$ representing a set of continuous functions \f$\mathrm{T}(D,p,e)\f$ by * \f[ \mathrm{T}(D,p,e) = \{ f:\R^n\rightarrow \R \mid \sup_{x\in D}|f(x)-p(x)| \leq e \} . \f] * Note that there is no need for the functions \f$f\f$ to be themselves polynomial, and that no information is given * about the values of \f$f\f$ outside of \f$D\f$. Information about the derivatives of \f$f\f$ is also unavailable. @@ -129,7 +129,7 @@ template struct AlgebraOperations> { * Finding exact bounds for the range of \f$p\f$ over \f$D\f$ is an NP-complete problem, * for but there are a number of techniques available. * - * \sa Expansion, TaylorModel, ValidatedVectorTaylorFunctionModelDP, TaylorConstrainedImageSet. + * \sa Expansion, TaylorModel, ValidatedVectorMultivariateTaylorFunctionModelDP, TaylorConstrainedImageSet. */ template class ScaledFunctionPatch : public ScalarMultivariateFunctionModelMixin, typename M::Paradigm, BoxDomainType, typename M::PrecisionType, typename M::ErrorPrecisionType> @@ -512,7 +512,7 @@ template ScaledFunctionPatch midpoint(const ScaledFunctionPatch& /*! \ingroup FunctionModelSubModule * \brief A Taylor function model with multivalued codomain built from the TaylorModel class. * - * See also TaylorModel, ScaledFunctionPatch, ValidatedVectorTaylorFunctionModelDP. + * See also TaylorModel, ScaledFunctionPatch, ValidatedVectorMultivariateTaylorFunctionModelDP. */ template class VectorScaledFunctionPatch : public VectorMultivariateFunctionModelMixin,typename M::Paradigm,BoxDomainType,typename M::PrecisionType,typename M::ErrorPrecisionType> diff --git a/source/function/taylor_function.hpp b/source/function/taylor_function.hpp index 720b69d16..910a07d8a 100644 --- a/source/function/taylor_function.hpp +++ b/source/function/taylor_function.hpp @@ -46,24 +46,15 @@ namespace Ariadne { template class TaylorModel; class TaylorFunctionFactory; -typedef ScalarScaledFunctionPatch ValidatedScalarTaylorFunctionModelDP; -typedef VectorScaledFunctionPatch ValidatedVectorTaylorFunctionModelDP; +template using ScalarMultivariateTaylorFunctionModel = ScalarScaledFunctionPatch>; +template using VectorMultivariateTaylorFunctionModel = VectorScaledFunctionPatch>; -/* -class ValidatedScalarTaylorFunctionModelDP : public ScaledFunctionPatch { - public: - using ScaledFunctionPatch::ScaledFunctionPatch; - ValidatedScalarTaylorFunctionModelDP() : ScaledFunctionPatch() { } - ValidatedScalarTaylorFunctionModelDP(ScaledFunctionPatch const& f) : ScaledFunctionPatch(f) { } -}; +template using ValidatedScalarMultivariateTaylorFunctionModel = ScalarScaledFunctionPatch>; +template using ValidatedVectorMultivariateTaylorFunctionModel = VectorScaledFunctionPatch>; + +using ValidatedScalarMultivariateTaylorFunctionModelDP = ScalarScaledFunctionPatch; +using ValidatedVectorMultivariateTaylorFunctionModelDP = VectorScaledFunctionPatch; -class ValidatedVectorTaylorFunctionModelDP : public VectorScaledFunctionPatch { - public: - using VectorScaledFunctionPatch::VectorScaledFunctionPatch; - ValidatedVectorTaylorFunctionModelDP() : VectorScaledFunctionPatch() { } - ValidatedVectorTaylorFunctionModelDP(VectorScaledFunctionPatch const& f) : VectorScaledFunctionPatch(f) { } -}; -*/ class TaylorFunctionFactory : public ScaledFunctionPatchFactory> diff --git a/source/function/taylor_model.hpp b/source/function/taylor_model.hpp index 50f8974ed..59e222be7 100644 --- a/source/function/taylor_model.hpp +++ b/source/function/taylor_model.hpp @@ -92,7 +92,7 @@ template struct AlgebraOperations> /*! \brief A class representing a power series expansion, scaled to the unit box, with an error term. * - * See also Expansion, ValidatedScalarTaylorFunctionModelDP, ValidatedVectorTaylorFunctionModelDP, TaylorConstrainedImageSet. + * See also Expansion, ValidatedScalarMultivariateTaylorFunctionModelDP, ValidatedVectorMultivariateTaylorFunctionModelDP, TaylorConstrainedImageSet. */ template class TaylorModel diff --git a/source/geometry/enclosure.cpp b/source/geometry/enclosure.cpp index 803b7731b..c3d410ce0 100644 --- a/source/geometry/enclosure.cpp +++ b/source/geometry/enclosure.cpp @@ -1153,7 +1153,7 @@ TaylorModel recondition(const TaylorModel(&this->state_function().reference())) { + if(!dynamic_cast(&this->state_function().reference())) { ARIADNE_WARN("Cannot Kuhn reduce an Enclosure which is not given by TaylorFunctions."); } @@ -1168,7 +1168,7 @@ Enclosure::kuhn_recondition() return; } - const ValidatedVectorTaylorFunctionModelDP& function=dynamic_cast(this->state_function().reference()); + const ValidatedVectorMultivariateTaylorFunctionModelDP& function=dynamic_cast(this->state_function().reference()); const Vector& models = function.models(); Matrix dependencies(this->state_dimension(),this->number_of_parameters()); for(SizeType i=0; i!=dependencies.row_size(); ++i) { @@ -1214,17 +1214,17 @@ Enclosure::kuhn_recondition() this->_domain = new_domain; this->_reduced_domain = new_reduced_domain; - Enclosure new_set(new_domain,ValidatedVectorTaylorFunctionModelDP(new_domain,new_models),this->function_factory()); + Enclosure new_set(new_domain,ValidatedVectorMultivariateTaylorFunctionModelDP(new_domain,new_models),this->function_factory()); for(SizeType i=0; i!=this->_constraints.size(); ++i) { const ValidatedConstraintModel& constraint=this->_constraints[i]; - ValidatedScalarTaylorFunctionModelDP const& constraint_function=dynamic_cast(constraint.function().reference()); - ValidatedScalarMultivariateFunctionModelDP new_constraint_function=ValidatedScalarTaylorFunctionModelDP(new_domain,Ariadne::recondition(constraint_function.model(),discarded_parameters,number_of_error_parameters)); + ValidatedScalarMultivariateTaylorFunctionModelDP const& constraint_function=dynamic_cast(constraint.function().reference()); + ValidatedScalarMultivariateFunctionModelDP new_constraint_function=ValidatedScalarMultivariateTaylorFunctionModelDP(new_domain,Ariadne::recondition(constraint_function.model(),discarded_parameters,number_of_error_parameters)); new_set._constraints.append(ValidatedConstraintModel(constraint.lower_bound(),new_constraint_function,constraint.upper_bound())); } - ValidatedScalarTaylorFunctionModelDP const& time=dynamic_cast(this->_time_function.reference()); - new_set._time_function=ValidatedScalarTaylorFunctionModelDP(new_domain,Ariadne::recondition(time.model(),discarded_parameters,number_of_error_parameters)); - ValidatedScalarTaylorFunctionModelDP const& dwell_time=dynamic_cast(this->_dwell_time_function.reference()); - new_set._dwell_time_function=ValidatedScalarTaylorFunctionModelDP(new_domain,Ariadne::recondition(dwell_time.model(),discarded_parameters,number_of_error_parameters)); + ValidatedScalarMultivariateTaylorFunctionModelDP const& time=dynamic_cast(this->_time_function.reference()); + new_set._time_function=ValidatedScalarMultivariateTaylorFunctionModelDP(new_domain,Ariadne::recondition(time.model(),discarded_parameters,number_of_error_parameters)); + ValidatedScalarMultivariateTaylorFunctionModelDP const& dwell_time=dynamic_cast(this->_dwell_time_function.reference()); + new_set._dwell_time_function=ValidatedScalarMultivariateTaylorFunctionModelDP(new_domain,Ariadne::recondition(dwell_time.model(),discarded_parameters,number_of_error_parameters)); (*this)=new_set; diff --git a/source/geometry/function_set.cpp b/source/geometry/function_set.cpp index 52434c912..21e3b0b17 100644 --- a/source/geometry/function_set.cpp +++ b/source/geometry/function_set.cpp @@ -59,11 +59,11 @@ uint DRAWING_ACCURACY=1u; template StringType str(const T& t) { StringStream ss; ss< nonlinearities_zeroth_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom); -Matrix nonlinearities_zeroth_order(const ValidatedVectorTaylorFunctionModelDP& f, const ExactBoxType& dom); +Matrix nonlinearities_zeroth_order(const ValidatedVectorMultivariateTaylorFunctionModelDP& f, const ExactBoxType& dom); Matrix nonlinearities_first_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom); Matrix nonlinearities_second_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom); Pair nonlinearity_index_and_error(const ValidatedVectorMultivariateFunction& function, const ExactBoxType& domain); -Pair nonlinearity_index_and_error(const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType domain); +Pair nonlinearity_index_and_error(const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType domain); Pair lipschitz_index_and_error(const ValidatedVectorMultivariateFunction& function, const ExactBoxType& domain); Interval make_interval(ValidatedLowerNumber const& lb, ValidatedUpperNumber const& ub); @@ -73,11 +73,11 @@ ExactBoxType over_approximation(const EffectiveBoxType& rbx); ExactBoxType approximation(const EffectiveBoxType& rbx); -Matrix nonlinearities_zeroth_order(const ValidatedVectorTaylorFunctionModelDP& f, const ExactBoxType& dom) +Matrix nonlinearities_zeroth_order(const ValidatedVectorMultivariateTaylorFunctionModelDP& f, const ExactBoxType& dom) { const Nat m=f.result_size(); const Nat n=f.argument_size(); - ValidatedVectorTaylorFunctionModelDP g=restriction(f,dom); + ValidatedVectorMultivariateTaylorFunctionModelDP g=restriction(f,dom); Matrix nonlinearities=Matrix::zero(m,n); MultiIndex a; @@ -166,7 +166,7 @@ Matrix nonlinearities_second_order(const ValidatedVectorMultivariateFun return nonlinearities; } -Pair nonlinearity_index_and_error(const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType domain) { +Pair nonlinearity_index_and_error(const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType domain) { Matrix nonlinearities=Ariadne::nonlinearities_zeroth_order(function,domain); // Compute the row of the nonlinearities Array which has the highest norm @@ -725,8 +725,8 @@ ConstrainedImageSet image(ConstrainedImageSet set, const EffectiveVectorMultivar Matrix nonlinearities_zeroth_order(const ValidatedVectorMultivariateFunction& f, const ExactBoxType& dom) { - ARIADNE_ASSERT(dynamic_cast(f.raw_pointer())); - return nonlinearities_zeroth_order(dynamic_cast(*f.raw_pointer()),dom); + ARIADNE_ASSERT(dynamic_cast(f.raw_pointer())); + return nonlinearities_zeroth_order(dynamic_cast(*f.raw_pointer()),dom); } /* @@ -878,7 +878,7 @@ ConstrainedImageSet::write(OutputStream& os) const template struct FunctionTraits; template struct FunctionTraits< ScalarMultivariateFunction > { typedef VectorMultivariateFunction VectorMultivariateFunctionType; }; -template<> struct FunctionTraits< ValidatedScalarTaylorFunctionModelDP > { typedef ValidatedVectorTaylorFunctionModelDP VectorMultivariateFunctionType; }; +template<> struct FunctionTraits< ValidatedScalarMultivariateTaylorFunctionModelDP > { typedef ValidatedVectorMultivariateTaylorFunctionModelDP VectorMultivariateFunctionType; }; template class TemplatedConstraintSet; template class TemplatedConstrainedImageSet; @@ -913,17 +913,17 @@ ValidatedAffineConstrainedImageSet ValidatedConstrainedImageSet::affine_over_approximation() const { this->_check(); - typedef List::ConstIterator ConstIterator; + typedef List::ConstIterator ConstIterator; const Nat nx=this->state_dimension(); const Nat nc=this->number_of_constraints(); const Nat np=this->number_of_parameters(); AffineSweeper affine_sweeper((dp)); - ValidatedVectorTaylorFunctionModelDP state_function=dynamic_cast(this->_state_function.reference()); - ValidatedScalarTaylorFunctionModelDP time_function=dynamic_cast(this->_time_function.reference()); - List constraint_functions; - for(Nat i=0; i!=nc; ++i) { constraint_functions.append(dynamic_cast(this->_constraints[i].function().reference())); } + ValidatedVectorMultivariateTaylorFunctionModelDP state_function=dynamic_cast(this->_state_function.reference()); + ValidatedScalarMultivariateTaylorFunctionModelDP time_function=dynamic_cast(this->_time_function.reference()); + List constraint_functions; + for(Nat i=0; i!=nc; ++i) { constraint_functions.append(dynamic_cast(this->_constraints[i].function().reference())); } //std::cerr<<"\n"< G(nx,np+nerr); Nat ierr=0; // The index where the error bound should go for(Nat i=0; i!=nx; ++i) { - ValidatedScalarTaylorFunctionModelDP component_function=function[i]; + ValidatedScalarMultivariateTaylorFunctionModelDP component_function=function[i]; h[i]=component_function.model().value(); for(Nat j=0; j!=np; ++j) { G[i][j]=component_function.model().gradient(j); @@ -997,7 +997,7 @@ ValidatedConstrainedImageSet::affine_over_approximation() const FloatDP b; for(ConstIterator iter=this->_constraints.begin(); iter!=this->_constraints.end(); ++iter) { - ValidatedScalarTaylorFunctionModelDP constraint_function(this->_reduced_domain,iter->function(),affine_sweeper); + ValidatedScalarMultivariateTaylorFunctionModelDP constraint_function(this->_reduced_domain,iter->function(),affine_sweeper); b=sub(up,constraint_function.model().error(),constraint_function.model().value()); for(Nat j=0; j!=np; ++j) { a[j]=constraint_function.model().gradient(j); } result.new_parameter_constraint(-inf,a,b); diff --git a/source/geometry/paver.cpp b/source/geometry/paver.cpp index 0b32b88f3..e34e33593 100644 --- a/source/geometry/paver.cpp +++ b/source/geometry/paver.cpp @@ -420,14 +420,14 @@ Void hotstarted_constraint_adjoin_outer_approximation_recursion( TrivialSweeper sweeper{dp}; EffectiveScalarMultivariateFunction zero_function=EffectiveScalarMultivariateFunction::zero(m); EffectiveVectorMultivariateFunction identity_function=EffectiveVectorMultivariateFunction::identity(m); - ValidatedScalarTaylorFunctionModelDP txg(domain,zero_function,sweeper); + ValidatedScalarMultivariateTaylorFunctionModelDP txg(domain,zero_function,sweeper); FloatDPBounds cnst = {0,pr}; for(Nat j=0; j!=n; ++j) { - txg = txg - (FloatDPBounds(x[j])-FloatDPBounds(x[n+j]))*ValidatedScalarTaylorFunctionModelDP(domain,ValidatedScalarMultivariateFunction(fg[j]),sweeper); + txg = txg - (FloatDPBounds(x[j])-FloatDPBounds(x[n+j]))*ValidatedScalarMultivariateTaylorFunctionModelDP(domain,ValidatedScalarMultivariateFunction(fg[j]),sweeper); cnst += (bx[j].upper()*x[j]-bx[j].lower()*x[n+j]); } for(Nat i=0; i!=m; ++i) { - txg = txg - (FloatDPBounds(x[2*n+i])-FloatDPBounds(x[2*n+m+i]))*ValidatedScalarTaylorFunctionModelDP(domain,ValidatedScalarMultivariateFunction(identity_function[i]),sweeper); + txg = txg - (FloatDPBounds(x[2*n+i])-FloatDPBounds(x[2*n+m+i]))*ValidatedScalarMultivariateTaylorFunctionModelDP(domain,ValidatedScalarMultivariateFunction(identity_function[i]),sweeper); cnst += (d[i].upper()*x[2*n+i]-d[i].lower()*x[2*n+m+i]); } txg = FloatDPBounds(cnst) + txg; @@ -486,7 +486,7 @@ Void hotstarted_constraint_adjoin_outer_approximation_recursion( } -Void hotstarted_optimal_constraint_adjoin_outer_approximation_recursion(PavingInterface& r, const ExactBoxType& d, const ValidatedVectorTaylorFunctionModelDP& fg, const ExactBoxType& c, const GridCell& b, ExactPoint& x, ExactPoint& y, Nat e) +Void hotstarted_optimal_constraint_adjoin_outer_approximation_recursion(PavingInterface& r, const ExactBoxType& d, const ValidatedVectorMultivariateTaylorFunctionModelDP& fg, const ExactBoxType& c, const GridCell& b, ExactPoint& x, ExactPoint& y, Nat e) { auto properties = fg.properties(); auto pr = properties.precision(); @@ -533,14 +533,14 @@ Void hotstarted_optimal_constraint_adjoin_outer_approximation_recursion(PavingIn // Use the computed dual variables to try to make a scalar function which is negative over the entire domain. // This should be easier than using all constraints separately - ValidatedScalarTaylorFunctionModelDP xg=ValidatedScalarTaylorFunctionModelDP::zero(d,properties); + ValidatedScalarMultivariateTaylorFunctionModelDP xg=ValidatedScalarMultivariateTaylorFunctionModelDP::zero(d,properties); FloatDPBounds cnst = {0,pr}; for(Nat j=0; j!=n; ++j) { - xg = xg - (x[j]-x[n+j])*ValidatedScalarTaylorFunctionModelDP(d,fg[j],properties); + xg = xg - (x[j]-x[n+j])*ValidatedScalarMultivariateTaylorFunctionModelDP(d,fg[j],properties); cnst += (bx[j].upper()*x[j]-bx[j].lower()*x[n+j]); } for(Nat i=0; i!=m; ++i) { - xg = xg - (x[2*n+i]-x[2*n+m+i])*ValidatedScalarTaylorFunctionModelDP::coordinate(d,i,properties); + xg = xg - (x[2*n+i]-x[2*n+m+i])*ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(d,i,properties); cnst += (d[i].upper()*x[2*n+i]-d[i].lower()*x[2*n+m+i]); } xg = (cnst) + xg; @@ -640,22 +640,22 @@ Void optimal_constraint_adjoin_outer_approximation(PavingInterface& p, const Exa const Nat l=(d.size()+f.result_size()+g.result_size())*2; ExactPoint x(l); for(Nat k=0; k!=l; ++k) { x[k]=FloatDPValue(1.0/l); } - ValidatedVectorTaylorFunctionModelDP fg; - const ValidatedVectorTaylorFunctionModelDP* tfptr; - if( (tfptr=dynamic_cast(f.raw_pointer())) ) { - const ValidatedVectorTaylorFunctionModelDP* tgptr; - if( ( tgptr = dynamic_cast(g.raw_pointer()) ) ) { + ValidatedVectorMultivariateTaylorFunctionModelDP fg; + const ValidatedVectorMultivariateTaylorFunctionModelDP* tfptr; + if( (tfptr=dynamic_cast(f.raw_pointer())) ) { + const ValidatedVectorMultivariateTaylorFunctionModelDP* tgptr; + if( ( tgptr = dynamic_cast(g.raw_pointer()) ) ) { fg=join(*tfptr,*tgptr); } else { if(g.result_size()>0) { - fg=join(*tfptr,ValidatedVectorTaylorFunctionModelDP(tfptr->domain(),g,tfptr->properties())); + fg=join(*tfptr,ValidatedVectorMultivariateTaylorFunctionModelDP(tfptr->domain(),g,tfptr->properties())); } else { fg=*tfptr; } } } else { ThresholdSweeper swp(dp,1e-12); - fg=ValidatedVectorTaylorFunctionModelDP(d,join(f,g),swp); + fg=ValidatedVectorMultivariateTaylorFunctionModelDP(d,join(f,g),swp); } Ariadne::hotstarted_optimal_constraint_adjoin_outer_approximation_recursion(p,d,fg,rc,b,x,y,e); } diff --git a/source/hybrid/hybrid_enclosure.cpp b/source/hybrid/hybrid_enclosure.cpp index 978f45d0e..38489013d 100644 --- a/source/hybrid/hybrid_enclosure.cpp +++ b/source/hybrid/hybrid_enclosure.cpp @@ -617,7 +617,7 @@ Void HybridEnclosure::draw(CanvasInterface& canvas, const Set& OutputStream& operator<<(OutputStream& os, ValidatedConstraint const& c) { - auto tcf = std::dynamic_pointer_cast(c.function().managed_pointer()); + auto tcf = std::dynamic_pointer_cast(c.function().managed_pointer()); if(tcf == nullptr) { auto ecf = tcf->error(); const_cast&>(*tcf).clobber(); diff --git a/source/solvers/constraint_solver.cpp b/source/solvers/constraint_solver.cpp index 26dabd2d3..a10d8f799 100644 --- a/source/solvers/constraint_solver.cpp +++ b/source/solvers/constraint_solver.cpp @@ -126,7 +126,7 @@ Pair ConstraintSolver::feasible(const ExactBoxType FloatDPApproximation& t=violation; FloatApproximationVector& x=multipliers; FloatApproximationVector& y=point; FloatApproximationVector& z=slack; // Aliases for the main quantities used const ExactBoxType& d=domain; const ValidatedVectorMultivariateFunction& fn=function; const ExactBoxType& c=codomain; // Aliases for the main quantities used - ValidatedVectorTaylorFunctionModelDP tfn(d,fn,default_sweeper()); + ValidatedVectorMultivariateTaylorFunctionModelDP tfn(d,fn,default_sweeper()); point=static_cast(midpoint(d)); for(Nat k=0; k!=l; ++k) { multipliers[k]=1.0/l; } @@ -156,14 +156,14 @@ Pair ConstraintSolver::feasible(const ExactBoxType Vector x_exact=cast_exact(x); // Use the computed dual variables to try to make a scalar function which is negative over the entire domain. // This should be easier than using all constraints separately - ValidatedScalarTaylorFunctionModelDP txg=ValidatedScalarTaylorFunctionModelDP::zero(d,default_sweeper()); + ValidatedScalarMultivariateTaylorFunctionModelDP txg=ValidatedScalarMultivariateTaylorFunctionModelDP::zero(d,default_sweeper()); ValidatedNumericType cnst(0,prec); for(Nat j=0; j!=n; ++j) { txg = txg - (x_exact[j]-x_exact[n+j])*tfn[j]; cnst += (c[j].upper()*x_exact[j]-c[j].lower()*x_exact[n+j]); } for(Nat i=0; i!=m; ++i) { - txg = txg - (x_exact[2*n+i]-x_exact[2*n+m+i])*ValidatedScalarTaylorFunctionModelDP::coordinate(d,i,default_sweeper()); + txg = txg - (x_exact[2*n+i]-x_exact[2*n+m+i])*ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(d,i,default_sweeper()); cnst += (d[i].upper()*x_exact[2*n+i]-d[i].lower()*x_exact[2*n+m+i]); } txg = cnst + txg; @@ -363,17 +363,17 @@ Bool ConstraintSolver::monotone_reduce(UpperBoxType& domain, const ValidatedScal -Bool ConstraintSolver::lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType& bounds, +Bool ConstraintSolver::lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType& bounds, FloatApproximationVector centre, FloatApproximationVector multipliers) const { return this->lyapunov_reduce(domain,function,bounds,cast_exact(centre),cast_exact(multipliers)); } -Bool ConstraintSolver::lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType& bounds, +Bool ConstraintSolver::lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType& bounds, ExactFloatVector centre, ExactFloatVector multipliers) const { - ValidatedScalarTaylorFunctionModelDP g(function.domain(),default_sweeper()); + ValidatedScalarMultivariateTaylorFunctionModelDP g(function.domain(),default_sweeper()); UpperIntervalType C(0); for(Nat i=0; i!=function.result_size(); ++i) { g += cast_exact(multipliers[i]) * function[i]; diff --git a/source/solvers/constraint_solver.hpp b/source/solvers/constraint_solver.hpp index 90c54af3d..227557a01 100644 --- a/source/solvers/constraint_solver.hpp +++ b/source/solvers/constraint_solver.hpp @@ -48,7 +48,7 @@ typedef Procedure ValidatedProcedure; template class TaylorModel; template class VectorScaledFunctionPatch; -typedef VectorScaledFunctionPatch> ValidatedVectorTaylorFunctionModelDP; +typedef VectorScaledFunctionPatch> ValidatedVectorMultivariateTaylorFunctionModelDP; template struct FeasibilityState { X t; @@ -104,9 +104,9 @@ class ConstraintSolver //! \brief Reduce the \a domain by testing intersection of \a multipliers inner product \a function(\a domain) //! with \a multipliers innner product \a codomain, centering at \a centre. //! Reduces \f$(\lambda\cdot f)(X) \cap (\lambda\cdot C)\f$, evaluating \f$g(x)=g(x^*)+Dg(X) (X-x^*)\f$. - Bool lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType& codomain, + Bool lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType& codomain, Vector centre, Vector multpliers) const; - Bool lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorTaylorFunctionModelDP& function, const ExactBoxType& codomain, + Bool lyapunov_reduce(UpperBoxType& domain, const ValidatedVectorMultivariateTaylorFunctionModelDP& function, const ExactBoxType& codomain, Vector centre, Vector multpliers) const; //! \brief Try to enforce hull consistency by reducing a constraint with respect to one variable. Bool box_reduce(UpperBoxType& bx, const ValidatedScalarMultivariateFunction& function, const ExactIntervalType&, Nat j) const; diff --git a/source/solvers/integrator.cpp b/source/solvers/integrator.cpp index 2e1623ccd..76d90bc43 100644 --- a/source/solvers/integrator.cpp +++ b/source/solvers/integrator.cpp @@ -457,10 +457,10 @@ Vector flow_differential(Vector& dphi, const ExactBoxType& dx, const StepSizeType& h, double swpt, Nat verbosity=0) { +ValidatedVectorMultivariateTaylorFunctionModelDP flow_function(const Vector& dphi, const ExactBoxType& dx, const StepSizeType& h, double swpt, Nat verbosity=0) { const Nat n=dphi.size(); Sweeper sweeper(new ThresholdSweeper(dp,swpt)); - ValidatedVectorTaylorFunctionModelDP tphi(n,join(dx,ExactIntervalType(-h,+h)),sweeper); + ValidatedVectorMultivariateTaylorFunctionModelDP tphi(n,join(dx,ExactIntervalType(-h,+h)),sweeper); for(Nat i=0; i!=n; ++i) { ValidatedTaylorModelDP& model=tphi.model(i); @@ -533,7 +533,7 @@ series_flow_step(const ValidatedVectorMultivariateFunction& f, const ExactBoxTyp Vector dphi=flow_differential(dphia,dphib,dphic,dphid,so,to,verbosity); ARIADNE_LOG(5,"dphi="< ndphi=flow_differential(ndphia,ndphib,ndphic,ndphid,nso,nto,verbosity); - ValidatedVectorTaylorFunctionModelDP ntphi=flow_function(ndphi,bdx,h,swpt,verbosity); + ValidatedVectorMultivariateTaylorFunctionModelDP ntphi=flow_function(ndphi,bdx,h,swpt,verbosity); Nat nnnz=0; for(Nat i=0; i!=tphi.size(); ++i) { nnnz+=tphi.model(i).number_of_nonzeros(); } ARIADNE_LOG(3,"nso="< ScaledFunctionPatch compose(ScaledFunctionPatch const& f } template ScalarFunctionModel compose(ScalarFunctionModel const& f, Projection const& prj) { - auto fpp = std::dynamic_pointer_cast(f.managed_pointer()); + auto fpp = std::dynamic_pointer_cast(f.managed_pointer()); if(fpp) { - return compose(ValidatedScalarTaylorFunctionModelDP(fpp),prj); + return compose(ValidatedScalarMultivariateTaylorFunctionModelDP(fpp),prj); } auto f_dom=f.domain(); BoxDomainType dom=preimage(prj,f_dom); diff --git a/tests/function/test_taylor_function.cpp b/tests/function/test_taylor_function.cpp index 9f0f21119..17feebd75 100644 --- a/tests/function/test_taylor_function.cpp +++ b/tests/function/test_taylor_function.cpp @@ -50,7 +50,7 @@ extern template Ariadne::Nat Ariadne::Error::output_places; inline Vector e(Nat n, Nat i) { return Vector::unit(n,i); } inline Polynomial p(Nat n, Nat j) { return Polynomial::variable(n,j); } -inline ValidatedScalarTaylorFunctionModelDP t(ExactBoxType d, Nat j,Sweeper swp) { return ValidatedScalarTaylorFunctionModelDP::coordinate(d,j,swp); } +inline ValidatedScalarMultivariateTaylorFunctionModelDP t(ExactBoxType d, Nat j,Sweeper swp) { return ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate(d,j,swp); } template Vector< Expansion > operator*(const Expansion& e, const Vector v) { Vector< Expansion > r(v.size(),Expansion(e.argument_size())); @@ -117,8 +117,8 @@ Void TestScalarTaylorFunction::test_concept() const FloatDPBounds i; const Vector vf; const Vector vi; - const ValidatedScalarTaylorFunctionModelDP t; - ValidatedScalarTaylorFunctionModelDP tr; + const ValidatedScalarMultivariateTaylorFunctionModelDP t; + ValidatedScalarMultivariateTaylorFunctionModelDP tr; tr=t+f; tr=t-f; tr=t*f; tr=t/f; tr=f+t; tr=f-t; tr=f*t; tr=f/t; @@ -146,7 +146,7 @@ Void TestScalarTaylorFunction::test_concept() Void TestScalarTaylorFunction::test_constructors() { - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,tv1,({{-1,+1},{-1,+1}},{{{0,0},1.},{{1,0},2.},{{0,1},3.},{{2,0},4.},{{1,1},5.},{{0,2},6.},{{3,0},7.},{{2,1},8.},{{1,2},9.},{{0,3},10.}},0.25,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP,tv1,({{-1,+1},{-1,+1}},{{{0,0},1.},{{1,0},2.},{{0,1},3.},{{2,0},4.},{{1,1},5.},{{0,2},6.},{{3,0},7.},{{2,1},8.},{{1,2},9.},{{0,3},10.}},0.25,swp)); ARIADNE_ASSERT_EQUAL(tv1.domain(),Box({{-1,+1},{-1,+1}})); ARIADNE_ASSERT_EQUAL(tv1.argument_size(),2); @@ -160,8 +160,8 @@ Void TestScalarTaylorFunction::test_create() ExactBoxType D={{-0.5,0.5},{-1.0,2.0}}; FloatDPValue c1={1,pr}; FloatDPValue c2={1,pr}; - ValidatedScalarTaylorFunctionModelDP pf1=ValidatedScalarTaylorFunctionModelDP::constant(D,c1,swp); - ValidatedScalarTaylorFunctionModelDP pf2=ValidatedScalarTaylorFunctionModelDP::constant(D,c2,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP pf1=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(D,c1,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP pf2=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(D,c2,swp); ValidatedScalarMultivariateFunctionModelDP fm1=pf1; ValidatedScalarMultivariateFunctionModelDP fm2=pf2; ValidatedScalarMultivariateFunction f2=fm2; @@ -174,10 +174,10 @@ Void TestScalarTaylorFunction::test_create() Void TestScalarTaylorFunction::test_predicates() { - ValidatedScalarTaylorFunctionModelDP tv1(d(1),{{{0},1.00},{{1},2.00},{{2},3.00}}, 0.75, swp); - ValidatedScalarTaylorFunctionModelDP tv2(d(1),{{{0},1.00},{{1},1.75},{{2},3.25}}, 0.25, swp); - ValidatedScalarTaylorFunctionModelDP tv3(d(1),{{{0},1.125},{{1},1.75},{{2},3.25}}, 0.25, swp); - ValidatedScalarTaylorFunctionModelDP tv4(d(1),{{{0},1.00},{{1},2.25},{{2},3.00},{{3},-0.25}}, 0.25, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tv1(d(1),{{{0},1.00},{{1},2.00},{{2},3.00}}, 0.75, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tv2(d(1),{{{0},1.00},{{1},1.75},{{2},3.25}}, 0.25, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tv3(d(1),{{{0},1.125},{{1},1.75},{{2},3.25}}, 0.25, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tv4(d(1),{{{0},1.00},{{1},2.25},{{2},3.00},{{3},-0.25}}, 0.25, swp); ARIADNE_TEST_BINARY_PREDICATE(refines,tv1,tv1); ARIADNE_TEST_BINARY_PREDICATE(refines,tv2,tv1); @@ -187,14 +187,14 @@ Void TestScalarTaylorFunction::test_predicates() Void TestScalarTaylorFunction::test_approximation() { -// ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,tv1,(d(2),e(2,3,{1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0}),0.25,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,tv2,(d(1),{{{0},1.0},{{1},2.0},{{2},3.0}},0.25,swp)); +// ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP,tv1,(d(2),e(2,3,{1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0}),0.25,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP,tv2,(d(1),{{{0},1.0},{{1},2.0},{{2},3.0}},0.25,swp)); } Void TestScalarTaylorFunction::test_evaluate() { Vector iv({{0.25_exact,0.5_exact},{-0.75_exact,-0.5_exact}}); - ValidatedScalarTaylorFunctionModelDP tv(d(2),{{{0,0},1.0},{{1,0},2.0},{{0,1},3.0},{{2,0},4.0},{{1,1},5.0},{{0,2},6.0}},0.25,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP tv(d(2),{{{0,0},1.0},{{1,0},2.0},{{0,1},3.0},{{2,0},4.0},{{1,1},5.0},{{0,2},6.0}},0.25,swp); ARIADNE_TEST_SAME(evaluate(tv,iv),FloatDPBounds(-0.375000,3.43750)); } @@ -211,51 +211,51 @@ Void TestScalarTaylorFunction::test_gradient() Vector point1=Vector{0.0_exact,0.0_exact}; Vector point2=Vector{0.0_exact,0.25_exact}; - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain1,quadratic,swp).gradient(point1),quadratic.gradient(point1)); - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain1,quadratic,swp).gradient(point2),quadratic.gradient(point2)); - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain2,quadratic,swp).gradient(point1),quadratic.gradient(point1)); - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain2,quadratic,swp).gradient(point2),quadratic.gradient(point2)); - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain3,quadratic,swp).gradient(point1),quadratic.gradient(point1)); - ARIADNE_TEST_EQUAL(ValidatedScalarTaylorFunctionModelDP(domain3,quadratic,swp).gradient(point2),quadratic.gradient(point2)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain1,quadratic,swp).gradient(point1),quadratic.gradient(point1)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain1,quadratic,swp).gradient(point2),quadratic.gradient(point2)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain2,quadratic,swp).gradient(point1),quadratic.gradient(point1)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain2,quadratic,swp).gradient(point2),quadratic.gradient(point2)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain3,quadratic,swp).gradient(point1),quadratic.gradient(point1)); + ARIADNE_TEST_EQUAL(ValidatedScalarMultivariateTaylorFunctionModelDP(domain3,quadratic,swp).gradient(point2),quadratic.gradient(point2)); } Void TestScalarTaylorFunction::test_arithmetic() { //Operations which can be performed exactly with floating-point arithmetic. - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+(-3), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},-2.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-(-3), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},4.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*(-3), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},-3.0},{{1},6.0},{{2},-9.0}}, 2.25, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)/(-4), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},-0.25},{{1},0.5},{{2},-0.75}}, 0.1875, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+FloatDPBounds(-1,2), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.5},{{1},-2.0},{{2},3.0}}, 2.25, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-FloatDPBounds(-1,2), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},0.5},{{1},-2.0},{{2},3.0}}, 2.25, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*FloatDPBounds(-1,2), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},0.5},{{1},-1.0},{{2},1.5}}, 10.5, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)/FloatDPBounds(0.25,2.0), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},2.25},{{1},-4.5},{{2},6.75}}, 13.5, swp)); - ARIADNE_TEST_SAME(+ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); - ARIADNE_TEST_SAME(-ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},-1.0},{{1},2.0},{{2},-3.0}}, 0.75, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+(-3), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},-2.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-(-3), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},4.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*(-3), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},-3.0},{{1},6.0},{{2},-9.0}}, 2.25, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)/(-4), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},-0.25},{{1},0.5},{{2},-0.75}}, 0.1875, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+FloatDPBounds(-1,2), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.5},{{1},-2.0},{{2},3.0}}, 2.25, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-FloatDPBounds(-1,2), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},0.5},{{1},-2.0},{{2},3.0}}, 2.25, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*FloatDPBounds(-1,2), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},0.5},{{1},-1.0},{{2},1.5}}, 10.5, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)/FloatDPBounds(0.25,2.0), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},2.25},{{1},-4.5},{{2},6.75}}, 13.5, swp)); + ARIADNE_TEST_SAME(+ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)); + ARIADNE_TEST_SAME(-ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},-1.0},{{1},2.0},{{2},-3.0}}, 0.75, swp)); // Regression test to check subtraction yielding zero coefficients - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},4.0},{{1},0.0},{{2},-1.0}}, 1.25, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)+ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},4.0},{{1},0.0},{{2},-1.0}}, 1.25, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},-2.0},{{1},-4.0},{{2},7.0}}, 1.25, swp)); - ARIADNE_TEST_SAME(ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), - ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},-4.0},{{2},1.0},{{3},14.0},{{4},-12.0}}, 10.125, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)-ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},-2.0},{{1},-4.0},{{2},7.0}}, 1.25, swp)); + ARIADNE_TEST_SAME(ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.0},{{1},-2.0},{{2},3.0}}, 0.75, swp)*ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},2.0},{{2},-4.0}}, 0.5, swp), + ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},3.0},{{1},-4.0},{{2},1.0},{{3},14.0},{{4},-12.0}}, 10.125, swp)); } Void TestScalarTaylorFunction::test_functions() { - ValidatedScalarTaylorFunctionModelDP xz(d(1),{{{0},0.0},{{1}, 0.5}}, 0.0, swp); - ValidatedScalarTaylorFunctionModelDP xo(d(1),{{{0},1.0},{{1}, 0.5}}, 0.0, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP xz(d(1),{{{0},0.0},{{1}, 0.5}}, 0.0, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP xo(d(1),{{{0},1.0},{{1}, 0.5}}, 0.0, swp); //Functions based on their natural defining points - ARIADNE_TEST_BINARY_PREDICATE(refines,exp(xz),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.00000},{{1},0.50000},{{2},0.12500},{{3},0.02083},{{4},0.00260},{{5},0.00026},{{6},0.00002}}, 0.00003, swp)); - ARIADNE_TEST_BINARY_PREDICATE(refines,sin(xz),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},0.00000},{{1},0.50000},{{2},0.0000},{{3},-0.02083},{{4},0.00000},{{5},0.00026},{{6},0.00000}}, 0.00003, swp)); - ARIADNE_TEST_BINARY_PREDICATE(refines,cos(xz),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.00000},{{1},0.0000},{{2},-0.12500},{{3},0.00000},{{4},0.00260},{{5},0.0000},{{6},-0.00002}}, 0.00003, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,exp(xz),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.00000},{{1},0.50000},{{2},0.12500},{{3},0.02083},{{4},0.00260},{{5},0.00026},{{6},0.00002}}, 0.00003, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,sin(xz),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},0.00000},{{1},0.50000},{{2},0.0000},{{3},-0.02083},{{4},0.00000},{{5},0.00026},{{6},0.00000}}, 0.00003, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,cos(xz),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.00000},{{1},0.0000},{{2},-0.12500},{{3},0.00000},{{4},0.00260},{{5},0.0000},{{6},-0.00002}}, 0.00003, swp)); - ARIADNE_TEST_BINARY_PREDICATE(refines,rec(xo),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.000000},{{1},-0.500000},{{2},0.250000},{{3},-0.125000},{{4}, 0.062500},{{5},-0.031250},{{6},0.015625}}, 0.018, swp)); - ARIADNE_TEST_BINARY_PREDICATE(refines,sqrt(xo),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},1.000000},{{1}, 0.250000},{{2},-0.031250},{{3}, 0.007813},{{4},-0.002441},{{5}, 0.000854},{{6},-0.000320}}, 0.0003, swp)); - ARIADNE_TEST_BINARY_PREDICATE(refines,log(xo),ValidatedScalarTaylorFunctionModelDP(d(1),{{{0},0.000000},{{1},0.500000},{{2},-0.125000},{{3}, 0.041667},{{4},-0.015625},{{5}, 0.006250},{{6},-0.002604}}, 0.003, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,rec(xo),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.000000},{{1},-0.500000},{{2},0.250000},{{3},-0.125000},{{4}, 0.062500},{{5},-0.031250},{{6},0.015625}}, 0.018, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,sqrt(xo),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},1.000000},{{1}, 0.250000},{{2},-0.031250},{{3}, 0.007813},{{4},-0.002441},{{5}, 0.000854},{{6},-0.000320}}, 0.0003, swp)); + ARIADNE_TEST_BINARY_PREDICATE(refines,log(xo),ValidatedScalarMultivariateTaylorFunctionModelDP(d(1),{{{0},0.000000},{{1},0.500000},{{2},-0.125000},{{3}, 0.041667},{{4},-0.015625},{{5}, 0.006250},{{6},-0.002604}}, 0.003, swp)); } @@ -267,22 +267,22 @@ Void TestScalarTaylorFunction::test_compose() Void TestScalarTaylorFunction::test_antiderivative() { - ValidatedScalarTaylorFunctionModelDP tm=ValidatedScalarTaylorFunctionModelDP::constant(d(2),1.0_exact,swp); - ValidatedScalarTaylorFunctionModelDP atm=antiderivative(tm,1u); + ValidatedScalarMultivariateTaylorFunctionModelDP tm=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(d(2),1.0_exact,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP atm=antiderivative(tm,1u); ARIADNE_TEST_CONSTRUCT(ExactBoxType,dom,({{1.0, 4.0}, {0.0, 2.0}})); - ValidatedVectorTaylorFunctionModelDP x = ValidatedVectorTaylorFunctionModelDP::identity(dom,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP x = ValidatedVectorMultivariateTaylorFunctionModelDP::identity(dom,swp); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP, f, (1 + 2*x[0]+3*x[1]+5*x[0]*x[0]+4*x[0]*x[1])); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP, g, (antiderivative(f,0,2.0_exact)) ); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP, f, (1 + 2*x[0]+3*x[1]+5*x[0]*x[0]+4*x[0]*x[1])); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP, g, (antiderivative(f,0,2.0_exact)) ); ARIADNE_TEST_PRINT( derivative(g,0) ); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP, dg, (derivative(g,0)) ); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP, dg, (derivative(g,0)) ); ARIADNE_TEST_LESS(norm(dg-f),1e-8); // We should have f(c,s)=0 for all x1 - ValidatedScalarTaylorFunctionModelDP s = ValidatedScalarTaylorFunctionModelDP::coordinate({dom[1]},0u,swp); - ValidatedScalarTaylorFunctionModelDP c = ValidatedScalarTaylorFunctionModelDP::constant(s.domain(),2.0_exact,swp); - ValidatedScalarTaylorFunctionModelDP h=compose(g,ValidatedVectorTaylorFunctionModelDP({c,s})); + ValidatedScalarMultivariateTaylorFunctionModelDP s = ValidatedScalarMultivariateTaylorFunctionModelDP::coordinate({dom[1]},0u,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP c = ValidatedScalarMultivariateTaylorFunctionModelDP::constant(s.domain(),2.0_exact,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP h=compose(g,ValidatedVectorMultivariateTaylorFunctionModelDP({c,s})); Vector hdom=h.domain(); Vector domv(reinterpret_castconst&>(hdom)); @@ -311,14 +311,14 @@ Void TestScalarTaylorFunction::test_conversion() { Vector ipt(pt); EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); ARIADNE_TEST_PRINT(x); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,tx,(D,x,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,tx,(D,x,swp)); ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,f,(1-x[0]*x[0]-x[1]/2)); ARIADNE_TEST_PRINT(compose(f,tx)); ARIADNE_TEST_CONSTRUCT(EffectiveScalarMultivariateFunction,y,(x[1]/2)); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,ty,(D,x[1]/2,swp)); - ARIADNE_TEST_PRINT(ValidatedScalarTaylorFunctionModelDP(D,x[1],swp)/2); - ARIADNE_TEST_CONSTRUCT(ValidatedScalarTaylorFunctionModelDP,tf,(D,f,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP,ty,(D,x[1]/2,swp)); + ARIADNE_TEST_PRINT(ValidatedScalarMultivariateTaylorFunctionModelDP(D,x[1],swp)/2); + ARIADNE_TEST_CONSTRUCT(ValidatedScalarMultivariateTaylorFunctionModelDP,tf,(D,f,swp)); // Conversion to TaylorFunction should be exact in second component ARIADNE_TEST_BINARY_PREDICATE(refines,f(ipt),tf(ipt)); @@ -330,9 +330,9 @@ Void TestScalarTaylorFunction::test_generic() { FloatDPValue c0={0,pr}; FloatDPValue c1={0,pr}; FloatDPValue c2={0,pr}; - ValidatedScalarTaylorFunctionModelDP pf0=ValidatedScalarTaylorFunctionModelDP::constant(D,c0,swp); - ValidatedScalarTaylorFunctionModelDP pf1=ValidatedScalarTaylorFunctionModelDP::constant(D,c1,swp); - ValidatedScalarTaylorFunctionModelDP pf2=ValidatedScalarTaylorFunctionModelDP::constant(D,c2,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP pf0=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(D,c0,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP pf1=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(D,c1,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP pf2=ValidatedScalarMultivariateTaylorFunctionModelDP::constant(D,c2,swp); ValidatedScalarMultivariateFunctionModelDP fm1=pf1; ValidatedScalarMultivariateFunctionModelDP fm2=pf2; ValidatedScalarMultivariateFunctionModelDP fm4=pf0; @@ -350,9 +350,9 @@ Void TestScalarTaylorFunction::test_generic() { } /* -ValidatedVectorTaylorFunctionModelDP henon(const ValidatedVectorTaylorFunctionModelDP& x, const Vector& p) +ValidatedVectorMultivariateTaylorFunctionModelDP henon(const ValidatedVectorMultivariateTaylorFunctionModelDP& x, const Vector& p) { - ValidatedVectorTaylorFunctionModelDP r(2,2,x.degree()); henon(r,x,p); return r; + ValidatedVectorMultivariateTaylorFunctionModelDP r(2,2,x.degree()); henon(r,x,p); return r; } */ @@ -414,16 +414,16 @@ Void TestVectorTaylorFunction::test_constructors() EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); Real a(1.5); Real b(0.25); EffectiveVectorMultivariateFunction henon_function={a-x[0]*x[0]+b*x[1], x[0]*1}; - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,henon_model,(domain,henon_function,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,henon_model,(domain,henon_function,swp)); ARIADNE_TEST_EQUAL(henon_model.models()[0].expansion(),expansion[0]) ARIADNE_TEST_EQUAL(henon_model.models()[1].expansion(),expansion[1]) Vector e0(e(2,0),pr); Vector e1(e(2,1),pr); - ValidatedVectorTaylorFunctionModelDP t=ValidatedVectorTaylorFunctionModelDP::identity(domain,swp); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,variables_model,((1.5_exact-t[0]*t[0]+0.25_exact*t[1])*e0+t[0]*e1)); + ValidatedVectorMultivariateTaylorFunctionModelDP t=ValidatedVectorMultivariateTaylorFunctionModelDP::identity(domain,swp); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,variables_model,((1.5_exact-t[0]*t[0]+0.25_exact*t[1])*e0+t[0]*e1)); ARIADNE_TEST_EXECUTE(variables_model.simplify()); - ARIADNE_TEST_SAME(variables_model,ValidatedVectorTaylorFunctionModelDP(domain,expansion,errors,swp)); + ARIADNE_TEST_SAME(variables_model,ValidatedVectorMultivariateTaylorFunctionModelDP(domain,expansion,errors,swp)); } @@ -437,8 +437,8 @@ Void TestVectorTaylorFunction::test_restrict() Expansion subexpansion1({{{0,0},1.031250},{{1,0},1.812500},{{0,1},0.625000}, {{2,0},1.812500},{{1,1},0.562500},{{0,2},0.0468750}, {{3,0},0.875000},{{2,1},0.500000},{{1,2},0.281250},{{0,3},0.156250}}); Vector error1={0.0}; - ValidatedVectorTaylorFunctionModelDP function1(domain1,expansion1*unit0,error1,swp); - ValidatedVectorTaylorFunctionModelDP restricted_function1(subdomain1,subexpansion1*unit0,error1,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP function1(domain1,expansion1*unit0,error1,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP restricted_function1(subdomain1,subexpansion1*unit0,error1,swp); ARIADNE_TEST_SAME(restriction(function1,subdomain1),restricted_function1); ExactBoxType domain2={{-1.0,+1.0}}; @@ -447,8 +447,8 @@ Void TestVectorTaylorFunction::test_restrict() Vector subdomain2={{3e-16,1.0}}; Expansion subexpansion2={{{0},0.50000000000000022},{{1},0.49999999999999989}}; Vector suberror2={0.125000000000000028}; - ValidatedVectorTaylorFunctionModelDP function2(domain2,expansion2*unit0,error2,swp); - ValidatedVectorTaylorFunctionModelDP restricted_function2(subdomain2,subexpansion2*unit0,suberror2,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP function2(domain2,expansion2*unit0,error2,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP restricted_function2(subdomain2,subexpansion2*unit0,suberror2,swp); FloatDPValue::set_output_places(18); FloatDPError::set_output_places(18); ARIADNE_TEST_SAME(restriction(function2,subdomain2),restricted_function2); @@ -470,12 +470,12 @@ Void TestVectorTaylorFunction::test_jacobian() Vector point2=Vector{0.0_exact,0.25_exact}; //Vector point1=Vector{0.0,0.0}; //Vector point2=Vector{0.5,0.25}; - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain1,henon,swp).jacobian(point1),henon.jacobian(point1)); - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain1,henon,swp).jacobian(point2),henon.jacobian(point2)); - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain2,henon,swp).jacobian(point1),henon.jacobian(point1)); - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain2,henon,swp).jacobian(point2),henon.jacobian(point2)); - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain3,henon,swp).jacobian(point1),henon.jacobian(point1)); - ARIADNE_TEST_EQUAL(ValidatedVectorTaylorFunctionModelDP(domain3,henon,swp).jacobian(point2),henon.jacobian(point2)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain1,henon,swp).jacobian(point1),henon.jacobian(point1)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain1,henon,swp).jacobian(point2),henon.jacobian(point2)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain2,henon,swp).jacobian(point1),henon.jacobian(point1)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain2,henon,swp).jacobian(point2),henon.jacobian(point2)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain3,henon,swp).jacobian(point1),henon.jacobian(point1)); + ARIADNE_TEST_EQUAL(ValidatedVectorMultivariateTaylorFunctionModelDP(domain3,henon,swp).jacobian(point2),henon.jacobian(point2)); } Void TestVectorTaylorFunction::test_compose() @@ -493,10 +493,10 @@ Void TestVectorTaylorFunction::test_compose() ARIADNE_TEST_PRINT(e(2,0)); ARIADNE_TEST_PRINT((a-x*x+b*y)*e(2,0)); ARIADNE_TEST_PRINT(henon_polynomial); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,function1,(domain1,henon_polynomial,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,function2,(domain2,henon_polynomial,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,function1,(domain1,henon_polynomial,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,function2,(domain2,henon_polynomial,swp)); - ValidatedVectorTaylorFunctionModelDP composition1(domain1,henon_square_polynomial,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP composition1(domain1,henon_square_polynomial,swp); ARIADNE_TEST_SAME(compose(function2,function1),composition1); } @@ -509,27 +509,27 @@ Void TestVectorTaylorFunction::test_antiderivative() Vector unit0={1}; ExactBoxType domain1={{-1,+1},{-1,+1}}; Expansion expansion1={{{0,0},3.0}}; - ValidatedVectorTaylorFunctionModelDP function1(domain1,expansion1*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP function1(domain1,expansion1*unit0,swp); Expansion aexpansion1={{{0,1},3.0}}; - ValidatedVectorTaylorFunctionModelDP antiderivative1(domain1,aexpansion1*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP antiderivative1(domain1,aexpansion1*unit0,swp); ARIADNE_TEST_SAME(antiderivative(function1,index1),antiderivative1); ExactBoxType domain2={{-0.25,0.75},{0.0,0.5}}; Expansion expansion2={{{0,0},3.0}}; - ValidatedVectorTaylorFunctionModelDP function2(domain2,expansion2*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP function2(domain2,expansion2*unit0,swp); Expansion aexpansion2={{{0,1},0.75}}; - ValidatedVectorTaylorFunctionModelDP antiderivative2(domain2,aexpansion2*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP antiderivative2(domain2,aexpansion2*unit0,swp); ARIADNE_TEST_SAME(antiderivative(function2,index1),antiderivative2); ExactBoxType domain3={{-0.25,0.75},{0.0,0.5}}; Expansion expansion3={{{0,0},1.0},{{1,0},2.0},{{0,1},3.0},{{2,0},4.0},{{1,1},5.0},{{0,2},6.0}}; - ValidatedVectorTaylorFunctionModelDP function3(domain3,expansion3*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP function3(domain3,expansion3*unit0,swp); Expansion aexpansion30={{{1,0},0.5},{{2,0},0.5},{{1,1},1.5},{{3,0},0.66666666666666663},{{2,1},1.25},{{1,2},3.0}}; Vector aerror30={5.5511151231257827e-17}; - ValidatedVectorTaylorFunctionModelDP antiderivative30(domain3,aexpansion30*unit0,aerror30,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP antiderivative30(domain3,aexpansion30*unit0,aerror30,swp); ARIADNE_TEST_SAME(antiderivative(function3,index0),antiderivative30); Expansion aexpansion31={{{0,1},0.25},{{1,1},0.5},{{0,2},0.375},{{2,1},1.0},{{1,2},0.625},{{0,3},0.5}}; - ValidatedVectorTaylorFunctionModelDP antiderivative31(domain3,aexpansion31*unit0,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP antiderivative31(domain3,aexpansion31*unit0,swp); ARIADNE_TEST_SAME(antiderivative(function3,index1),antiderivative31); } @@ -543,9 +543,9 @@ Void TestVectorTaylorFunction::test_join() EffectiveVectorMultivariateFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + (4*x[0]*x[0]+5*x[0]*x[1]+6*x[1]*x[1])*e(3,2); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction1,(domain,function1,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction2,(domain,function2,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction3,(domain,function3,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction1,(domain,function1,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction2,(domain,function2,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction3,(domain,function3,swp)); ARIADNE_TEST_SAME(join(taylorfunction1,taylorfunction2),taylorfunction3); } @@ -564,9 +564,9 @@ Void TestVectorTaylorFunction::test_combine() x=EffectiveVectorMultivariateFunction::identity(5); EffectiveVectorMultivariateFunction function3 = (x[0]*x[0]+2*x[0]*x[1]+3*x[1]*x[1])*e(3,0) + (4*x[2]*x[2]+5*x[2]*x[3]+6*x[3]*x[4])*e(3,2); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction1,(domain1,function1,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction2,(domain2,function2,swp)); - ARIADNE_TEST_CONSTRUCT(ValidatedVectorTaylorFunctionModelDP,taylorfunction3,(domain3,function3,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction1,(domain1,function1,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction2,(domain2,function2,swp)); + ARIADNE_TEST_CONSTRUCT(ValidatedVectorMultivariateTaylorFunctionModelDP,taylorfunction3,(domain3,function3,swp)); ARIADNE_TEST_SAME(combine(taylorfunction1,taylorfunction2),taylorfunction3); } @@ -581,7 +581,7 @@ Void TestVectorTaylorFunction::test_conversion() EffectiveVectorMultivariateFunction x=EffectiveVectorMultivariateFunction::identity(2); EffectiveVectorMultivariateFunction h={1-x[0]*x[0]-x[1]/2,x[0]+Real(0)}; - ValidatedVectorTaylorFunctionModelDP th(D,h,swp); + ValidatedVectorMultivariateTaylorFunctionModelDP th(D,h,swp); ARIADNE_TEST_PRINT(h); ARIADNE_TEST_PRINT(th); @@ -603,18 +603,18 @@ Void TestVectorTaylorFunction::test_domain() EffectiveScalarMultivariateFunction x1=EffectiveScalarMultivariateFunction::coordinate(2,1); ExactBoxType D1={{-1.0,1.0},{-1.0,1.0}}; - ValidatedVectorTaylorFunctionModelDP t1(D1, {o,x0+x1}, swp); + ValidatedVectorMultivariateTaylorFunctionModelDP t1(D1, {o,x0+x1}, swp); ARIADNE_TEST_PRINT(t1); ARIADNE_TEST_PRINT(t1.codomain()); ExactBoxType D2={{1.0,1.0},{-2.0,2.0}}; - ValidatedScalarTaylorFunctionModelDP t2(D2,2*x0+x1*x1,swp); + ValidatedScalarMultivariateTaylorFunctionModelDP t2(D2,2*x0+x1*x1,swp); ARIADNE_TEST_PRINT(t2.domain()); ARIADNE_TEST_PRINT(t2.model()); ARIADNE_TEST_PRINT(t2.codomain()); ARIADNE_TEST_PRINT(t2); ARIADNE_TEST_PRINT(compose(t2,t1)); - ValidatedScalarTaylorFunctionModelDP t3(D1,2+(x0+x1)*(x0+x1),swp); + ValidatedScalarMultivariateTaylorFunctionModelDP t3(D1,2+(x0+x1)*(x0+x1),swp); ARIADNE_TEST_SAME(compose(t2,t1),t3); Vector x={FloatDPBounds{1.0,1.0},FloatDPBounds{0.5,1.5}}; @@ -627,11 +627,11 @@ Void TestVectorTaylorFunction::test_domain() ARIADNE_TEST_THROWS(evaluate(t2,xe),DomainException); // Ensure evaluation and composition throw errors when expected - ValidatedVectorTaylorFunctionModelDP vt2={t2}; + ValidatedVectorMultivariateTaylorFunctionModelDP vt2={t2}; ARIADNE_TEST_THROWS(vt2(xe),DomainException); ARIADNE_TEST_THROWS(evaluate(vt2,xe),DomainException); - ValidatedVectorTaylorFunctionModelDP te1=t1; te1[0]=te1[0]+FloatDPBounds(-0.125,+0.125); + ValidatedVectorMultivariateTaylorFunctionModelDP te1=t1; te1[0]=te1[0]+FloatDPBounds(-0.125,+0.125); ARIADNE_TEST_THROWS(compose(t2,te1),DomainException); ARIADNE_TEST_THROWS(compose(vt2,te1),DomainException); @@ -639,11 +639,11 @@ Void TestVectorTaylorFunction::test_domain() // Regression test for printing functions with trivial domain component ExactBoxType D4={{1.0,1.0},{0.0,2.0}}; - ValidatedScalarTaylorFunctionModelDP st40(D4, x0, swp); - ValidatedScalarTaylorFunctionModelDP st41(D4, x1, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP st40(D4, x0, swp); + ValidatedScalarMultivariateTaylorFunctionModelDP st41(D4, x1, swp); ARIADNE_TEST_PRINT(st40); ARIADNE_TEST_PRINT(st41); - ValidatedVectorTaylorFunctionModelDP t4(D4, {x0,x1}, swp); + ValidatedVectorMultivariateTaylorFunctionModelDP t4(D4, {x0,x1}, swp); ARIADNE_TEST_PRINT(t4); } @@ -674,13 +674,13 @@ Void TestTaylorFunctionFactory::test_create() Vector dom={{-1,+1},{0.5,3.5}}; Vector args=reinterpret_castconst&>(dom); - ValidatedScalarTaylorFunctionModelDP stf=factory.create(dom, EffectiveScalarMultivariateFunction::zero(dom.size()) ); + ValidatedScalarMultivariateTaylorFunctionModelDP stf=factory.create(dom, EffectiveScalarMultivariateFunction::zero(dom.size()) ); ARIADNE_TEST_PRINT(stf); ARIADNE_TEST_EQUALS(&stf.properties(),&sweeper); ARIADNE_TEST_EQUALS(stf(args),FloatDPBounds(0.0)); ARIADNE_TEST_EQUALS(evaluate(stf,args),FloatDPBounds(0.0)); - ValidatedVectorTaylorFunctionModelDP vtf=factory.create(dom, EffectiveVectorMultivariateFunction::identity(dom.size()) ); + ValidatedVectorMultivariateTaylorFunctionModelDP vtf=factory.create(dom, EffectiveVectorMultivariateFunction::identity(dom.size()) ); ARIADNE_TEST_PRINT(vtf); // Test evaluation gives a superset with small additional error diff --git a/tests/solvers/test_integrator.cpp b/tests/solvers/test_integrator.cpp index ee0bf1178..fc05f1ffb 100644 --- a/tests/solvers/test_integrator.cpp +++ b/tests/solvers/test_integrator.cpp @@ -166,7 +166,7 @@ class TestIntegrator //ExactIntervalVectorType d(1u,ExactIntervalType(-0.125,+0.125)); //StepSizeType h=0.125_x; ValidatedVectorMultivariateFunctionModelDP flow=integrator_ptr->flow_step(f,d,h); - ValidatedVectorTaylorFunctionModelDP taylor_flow=dynamic_cast(flow.reference()); + ValidatedVectorMultivariateTaylorFunctionModelDP taylor_flow=dynamic_cast(flow.reference()); //EffectiveVectorMultivariateFunction expected_flow( (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t, y0+t) ); //EffectiveVectorMultivariateFunction expected_flow(1u, (x0+x0*(1-x0)*t+x0*(1-x0)*(1-2*x0)/2*t*t) ); EffectiveVectorMultivariateFunction expected_flow(1u, flowf ); diff --git a/tests/solvers/test_solvers.cpp b/tests/solvers/test_solvers.cpp index 8e4f681b2..1816b0fb9 100644 --- a/tests/solvers/test_solvers.cpp +++ b/tests/solvers/test_solvers.cpp @@ -173,7 +173,7 @@ class TestSolver r=ExactIntervalType(-1,1); f=EffectiveScalarMultivariateFunction(x-2*a); ARIADNE_TEST_PRINT(f); - ValidatedScalarMultivariateFunctionModelDP g=ValidatedScalarTaylorFunctionModelDP(join(p,r),f,ThresholdSweeper(dp,1e-12)); + ValidatedScalarMultivariateFunctionModelDP g=ValidatedScalarMultivariateTaylorFunctionModelDP(join(p,r),f,ThresholdSweeper(dp,1e-12)); ARIADNE_TEST_PRINT(g); try { h=solver->implicit(g,p,r); @@ -191,24 +191,7 @@ class TestSolver #include "algebra/differential.hpp" Int main(Int argc, const char **argv) { -/* - ExactIntervalVectorType D={{-1,+1},{-1,+1}}; - ValidatedVectorTaylorFunctionModelDP x=ValidatedVectorTaylorFunctionModelDP::identity(D,ThresholdSweeper(1e-10)); - ValidatedScalarTaylorFunctionModelDP f=2*x[0]-x[1]; - std::cerr<<"D="<> dx=Differential::variables(2,2,1u,D); - Differential dx0=dx[0]; - std::cerr<<"dx="<(double_precision,1e-4)); + auto th = ValidatedVectorMultivariateTaylorFunctionModelDP(dom,h,ThresholdSweeper(double_precision,1e-4)); print(th); auto thh=compose(h,th); print(thh); From 3c6f4431daa3f30db0cf1f0626101a133296935a Mon Sep 17 00:00:00 2001 From: Pieter Collins Date: Thu, 11 Oct 2018 09:27:47 +0200 Subject: [PATCH 7/8] Added operations on generic numbers to FunctionModel and ScaledFunctionPatch. --- python/source/calculus_submodule.cpp | 2 +- source/algebra/operations.hpp | 13 +++- source/function/function_model.hpp | 67 +++++++++++-------- source/function/scaled_function_patch.hpp | 45 +++++++++++-- source/function/scaled_function_patch.tpl.hpp | 16 +++++ tests/function/test_taylor_function.cpp | 63 +++++++++-------- 6 files changed, 143 insertions(+), 63 deletions(-) diff --git a/python/source/calculus_submodule.cpp b/python/source/calculus_submodule.cpp index 685dfe13e..1626b8ddc 100644 --- a/python/source/calculus_submodule.cpp +++ b/python/source/calculus_submodule.cpp @@ -340,7 +340,7 @@ Void export_scalar_function_model(pybind11::module& module) scalar_function_model_class.def("__str__", &__cstr__); scalar_function_model_class.def("__repr__", &__crepr__); - module.def("evaluate", (ValidatedNumericType(*)(const ValidatedScalarMultivariateFunctionModelDP&,const Vector&)) &evaluate); + module.def("evaluate", &_evaluate_>); module.def("partial_evaluate", &_partial_evaluate_); module.def("compose", _compose_); diff --git a/source/algebra/operations.hpp b/source/algebra/operations.hpp index 88e64c6d3..5a0ca7600 100644 --- a/source/algebra/operations.hpp +++ b/source/algebra/operations.hpp @@ -169,7 +169,7 @@ template struct DeclareTranscendentalAlgebraOperations : Decla template struct DispatchMixedAlgebraNumberOperations; -template struct DispatchConcreteGenericAlgebraNumberOperations { +template struct DispatchConcreteGenericAlgebraNumberOperators { friend X create(Y const& y, A const& a) { return X(y,a.precision()); } friend A& operator+=(A& a1, Y const& y2) { X x2=create(y2,a1); return a1+=x2; } friend A& operator-=(A& a1, Y const& y2) { X x2=create(y2,a1); return a1-=x2; } @@ -185,6 +185,17 @@ template struct DispatchConcreteGenericAlgebraNumberO friend A operator/(Y const& y1, A a2) { return rec(a2)*y1; } }; +template struct DispatchConcreteGenericAlgebraNumberOperations : DispatchConcreteGenericAlgebraNumberOperators { + friend A add(A a1, Y const& y2) { a1+=y2; return std::move(a1); } + friend A sub(A a1, Y const& y2) { a1-=y2; return std::move(a1); } + friend A mul(A a1, Y const& y2) { a1*=y2; return std::move(a1); } + friend A div(A a1, Y const& y2) { a1/=y2; return std::move(a1); } + friend A add(Y const& y1, A a2) { return a2+y1; } + friend A sub(Y const& y1, A a2) { return (-a2)+y1; } + friend A mul(Y const& y1, A a2) { return a2*y1; } + friend A div(Y const& y1, A a2) { return rec(a2)*y1; } +}; + template struct DispatchAlgebraOperators { diff --git a/source/function/function_model.hpp b/source/function/function_model.hpp index 8eb70f615..48beea7ba 100644 --- a/source/function/function_model.hpp +++ b/source/function/function_model.hpp @@ -159,21 +159,26 @@ template class FunctionModelCreator { template class FunctionModel // : public DispatchTranscendentalAlgebraOperations, CanonicalNumericType> : public DispatchTranscendentalAlgebraOperations, CanonicalNumericType> - , public ProvideConcreteGenericArithmeticOperators,ScalarMultivariateFunction

> - , public ProvideConcreteGenericArithmeticOperators,Number

> + , public ProvideConcreteGenericArithmeticOperations,ScalarMultivariateFunction

> + , public ProvideConcreteGenericArithmeticOperations,Number

> { static_assert(IsSame::value or IsSame::value,""); typedef IntervalDomainType C; public: typedef ScalarFunction GenericType; + typedef P Paradigm; typedef PR PrecisionType; typedef D DomainType; typedef C CodomainType; typedef CanonicalCoefficientType CoefficientType; typedef CanonicalErrorType ErrorType; typedef CanonicalNumericType NumericType; + typedef Number

GenericNumericType; typedef FloatError NormType; typedef Interval> RangeType; + + template using Argument = typename ElementTraits::template Type; + template using Result = ElementTraits::template Type; public: clone_on_copy_ptr< ScalarFunctionModelInterface > _ptr; public: @@ -221,6 +226,15 @@ template class FunctionModel factory(f._ptr->_factory()); return FunctionModelCreator,D>(f.domain(),factory); } public: public: + friend CanonicalNumericType evaluate(const ScalarFunctionModel& f, const Vector>& x) { + return f._ptr->_evaluate(x); } + friend Number

evaluate(const ScalarFunctionModel& f, const Vector>& x) { + return f._ptr->_evaluate(Vector>(x,f.precision())); } + friend CanonicalNumericType unchecked_evaluate(const ScalarFunctionModel& f, const Vector>& x) { + return f._ptr->_unchecked_evaluate(x); } + friend Number

unchecked_evaluate(const ScalarFunctionModel& f, const Vector>& x) { + return f._ptr->_unchecked_evaluate(Vector>(x,f.precision())); } + friend ScalarFunctionModel partial_evaluate(const ScalarFunctionModel& f, SizeType j, const CanonicalNumericType& c) { return ScalarFunctionModel(f._ptr->_partial_evaluate(j,c)); } friend ScalarFunctionModel partial_evaluate(const ScalarFunctionModel& f, SizeType j, const Number

& c) { @@ -325,18 +339,7 @@ template struct AlgebraOperations inline -ScalarFunctionModel refinement(const ScalarFunctionModel& f1, const ScalarFunctionModel& f2) { - return ScalarFunctionModel(f1._ptr->_refinement(f2)); } -template inline -Boolean inconsistent(const ScalarFunctionModel& f1, const ScalarFunctionModel& f2) { - return f1._ptr->_inconsistent(f2); } -template inline -Boolean refines(const ScalarFunctionModel& f1, const ScalarFunctionModel& f2) { - return f1._ptr->_refines(f2); } -*/ - // FIXME: Should not be needed since ScalarMultivariateFunctionModel has a representation +// FIXME: Should not be needed since ScalarMultivariateFunctionModel has a representation template inline ScalarMultivariateFunctionModel embed(const ScalarMultivariateFunction

& f, const IntervalDomainType& d) { return embed(ScalarMultivariateFunctionModel(f),d); } @@ -399,13 +402,19 @@ template class FunctionModel > _ptr; public: + typedef VectorFunction GenericType; + typedef P Paradigm; typedef PR PrecisionType; typedef D DomainType; typedef C CodomainType; typedef CanonicalCoefficientType CoefficientType; typedef CanonicalErrorType ErrorType; typedef CanonicalNumericType NumericType; + typedef Number

GenericNumericType; typedef Box>> RangeType; + + template using Argument = typename ElementTraits::template Type; + template using Result = ElementTraits::template Type; public: inline FunctionModel() : _ptr() { } inline FunctionModel(SharedPointer> vfp) @@ -512,8 +521,23 @@ template class FunctionModel restriction(const VectorFunctionModel& f, const DomainType& d) { VectorFunctionModelInterface* rptr=f._ptr->_clone(); rptr->restrict(d); return VectorFunctionModel(rptr); } + friend Vector> evaluate(const VectorFunctionModel& f, const Vector>& x) { + return f._ptr->_evaluate(x); } + friend Vector> evaluate(const VectorFunctionModel& f, const Vector>& x) { + return f._ptr->_evaluate(Vector>(x,f.precision())); } + friend Vector> unchecked_evaluate(const VectorFunctionModel& f, const Vector>& x) { return f._ptr->_unchecked_evaluate(x); } + friend Vector> unchecked_evaluate(const VectorFunctionModel& f, const Vector>& x) { + return f._ptr->_unchecked_evaluate(Vector>(x,f.precision())); } + + friend VectorFunctionModel partial_evaluate(const VectorFunctionModel& f, SizeType j, const CanonicalNumericType& c) { + return VectorFunctionModel(f._ptr->_partial_evaluate(j,c)); } + friend VectorFunctionModel partial_evaluate(const VectorFunctionModel& f, SizeType j, const Number

& c) { + return partial_evaluate(f,j,CanonicalNumericType(c,f.precision())); } + + friend OutputStream& operator<<(OutputStream& os, const VectorFunctionModel& f) { + return os << f.operator VectorMultivariateFunction

(); } friend ScalarFunctionModel unchecked_compose(const ScalarMultivariateFunction

& f, const VectorFunctionModel& g) { ScalarFunctionModelInterface const* fptr = dynamic_cast const*>(f.raw_pointer()); @@ -559,21 +583,8 @@ template class FunctionModel(c,f[0].value().precision())); } - friend VectorFunctionModel partial_evaluate(const VectorFunctionModel& f, SizeType j, const CanonicalNumericType& c) { - return VectorFunctionModel(f._ptr->_partial_evaluate(j,c)); } - friend VectorFunctionModel partial_evaluate(const VectorFunctionModel& f, SizeType j, const Number

& c) { - return partial_evaluate(f,j,CanonicalNumericType(c,f.precision())); } - - friend OutputStream& operator<<(OutputStream& os, const VectorFunctionModel& f) { - return os << f.operator VectorMultivariateFunction

(); } - }; -template inline CanonicalNumericType evaluate(const ScalarFunctionModel& f, const Vector>& x) { - return f(x); } -template inline CanonicalNumericType unchecked_evaluate(const ScalarFunctionModel& f, const Vector>& x) { - return f._ptr->_unchecked_evaluate(x); } - // FIXME: Implement for Multiple-Precision versions template inline CanonicalNumeric64Type

unchecked_evaluate(const ScalarMultivariateFunction

& f, const Vector>& x) { ScalarMultivariateFunctionModelDPInterface

const* fptr = dynamic_cast const*>(f.raw_pointer()); @@ -595,6 +606,8 @@ template ScalarFunctionModel(g._ptr->_unchecked_compose(f)); } template VectorFunctionModel unchecked_compose(const VectorMultivariateFunctionModel& f, const VectorFunctionModel& g) { return VectorFunctionModel(g._ptr->_unchecked_compose(f)); } + +// FIXME: Should be unneeded template ScalarFunctionModel restrict(const ScalarFunctionModel& f, const D& dom) { return ScalarFunctionModel(f._ptr->_restriction(dom)); } template VectorFunctionModel restrict(const VectorFunctionModel& f, const D& dom) { diff --git a/source/function/scaled_function_patch.hpp b/source/function/scaled_function_patch.hpp index 88c4bf442..8de40506a 100644 --- a/source/function/scaled_function_patch.hpp +++ b/source/function/scaled_function_patch.hpp @@ -160,6 +160,9 @@ template class ScaledFunctionPatch typedef ScalarMultivariateFunction GenericType; typedef Number GenericNumericType; typedef typename M::PropertiesType PropertiesType; + + template using Argument = typename ElementTraits::template Type; + template using Result = ElementTraits::template Type; private: static const CoefficientType _zero; DomainType _domain; @@ -188,8 +191,10 @@ template class ScaledFunctionPatch //@{ //! \name Assignment to constant values. - //! \brief Set equal to an interval constant, keeping the same number of arguments. + //! \brief Set equal to a constant, keeping the same number of arguments. ScaledFunctionPatch& operator=(const NumericType& c) { this->_model=c; return *this; } + //! \brief Set equal to a constant, keeping the same number of arguments. + ScaledFunctionPatch& operator=(const GenericNumericType c) { this->_model=c; return *this; } //@} //@{ @@ -302,6 +307,7 @@ template class ScaledFunctionPatch FloatBounds operator()(const Vector>& x) const; FloatBounds operator()(const Vector>& x) const; FloatApproximation operator()(const Vector>& x) const; + ValidatedNumber operator()(const Vector& x) const; //! \brief Compute an approximation to gradient derivative of the function at the point \a x. Covector gradient(const Vector& x) const; @@ -408,15 +414,24 @@ template class ScaledFunctionPatch VectorScaledFunctionPatch h ( VectorScaledFunctionPatch::identity(f.domain(),f.properties()) ); h[k] = ScaledFunctionPatch::constant(f.domain(),c,f.properties()); return g-compose(g,h); } - + friend ScaledFunctionPatch antiderivative(const ScaledFunctionPatch& f, SizeType k, const GenericNumericType& c) { + return antiderivative(f,k,NumericType(c,f.precision())); } + friend ScaledFunctionPatch partial_evaluate(const ScaledFunctionPatch& f, SizeType k, const NumericType& c) { ARIADNE_ASSERT(decide(contains(f.domain()[k],c))); return ScaledFunctionPatch(remove(f.domain(),k),partial_evaluate(f.model(),k,unscale(c,f.domain()[k]))); } + friend ScaledFunctionPatch partial_evaluate(const ScaledFunctionPatch& f, SizeType k, const GenericNumericType& c) { + ARIADNE_ASSERT(decide(contains(f.domain()[k],c))); + return partial_evaluate(f,k,NumericType(c,f.precision())); } friend NumericType evaluate(const ScaledFunctionPatch& f, const Vector& x) { if(!definitely(contains(f.domain(),x))) { ARIADNE_THROW(DomainException,"evaluate(f,x) with f="< systems = {HS(),CR(),LV(),JE(),PI(),J21(),LA(),RA(),J16(),DC(),HO()}; + List systems = {HS(),CR(),LV(),JE(),PI(),J21(),LA(),RA(),J16(),DC()}; for (SystemType s : systems) { std::cout << std::get<0>(s) << std::endl; diff --git a/examples/noisy/noisy-utilities.hpp b/examples/noisy/noisy-utilities.hpp index 400084f28..3f3dcc263 100644 --- a/examples/noisy/noisy-utilities.hpp +++ b/examples/noisy/noisy-utilities.hpp @@ -29,8 +29,8 @@ namespace Ariadne { typedef Tuple SystemType; -void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw); -void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw); +void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw); +void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw); void run_noisy_system(String name, const DottedRealAssignments& dynamics, const RealVariablesBox& inputs, const RealVariablesBox& initial, Real evolution_time, double step); void run_noisy_system(SystemType system); @@ -53,7 +53,7 @@ template struct Reverse { template Reverse reverse(C const& c) { return Reverse(c); } -void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw) { +void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw) { typedef typename ValidatedVectorMultivariateFunctionModelType::NumericType NumericType; typedef typename NumericType::PrecisionType PrecisionType; @@ -104,10 +104,10 @@ void run_single(String name, DifferentialInclusionIVP const& ivp, Real evolution } } -void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw) { +void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity, bool draw) { for (auto appro: approximations) { - List singleapproximation = {appro}; + List singleapproximation = {appro}; std::cout << appro << std::endl; run_single(name,ivp,evolution_time,step,singleapproximation,sweeper,freq,verbosity,draw); } @@ -125,12 +125,12 @@ void run_noisy_system(String name, const DottedRealAssignments& dynamics, const bool draw = false; DRAWING_METHOD = DrawingMethod::BOX; - List approximations; - approximations.append(InputApproximation::ZERO); - approximations.append(InputApproximation::CONSTANT); - approximations.append(InputApproximation::AFFINE); - approximations.append(InputApproximation::SINUSOIDAL); - approximations.append(InputApproximation::PIECEWISE); + List approximations; + approximations.append(InputApproximationKind::ZERO); + approximations.append(InputApproximationKind::CONSTANT); + approximations.append(InputApproximationKind::AFFINE); + approximations.append(InputApproximationKind::SINUSOIDAL); + approximations.append(InputApproximationKind::PIECEWISE); run_single(name,ivp,evolution_time,step,approximations,sweeper,freq,verbosity,draw); //run_each_approximation(name,ivp,evolution_time,step,approximations,sweeper,freq,verbosity,draw); diff --git a/source/dynamics/differential_inclusion.cpp b/source/dynamics/differential_inclusion.cpp index 8a8d7ffb9..b75333b04 100644 --- a/source/dynamics/differential_inclusion.cpp +++ b/source/dynamics/differential_inclusion.cpp @@ -55,21 +55,18 @@ inline std::ostream& operator<<(std::ostream& os, const DifferentialInclusionIVP struct ScheduledApproximator { - SizeType step; + Nat step; InputApproximator approximator; - ScheduledApproximator(SizeType s, InputApproximator a) : step(s), approximator(a) {} + ScheduledApproximator(Nat s, InputApproximator a) : step(s), approximator(a) {} }; inline OutputStream& operator<<(OutputStream& os, ScheduledApproximator const& sa) { return os << "(" << sa.step << ":" << sa.approximator.kind() << ")"; } -struct ScheduledApproximatorComparator -{ - inline bool operator() (const ScheduledApproximator& sa1, const ScheduledApproximator& sa2) - { - return (sa1.step > sa2.step); - } +struct ScheduledApproximatorComparator { + inline bool operator() (const ScheduledApproximator& sa1, const ScheduledApproximator& sa2) { + return (sa1.step > sa2.step); } }; inline char activity_symbol(SizeType step) { @@ -168,14 +165,14 @@ inline Box apply(VectorMultivariateFunctioncons return apply(f,Box(bx)); } -inline Map convert_to_percentages(const Map& approximation_global_frequencies) { +inline Map convert_to_percentages(const Map& approximation_global_frequencies) { SizeType total_steps(0); for (auto entry: approximation_global_frequencies) { total_steps += entry.second; } - Map result; + Map result; for (auto entry: approximation_global_frequencies) { result[entry.first] = 1.0/total_steps*entry.second; } @@ -351,21 +348,21 @@ template Vector ApproximationErrorProcessor::p } InputApproximator -InputApproximatorFactory::create(DifferentialInclusion const& di, InputApproximation kind, SweeperDP sweeper) const { +InputApproximatorFactory::create(DifferentialInclusion const& di, InputApproximationKind kind, SweeperDP sweeper) const { switch(kind) { - case InputApproximation::ZERO : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); - case InputApproximation::CONSTANT : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); - case InputApproximation::AFFINE : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); - case InputApproximation::SINUSOIDAL: return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); - case InputApproximation::PIECEWISE : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); + case InputApproximationKind::ZERO : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); + case InputApproximationKind::CONSTANT : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); + case InputApproximationKind::AFFINE : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); + case InputApproximationKind::SINUSOIDAL: return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); + case InputApproximationKind::PIECEWISE : return InputApproximator(SharedPointer(new InputApproximatorBase(di,sweeper))); default: ARIADNE_FAIL_MSG("Unexpected input approximation kind "< approximations, SweeperDP sweeper, StepSize step_size_) +InclusionIntegrator::InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size_) : _approximations(approximations) , _sweeper(sweeper) , _step_size(step_size_) @@ -377,7 +374,12 @@ InclusionIntegrator::InclusionIntegrator(List approximations static const SizeType NUMBER_OF_PICARD_ITERATES=6; +Bool InclusionIntegrator::must_recondition(Nat step) const { + return (step%this->_number_of_steps_between_simplifications == this->_number_of_steps_between_simplifications-1); +} + List InclusionIntegrator::flow(DifferentialInclusionIVP const& ivp, Real tmax) { + ARIADNE_LOG(2,"\n"< InclusionIntegrator::flow(Diffe ValidatedVectorMultivariateFunctionModelDP evolve_function = ValidatedVectorMultivariateTaylorFunctionModelDP::identity(X0,this->_sweeper); auto t=PositiveFloatDPValue(0.0); - Map approximation_global_frequencies, approximation_local_frequencies; + Map approximation_global_frequencies, approximation_local_frequencies; + Map delays; for (auto appro: _approximations) { approximation_global_frequencies[appro] = 0; approximation_local_frequencies[appro] = 0; + delays[appro] = 0; } - List result; - - SizeType step = 0; - List schedule; - Map delays; List approximations; InputApproximatorFactory factory; @@ -414,10 +413,11 @@ List InclusionIntegrator::flow(Diffe approximations.append(factory.create(di,appro,_sweeper)); for (auto appro: approximations) { - schedule.push_back(ScheduledApproximator(SizeType(step),appro)); - delays[appro.kind()] = 0; + schedule.push_back(ScheduledApproximator(0u,appro)); } + List result; + Nat step = 0u; while (possibly(t InclusionIntegrator::flow(Diffe reach_function = best_reach_function; evolve_function = best_evolve_function; - if (step%freq==freq-1) { + if (must_recondition(step)) { double base = 0; double rho = 6.0; for (auto appro: approximation_local_frequencies) { SizeType ppi; switch (appro.first) { - case InputApproximation::ZERO: + case InputApproximationKind::ZERO: ppi = 0; break; - case InputApproximation::CONSTANT: + case InputApproximationKind::CONSTANT: ppi = 1; break; default: @@ -523,12 +523,13 @@ List InclusionIntegrator::flow(Diffe double partial = n + rho*(n+2*m) + (freq-1)*m*(2 - ppi); base += partial*appro.second/freq; } - LohnerReconditioner& lreconditioner = dynamic_cast(*this->_reconditioner); Nat num_variables_to_keep(base); ARIADNE_LOG(5,"simplifying to "<(*this->_reconditioner); lreconditioner.set_number_of_variables_to_keep(num_variables_to_keep); - this->_reconditioner->simplify(evolve_function); + lreconditioner.simplify(evolve_function); + for (auto appro: _approximations) { approximation_local_frequencies[appro] = 0; } @@ -559,7 +560,7 @@ InclusionIntegrator::reach(DifferentialInclusion const& di, BoxDomainType D, Val ValidatedVectorMultivariateFunctionModelType result; - if (this->_approximator->kind() != InputApproximation::PIECEWISE) { + if (this->_approximator->kind() != InputApproximationKind::PIECEWISE) { auto e=this->_approximator->compute_errors(h,B); ARIADNE_LOG(6,"approximation errors:"<_approximator->build_flow_domain(D,di.V(),h); @@ -745,24 +746,6 @@ compute_flow_function(ValidatedVectorMultivariateFunction const& dyn, BoxDomainT picardPhi=antiderivative(dyn_of_phi,dyn_of_phi.argument_size()-1)+x0f; } - /* - TaylorSeriesIntegrator integrator(MaximumError(1e-4),SweepThreshold(1e-8),LipschitzConstant(0.5)); - - auto BVh =_approximator->build_flow_domain(cast_exact_box(B), V, h); - - auto seriesPhi = integrator.flow_step(dyn,DVh,h,BVh); - - if (volume(picardPhi.range()) < volume(seriesPhi.range())) { - ARIADNE_LOG(2,"Picard flow function chosen\n"); - return picardPhi; - - } else { - ARIADNE_LOG(2,"Series flow function chosen\n"); - return seriesPhi; - } - */ - - return picardPhi; } diff --git a/source/dynamics/differential_inclusion.hpp b/source/dynamics/differential_inclusion.hpp index bc788f6ca..35261e3fb 100644 --- a/source/dynamics/differential_inclusion.hpp +++ b/source/dynamics/differential_inclusion.hpp @@ -177,44 +177,29 @@ inline std::ostream& operator << (std::ostream& os, const C1Norms& n) { C1Norms compute_norms(DifferentialInclusion const&, PositiveFloatDPValue const&, UpperBoxType const&); -enum class InputApproximation : std::uint8_t { ZERO, CONSTANT, AFFINE, SINUSOIDAL, PIECEWISE }; +enum class InputApproximationKind : std::uint8_t { ZERO, CONSTANT, AFFINE, SINUSOIDAL, PIECEWISE }; -inline std::ostream& operator << (std::ostream& os, const InputApproximation& kind) { +inline std::ostream& operator << (std::ostream& os, const InputApproximationKind& kind) { switch (kind) { - case InputApproximation::ZERO: os << "ZERO"; break; - case InputApproximation::CONSTANT: os << "CONSTANT"; break; - case InputApproximation::AFFINE: os << "AFFINE"; break; - case InputApproximation::SINUSOIDAL: os << "SINUSOIDAL"; break; - case InputApproximation::PIECEWISE: os << "PIECEWISE"; break; + case InputApproximationKind::ZERO: os << "ZERO"; break; + case InputApproximationKind::CONSTANT: os << "CONSTANT"; break; + case InputApproximationKind::AFFINE: os << "AFFINE"; break; + case InputApproximationKind::SINUSOIDAL: os << "SINUSOIDAL"; break; + case InputApproximationKind::PIECEWISE: os << "PIECEWISE"; break; default: ARIADNE_FAIL_MSG("Unhandled input approximation for output streaming\n"); } return os; } -class ParametricInputApproximation { -protected: - ParametricInputApproximation(InputApproximation kind) : _kind(kind) { } -public: - InputApproximation kind() { return _kind; } -private: - InputApproximation _kind; +template struct InputApproximationKindTrait { + static InputApproximationKind kind() { return A; } }; -class ZeroApproximation : public ParametricInputApproximation { -public: ZeroApproximation() : ParametricInputApproximation(InputApproximation::ZERO) { } -}; -class ConstantApproximation : public ParametricInputApproximation { -public: ConstantApproximation() : ParametricInputApproximation(InputApproximation::CONSTANT) { } -}; -class AffineApproximation : public ParametricInputApproximation { -public: AffineApproximation() : ParametricInputApproximation(InputApproximation::AFFINE) { } -}; -class SinusoidalApproximation : public ParametricInputApproximation { -public: SinusoidalApproximation() : ParametricInputApproximation(InputApproximation::SINUSOIDAL) { } -}; -class PiecewiseApproximation : public ParametricInputApproximation { -public: PiecewiseApproximation() : ParametricInputApproximation(InputApproximation::PIECEWISE) { } -}; +class ZeroApproximation : public InputApproximationKindTrait { }; +class ConstantApproximation : public InputApproximationKindTrait { }; +class AffineApproximation : public InputApproximationKindTrait { }; +class SinusoidalApproximation : public InputApproximationKindTrait { }; +class PiecewiseApproximation : public InputApproximationKindTrait { }; template ErrorType r_value(); template<> ErrorType r_value() { return ErrorType(0u); } @@ -223,13 +208,6 @@ template<> ErrorType r_value() { return ErrorType(5.0/3u); template<> ErrorType r_value() { return ErrorType(5.0/4u); } template<> ErrorType r_value() { return ErrorType(1.3645_upper); } -template constexpr InputApproximation approximation_kind(); -template<> constexpr InputApproximation approximation_kind() { return InputApproximation::ZERO; } -template<> constexpr InputApproximation approximation_kind() { return InputApproximation::CONSTANT; } -template<> constexpr InputApproximation approximation_kind() { return InputApproximation::AFFINE; } -template<> constexpr InputApproximation approximation_kind() { return InputApproximation::SINUSOIDAL; } -template<> constexpr InputApproximation approximation_kind() { return InputApproximation::PIECEWISE; } - template constexpr Nat num_params_per_input(); template<> constexpr Nat num_params_per_input() { return 0u; } template<> constexpr Nat num_params_per_input() { return 1u; } @@ -237,32 +215,21 @@ template<> constexpr Nat num_params_per_input() { return 2u template<> constexpr Nat num_params_per_input() { return 2u; } template<> constexpr Nat num_params_per_input() { return 2u; } -enum class InputsRoles : std::uint8_t { AFFINE, SINGULAR, ADDITIVE}; +enum class InputsRelationKind : std::uint8_t { AFFINE, SINGULAR, ADDITIVE}; -class InputsRole { -protected: - InputsRole(InputsRoles kind) : _kind(kind) { } -public: - InputsRoles kind() { return _kind; } -private: - InputsRoles _kind; +template struct InputsRelationKindTrait { + static InputsRelationKind kind() { return R; } }; -class AffineInputs : public InputsRole { -public: AffineInputs() : InputsRole(InputsRoles::AFFINE) { } -}; -class SingularInput : public InputsRole { -public: SingularInput() : InputsRole(InputsRoles::SINGULAR) { } -}; -class AdditiveInputs : public InputsRole { -public: AdditiveInputs() : InputsRole(InputsRoles::ADDITIVE) { } -}; +class AffineInputs : public InputsRelationKindTrait { }; +class SingularInput : public InputsRelationKindTrait { }; +class AdditiveInputs : public InputsRelationKindTrait { }; -inline std::ostream& operator<<(std::ostream& os, const InputsRoles& kind) { +inline std::ostream& operator<<(std::ostream& os, const InputsRelationKind& kind) { switch (kind) { - case InputsRoles::AFFINE: os << "AFFINE"; break; - case InputsRoles::SINGULAR: os << "SINGULAR"; break; - case InputsRoles::ADDITIVE: os << "ADDITIVE"; break; + case InputsRelationKind::AFFINE: os << "AFFINE"; break; + case InputsRelationKind::SINGULAR: os << "SINGULAR"; break; + case InputsRelationKind::ADDITIVE: os << "ADDITIVE"; break; default: ARIADNE_FAIL_MSG("Unhandled InputsRoles for output streaming\n"); } return os; @@ -288,7 +255,7 @@ class InputApproximatorInterface; class InputApproximatorFactory { public: - InputApproximator create(DifferentialInclusion const& di, InputApproximation kind, SweeperDP sweeper) const; + InputApproximator create(DifferentialInclusion const& di, InputApproximationKind kind, SweeperDP sweeper) const; }; template class ApproximationErrorProcessorInterface { @@ -325,7 +292,7 @@ class ApproximationErrorProcessorFactory { class InputApproximatorInterface { public: - virtual InputApproximation kind() const = 0; + virtual InputApproximationKind kind() const = 0; virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const = 0; virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const = 0; virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const = 0; @@ -341,7 +308,7 @@ class InputApproximator : public InputApproximatorInterface { InputApproximator(InputApproximator const& other) : _impl(other._impl) { } InputApproximator& operator=(InputApproximator const& other) { _impl = other._impl; return *this; } public: - virtual InputApproximation kind() const override { return _impl->kind(); } + virtual InputApproximationKind kind() const override { return _impl->kind(); } virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const override { return _impl->compute_errors(h,B); } virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const override { return _impl->build_flow_domain(D,V,h); } virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override { return _impl->build_w_functions(DVh,n,m); } @@ -357,12 +324,12 @@ class InputApproximatorBase : public InputApproximatorInterface { SweeperDP _sweeper; SharedPointer> _processor; InputApproximatorBase(DifferentialInclusion const& di, SweeperDP const& sweeper) : - _di(di), _sweeper(sweeper), _processor(ApproximationErrorProcessorFactory().create(di)), _kind(approximation_kind()), _num_params_per_input(num_params_per_input()) { } + _di(di), _sweeper(sweeper), _processor(ApproximationErrorProcessorFactory().create(di)), _kind(A::kind()), _num_params_per_input(num_params_per_input()) { } private: - const InputApproximation _kind; + const InputApproximationKind _kind; const Nat _num_params_per_input; public: - virtual InputApproximation kind() const override { return _kind; } + virtual InputApproximationKind kind() const override { return _kind; } virtual Vector compute_errors(PositiveFloatDPValue h, UpperBoxType const& B) const override { return _processor->process(h,B); } virtual BoxDomainType build_flow_domain(BoxDomainType D, BoxDomainType V, PositiveFloatDPValue h) const override; virtual Vector build_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const override; @@ -399,7 +366,7 @@ class InclusionIntegratorInterface { class InclusionIntegrator : public virtual InclusionIntegratorInterface, public Loggable { protected: - List _approximations; + List _approximations; SharedPointer _approximator; SharedPointer _reconditioner; SweeperDP _sweeper; @@ -407,8 +374,8 @@ class InclusionIntegrator : public virtual InclusionIntegratorInterface, public Nat _number_of_steps_between_simplifications; Nat _number_of_variables_to_keep; public: - InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size); - template InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size, AS... attributes); + InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size); + template InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size, AS... attributes); public: InclusionIntegrator& set(NumberOfStepsBetweenSimplifications n) { _number_of_steps_between_simplifications=n; return *this; } InclusionIntegrator& set(NumberOfVariablesToKeep n) { _number_of_variables_to_keep=n; return *this; } @@ -424,9 +391,11 @@ class InclusionIntegrator : public virtual InclusionIntegratorInterface, public ValidatedVectorMultivariateFunctionModelDP evaluate_evolve_function(ValidatedVectorMultivariateFunctionModelDP reach_function, PositiveFloatDPValue t) const; ValidatedVectorMultivariateFunctionModelDP build_secondhalf_piecewise_reach_function(ValidatedVectorMultivariateFunctionModelDP evolve_function, ValidatedVectorMultivariateFunctionModelDP Phi, SizeType m, PositiveFloatDPValue t, PositiveFloatDPValue new_t) const; Vector build_secondhalf_piecewise_w_functions(BoxDomainType DVh, SizeType n, SizeType m) const; + private: + Bool must_recondition(Nat step) const; }; -template InclusionIntegrator::InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size_, AS... attributes) +template InclusionIntegrator::InclusionIntegrator(List approximations, SweeperDP sweeper, StepSize step_size_, AS... attributes) : InclusionIntegrator::InclusionIntegrator(approximations, sweeper,step_size_) { this->set(attributes...); _reconditioner.reset(new LohnerReconditioner(_sweeper,_number_of_variables_to_keep)); diff --git a/tests/dynamics/test_differential_inclusion.cpp b/tests/dynamics/test_differential_inclusion.cpp index 383b5c37f..5e4257d91 100644 --- a/tests/dynamics/test_differential_inclusion.cpp +++ b/tests/dynamics/test_differential_inclusion.cpp @@ -41,16 +41,16 @@ using namespace Ariadne; class TestInclusionIntegrator { - Void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity) const + Void run_each_approximation(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity) const { for (auto appro: approximations) { - List singleapproximation = {appro}; + List singleapproximation = {appro}; std::cout << appro << std::endl; run_single_test(name,ivp,evolution_time,step,singleapproximation,sweeper,freq,verbosity); } } - Void run_single_test(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity) const + Void run_single_test(String name, DifferentialInclusionIVP const& ivp, Real evolution_time, double step, List approximations, SweeperDP sweeper, SizeType freq, unsigned int verbosity) const { auto integrator = InclusionIntegrator(approximations,sweeper,step_size=step,number_of_steps_between_simplifications=freq,number_of_variables_to_keep=20000); integrator.verbosity = verbosity; @@ -66,12 +66,12 @@ class TestInclusionIntegrator { ThresholdSweeperDP sweeper(DoublePrecision(),1e-8); unsigned int verbosity = 0; - List approximations; - approximations.append(InputApproximation::ZERO); - approximations.append(InputApproximation::CONSTANT); - approximations.append(InputApproximation::AFFINE); - approximations.append(InputApproximation::SINUSOIDAL); - approximations.append(InputApproximation::PIECEWISE); + List approximations; + approximations.append(InputApproximationKind::ZERO); + approximations.append(InputApproximationKind::CONSTANT); + approximations.append(InputApproximationKind::AFFINE); + approximations.append(InputApproximationKind::SINUSOIDAL); + approximations.append(InputApproximationKind::PIECEWISE); this->run_each_approximation(name,ivp,evolution_time,step,approximations,sweeper,freq,verbosity); }