HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r65:00b9e6e4b7f5

New TimeSeries classes mostly usable from Python...

jeandet -

r65:00b9e6e4b7f5

parent child

Context file:

r65:00b9e6e4b7f5

tests/TestUtils/PyTestWrapperExe.cpp created 644 +41 0

@@ -0,0 +1,41
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SciQLOP Software
	3	-- Copyright (C) 2019, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include <iostream>
	23	#include <pybind11/embed.h>
	24	#include <pybind11/pybind11.h>
	25	#include <string>
	26
	27	namespace py = pybind11;
	28
	29	int main(int argc, char** argv)
	30	{
	31	py::scoped_interpreter guard{};
	32	py::globals()["__file__"] = py::str(PYTEST_SCRIPT);
	33	try
	34	{
	35	py::eval_file(PYTEST_SCRIPT);
	36	} catch(py::error_already_set const& pythonErr)
	37	{
	38	std::cout << pythonErr.what();
	39	}
	40	return 0;
	41	}

external/TimeSeries +1 -1

	@@ -1,1 +1,1
	1	Subproject commit b8442947c778c24a35d33c5f8eed8548cbf9fead		1	Subproject commit 2146d47985f44d6914b224c3b99ebf9e16e87b3f

external/pybind11 +1 -1

	@@ -1,1 +1,1
	1	Subproject commit f7bc18f528bb35cd06c93d0a58c17e6eea3fa68c		1	Subproject commit 25abf7efba0b2990f5a6dfb0a31bc65c0f2f4d17

include/Data/SpectrogramTimeSerie.h +2 0

             #ifndef SCIQLOP_SPECTROGRAMTIMESERIE_H
             #define SCIQLOP_SPECTROGRAMTIMESERIE_H
             #include "CoreGlobal.h"
             #include <TimeSeries.h>
             class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
                 : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
             {
             public:
+              using item_t =
+                  decltype(TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>()[0]);
               SpectrogramTimeSerie() {}
               ~SpectrogramTimeSerie() = default;
               using TimeSerie::TimeSerie;
             };
             #endif // SCIQLOP_SPECTROGRAMTIMESERIE_H

src/pybind11_wrappers/CoreWrappers.cpp +89 -14

             #include "CoreWrappers.h"
             #include "pywrappers_common.h"
             #include <Data/DataSeriesType.h>
             #include <Data/IDataProvider.h>
             #include <Data/OptionalAxis.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             #include <Data/VectorSeries.h>
             #include <Network/Downloader.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <pybind11/chrono.h>
             #include <pybind11/embed.h>
             #include <pybind11/functional.h>
             #include <pybind11/numpy.h>
             #include <pybind11/operators.h>
             #include <pybind11/pybind11.h>
             #include <pybind11/stl.h>
             #include <pybind11/stl_bind.h>
             #include <sstream>
             #include <string>
             namespace py = pybind11;
             using namespace std::chrono;
