diff --git a/.gitignore b/.gitignore index 17afe23..56ee8ee 100644 --- a/.gitignore +++ b/.gitignore @@ -14,4 +14,3 @@ src/.old src/pch.hpp.gch test-python/ web/ - diff --git a/src/main.cpp b/src/main.cpp index a5556dc..153eead 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -149,7 +149,7 @@ void testTFI_TEBD() { // }); std::println("E = {}", model.energy(psi).real()); std::println("m = {}", psi.getSiteExpectationValues(sigma_z)); - std::println("chiS: {:b}", psi.getChi()); + std::println("chiS: {}", psi.getChi()); psi.print(); std::println("={}", psi.collapse(0)); @@ -166,7 +166,7 @@ void testTFI_TEBD() { std::println("E = {}", model.energy(psi).real()); std::println("m = {}", psi.getSiteExpectationValues(sigma_z)); - std::println("chiS: {:b}", psi.getChi()); + std::println("chiS: {}", psi.getChi()); // psi.print(); std::println("={}", psi.collapse(0)); diff --git a/src/models/transverse_field_ising.cpp b/src/models/transverse_field_ising.cpp index e5b2887..9855b7a 100644 --- a/src/models/transverse_field_ising.cpp +++ b/src/models/transverse_field_ising.cpp @@ -9,6 +9,8 @@ PauliMatrices TransverseFieldIsingModel1D::pm; template void TransverseFieldIsingModel1D::initH_Bonds() { T BHalf = this->B * static_cast(0.5); + ///@todo TODO remove this after testing! + // T BHalf = this->B; // TODO: improve code or directly initialize the tensors auto left = std::make_shared>( e::kroneckerProduct(pm.getSigmaZ(), pm.getSigmaZ()) * (-J) diff --git a/src/util.hpp b/src/util.hpp index 7160cf4..cd2c864 100644 --- a/src/util.hpp +++ b/src/util.hpp @@ -7,87 +7,104 @@ #include "type.hpp" -template -struct std::formatter> { - using T = std::vector; - // using std::formatter::parse; - constexpr auto parse(std::format_parse_context& ctx){ - auto pos = ctx.begin(); - while (pos != ctx.end() && *pos != '}') { - if (*pos == 'a') { useChar = 1; } - else if (*pos == 'b') { useChar = 2; } - else if (*pos == 'p') { useChar = 3; } - ++pos; - } - return pos; // expect `}` at this position, otherwise its an error - } - - auto format(const T& v, auto& ctx) const { - // TODO figure out why tf it doesnt compile with openChars.at(..) - auto out = ctx.out(); - // out = std::format_to(out, "{}", openChars.at(useChar)); - char c = '{'; - if (useChar > 0) { c = '<'; } - out = std::format_to(out, "{}", c); - - auto it = v.begin(); - if (it != v.end()) { - out = std::format_to(out, "{}", *it); - } - it++; - for (; it != v.end(); it++) { - out = std::format_to(out, ", {}", *it); - } - // return std::format_to(out, "{}", closeChars.at(useChar)); - c = '}'; - if (useChar > 0) { c = '>'; } - return std::format_to(out, "{}", c); - // return out; - } - public: - size_t useChar = 0; - static constexpr std::string openChars{"(<[{"}; - static constexpr std::string closeChars{")>]}"}; -}; +// FORMATING +template +concept FormatableRange = std::ranges::forward_range && std::formattable, CharT>; +/** + * @brief Format ranges + * @details + * Format string accepts c = {curly brackets}, b = [box brackets], a = , r = (round brackets) + * @note With some clang lib update, this became obsolete! + */ +/*template requires FormatableRange*/ +/*struct std::formatter {*/ +/* using T = std::ranges::range_value_t;*/ +/* constexpr auto parse(std::format_parse_context& ctx){*/ +/* auto pos = ctx.begin();*/ +/* while (pos != ctx.end() && *pos != '}') {*/ +/* if (*pos == 'a') { useChar = 0; } // ngle*/ +/* else if (*pos == 'b') { useChar = 1; } // [b]ox*/ +/* else if (*pos == 'c') { useChar = 2; } // {c}urly*/ +/* else if (*pos == 'p') { useChar = 3; } // (r)ound*/ +/* else {*/ +/* throw std::format_error("Invalid format args for forward range.");*/ +/* }*/ +/* ++pos;*/ +/* }*/ +/* return pos; // expect `}` at this position, otherwise its an error*/ +/* }*/ +/* auto format(const U& v, auto& ctx) const {*/ +/* auto out = ctx.out();*/ +/* char c = openChars.at(useChar);*/ +/* out = std::format_to(out, "{}", c);*/ +/**/ +/* auto it = v.begin();*/ +/* if (it != v.end()) {*/ +/* out = std::format_to(out, "{}", *it);*/ +/* }*/ +/* it++;*/ +/* for (; it != v.end(); it++) {*/ +/* out = std::format_to(out, ", {}", *it);*/ +/* }*/ +/* c = closeChars.at(useChar);*/ +/* return std::format_to(out, "{}", c);*/ +/* // return out;*/ +/* }*/ +/* public:*/ +/* size_t useChar = 2; */ +/* static constexpr std::string_view openChars = "<[{()";*/ +/* static constexpr std::string_view closeChars{">]})"};*/ +/*};*/ +/** + * @brief Format complex numbers + */ template struct std::formatter> : std::formatter { using T = std::complex; + // use default formater for the value type using std::formatter::parse; + + /*constexpr auto parse(std::format_parse_context& ctx){*/ + /* auto pos = ctx.begin();*/ + /* while (pos != ctx.end() && *pos != '}') {*/ + /* if (*pos == 'i') { useImag = true; }*/ + /* ++pos;*/ + /* }*/ + /* return pos;*/ + /*}*/ auto format(const T& v, auto& ctx) const { auto out = ctx.out(); - out = std::format_to(out, "({}, {})", v.real(), v.imag()); + if (useImag) { + out = std::format_to(out, "{}+{}i", v.real(), v.imag()); + } + else { + out = std::format_to(out, "({}, {})", v.real(), v.imag()); + } return out; } + bool useImag = false; +}; + +// Make every class with public std::string format() const member formatable +template +concept HasFormat = requires(const T obj) { + { obj.format() } -> std::convertible_to; +}; +template +struct std::formatter { + constexpr auto parse(std::format_parse_context& ctx) { + return ctx.begin(); + } + auto format(const T& obj, auto& ctx) const { + return std::format_to(ctx.out(), "{}", obj.format()); + } }; -// // Formatter specialization for std::complex -// template -// struct std::formatter> { -// std::formatter inner_formatter; // Inner formatter for real/imaginary parts - -// // Parse the format specifier -// constexpr auto parse(std::format_parse_context& ctx) { -// // Use the same format specifier for real/imaginary parts as for other types -// return inner_formatter.parse(ctx); -// } - -// // Format the complex number -// template -// auto format(const std::complex& c, FormatContext& ctx) { -// // Format both real and imaginary parts using the inner formatter -// return std::format_to( -// ctx.out(), -// "({} + {}i)", -// std::format(inner_formatter, c.real()), // Format real part -// std::format(inner_formatter, c.imag()) // Format imaginary part -// ); -// } -// }; - +// OTHER template void printTensor(const T& t, string_type name="") { std::cout << name << "(" << t.dimensions() << ") = \n" << t << "\n" << std::endl; @@ -116,17 +133,3 @@ void throwIfLessThan(const T& v, const T& compare, std::string_view name) { } } -// Make every class with public std::string format() const member formatable -template -concept HasFormat = requires(const T obj) { - { obj.format() } -> std::convertible_to; -}; -template -struct std::formatter { - constexpr auto parse(std::format_parse_context& ctx) { - return ctx.begin(); - } - auto format(const T& obj, auto& ctx) const { - return std::format_to(ctx.out(), "{}", obj.format()); - } -}; diff --git a/src/wasm/result.hpp b/src/wasm/result.hpp index 3f03e07..616f234 100644 --- a/src/wasm/result.hpp +++ b/src/wasm/result.hpp @@ -22,7 +22,6 @@ class Results { virtual void finalize(std::shared_ptr model, const MPS& psi) = 0; /// Norm of the MPS dtype finalNorm = 0; - std::vector finalStates; }; @@ -31,7 +30,7 @@ class TfiResults : public Results { using Model_t = TfiModel; TfiResults(ems::val callback, double convergence) : callback(callback), convergence(convergence), previousE(std::numeric_limits::max()) { sigmaZ.setValues({{1, 0}, {0, -1}}); - // sigmaZ.setValues({{0, 1}, {1, 0}}); + sigmaX.setValues({{0, 1}, {1, 0}}); }; /// @todo write a second postUpdateFunction without the JS callback and return that one if callback is null postUpdateFunction_t getPostUpdateFunction(std::shared_ptr model) override { @@ -51,10 +50,14 @@ class TfiResults : public Results { } void finalize(std::shared_ptr model, const MPS& psi) override { this->finalNorm = psi.collapse(0); - this->finalStates = psi.getSiteExpectationValues(this->sigmaZ); + this->finalStatesZ = psi.getSiteExpectationValues(this->sigmaZ); + this->finalStatesX = psi.getSiteExpectationValues(this->sigmaX); } + std::vector finalStatesZ; + std::vector finalStatesX; private: e::TensorFixedSize> sigmaZ; + e::TensorFixedSize> sigmaX; ems::val callback; double convergence; double previousE; @@ -86,8 +89,9 @@ class BoseHubbardResults : public Results { void finalize(std::shared_ptr model, const MPS& psi) override { e::TensorMap> particleNumberOperator(model->getLadderOperators().getN().data(), model->localDim, model->localDim); this->finalNorm = psi.collapse(0); - this->finalStates = psi.getSiteExpectationValues(particleNumberOperator); + this->finalStatesN = psi.getSiteExpectationValues(particleNumberOperator); } + std::vector finalStatesN; private: ems::val callback; double convergence; diff --git a/src/wasm/run.cpp b/src/wasm/run.cpp index 0e20875..9758eb4 100644 --- a/src/wasm/run.cpp +++ b/src/wasm/run.cpp @@ -50,17 +50,18 @@ EMSCRIPTEN_BINDINGS(run) { // RESULTS ems::class_>("ResultsBaseTfi") .property("finalNorm", &Results::finalNorm) - .property("finalStates", &Results::finalStates, ems::return_value_policy::reference()) ; ems::class_>("ResultsBaseBh") .property("finalNorm", &Results::finalNorm) - .property("finalStates", &Results::finalStates, ems::return_value_policy::reference()) ; ems::class_>>("ResultsTfi") .constructor() + .property("finalStatesX", &TfiResults::finalStatesX, ems::return_value_policy::reference()) + .property("finalStatesZ", &TfiResults::finalStatesZ, ems::return_value_policy::reference()) ; ems::class_>>("ResultsBh") .constructor() + .property("finalStatesN", &BoseHubbardResults::finalStatesN, ems::return_value_policy::reference()) ; // MODELS ems::class_>("Model1D")