1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
// (C) Copyright Anton Bikineev 2014 // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_MATH_TOOLS_RECURRENCE_HPP_ #define BOOST_MATH_TOOLS_RECURRENCE_HPP_ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace math { namespace tools { namespace detail{ // // Function ratios directly from recurrence relations: // H. Shintan, Note on Miller's recurrence algorithm, J. Sci. Hiroshima Univ. Ser. A-I // Math., 29 (1965), pp. 121 - 133. // and: // COMPUTATIONAL ASPECTS OF THREE-TERM RECURRENCE RELATIONS // WALTER GAUTSCHI // SIAM REVIEW Vol. 9, No. 1, January, 1967 // template struct function_ratio_from_backwards_recurrence_fraction { typedef typename std::remove_reference(std::declval()(0)))>::type value_type; typedef std::pair result_type; function_ratio_from_backwards_recurrence_fraction(const Recurrence& r) : r(r), k(0) {} result_type operator()() { value_type a, b, c; std::tie(a, b, c) = r(k); ++k; // an and bn defined as per Gauchi 1.16, not the same // as the usual continued fraction a' and b's. value_type bn = a / c; value_type an = b / c; return result_type(-bn, an); } private: function_ratio_from_backwards_recurrence_fraction operator=(const function_ratio_from_backwards_recurrence_fraction&) = delete; Recurrence r; int k; }; template struct recurrence_reverser { recurrence_reverser(const R& r) : r(r) {} std::tuple operator()(int i) { using std::swap; std::tuple t = r(-i); swap(std::get<0>(t), std::get<2>(t)); return t; } R r; }; template struct recurrence_offsetter { typedef decltype(std::declval()(0)) result_type; recurrence_offsetter(Recurrence const& rr, int offset) : r(rr), k(offset) {} result_type operator()(int i) { return r(i + k); } private: Recurrence r; int k; }; } // namespace detail // // Given a stable backwards recurrence relation: // a f_n-1 + b f_n + c f_n+1 = 0 // returns the ratio f_n / f_n-1 // // Recurrence: a functor that returns a tuple of the factors (a,b,c). // factor: Convergence criteria, should be no less than machine epsilon. // max_iter: Maximum iterations to use solving the continued fraction. // template T function_ratio_from_backwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter) { detail::function_ratio_from_backwards_recurrence_fraction f(r); return boost::math::tools::continued_fraction_a(f, factor, max_iter); } // // Given a stable forwards recurrence relation: // a f_n-1 + b f_n + c f_n+1 = 0 // returns the ratio f_n / f_n+1 // // Note that in most situations where this would be used, we're relying on // pseudo-convergence, as in most cases f_n will not be minimal as N -> -INF // as long as we reach convergence on the continued-fraction before f_n // switches behaviour, we should be fine. // // Recurrence: a functor that returns a tuple of the factors (a,b,c). // factor: Convergence criteria, should be no less than machine epsilon. // max_iter: Maximum iterations to use solving the continued fraction. // template T function_ratio_from_forwards_recurrence(const Recurrence& r, const T& factor, std::uintmax_t& max_iter) { boost::math::tools::detail::function_ratio_from_backwards_recurrence_fraction > f(r); return boost::math::tools::continued_fraction_a(f, factor, max_iter); } // solves usual recurrence relation for homogeneous // difference equation in stable forward direction // a(n)w(n-1) + b(n)w(n) + c(n)w(n+1) = 0 // // Params: // get_coefs: functor returning a tuple, where // get<0>() is a(n); get<1>() is b(n); get<2>() is c(n); // last_index: index N to be found; // first: w(-1); // second: w(0); // template inline T apply_recurrence_relation_forward(const NextCoefs& get_coefs, unsigned number_of_steps, T first, T second, long long* log_scaling = nullptr, T* previous = nullptr) { BOOST_MATH_STD_USING using std::tuple; using std::get; using std::swap; T third; T a, b, c; for (unsigned k = 0; k < number_of_steps; ++k) { tie(a, b, c) = get_coefs(k); if ((log_scaling) && ((fabs(tools::max_value() * (c / (a * 2048))) < fabs(first)) || (fabs(tools::max_value() * (c / (b * 2048))) < fabs(second)) || (fabs(tools::min_value() * (c * 2048 / a)) > fabs(first)) || (fabs(tools::min_value() * (c * 2048 / b)) > fabs(second)) )) { // Rescale everything: long long log_scale = lltrunc(log(fabs(second))); T scale = exp(T(-log_scale)); second *= scale; first *= scale; *log_scaling += log_scale; } // scale each part separately to avoid spurious overflow: third = (a / -c) * first + (b / -c) * second; BOOST_MATH_ASSERT((boost::math::isfinite)(third)); swap(first, second); swap(second, third); } if (previous) *previous = first; return second; } // solves usual recurrence relation for homogeneous // difference equation in stable backward direction // a(n)w(n-1) + b(n)w(n) + c(n)w(n+1) = 0 // // Params: // get_coefs: functor returning a tuple, where // get<0>() is a(n); get<1>() is b(n); get<2>() is c(n); // number_of_steps: index N to be found; // first: w(1); // second: w(0); // template inline T apply_recurrence_relation_backward(const NextCoefs& get_coefs, unsigned number_of_steps, T first, T second, long long* log_scaling = nullptr, T* previous = nullptr) { BOOST_MATH_STD_USING using std::tuple; using std::get; using std::swap; T next; T a, b, c; for (unsigned k = 0; k < number_of_steps; ++k) { tie(a, b, c) = get_coefs(-static_cast(k)); if ((log_scaling) && (second != 0) && ( (fabs(tools::max_value() * (a / b) / 2048) < fabs(second)) || (fabs(tools::max_value() * (a / c) / 2048) < fabs(first)) || (fabs(tools::min_value() * (a / b) * 2048) > fabs(second)) || (fabs(tools::min_value() * (a / c) * 2048) > fabs(first)) )) { // Rescale everything: int log_scale = itrunc(log(fabs(second))); T scale = exp(T(-log_scale)); second *= scale; first *= scale; *log_scaling += log_scale; } // scale each part separately to avoid spurious overflow: next = (b / -a) * second + (c / -a) * first; BOOST_MATH_ASSERT((boost::math::isfinite)(next)); swap(first, second); swap(second, next); } if (previous) *previous = first; return second; } template struct forward_recurrence_iterator { typedef typename std::remove_reference(std::declval()(0)))>::type value_type; forward_recurrence_iterator(const Recurrence& r, value_type f_n_minus_1, value_type f_n) : f_n_minus_1(f_n_minus_1), f_n(f_n), coef(r), k(0) {} forward_recurrence_iterator(const Recurrence& r, value_type f_n) : f_n(f_n), coef(r), k(0) { std::uintmax_t max_iter = boost::math::policies::get_max_series_iterations >(); f_n_minus_1 = f_n * boost::math::tools::function_ratio_from_forwards_recurrence(detail::recurrence_offsetter(r, -1), value_type(boost::math::tools::epsilon() * 2), max_iter); boost::math::policies::check_series_iterations("forward_recurrence_iterator<>::forward_recurrence_iterator", max_iter, boost::math::policies::policy<>()); } forward_recurrence_iterator& operator++() { using std::swap; value_type a, b, c; std::tie(a, b, c) = coef(k); value_type f_n_plus_1 = a * f_n_minus_1 / -c + b * f_n / -c; swap(f_n_minus_1, f_n); swap(f_n, f_n_plus_1); ++k; return *this; } forward_recurrence_iterator operator++(int) { forward_recurrence_iterator t(*this); ++(*this); return t; } value_type operator*() { return f_n; } value_type f_n_minus_1, f_n; Recurrence coef; int k; }; template struct backward_recurrence_iterator { typedef typename std::remove_reference(std::declval()(0)))>::type value_type; backward_recurrence_iterator(const Recurrence& r, value_type f_n_plus_1, value_type f_n) : f_n_plus_1(f_n_plus_1), f_n(f_n), coef(r), k(0) {} backward_recurrence_iterator(const Recurrence& r, value_type f_n) : f_n(f_n), coef(r), k(0) { std::uintmax_t max_iter = boost::math::policies::get_max_series_iterations >(); f_n_plus_1 = f_n * boost::math::tools::function_ratio_from_backwards_recurrence(detail::recurrence_offsetter(r, 1), value_type(boost::math::tools::epsilon() * 2), max_iter); boost::math::policies::check_series_iterations("backward_recurrence_iterator<>::backward_recurrence_iterator", max_iter, boost::math::policies::policy<>()); } backward_recurrence_iterator& operator++() { using std::swap; value_type a, b, c; std::tie(a, b, c) = coef(k); value_type f_n_minus_1 = c * f_n_plus_1 / -a + b * f_n / -a; swap(f_n_plus_1, f_n); swap(f_n, f_n_minus_1); --k; return *this; } backward_recurrence_iterator operator++(int) { backward_recurrence_iterator t(*this); ++(*this); return t; } value_type operator*() { return f_n; } value_type f_n_plus_1, f_n; Recurrence coef; int k; }; } } } // namespaces #endif // BOOST_MATH_TOOLS_RECURRENCE_HPP_