+            template<typename T, typename U, bool row_major = true>
+            void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
+                             U& dest_values)
+            {
+              auto t_view      = t.unchecked<1>();
+              auto values_view = values.unchecked<2>();
+              if constexpr(row_major)
+              {
+                for(std::size_t i = 0; i < t.size(); i++)
+                {
+                  dest_t[i]      = t_view[i];
+                  dest_values[i] = {values_view(i, 0), values_view(i, 1),
+                                    values_view(i, 2)};
+                }
+              }
+              else
+              {
+                for(std::size_t i = 0; i < t.size(); i++)
+                {
+                  dest_t[i]      = t_view[i];
+                  dest_values[i] = {values_view(0, i), values_view(1, i),
+                                    values_view(2, i)};
+                }
+              }
+            }
+            template<typename T, typename U>
+            void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
+                             U& dest_values)
+            {
+              auto t_view      = t.unchecked<1>();
+              auto values_view = values.unchecked<1>();
+              for(std::size_t i = 0; i < t.size(); i++)
+              {
+                dest_t[i]      = t_view[i];
+                dest_values[i] = values_view[i];
+              }
+            }
+            template<typename T, typename U>
+            void copy_spectro(py::array_t<double>& t, py::array_t<double>& values,
+                              T& dest_t, U& dest_values)
+            {
+              auto t_view      = t.unchecked<1>();
+              auto values_view = values.unchecked<2>();
+              const auto width = values.shape(0);
+              std::cout << "WIDTH" << width << std::endl;
+              for(std::size_t i = 0; i < t.size(); i++)
+              {
+                dest_t[i] = t_view[i];
+                for(int j = 0; j < width; j++)
+                {
+                  dest_values[i * width + j] = values_view(j, i);
+                  std::cout << "dest_values[" << i * width + j << "] = values_view(" << j
+                            << ", " << i << ") = " << values_view(j, i) << std::endl;
+                }
+              }
+            }
             PYBIND11_MODULE(pysciqlopcore, m)
             {
               pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
               py::enum_<DataSeriesType>(m, "DataSeriesType")
                   .value("SCALAR", DataSeriesType::SCALAR)
                   .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
                   .value("VECTOR", DataSeriesType::VECTOR)
                   .value("NONE", DataSeriesType::NONE)
                   .export_values();
               py::class_<Unit>(m, "Unit")
                   .def_readwrite("name", &Unit::m_Name)
                   .def_readwrite("time_unit", &Unit::m_TimeUnit)
                   .def(py::self == py::self)
                   .def(py::self != py::self)
                   .def("__repr__", __repr__<Unit>);
               py::class_<Response>(m, "Response")
                   .def("status_code", &Response::status_code);
               py::class_<Downloader>(m, "Downloader")
                   .def_static("get", Downloader::get)
                   .def_static("getAsync", Downloader::getAsync)
                   .def_static("downloadFinished", Downloader::downloadFinished);
               py::class_<ArrayDataIteratorValue>(m, "ArrayDataIteratorValue")
                   .def_property_readonly("value", &ArrayDataIteratorValue::first);
               py::class_<OptionalAxis>(m, "OptionalAxis")
                   .def("__len__", &OptionalAxis::size)
                   .def_property_readonly("size", &OptionalAxis::size)
                   .def("__getitem__",
                        [](OptionalAxis& ax, int key) {
                          return (*(ax.begin() + key)).first();
                        },
                        py::is_operator())
                   .def("__iter__",
                        [](OptionalAxis& ax) {
                          return py::make_iterator(ax.begin(), ax.end());
                        },
                        py::keep_alive<0, 1>());
               py::class_<DataSeriesIteratorValue>(m, "DataSeriesIteratorValue")
                   .def_property_readonly("x", &DataSeriesIteratorValue::x)
                   .def_property_readonly("y", &DataSeriesIteratorValue::y)
                   .def("value",
                        py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
                   .def("value",
                        py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_))
                   .def("values", &DataSeriesIteratorValue::values);
               py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
                   .def("nbPoints", &IDataSeries::nbPoints)
                   .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
                   .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
                   .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
                   .def("__getitem__",
                        [](IDataSeries& serie, int key) { return *(serie.begin() + key); },
                        py::is_operator())
                   .def("__len__", &IDataSeries::nbPoints)
                   .def("__iter__",
                        [](IDataSeries& serie) {
                          return py::make_iterator(serie.begin(), serie.end());
                        },
                        py::keep_alive<0, 1>())
                   .def("__repr__", __repr__<IDataSeries>);
               py::class_<ArrayData<1>, std::shared_ptr<ArrayData<1>>>(m, "ArrayData1d")
                   .def("cdata", [](ArrayData<1>& array) { return array.cdata(); });
               py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(
                   m, "ScalarSeries")
                   .def("nbPoints", &ScalarSeries::nbPoints);
               py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(
                   m, "VectorSeries")
                   .def("nbPoints", &VectorSeries::nbPoints);
               py::class_<DataSeries<2>, std::shared_ptr<DataSeries<2>>, IDataSeries>(
                   m, "DataSeries2d")
                   .def_property_readonly(
                       "xAxis", py::overload_cast<>(&DataSeries<2>::xAxisData, py::const_))
                   .def_property_readonly(
                       "yAxis", py::overload_cast<>(&DataSeries<2>::yAxis, py::const_));
               py::class_<SpectrogramSeries, std::shared_ptr<SpectrogramSeries>,
                          DataSeries<2>>(m, "SpectrogramSeries")
                   .def("nbPoints", &SpectrogramSeries::nbPoints)
                   .def("xRes", &SpectrogramSeries::xResolution);
               py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
               py::class_<Variable, std::shared_ptr<Variable>>(m, "Variable")
                   .def(py::init<const QString&>())
                   .def_property("name", &Variable::name, &Variable::setName)
                   .def_property("range", &Variable::range, &Variable::setRange)
                   .def_property("cacheRange", &Variable::cacheRange,
                                 &Variable::setCacheRange)
                   .def_property_readonly("nbPoints", &Variable::nbPoints)
                   .def_property_readonly("dataSeries", &Variable::dataSeries)
                   .def("__len__",
                        [](Variable& variable) {
                          auto rng = variable.dataSeries()->xAxisRange(
                              variable.range().m_TStart, variable.range().m_TEnd);
                          return std::distance(rng.first, rng.second);
                        })
                   .def("__iter__",
                        [](Variable& variable) {
                          auto rng = variable.dataSeries()->xAxisRange(
                              variable.range().m_TStart, variable.range().m_TEnd);
                          return py::make_iterator(rng.first, rng.second);
                        },
                        py::keep_alive<0, 1>())
                   .def("__getitem__",
                        [](Variable& variable, int key) {
                          // insane and slow!
                          auto rng = variable.dataSeries()->xAxisRange(
                              variable.range().m_TStart, variable.range().m_TEnd);
                          if(key < 0)
                            return *(rng.second + key);
                          else
                            return *(rng.first + key);
                        })
                   .def("__repr__", __repr__<Variable>);
               py::class_<TimeSeries::ITimeSerie>(m, "ITimeSerie")
                   .def_property_readonly(
                       "size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
+                  .def("__len__",
+                       [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
                   .def_property_readonly(
                       "shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
                   .def_property_readonly(
                       "t",
                       [](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
                         return ts.axis(0);
                       },
                       py::return_value_policy::reference);
               py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie>(m, "ScalarTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() == values.size());
                     ScalarTimeSerie::axis_t _t(t.size());
                     ScalarTimeSerie::axis_t _values(t.size());
-                    auto t_vew      = t.unchecked<1>();
+                    copy_scalar(t, values, _t, _values);
-                    auto values_vew = values.unchecked<1>();
-                    for(std::size_t i = 0; i < t.size(); i++)
-                      _t[i]      = t_vew[i];
-                      _values[i] = values_vew[i];
                     return ScalarTimeSerie(_t, _values);
                   }))
                   .def("__getitem__",
                        [](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
                   .def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
                                          double value) { *(ts.begin() + key) = value; });
               py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
                   .def(py::init<>())
                   .def(py::init<double, double, double>())
                   .def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
                   .def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
                   .def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
                   .def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
               py::class_<VectorTimeSerie, TimeSeries::ITimeSerie>(m, "VectorTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() * 3 == values.size());
                     VectorTimeSerie::axis_t _t(t.size());
                     VectorTimeSerie::container_type<VectorTimeSerie::raw_value_type>
                         _values(t.size());
-                    auto t_vew      = t.unchecked<1>();
+                    if(values.shape()[0] == 3 && values.shape(1) != 3)
-                    auto values_vew = values.unchecked<2>();
-                    for(std::size_t i = 0; i < t.size(); i++)
                     {
-                      _t[i]      = t_vew[i];
+                      copy_vector<decltype(_t), decltype(_values), false>(t, values, _t,
-                      _values[i] = VectorTimeSerie::raw_value_type{
+                                                                          _values);
-                          values_vew(0, i), values_vew(1, i), values_vew(2, i)};
                     }
+                    else
+                    {
+                      copy_vector(t, values, _t, _values);
+                    }
                     return VectorTimeSerie(_t, _values);
                   }))
                   .def("__getitem__",
                        [](VectorTimeSerie& ts, std::size_t key)
                            -> VectorTimeSerie::raw_value_type& { return ts[key]; },
                        py::return_value_policy::reference)
                   .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
                                          VectorTimeSerie::raw_value_type value) {
                     *(ts.begin() + key) = value;
                   });
