wip

Author: folosuru

stock_emu_lib/StockMeta.hpp

@@ -1,10 +1,27 @@
 #pragma once
 
 #ifndef INCLUDE_STOCKMETA_HPP_
-#include "stock_emu_lib/trade/Trade.hpp"
+#include <stock_emu_lib/Stock.hpp>
+#include <stock_emu_lib/util/MultiVector.hpp>
 
-class StockMeta {
-    TradeBoard board;
+struct StockMeta {
+    std::tuple<double, double> price_standard_base;
+};
+
+class StockMetaList {
+public:
+    const auto& getRate() const noexcept {
+        return price_standard_rate;
+    }
+
+    void add(StockMeta&& add_meta) {
+        meta.push_back(std::move(add_meta));
+        price_standard_rate.push(0, 0);
+    }
+
+private:
+    std::vector<StockMeta> meta;
+    util::MultiVector<double, double> price_standard_rate;
 };
 
 #endif  // INCLUDE_STOCKMETA_HPP_

stock_emu_lib/bot/trader/Trader.cpp

@@ -93,51 +93,9 @@ void Fundamental::Trade(Trader &trader, StockMarketRef market) {
     // board->getCurrentPrice().latest.getValue()
     //          << "\n";
     //
-
-    if (board->getCurrentPrice().higer) {
-        // StockValue よりも安く買える
-        if (board->getCurrentPrice().higer.value() < board->StockValue()) {
-            StockPrice price = getMarketPriceHigher(board, board->StockValue(), 1);
-            trader.buy(price, {getTradeAmount()}, board->id, market);
-            return;
-        } else {
-            // StockValueより高い
-
-            // 買い手がいない
-            if (!board->getCurrentPrice().lower) {
-                StockPrice price = getMarketPriceLower(board, board->StockValue(), 1);
-                if (price <= board->StockValue()) {
-                    return;
-                }
-                auto count_tmp = getTradeAmount();
-                auto count =
-                    StockCount{trader.stock[stock] >= count_tmp ? count_tmp : trader.stock[stock].to_StockCount()};
-                trader.sell(price, count, board->id, market);
-                return;
-            }
-        }
-    }
-    if (board->getCurrentPrice().lower) {
-        if (board->getCurrentPrice().lower.value() > board->StockValue()) {
-            //  std::cout << "high\n";
-            StockPrice price = getMarketPriceLower(board, board->StockValue(), 1);
-            auto count_tmp = getTradeAmount();
-            auto count = StockCount{trader.stock[stock] >= count_tmp ? count_tmp : trader.stock[stock].to_StockCount()};
-            trader.sell(price, count, board->id, market);
-            return;
-        } else {
-            // 売り手がいない
-            if (!board->getCurrentPrice().higer) {
-                StockPrice price = getMarketPriceHigher(board, board->StockValue(), 1);
-                if (price >= board->StockValue()) {
-                    return;
-                }
-                trader.buy(price, {getTradeAmount()}, board->id, market);
-                return;
-            }
-        }
-    }
-    // std::cout << "nothing\n";
+    const auto &datalist = market->getDatalist();
+    auto data = datalist.getRate().getRow(stock);
+    auto value_data1 = std::get<0>(data);
 }
 
 }  // namespace bot::trader

stock_emu_lib/trade/Trade.cpp

@@ -135,15 +135,7 @@ void TradeBoard::tick() noexcept {
     }
 }
 
