numdaplot 0.1.0__py3-none-any.whl

numdaplot/plots/charts/missing_map_chart.py

@@ -0,0 +1,27 @@
+"""
+Chart drawing where the values of a Table are missing.
+
+.. versionadded:: 0.1.0
+"""
+
+from dataclasses import dataclass
+
+from numdaplot.plots.charts.chart import Chart
+
+
+@dataclass(frozen=True)
+class MissingMapChart(Chart):
+	"""
+	Chart drawing each value of a Table as a cell, dark when missing, made by ``Plot.missing_map``.
+
+	It has no setting, so ``Plot.missing_map`` creates it itself.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.charts.missing_map_chart import MissingMapChart
+	>>> isinstance(MissingMapChart(), ndp.Chart)
+	True
+	"""

numdaplot/plots/charts/orientation.py

@@ -0,0 +1,58 @@
+"""
+Direction of the bars of a BarChart.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class Orientation(Enum):
+	"""
+	Direction of the bars of a ``BarChart``.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> days = ndp.Array.from_list([1, 2, 3, 4])
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0])
+	>>> costs = ndp.Array.from_list([8.0, 9.5, 9.0, 10.0])
+	>>> sales = ndp.Table.from_arrays({"day": days, "price": prices, "cost": costs})
+	>>> chart = ndp.BarChart(x="day", y=["price", "cost"], orientation=ndp.Orientation.HORIZONTAL)
+	>>> plot = ndp.Plot.bar(sales, chart)
+	>>> plot.show()
+	"""
+
+	VERTICAL = auto()
+	"""
+	Bars rising from the horizontal axis. Default value.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> days = ndp.Array.from_list([1, 2, 3, 4])
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0])
+	>>> costs = ndp.Array.from_list([8.0, 9.5, 9.0, 10.0])
+	>>> sales = ndp.Table.from_arrays({"day": days, "price": prices, "cost": costs})
+	>>> chart = ndp.BarChart(x="day", y=["price", "cost"], orientation=ndp.Orientation.VERTICAL)
+	>>> plot = ndp.Plot.bar(sales, chart)
+	>>> plot.show()
+	"""
+
+	HORIZONTAL = auto()
+	"""
+	Bars extending from the vertical axis, which then holds the ``x`` values.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> days = ndp.Array.from_list([1, 2, 3, 4])
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0])
+	>>> costs = ndp.Array.from_list([8.0, 9.5, 9.0, 10.0])
+	>>> sales = ndp.Table.from_arrays({"day": days, "price": prices, "cost": costs})
+	>>> chart = ndp.BarChart(x="day", y=["price", "cost"], orientation=ndp.Orientation.HORIZONTAL)
+	>>> plot = ndp.Plot.bar(sales, chart)
+	>>> plot.show()
+	"""

numdaplot/plots/charts/outliers.py

@@ -0,0 +1,49 @@
+"""
+Whether a BoxChart draws its outliers.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class Outliers(Enum):
+	"""
+	Whether a ``BoxChart`` draws its outliers, the values beyond its whiskers.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0, 13.5, 16.0, 14.5, 29.0])
+	>>> chart = ndp.BoxChart(outliers=ndp.Outliers.HIDDEN)
+	>>> plot = ndp.Plot.box(prices, chart)
+	>>> plot.show()
+	"""
+
+	SHOWN = auto()
+	"""
+	Each outlier is drawn as a point. Default value.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0, 13.5, 16.0, 14.5, 29.0])
+	>>> chart = ndp.BoxChart(outliers=ndp.Outliers.SHOWN)
+	>>> plot = ndp.Plot.box(prices, chart)
+	>>> plot.show()
+	"""
+
+	HIDDEN = auto()
+	"""
+	The outliers are not drawn. They still count in the box and the whiskers.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> prices = ndp.Array.from_list([12.0, 15.5, 14.0, 17.0, 13.5, 16.0, 14.5, 29.0])
+	>>> chart = ndp.BoxChart(outliers=ndp.Outliers.HIDDEN)
+	>>> plot = ndp.Plot.box(prices, chart)
+	>>> plot.show()
+	"""