+              py::class_<SpectrogramTimeSerie::item_t>(m, "SpectrogramTimeSerieItem")
+                  .def("__getitem__", [](SpectrogramTimeSerie::item_t& self,
+                                         std::size_t key) { return self[key]; });
               py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie>(
                   m, "SpectrogramTimeSerie")
                   .def(py::init<>())
-                  .def(py::init<const std::vector<std::size_t>>());
+                  .def(py::init<const std::vector<std::size_t>>())
+                  .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
+                    assert(t.size() < values.size()); // TODO check geometry
+                    SpectrogramTimeSerie::axis_t _t(t.size());
+                    SpectrogramTimeSerie::container_type<
+                        SpectrogramTimeSerie::raw_value_type>
+                        _values(values.size());
+                    copy_spectro(t, values, _t, _values);
+                    std::vector<std::size_t> shape;
+                    shape.push_back(values.shape(1));
+                    shape.push_back(values.shape(0));
+                    return SpectrogramTimeSerie(_t, _values, shape);
+                  }))
+                  .def("__getitem__",
+                       [](SpectrogramTimeSerie& ts, std::size_t key) { return ts[key]; });
               py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
                   .def(py::init<const QString&>())
                   .def_property("name", &Variable2::name, &Variable2::setName)
                   .def_property_readonly("range", &Variable2::range)
                   .def_property_readonly("nbPoints", &Variable2::nbPoints)
                   .def_property_readonly(
                       "data",
                       [](const Variable2& var) -> TimeSeries::ITimeSerie* {
                         auto data = var.data();
                         if(data) return data->base();
                         return nullptr;
                       })
                   .def("set_data",
                        [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
                           const DateTimeRange& range) { var.setData(ts_list, range); })
                   .def("__len__", &Variable2::nbPoints)
                   .def("__repr__", __repr__<Variable2>);
               py::class_<DateTimeRange>(m, "SqpRange")
                   //.def("fromDateTime", &DateTimeRange::fromDateTime,
                   // py::return_value_policy::move)
                   .def(py::init([](double start, double stop) {
                     return DateTimeRange{start, stop};
                   }))
                   .def(py::init(
                       [](system_clock::time_point start, system_clock::time_point stop) {
                         double start_ =
 .001 *
                             duration_cast<milliseconds>(start.time_since_epoch()).count();
                         double stop_ =
 .001 *
                             duration_cast<milliseconds>(stop.time_since_epoch()).count();
                         return DateTimeRange{start_, stop_};
                       }))
                   .def_property_readonly("start",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TStart);
                                          })
                   .def_property_readonly("stop",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TEnd);
                                          })
                   .def("__repr__", __repr__<DateTimeRange>);
             }

