probabilistic-library 26.1.1rc5__tar.gz

probabilistic_library-26.1.1rc5/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: probabilistic_library
+Version: 26.1.1rc5
+Summary: Package which provides probabilistic methods
+Author: Deltares
+Author-email: Deltares <d-prob-support@deltares.nl>
+License: LGPL-3.0
+Project-URL: Homepage, https://deltares.github.io/ProbabilisticLibrary/
+Project-URL: Documentation, https://github.com/Deltares/ProbabilisticLibrary/tree/master/doc
+Project-URL: Repository, https://github.com/Deltares/ProbabilisticLibrary
+Project-URL: issues, https://github.com/Deltares/ProbabilisticLibrary/issues
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: requires-python
+
+[![Python 3.11](https://img.shields.io/badge/Python-3.11-blue.svg)](https://www.python.org/downloads/release/python-31110/) 
+[![C++][c++-image]][c++standard]
+[![docs2](https://github.com/Deltares/ProbabilisticLibrary/actions/workflows/docs.yml/badge.svg)](https://github.com/Deltares/ProbabilisticLibrary/actions/workflows/docs.yml)
+
+[c++-image]: https://img.shields.io/badge/C++-20-blue.svg?style=flat&logo=c%2B%2B
+[c++standard]: https://isocpp.org/std/the-standard
+
+# Probabilistic Library
+
+This is the Probabilistic Library of Deltares.
+The library provides a set of routines that enable reliability, uncertainty, and sensitivity analyses.
+
+## Scientific background
+
+The scientific background of the library can be found here:
+[scientific_background.pdf](https://github.com/Deltares/ProbabilisticLibrary/releases/download/25.3.1/scientific_background.pdf)
+
+## Python wrapper
+
+A description of the Python classes is given here:
+[API documentation](https://deltares.github.io/ProbabilisticLibrary/probabilistic_library.html)
+
+## Tutorials
+
+See the [Tutorials](https://github.com/Deltares/ProbabilisticLibrary/blob/master/sources/Deltares.Probabilistic.PWrapper.Notebooks/gallery/gallery.md) for several demonstrations and instructions on how to use the Probabilistic Library.

probabilistic_library-26.1.1rc5/probabilistic_library/__init__.py

@@ -0,0 +1,44 @@
+# Copyright (C) Stichting Deltares. All rights reserved.
+#
+# This file is part of the Probabilistic Library.
+#
+# The Probabilistic Library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# All names, logos, and references to "Deltares" are registered trademarks of
+# Stichting Deltares and remain full property of Stichting Deltares at all times.
+# All rights reserved.
+#
+"""The Probabilistic Library provides functionality to perform reliability, uncertainty and sensitivity analyses via a
+`probabilistic_library.project.ReliabilityProject`, `probabilistic_library.project.UncertaintyProject` or
+`probabilistic_library.project.SensitivityProject`.
+
+Using an externally defined model as a python script, the Probabilistic Library derives input and output values. They will be
+provided to the user as `probabilistic_library.statistic.Stochast`s, so that the user can provide uncertainty to them. Correlations
+are provided via a `probabilistic_library.statistic.CorrelationMatrix`.
+
+When running an analysis, the result is a `probabilistic_library.reliability.DesignPoint`, `probabilistic_library.uncertainty.UncertaintyResult`
+or `probabilistic_library.sensitivity.SensitivityResult`.
+"""
+
+__version__ = "26.1.1-rc5"
+
+from .interface import *
+from .logging import *
+from .statistic import *
+from .reliability import *
+from .uncertainty import *
+from .sensitivity import *
+from .project import *
+
+

probabilistic_library-26.1.1rc5/probabilistic_library/bin/__init__.py

@@ -0,0 +1,24 @@
+# Copyright (C) Stichting Deltares. All rights reserved.
+#
+# This file is part of the Probabilistic Library.
+#
+# The Probabilistic Library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# All names, logos, and references to "Deltares" are registered trademarks of
+# Stichting Deltares and remain full property of Stichting Deltares at all times.
+# All rights reserved.
+#
+
+__version__ = "26.1.1-rc5"
+

probabilistic_library-26.1.1rc5/probabilistic_library/interface.py

@@ -0,0 +1,275 @@
+# Copyright (C) Stichting Deltares. All rights reserved.
+#
+# This file is part of the Probabilistic Library.
+#
+# The Probabilistic Library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# All names, logos, and references to "Deltares" are registered trademarks of
+# Stichting Deltares and remain full property of Stichting Deltares at all times.
+# All rights reserved.
+#
+from ast import Pass
+import ctypes
+import sys
+import os
+import time
+
+from pathlib import Path
+from ctypes import cdll
+
+CALLBACK = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double))
+MULTIPLE_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_int, ctypes.POINTER(ctypes.POINTER(ctypes.c_double)), ctypes.c_int, ctypes.POINTER(ctypes.POINTER(ctypes.c_double)))
+EMPTY_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_void_p)
+
+def _print_error(message):
+	print('error: ' + str(message), flush = True)
+
+def LoadLibrary(lib_full_path):
+	global lib
+	lib = None
+	if os.path.isfile(lib_full_path):
+		try:
+			lib = cdll.LoadLibrary(lib_full_path)
+		except:
+			message = sys.exc_info()[0]
+			_print_error(message)
+			raise
+	if lib == None:
+		print("ERROR: Could not find " + lib_full_path)
+
+def IsLibraryLoaded():
+	return 'lib' in globals() and not lib is None
+
+def LoadDefaultLibrary():
+	dir_path = os.path.dirname(os.path.realpath(__file__))
+	if (sys.platform.startswith("linux")):
+		lib_file = 'libDeltares.Probabilistic.CWrapper.so'
+	else:
+		lib_file = 'Deltares.Probabilistic.CWrapper.dll'
+	lib_full_path = os.path.join(dir_path, 'bin', lib_file);
+	LoadLibrary(lib_full_path)
+
+def AddLibrary(add_lib_full_path):
+	if not IsLibraryLoaded():
+		LoadDefaultLibrary()
+		
+	if os.path.isfile(add_lib_full_path):
+		try:
+			lib.AddLibrary(bytes(add_lib_full_path, 'utf-8'))
+		except:
+			message = sys.exc_info()[0]
+			_print_error(message)
+			raise
+
+
+def Create(object_type):
+	try:
+		object_type_b = bytes(object_type, 'utf-8')
+		lib.Create.restype = ctypes.c_int
+		return lib.Create(object_type_b)
+	except:
+		message = sys.exc_info()[0]
+		_print_error(message)
+		raise
+
+def Destroy(id_):
+	lib.Destroy(ctypes.c_int(id_))
+
+def Exit():
+	lib.Exit()
+
+def GetValue(id_, property_):
+	lib.GetValue.restype = ctypes.c_double
+	return lib.GetValue(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+
+def SetValue(id_, property_, value_):
+	lib.SetValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_double(value_))
+
+def GetIntValue(id_, property_):
+	lib.GetIntValue.restype = ctypes.c_int
+	return lib.GetIntValue(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+
+def SetIntValue(id_, property_, value_):
+	lib.SetIntValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(value_))
+
+def GetIdValue(id_, property_):
+	lib.GetIdValue.restype = ctypes.c_int
+	return lib.GetIdValue(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+
+def GetIntArgValue(id_, arg_, property_):
+	lib.GetIntArgValue.restype = ctypes.c_double
+	return lib.GetIntArgValue(ctypes.c_int(id_), ctypes.c_int(arg_), bytes(property_, 'utf-8'))
+
+def SetIntArgValue(id_, arg_, property_, value_):
+	lib.SetIntArgValue(ctypes.c_int(id_), ctypes.c_int(arg_), bytes(property_, 'utf-8'), ctypes.c_double(value_))
+
+def GetBoolValue(id_, property_):
+	lib.GetBoolValue.restype = ctypes.c_bool
+	return lib.GetBoolValue(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+
+def SetBoolValue(id_, property_, value_):
+	lib.SetBoolValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_bool(value_))
+
+def GetStringValue(id_, property_):
+
+	lib.GetStringLength.restype = ctypes.c_int
+	size = lib.GetStringLength(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+
+	result = ctypes.create_string_buffer(size+1)
+	lib.GetStringValue.restype = ctypes.c_void_p
+	lib.GetStringValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), result, ctypes.c_size_t(ctypes.sizeof(result)))
+	result_str = result.value.decode()
+	return result_str
+
+def GetIndexedStringValue(id_, property_, index_):
+
+	lib.GetIndexedStringLength.restype = ctypes.c_int
+	size = lib.GetIndexedStringLength(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index_))
+
+	result = ctypes.create_string_buffer(size+1)
+	lib.GetIndexedStringValue.restype = ctypes.c_void_p
+	lib.GetIndexedStringValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index_), result, ctypes.c_size_t(ctypes.sizeof(result)))
+	result_str = result.value.decode()
+	return result_str
+
+def SetStringValue(id_, property_, value_):
+	lib.SetStringValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), bytes(value_, 'utf-8'))
+
+def FillArrayValue(id_, property_, values_, size):
+	lib.FillArrayValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), values_, ctypes.c_uint(size))
+
+def SetArrayValue(id_, property_, values_):
+	cvalues = (ctypes.c_double * len(values_))(*values_)
+	lib.SetArrayValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.POINTER(ctypes.c_double)(cvalues), ctypes.c_uint(len(values_)))
+
+def GetArgValues(id_, property_, values_, output_values_):
+	cvalues = (ctypes.c_double * len(values_))(*values_)
+	lib.GetArgValues.restype = ctypes.c_void_p
+	lib.GetArgValues(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.POINTER(ctypes.c_double)(cvalues), ctypes.c_uint(len(values_)), output_values_)
+
+def GetArrayValue(id_, property_):
+
+	count_property = property_ + '_count'
+	count = GetIntValue(id_, count_property)
+
+	lib.GetIndexedValue.restype = ctypes.c_double
+
+	values = []
+	for i in range(count):
+		value = lib.GetIndexedValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(i))
+		values.append(value)
+
+	return values
+
+def GetArrayIntValue(id_, property_):
+
+	count_property = property_ + '_count'
+	count = GetIntValue(id_, count_property)
+
+	lib.GetIndexedIntValue.restype = ctypes.c_int
+
+	values = []
+	for i in range(count):
+		value = lib.GetIndexedIntValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(i))
+		values.append(value)
+
+	return values
+
+def GetArrayIdValue(id_, property_):
+
+	count_property = property_ + '_count'
+	count = GetIntValue(id_, count_property)
+
+	lib.GetIndexedIdValue.restype = ctypes.c_int
+
+	values = []
+	for i in range(count):
+		value = lib.GetIndexedIdValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(i))
+		values.append(value)
+
+	return values
+
+def GetArrayStringValue(id_, property_):
+
+	count_property = property_ + '_count'
+	count = GetIntValue(id_, count_property)
+
+	values = []
+	for i in range(count):
+		value = GetIndexedStringValue(id_, property_, i)
+		values.append(value)
+
+	return values
+
+def SetArrayIntValue(id_, property_, values_):
+	cvalues = (ctypes.c_int * len(values_))(*values_)
+	lib.SetArrayIntValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.POINTER(ctypes.c_int)(cvalues), ctypes.c_uint(len(values_)))
+
+def GetArgValue(id_, property_, arg_):
+	lib.GetArgValue.restype = ctypes.c_double
+	return lib.GetArgValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_double(arg_))
+
+def SetArgValue(id_, property_, arg_, value_):
+	lib.SetArgValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_double(arg_), ctypes.c_double(value_))
+
+def GetIndexedValue(id_, property_, index_):
+	lib.GetIndexedValue.restype = ctypes.c_double
+	return lib.GetIndexedValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index_))
+
+def SetIndexedValue(id_, property_, index_, value_):
+	lib.SetIndexedValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index_), ctypes.c_double(value_))
+
+def GetIndexedIndexedValue(id_, property_, index1_, index2_):
+	lib.GetIndexedIndexedValue.restype = ctypes.c_double
+	return lib.GetIndexedIndexedValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index1_), ctypes.c_int(index2_))
+
+def SetIndexedIndexedValue(id_, property_, index1_, index2_, value_):
+	lib.SetIndexedIndexedValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index1_), ctypes.c_int(index2_), ctypes.c_double(value_))
+
+def SetIndexedIndexedIntValue(id_, property_, index1_, index2_, value_):
+	lib.SetIndexedIndexedIntValue(ctypes.c_int(id_), bytes(property_, 'utf-8'), ctypes.c_int(index1_), ctypes.c_int(index2_), ctypes.c_int(value_))
+
+def SetCallBack(id_, property_, callBack_):
+	try:
+		lib.SetCallBack(ctypes.c_int(id_), bytes(property_, 'utf-8'), callBack_)
+	except:
+		message = sys.exc_info()[0]
+		_print_error(message)
+		raise
+
+def SetMultipleCallBack(id_, property_, callBack_):
+	try:
+		lib.SetMultipleCallBack(ctypes.c_int(id_), bytes(property_, 'utf-8'), callBack_)
+	except:
+		message = sys.exc_info()[0]
+		print('error: ' + str(message), flush = True)
+		raise
+
+def SetEmptyCallBack(id_, property_, callBack_):
+	try:
+		lib.SetEmptyCallBack(ctypes.c_int(id_), bytes(property_, 'utf-8'), callBack_)
+	except:
+		message = sys.exc_info()[0]
+		_print_error(message)
+		raise
+
+def GetCallBack(id_, property_):
+	try:
+		return lib.GetCallBack(ctypes.c_int(id_), bytes(property_, 'utf-8'))
+	except:
+		message = sys.exc_info()[0]
+		_print_error(message)
+		raise
+def Execute(id_, method_):
+	lib.Execute(ctypes.c_int(id_), bytes(method_, 'utf-8'))