numdaplot/plots/charts/percentages.py

@@ -0,0 +1,55 @@
+"""
+Whether the slices of a PieChart show their share.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class Percentages(Enum):
+	"""
+	Whether the slices of a ``PieChart`` show their share of the total.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> cities = ndp.Array.from_list(["Paris", "Lyon", "Pau"])
+	>>> sales = ndp.Array.from_list([120.0, 80.0, 45.0])
+	>>> shares = ndp.Table.from_arrays({"city": cities, "sales": sales})
+	>>> chart = ndp.PieChart(labels="city", values="sales", percentages=ndp.Percentages.HIDDEN)
+	>>> plot = ndp.Plot.pie(shares, chart)
+	>>> plot.show()
+	"""
+
+	SHOWN = auto()
+	"""
+	Each slice shows its share with one decimal, such as ``42.5%``. Default value.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> cities = ndp.Array.from_list(["Paris", "Lyon", "Pau"])
+	>>> sales = ndp.Array.from_list([120.0, 80.0, 45.0])
+	>>> shares = ndp.Table.from_arrays({"city": cities, "sales": sales})
+	>>> chart = ndp.PieChart(labels="city", values="sales", percentages=ndp.Percentages.SHOWN)
+	>>> plot = ndp.Plot.pie(shares, chart)
+	>>> plot.show()
+	"""
+
+	HIDDEN = auto()
+	"""
+	The slices only show their label.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> cities = ndp.Array.from_list(["Paris", "Lyon", "Pau"])
+	>>> sales = ndp.Array.from_list([120.0, 80.0, 45.0])
+	>>> shares = ndp.Table.from_arrays({"city": cities, "sales": sales})
+	>>> chart = ndp.PieChart(labels="city", values="sales", percentages=ndp.Percentages.HIDDEN)
+	>>> plot = ndp.Plot.pie(shares, chart)
+	>>> plot.show()
+	"""

numdaplot/plots/charts/pie_chart.py

@@ -0,0 +1,87 @@
+"""
+Chart sharing out a total as slices of a disc.
+
+.. versionadded:: 0.1.0
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from numdaplot.plots.charts.chart import Chart
+from numdaplot.plots.charts.chart_settings import copy_colors
+from numdaplot.plots.charts.percentages import Percentages
+from numdaplot.plots.style.color import Color
+from numdaplot.plots.style.custom_color import CustomColor
+from numdaplot.settings.field_types import require_field_types
+from numdaplot.tables.columns.column_names import require_column_name
+
+
+@dataclass(frozen=True)
+class PieChart(Chart):
+	"""
+	Chart drawing each row of a Table as a slice of a disc, sized by its share of the total, used by ``Plot.pie``.
+
+	The slices start at the top and follow each other clockwise, in the order of the rows, each labeled with
+	its text. Every value must be present and positive or 0, and every label must be different. Beyond 5 slices,
+	a ``ReadabilityWarning`` suggests a ``BarChart``.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	labels
+		The column of texts, booleans or times of day (written ``HH:MM``) naming the slices.
+	values
+		The column of numbers sizing the slices.
+	percentages
+		Whether each slice shows its share, such as ``42.5%``, ``Percentages.SHOWN`` by default.
+	colors
+		One color per slice, the colors of the default cycle when omitted. The chart keeps its own list.
+
+	Raises
+	------
+	InvalidTypeError
+		When a setting is not of the type its annotation names.
+	InvalidColumnNameError
+		When ``labels`` or ``values`` is an empty text.
+	EmptyListError
+		When ``colors`` is an empty list.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> cities = ndp.Array.from_list(["Paris", "Lyon", "Pau"])
+	>>> sales = ndp.Array.from_list([120.0, 80.0, 45.0])
+	>>> shares = ndp.Table.from_arrays({"city": cities, "sales": sales})
+	>>> chart = ndp.PieChart(labels="city", values="sales")
+	>>> plot = ndp.Plot.pie(shares, chart)
+	>>> plot.show()
+	"""
+
+	labels: str
+	values: str
+	percentages: Percentages = Percentages.SHOWN
+	colors: Sequence[Color | CustomColor] | None = None
+
+	def __post_init__(self) -> None:
+		"""
+		Check the colors and replace them with a copy that only the chart holds.
+
+		.. versionadded:: 0.1.0
+
+		Raises
+		------
+		InvalidTypeError
+			When a setting is not of the type its annotation names.
+		InvalidColumnNameError
+			When ``labels`` or ``values`` is an empty text.
+		EmptyListError
+			When ``colors`` is an empty list.
+		"""
+		require_field_types(self)
+
+		require_column_name(self.labels)
+		require_column_name(self.values)
+
+		colors_copy = copy_colors(self.colors)
+		object.__setattr__(self, "colors", colors_copy)