-void TradeBoard::updateStockValue(StockPrice price, StockMarketRef market) {
-    this->stock_value = price;
-    market->updatePricePerValue(*this);
-}
-
-void StockMarket::updatePricePerValue(const TradeBoard& ref) {
-    this->value_dondake_hanareteru.at(ref.id) =
-        std::abs(ref.getHistory().getCurrentPrice().latest.getValue() - ref.StockValue().getValue());
-}
+void StockMarket::updatePricePerValue(const TradeBoard& ref) {}
 
 void TradeBoard::sell_limit_destruct::run(std::deque<Trade::SellTradeRequest>& q) {
     for (auto& i : q) {

stock_emu_lib/trade/Trade.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "stock_emu_lib/StockMeta.hpp"
 #ifndef INCLUDE_TRADE_HPP_
 #define INCLUDE_TRADE_HPP_
 
@@ -29,8 +30,7 @@ struct TradeBoard {
 
     constexpr static int expire_time = 4;
 
-    TradeBoard(StockId id_, StockMarket& market_, StockPrice value = {300})
-        : id(id_), market_ref(market_), stock_value(value) {}
+    TradeBoard(StockId id_, StockMarket& market_) : id(id_), market_ref(market_) {}
 
     bool LimitOrder_Sell(StockPrice, StockCount, Trader&);
     bool LimitOrder_Buy(StockPrice, StockCount, Trader&);
@@ -48,12 +48,6 @@ struct TradeBoard {
         return sell;
     }
 
-    constexpr const auto& StockValue() const {
-        return stock_value;
-    }
-
-    void updateStockValue(StockPrice price, StockMarketRef market);
-
     void tick() noexcept;
 
     constexpr const auto& getHistory() const noexcept {
@@ -81,7 +75,6 @@ struct TradeBoard {
     Trade::TradeRequestBoard<Trade::SellTradeRequest, sell_limit_destruct> sell;
 
     StockMarket& market_ref;
-    StockPrice stock_value = {300};
 
     TradeBoardHistory history;
     PriceLimit limit;
@@ -97,10 +90,10 @@ class StockMarket {
         return get(id);
     }
 
-    StockId add(StockPrice value = {300}) {
+    StockId add(StockMeta&& meta) {
         auto new_id = static_cast<StockId>(boards.size());
-        value_dondake_hanareteru.emplace_back();
-        boards.emplace_back(new TradeBoard{new_id, *this, value});
+        data_list.add(std::move(meta));
+        boards.emplace_back(new TradeBoard{new_id, *this});
         return new_id;
     }
 
@@ -115,7 +108,11 @@ class StockMarket {
      * 気が向いたらいい名前を考える
      */
     const auto& get_value_dondake_hanareteru() const {
-        return value_dondake_hanareteru;
+        return data_list.getRate().getColumn<0>();
+    }
+
+    auto& getDatalist() const noexcept {
+        return data_list;
     }
 
     void tick() {
@@ -126,7 +123,7 @@ class StockMarket {
 
 private:
     std::vector<std::shared_ptr<TradeBoard>> boards;
-    std::vector<double> value_dondake_hanareteru;
+    StockMetaList data_list;
 };
 
 inline Trader::StockData_t Trader::StockData_t::create(const std::vector<std::pair<StockId, StockCount_data_t>>& data) {

stock_emu_lib/trade/TradeHistory.cpp

@@ -85,23 +85,21 @@ void TradeBoardHistory::update_history(StockPrice price, StockCount count) {
     CurrentStockPrice.latest = price;
     this->history.push_back({count, price});
 
-    auto& current_history = tick_history.back();
-    if (current_history.start.getValue() == TickHistory::nothing) {
-        current_history.start = price;
+    if (currentTick.start.getValue() == TickHistory::nothing) {
+        currentTick.start = price;
     }
 
-    current_history.end = price;
+    currentTick.end = price;
 
-    if (current_history.high < price) {
-        current_history.high = price;
-    }
-    if (current_history.low > price) {
-        current_history.low = price;
+    if (currentTick.high < price) {
+        currentTick.high = price;
     }
+    if (price < currentTick.low) currentTick.low = price;
 }
 
-const TickHistory& TradeBoardHistory::tick() {
-    const auto& result = tick_history.back();
-    tick_history.emplace_back();
+const TickHistory TradeBoardHistory::tick() {
+    const auto result = currentTick;
+    tick_history.push(result.start, result.end, result.high, result.low);
+    currentTick = TickHistory{};
     return result;
 }

stock_emu_lib/trade/TradeHistory.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "stock_emu_lib/util/MultiVector.hpp"
 #ifndef INCLUDE_TRADE_TRADEHISTORY_HPP
 #define INCLUDE_TRADE_TRADEHISTORY_HPP
 
@@ -20,6 +21,7 @@ struct TickHistory {
 
     constexpr static Money_data_t nothing = std::numeric_limits<Money_data_t>::min();
 };
+
 struct TradeBoard;
 
 /**
@@ -46,7 +48,7 @@ class TradeBoardHistory {
 
     void update_history(StockPrice price, StockCount count);
 
-    const TickHistory& tick();
+    const TickHistory tick();
 
 private:
     struct {
@@ -55,7 +57,9 @@ class TradeBoardHistory {
         StockPrice latest = {0};
     } CurrentStockPrice;
 
+    TickHistory currentTick;
+
     std::deque<TradeHistory> history{{{300}, {100}}};
-    std::deque<TickHistory> tick_history = {{}};
+    util::MultiVector<StockPrice, StockPrice, StockPrice, StockPrice> tick_history;
 };
 #endif  // INCLUDE_TRADE_TRADEHISTORY_HPP

stock_emu_lib/util/MultiVector.hpp

@@ -4,42 +4,76 @@
 #define INCLUDE_UTIL_MULTIVECTOR_HPP_
 #include <cstddef>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace util {
+#if __cplusplus >= 202002L
+template<class OutT, class... DataT>
+concept OutT_check = requires(DataT... args) { OutT{args...}; };
+#else
+template<class OutT, class... args>
+class OutT_check_class {
+    template<class OutT_, class... args_, typename = decltype(OutT_{std::declval<args_>()...})>
+    static std::true_type chk();
 
+    template<typename, typename...>
+    static std::false_type chk();
+
+public:
+    static constexpr bool value = decltype(chk<OutT, args...>())::value;
+};
+template<class OutT, class... args>
+constexpr bool OutT_check = OutT_check_class<OutT, args...>::value;
+
+#endif
 template<class... T>
-class MlutiVector {
+class MultiVector {
     std::tuple<std::vector<T>...> data;
+    size_t count = 0;
 
-    constexpr static size_t Data_Colum_count = std::tuple_size<decltype(data)>::value;
+    constexpr static size_t Data_Colum_count = sizeof...(T);
 
 public:
+    size_t getRowCount() const noexcept {
+        return count;
+    }
+
     void push(const T&... args) {
+        count++;
         push_helper<0>(args...);
     }
 
+    void push(const std::tuple<T...>& arg) {
+        count++;
+        push_helper(arg, std::make_index_sequence<Data_Colum_count>());
+    }
+
     template<size_t Index>
-    const auto& getColumn() {
+    const auto& getColumn() const {
         return std::get<Index>(data);
     }
 
-    void erase(size_t index) {
-        erase_helper(index, std::make_index_sequence<Data_Colum_count>());
+    std::tuple<T...> getRow(size_t index) const {
+        return get_As_helper<std::tuple<T...>>(index, std::make_index_sequence<Data_Colum_count>());
     }
 
     template<class Out_t>
     Out_t get_As(size_t index) {
-        static_assert(std::is_aggregate_v<Out_t>, "get_As need construct by {T...}");
-        return get_As_helper<Out_t>(index, std::make_index_sequence<Data_Colum_count>());
+        constexpr auto is_valid = OutT_check<Out_t, T&...>;
+        static_assert(is_valid, "get_As parameter type must need construct by {T&...}");
+        if constexpr (is_valid) {
+            return get_As_helper<Out_t>(index, std::make_index_sequence<Data_Colum_count>());
+        }
     }
 
     template<class Out_t>
     const Out_t get_As(size_t index) const {
-        static_assert(std::is_aggregate_v<Out_t>, "get_As need construct by {T...}");
-        return get_As_helper<Out_t>(index, std::make_index_sequence<Data_Colum_count>());
+        constexpr auto is_valid = OutT_check<Out_t, const T&...>;
+        static_assert(is_valid, "get_As parameter type must need construct by {const T&...}.");
+        if constexpr (is_valid) {
+            return get_As_helper<Out_t>(index, std::make_index_sequence<Data_Colum_count>());
+        }
     }
 
 private:
@@ -48,14 +82,9 @@ class MlutiVector {
         return {std::get<Seq>(data)[index]...};
     }
 
-    template<class VectorT>
-    static void eraseVector(std::vector<VectorT>& vec, size_t index) {
-        vec.erase(vec.begin() + index);
-    }
-
-    template<class IndexT, IndexT... Seq>
-    void erase_helper(size_t index, std::integer_sequence<IndexT, Seq...>) {
-        (..., eraseVector(std::get<Seq>(data), index));
+    template<class Out_t, class IndexT, IndexT... Seq>
+    Out_t get_As_helper(size_t index, std::integer_sequence<IndexT, Seq...>) const {
+        return {std::get<Seq>(data)[index]...};
     }
 
     template<size_t index, class Front>
@@ -68,6 +97,11 @@ class MlutiVector {
         std::get<index>(data).push_back(front);
         push_helper<index + 1>(tail...);
     }
+
+    template<class IndexT, IndexT... Seq>
+    void push_helper(std::tuple<T...> arg, std::integer_sequence<IndexT, Seq...>) {
+        (..., std::get<Seq>(data).push_back(std::get<Seq>(arg)));
+    }
 };
 }
 

test/CMakeLists.txt

@@ -13,13 +13,14 @@ FetchContent_MakeAvailable(googletest)
 enable_testing()
 add_executable(stock_emu_test 
     ./main.cpp
-    ./trade/trade.cpp
+    #./trade/trade.cpp
+    ./Fuzzy.cpp
 )
 
 target_include_directories(stock_emu_test PRIVATE ../)
 
 target_link_libraries(stock_emu_test PRIVATE
-    stock_emu_lib
+    # stock_emu_lib
     GTest::gtest_main
 )
 target_compile_options(stock_emu_test PRIVATE