probabilistic_library-26.1.1rc5/probabilistic_library/logging.py

@@ -0,0 +1,230 @@
+# Copyright (C) Stichting Deltares. All rights reserved.
+#
+# This file is part of the Probabilistic Library.
+#
+# The Probabilistic Library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# All names, logos, and references to "Deltares" are registered trademarks of
+# Stichting Deltares and remain full property of Stichting Deltares at all times.
+# All rights reserved.
+#
+from __future__ import annotations
+from math import isnan
+from enum import Enum
+
+from .utils import FrozenObject, FrozenList, PrintUtils
+from . import interface
+
+if not interface.IsLibraryLoaded():
+	interface.LoadDefaultLibrary()
+
+class MessageType(Enum):
+	"""Enumeration which defines the severity of a message."""
+	debug = 'debug'
+	info = 'info'
+	warning = 'warning'
+	error = 'error'
+	def __str__(self):
+		return str(self.value)
+
+class Message(FrozenObject):
+	"""Defines a message, which will be presented to the user.
+    A message may be the result of a validation request or an informative message of an algorithm"""
+
+	def __init__(self, id = None):
+		if id == None:
+			self._id = interface.Create('message')
+		else:
+			self._id = id
+		super()._freeze()
+
+	@classmethod
+	def from_message(cls, message_type, message_text):
+		message = cls()
+		interface.SetStringValue(message._id, 'type', str(message_type))
+		interface.SetStringValue(message._id, 'text', message_text)
+		return message
+
+	def __del__(self):
+		interface.Destroy(self._id)
+		
+	def __str__(self):
+		if self.subject == "":
+			return str(self.type) + ': ' + self.text
+		else:
+			return str(self.type) + ': ' + self.subject + ' => ' + self.text
+		
+	def __dir__(self):
+		return ['type',
+		        'subject',
+		        'text',
+		        'print']
+
+	@property
+	def type(self) -> MessageType:
+		"""Gets the message type, which indicates the severity of the message"""
+		return MessageType[interface.GetStringValue(self._id, 'type')]
+		
+	@property
+	def subject(self) -> str:
+		"""Gets the subject, the object to which the message applies"""
+		return interface.GetStringValue(self._id, 'subject')
+
+	@property
+	def text(self) -> str:
+		"""Gets the message text"""
+		return interface.GetStringValue(self._id, 'text')
+
+	def print(self):
+		"""Prints the message"""
+		text = str(self)
+		if len(text) > 0:
+			text = text[0].capitalize() + text[1:]
+		print(text)
+
+class ValidationReport(FrozenObject):
+	"""Result of a validation analysis, consists of a number of validation messages"""
+
+	def __init__(self, id = None):
+		if id == None:
+			self._id = interface.Create('validation_report')
+		else:
+			self._id = id
+		self._messages = None
+		super()._freeze()
+
+	def __del__(self):
+		interface.Destroy(self._id)
+
+	def __dir__(self):
+		return ['is_valid',
+		        'messages',
+		        'print']
+
+	def is_valid(self) -> bool:
+		"""Indicates whether this validation report should be interpreted as valid or non-valid"""
+		return interface.GetBoolValue(self._id, 'is_valid')
+
+	@property   
+	def messages(self) -> FrozenList[Message]:
+		"""List of all validation messages"""
+		if self._messages is None:
+			message_ids = interface.GetArrayIdValue(self._id, 'messages')
+			messages = []
+			for message_id in message_ids:
+				message = Message(message_id)
+				messages.append(message)
+			self._messages = FrozenList(messages)
+		return self._messages
+
+	def print(self):
+		"""Prints all validation messages or an indication in case of no validation messages"""
+		if len(self.messages) == 0:
+			print('ok')
+		else:
+			for message in self.messages:
+				message.print()
+
+		
+class Evaluation(FrozenObject):
+	"""Registers a sample and execution results of a model"""
+		
+	def __init__(self, id = None):
+		if id == None:
+			self._id = interface.Create('evaluation')
+		else:
+			self._id = id
+		self._input_values = None	
+		self._output_values = None	
+		super()._freeze()
+
+	def __del__(self):
+		interface.Destroy(self._id)
+
+	def __dir__(self):
+		return ['iteration',
+				'quantile',
+				'z',
+				'beta',
+				'weight',
+				'input_values',
+				'output_values',
+				'print']
+	
+	@property   
+	def iteration(self) -> int:
+		"""Iteration index in a reliability, uncertainty or sensitivity algorithm"""
+		return interface.GetIntValue(self._id, 'iteration')
+		
+	@property   
+	def quantile(self) -> float:
+		"""Quantile to which the sample belongs in an uncertainty algorithm"""
+		return interface.GetValue(self._id, 'quantile')
+		
+	@property   
+	def z(self) -> float:
+		"""Z-value, indicating failure or non-failure, used by a reliability algorithm"""
+		return interface.GetValue(self._id, 'z')
+		
+	@property   
+	def beta(self) -> float:
+		"""Distance of the sample to the origin in u-space"""
+		return interface.GetValue(self._id, 'beta')
+		
+	@property   
+	def weight(self) -> float:
+		"""Weight of the sample in the reliability or uncertainty algorithm"""
+		return interface.GetValue(self._id, 'weight')
+
+	@property   
+	def input_values(self) -> FrozenList[float]:
+		"""List of input values for the model"""
+		if self._input_values is None:
+			input_values = interface.GetArrayValue(self._id, 'input_values')
+			self._input_values = FrozenList(input_values)
+		return self._input_values
+		
+	@property   
+	def output_values(self) -> FrozenList[float]:
+		"""List of output values produced by the model"""
+		if self._output_values is None:
+			output_values = interface.GetArrayValue(self._id, 'output_values')
+			self._output_values = FrozenList(output_values)
+		return self._output_values
+
+	def print(self, decimals = 4):
+		"""Prints the evaluation
+
+        Parameters
+        ----------
+        decimals : int, optional.
+            The number of decimals to print"""
+
+		self._print(0, decimals)
+
+	def _print(self, indent, decimals = 4):
+		pre = PrintUtils.get_space_from_indent(indent)
+		input_values = ', '.join([f'{v:.{decimals}g}' for v in self.input_values])
+		output_values = ', '.join([f'{v:.{decimals}g}' for v in self.output_values])
+		if not isnan(self.quantile):
+			pre = pre + f'quantile {self.quantile:.{decimals}g}: '
+		if isnan(self.z) and len(self.output_values) == 0:
+			print(pre + f'[{input_values}]')
+		elif isnan(self.z) and len(self.output_values) > 0:
+			print(pre + f'[{input_values}] -> [{output_values}]')
+		elif not isnan(self.z) and len(self.output_values) == 0:
+			print(pre + f'[{input_values}] -> {self.z:.{decimals}g}')
+		elif not isnan(self.z) and len(self.output_values) > 0:
+			print(pre + f'[{input_values}] -> [{output_values}] -> {self.z:.{decimals}g}')
+