numdaplot/plots/charts/scatter_chart.py

@@ -0,0 +1,159 @@
+"""
+Chart drawing each row as a point.
+
+.. versionadded:: 0.1.0
+"""
+
+import math
+from dataclasses import dataclass
+
+from numdaplot.errors.conflicting_settings_error import ConflictingSettingsError
+from numdaplot.errors.invalid_opacity_error import InvalidOpacityError
+from numdaplot.errors.invalid_point_size_error import InvalidPointSizeError
+from numdaplot.errors.refused_setting_error import RefusedSettingError
+from numdaplot.plots.charts.chart import Chart
+from numdaplot.plots.charts.color_scale import ColorScale
+from numdaplot.plots.charts.marker_shape import MarkerShape
+from numdaplot.plots.style.color import Color
+from numdaplot.plots.style.custom_color import CustomColor
+from numdaplot.settings.field_types import require_field_types
+from numdaplot.tables.columns.column_names import require_optional_column_name
+
+CHART_NAME = "ScatterChart"
+COLOR_SETTING = "color"
+COLOR_BY_SETTING = "color_by"
+NO_MARKER_NAME = "MarkerShape.NONE"
+POINT_SIZE_SETTING = "point_size"
+SIZE_BY_SETTING = "size_by"
+SCALE_WITHOUT_COLOR_BY = "scale without color_by"
+
+
+@dataclass(frozen=True)
+class ScatterChart(Chart):
+	"""
+	Chart drawing each row as a point, used by ``Plot.scatter``.
+
+	A row with a missing value in one of the columns used is not drawn. In a dense cloud, a low ``opacity`` shows where
+	the points gather, and a small ``point_size`` separates them. The last group drawn stays on top of the others.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	x
+		For a Table, the column of the horizontal positions: numbers, dates, datetimes, times of day, texts or
+		booleans, the row numbers when omitted. An Array takes none, its rows being numbered. Times of day are placed
+		on an axis of one day labeled ``HH:MM``.
+	y
+		For a Table, the column of the vertical positions, holding numbers or times of day, the latter on an axis
+		labeled ``HH:MM``. A Table needs it. An Array takes none: when omitted, each of its columns is a series of
+		points.
+	color
+		The color of every point, the first color of the default cycle when omitted. With an Array of
+		several columns, the series take the colors of the default cycle and ``color`` is refused.
+	color_by
+		For a Table, the column coloring each point: numbers give a color scale shown next to the axes, texts, booleans
+		and times of day give one color per value, named in the legend, times being written ``HH:MM``. Every point
+		takes the same color when omitted.
+	size_by
+		For a Table, the column of numbers sizing each point, from the smallest to the largest value. Every point has
+		the same size when omitted.
+	marker
+		The shape of the points, ``MarkerShape.CIRCLE`` by default.
+	opacity
+		How opaque the points are, above 0 and up to 1, ``1.0`` by default. The legend and the color scale stay opaque.
+	point_size
+		The diameter of every point, in typographic points, 6 when omitted.
+	scale
+		The colors of a ``color_by`` column of numbers, ``ColorScale.VIRIDIS`` when omitted. It needs such a column.
+		``BLUES``, ``REDS``, ``GREENS`` and ``GRAYS`` skip their lightest colors, so that every point stays visible.
+		``RED_BLUE`` keeps white for 0, so the points close to 0 stay pale.
+
+	Raises
+	------
+	InvalidTypeError
+		When a setting is not of the type its annotation names.
+	InvalidColumnNameError
+		When ``x``, ``y``, ``color_by`` or ``size_by`` is an empty text.
+	ConflictingSettingsError
+		When ``color`` and ``color_by`` are both given, or ``point_size`` and ``size_by``.
+	RefusedSettingError
+		When ``marker`` is ``MarkerShape.NONE``, which would draw nothing, or ``scale`` is given without ``color_by``.
+	InvalidOpacityError
+		When ``opacity`` is 0 or lower, greater than 1, or not a number.
+	InvalidPointSizeError
+		When ``point_size`` is 0 or lower, infinite, or not a number.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> surfaces = ndp.Array.from_list([30.0, 45.0, 60.0, 80.0, 52.0])
+	>>> prices = ndp.Array.from_list([150.0, 210.0, 260.0, 330.0, 190.0])
+	>>> cities = ndp.Array.from_list(["Paris", "Paris", "Lyon", "Lyon", "Pau"])
+	>>> flats = ndp.Table.from_arrays({"surface": surfaces, "price": prices, "city": cities})
+	>>> chart = ndp.ScatterChart(x="surface", y="price", color_by="city", size_by="surface")
+	>>> plot = ndp.Plot.scatter(flats, chart)
+	>>> plot.show()
+	"""
+
+	x: str | None = None
+	y: str | None = None
+	color: Color | CustomColor | None = None
+	color_by: str | None = None
+	size_by: str | None = None
+	marker: MarkerShape = MarkerShape.CIRCLE
+	opacity: float = 1.0
+	point_size: float | None = None
+	scale: ColorScale | None = None
+
+	def __post_init__(self) -> None:
+		"""
+		Check that the color and the size settings exclude each other, and that the points can be drawn.
+
+		.. versionadded:: 0.1.0
+
+		Raises
+		------
+		InvalidTypeError
+			When a setting is not of the type its annotation names.
+		InvalidColumnNameError
+			When ``x``, ``y``, ``color_by`` or ``size_by`` is an empty text.
+		ConflictingSettingsError
+			When ``color`` and ``color_by`` are both given, or ``point_size`` and ``size_by``.
+		RefusedSettingError
+			When ``marker`` is ``MarkerShape.NONE``, or ``scale`` is given without ``color_by``.
+		InvalidOpacityError
+			When ``opacity`` is 0 or lower, greater than 1, or not a number.
+		InvalidPointSizeError
+			When ``point_size`` is 0 or lower, infinite, or not a number.
+		"""
+		require_field_types(self)
+
+		require_optional_column_name(self.x)
+		require_optional_column_name(self.y)
+		require_optional_column_name(self.color_by)
+		require_optional_column_name(self.size_by)
+
+		has_both_colors = self.color is not None and self.color_by is not None
+		if has_both_colors:
+			raise ConflictingSettingsError(COLOR_SETTING, COLOR_BY_SETTING)
+
+		if self.marker == MarkerShape.NONE:
+			raise RefusedSettingError(NO_MARKER_NAME, CHART_NAME)
+
+		has_scale_alone = self.scale is not None and self.color_by is None
+		if has_scale_alone:
+			raise RefusedSettingError(SCALE_WITHOUT_COLOR_BY, CHART_NAME)
+
+		has_both_sizes = self.point_size is not None and self.size_by is not None
+		if has_both_sizes:
+			raise ConflictingSettingsError(POINT_SIZE_SETTING, SIZE_BY_SETTING)
+
+		is_drawable_opacity = 0 < self.opacity <= 1
+		if not is_drawable_opacity:
+			raise InvalidOpacityError(self.opacity)
+
+		if self.point_size is not None:
+			is_drawable_size = 0 < self.point_size < math.inf
+			if not is_drawable_size:
+				raise InvalidPointSizeError(self.point_size)