tests/CMakeLists.txt +5 0

             add_definitions(-DCORE_TESTS_RESOURCES_DIR="${CMAKE_CURRENT_LIST_DIR}/../tests-resources")
             FILE (GLOB_RECURSE  TestUtilsSources
                 TestUtils/TestProviders.h
                 TestUtils/TestProviders.cpp
             )
             add_library(TestUtils ${TestUtilsSources})
             target_link_libraries(TestUtils sciqlopcore Qt5::Test)
             target_include_directories(TestUtils PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/TestUtils
             )
             declare_test(TestStringUtils TestStringUtils Common/TestStringUtils.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestContainers TestContainers Common/TestContainers.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestSyncGroup TestSyncGroup Variable/TestSyncGroup.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDateTimeRange TestDateTimeRange Data/TestDateTimeRange.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDataSeriesUtils TestDataSeriesUtils Data/TestDataSeriesUtils.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestOptionalAxis TestOptionalAxis Data/TestOptionalAxis.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestSpectrogramSeries TestSpectrogramSeries
                 "Data/TestSpectrogramSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestOneDimArrayData TestOneDimArrayData Data/TestOneDimArrayData.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestScalarSeries TestScalarSeries
                 "Data/TestScalarSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestTwoDimArrayData TestTwoDimArrayData Data/TestTwoDimArrayData.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestVectorSeries TestVectorSeries
                 "Data/TestVectorSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestDataSourceController TestDataSourceController
                 "DataSource/TestDataSourceController.cpp;DataSource/DataSourceItemBuilder.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestDataSourceItem TestDataSourceItem
                 "DataSource/TestDataSourceItem.cpp;DataSource/DataSourceItemBuilder.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestVariable TestVariable Variable/TestVariable.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDownloader TestDownloader Network/TestDownloader.cpp "sciqlopcore;Qt5::Test;Qt5::Concurrent")
             declare_test(TestVariableController2 TestVariableController2 Variable/TestVariableController2.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestVariableController2Async TestVariableController2Async Variable/TestVariableController2Async.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestVariableController2WithSync TestVariableController2WithSync Variable/TestVariableController2WithSync.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestCatalogueController TestCatalogueController CatalogueController/TestCatalogueController.cpp "sciqlopcore;TestUtils;Qt5::Test")
+            add_executable(TestVariablesEmbed TestUtils/PyTestWrapperExe.cpp)
+            target_link_libraries(TestVariablesEmbed PRIVATE pybind11::embed)
+            add_test(NAME TestTestVariablesEmbed COMMAND TestVariablesEmbed)
+            target_compile_definitions(TestVariablesEmbed PRIVATE -DPYTEST_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/TestVariables.py")
+            set_tests_properties(TestTestVariablesEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}/../)
             find_package(PythonInterp 3 REQUIRED)
             add_test(NAME TestVariables
               COMMAND ${PYTHON_EXECUTABLE}
                 ${CMAKE_CURRENT_LIST_DIR}/TestVariables.py
                 TestVariables)
             set_tests_properties(TestVariables  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}/../)