numdaplot/plots/charts/value_axis.py

@@ -0,0 +1,66 @@
+"""
+Vertical axis a chart added to a Plot is measured on.
+
+.. versionadded:: 0.1.0
+"""
+
+from enum import Enum, auto
+
+
+class ValueAxis(Enum):
+	"""
+	Vertical axis a chart added to a Plot with ``add_line``, ``add_bar`` or ``add_scatter`` is measured on.
+
+	A chart on the right axis gets its own scale, so values of different sizes, such as a number of sales and
+	a price, can share a Plot.
+
+	.. versionadded:: 0.1.0
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> months = ndp.Array.from_list(["Jan", "Feb", "Mar", "Apr"])
+	>>> sales = ndp.Array.from_list([120.0, 150.0, 90.0, 170.0])
+	>>> prices = ndp.Array.from_list([12.5, 11.0, 14.0, 10.5])
+	>>> shop = ndp.Table.from_arrays({"month": months, "sales": sales, "price": prices})
+	>>> style = ndp.PlotStyle(legend=ndp.LegendPosition.UPPER_LEFT)
+	>>> plot = ndp.Plot.bar(shop, ndp.BarChart(x="month", y=["sales"]), style)
+	>>> line = ndp.LineChart(x="month", y=["price"], marker=ndp.MarkerShape.CIRCLE)
+	>>> both = plot.add_line(shop, line, axis=ndp.ValueAxis.RIGHT)
+	>>> both.show()
+	"""
+
+	LEFT = auto()
+	"""
+	The axis on the left, shared with the first chart of the Plot. Default value.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> months = ndp.Array.from_list(["Jan", "Feb", "Mar", "Apr"])
+	>>> sales = ndp.Array.from_list([120.0, 150.0, 90.0, 170.0])
+	>>> targets = ndp.Array.from_list([130.0, 130.0, 140.0, 140.0])
+	>>> shop = ndp.Table.from_arrays({"month": months, "sales": sales, "target": targets})
+	>>> plot = ndp.Plot.bar(shop, ndp.BarChart(x="month", y=["sales"]))
+	>>> line = ndp.LineChart(x="month", y=["target"], line=ndp.LineType.DASHED)
+	>>> both = plot.add_line(shop, line, axis=ndp.ValueAxis.LEFT)
+	>>> both.show()
+	"""
+
+	RIGHT = auto()
+	"""
+	A second axis on the right, with its own scale and label.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> months = ndp.Array.from_list(["Jan", "Feb", "Mar", "Apr"])
+	>>> sales = ndp.Array.from_list([120.0, 150.0, 90.0, 170.0])
+	>>> prices = ndp.Array.from_list([12.5, 11.0, 14.0, 10.5])
+	>>> shop = ndp.Table.from_arrays({"month": months, "sales": sales, "price": prices})
+	>>> style = ndp.PlotStyle(y_label="Sales", right_label="Price (euros)", legend=ndp.LegendPosition.UPPER_LEFT)
+	>>> plot = ndp.Plot.bar(shop, ndp.BarChart(x="month", y=["sales"]), style)
+	>>> line = ndp.LineChart(x="month", y=["price"], marker=ndp.MarkerShape.CIRCLE)
+	>>> both = plot.add_line(shop, line, axis=ndp.ValueAxis.RIGHT)
+	>>> both.show()
+	"""

numdaplot/plots/data/__init__.py

@@ -0,0 +1,5 @@
+"""
+Values a Plot reads from a Table or an Array before drawing them.
+
+.. versionadded:: 0.1.0
+"""

numdaplot/plots/data/array_values.py

@@ -0,0 +1,128 @@
+"""
+Values a chart draws from the columns of an Array.
+
+.. versionadded:: 0.1.0
+"""
+
+from typing import Any
+
+import numpy
+from numpy.typing import NDArray
+
+from numdaplot.arrays.array import Array
+from numdaplot.arrays.array_data import read_stored_values
+from numdaplot.arrays.operations.type_requirements import require_family
+from numdaplot.data_types.numpy_mapping import from_numpy_dtype
+from numdaplot.data_types.type import Type
+from numdaplot.data_types.value_family import ValueFamily, find_family
+from numdaplot.errors.dimension_error import DimensionError
+from numdaplot.plots.data.chart_values import ChartValues, Positions, Series
+from numdaplot.plots.data.column_reading import count_hours, find_value_families
+from numdaplot.plots.data.position_kind import PositionKind
+
+ONE_DIMENSION = 1
+TWO_DIMENSIONS = 2
+FLOAT_DTYPE = numpy.dtype(numpy.float64)
+VALUE_LABEL = "Value"
+
+
+def read_array_values(array: Array, chart_name: str) -> ChartValues:
+	"""
+	Return the positions and the series a chart draws from an Array of numbers or times of day.
+
+	Only a chart measuring times of day accepts them. Each column is a series named after its number, and each row
+	is placed at its number.
+	A one-dimensional Array is a single column.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	array
+		An Array of numbers or times of day, of one or two dimensions.
+	chart_name
+		Name of the chart class, shown in error messages.
+
+	Returns
+	-------
+	ChartValues
+		The row numbers as positions, and one series per column.
+
+	Raises
+	------
+	IncompatibleTypesError
+		When the Array holds neither numbers nor times of day for a chart measuring them.
+	DimensionError
+		When the Array has more than two dimensions.
+
+	Examples
+	--------
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.data.array_values import read_array_values
+	>>> grid = ndp.Array.from_list([[1, 2], [3, 4]])
+	>>> read_array_values(grid, "LineChart").series[1].values
+	array([2., 4.])
+	"""
+	values = read_stored_values(array)
+	value_families = find_value_families(chart_name)
+	require_family(values, value_families, chart_name)
+	dimension_count = values.ndim
+	if dimension_count > TWO_DIMENSIONS:
+		raise DimensionError(chart_name, dimension_count)
+
+	if dimension_count == ONE_DIMENSION:
+		values = values.reshape(-1, 1)
+
+	value_type = from_numpy_dtype(values.dtype)
+	numbers = read_array_numbers(values, value_type)
+	row_count, column_count = values.shape
+	rows = numpy.arange(row_count)
+	row_numbers = rows.astype(FLOAT_DTYPE)
+	positions = Positions(PositionKind.NUMBERS, row_numbers, None)
+	series = list[Series]()
+
+	for i in range(column_count):
+		column_name = str(i)
+		column_numbers = numbers[:, i]
+		column_series = Series(column_name, column_numbers)
+		series.append(column_series)
+
+	chart_values = ChartValues(positions, series, rows, VALUE_LABEL, value_type)
+
+	return chart_values
+
+
+def read_array_numbers(values: NDArray[Any], value_type: Type) -> NDArray[numpy.float64]:
+	"""
+	Return the values of an Array as float64 numbers, a time of day being its hours since midnight.
+
+	.. versionadded:: 0.1.0
+
+	Parameters
+	----------
+	values
+		The stored values of an Array of numbers or times of day.
+	value_type
+		The type of the values.
+
+	Returns
+	-------
+	NDArray[numpy.float64]
+		The numbers, of the same shape, NaN where a time of day is missing.
+
+	Examples
+	--------
+	>>> import numpy
+	>>> import numdaplot as ndp
+	>>> from numdaplot.plots.data.array_values import read_array_numbers
+	>>> read_array_numbers(numpy.array([5400000000], dtype="timedelta64[us]"), ndp.Type.TIME)
+	array([1.5])
+	"""
+	value_family = find_family(value_type)
+	if value_family == ValueFamily.TIME:
+		hours = count_hours(values)
+		return hours
+
+	numbers = values.astype(FLOAT_DTYPE)
+
+	return numbers