tests/TestVariables.py +49 -4

             import sys
             import os
+            if not hasattr(sys, 'argv') or len(sys.argv)==0:
+                sys.argv = ['']
+            current_script_path = os.path.dirname(os.path.realpath(__file__))
+            sys.path.append(current_script_path)
             import sciqlopqt
             import pysciqlopcore
             import numpy as np
+            import pandas as pds
             import datetime
             import time
             import unittest
             import ddt
             def listify(obj):
                 if hasattr(obj, "__getitem__"):
                     return obj
                 return [obj]
             @ddt.ddt
             class TimeSeriesCtors(unittest.TestCase):
                 @ddt.data(
                          (pysciqlopcore.ScalarTimeSerie,10),
                          (pysciqlopcore.VectorTimeSerie,10),
-                         (pysciqlopcore.SpectrogramTimeSerie,[10,10]),
+                         (pysciqlopcore.SpectrogramTimeSerie,[10,10])
                 )
                 def test_construct(self, case):
                     ts = case[0](case[1])
                     self.assertEqual(ts.shape,listify(case[1]))
             class TimeSeriesData(unittest.TestCase):
                 def test_set_ScalarTimeSerie_values(self):
                     ts = pysciqlopcore.ScalarTimeSerie(10)
                     ts.t[0]=111.
                     self.assertEqual(ts.t[0],111.)
                     ts[0]=123.
                     self.assertEqual(ts[0],123.)
                 def test_build_ScalarTimeSerie_from_np_arrays(self):
-                    ts = pysciqlopcore.ScalarTimeSerie(np.arange(10),np.zeros(10))
+                    ts = pysciqlopcore.ScalarTimeSerie(np.arange(10), np.arange(10)*10)
+                    for i in range(len(ts)):
+                        self.assertEqual(ts[i],i*10.)
                 def test_build_VectorTimeSerie_from_np_arrays(self):
-                    ts = pysciqlopcore.VectorTimeSerie(np.arange(10),np.zeros((3,10)))
+                    v=np.ones((3,10))
+                    for i in range(3):
+                        v[:][i] = np.arange(10)*10**i
+                    ts = pysciqlopcore.VectorTimeSerie(np.arange(10), v)
+                    for i in range(len(ts)):
+                        self.assertEqual(ts[i].x,i)
+                        self.assertEqual(ts[i].y,i*10.)
+                        self.assertEqual(ts[i].z,i*100.)
+                def test_build_VectorTimeSerie_from_np_arrays_row(self):
+                    v=np.ones((10,3))
+                    for i in range(3):
+                        v.transpose()[:][i] = np.arange(10)*10**i
+                    ts = pysciqlopcore.VectorTimeSerie(np.arange(10), v)
+                    for i in range(len(ts)):
+                        self.assertEqual(ts[i].x,i)
+                        self.assertEqual(ts[i].y,i*10.)
+                        self.assertEqual(ts[i].z,i*100.)
+                def test_build_VectorTimeSerie_from_np_dataframe(self):
+                    df = pds.DataFrame(data=np.zeros((10,3)),index=np.arange(10))
+                    for i in range(3):
+                        df[i] = np.arange(10)*10**i
+                    ts = pysciqlopcore.VectorTimeSerie(df.index.values, df.values)
+                    for i in range(len(ts)):
+                        self.assertEqual(ts[i].x,i)
+                        self.assertEqual(ts[i].y,i*10.)
+                        self.assertEqual(ts[i].z,i*100.)
+                def test_build_SpectrogramTimeSerie_from_np_arrays(self):
+                    v=np.ones((4,10))
+                    for i in range(4):
+                        v[:][i] = np.arange(10)*10**i
+                    ts = pysciqlopcore.SpectrogramTimeSerie(np.arange(10), v)
+                    for i in range(len(ts)):
+                        for j in range(4):
+                            print(f"ts[{i}][{j}] = " + str(ts[i][j]))
             if __name__ == '__main__':
-                unittest.main()
+                unittest.main(exit=False)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages