BVB Source Codes

mars Show fp_traits.hpp Source code

Return Download mars: download fp_traits.hpp Source code - Download mars Source code - Type:.hpp
  1. // fp_traits.hpp
  2.  
  3. #ifndef BOOST_MATH_FP_TRAITS_HPP
  4. #define BOOST_MATH_FP_TRAITS_HPP
  5.  
  6. // Copyright (c) 2006 Johan Rade
  7.  
  8. // Distributed under the Boost Software License, Version 1.0.
  9. // (See accompanying file LICENSE_1_0.txt
  10. // or copy at http://www.boost.org/LICENSE_1_0.txt)
  11.  
  12. /*
  13. To support old compilers, care has been taken to avoid partial template
  14. specialization and meta function forwarding.
  15. With these techniques, the code could be simplified.
  16. */
  17.  
  18. #if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
  19. // The VAX floating point formats are used (for float and double)
  20. #   define BOOST_FPCLASSIFY_VAX_FORMAT
  21. #endif
  22.  
  23. #include <cstring>
  24.  
  25. #include <boost/assert.hpp>
  26. #include <boost/cstdint.hpp>
  27. #include <boost/detail/endian.hpp>
  28. #include <boost/static_assert.hpp>
  29. #include <boost/type_traits/is_floating_point.hpp>
  30.  
  31. #ifdef BOOST_NO_STDC_NAMESPACE
  32.   namespace std{ using ::memcpy; }
  33. #endif
  34.  
  35. #ifndef FP_NORMAL
  36.  
  37. #define FP_ZERO        0
  38. #define FP_NORMAL      1
  39. #define FP_INFINITE    2
  40. #define FP_NAN         3
  41. #define FP_SUBNORMAL   4
  42.  
  43. #else
  44.  
  45. #define BOOST_HAS_FPCLASSIFY
  46.  
  47. #ifndef fpclassify
  48. #  if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
  49.          && defined(_GLIBCXX_USE_C99_MATH) \
  50.          && !(defined(_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) \
  51.          && (_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC != 0))
  52. #     ifdef _STLP_VENDOR_CSTD
  53. #        if _STLPORT_VERSION >= 0x520
  54. #           define BOOST_FPCLASSIFY_PREFIX ::__std_alias::
  55. #        else
  56. #           define BOOST_FPCLASSIFY_PREFIX ::_STLP_VENDOR_CSTD::
  57. #        endif
  58. #     else
  59. #        define BOOST_FPCLASSIFY_PREFIX ::std::
  60. #     endif
  61. #  else
  62. #     undef BOOST_HAS_FPCLASSIFY
  63. #     define BOOST_FPCLASSIFY_PREFIX
  64. #  endif
  65. #elif (defined(__HP_aCC) && !defined(__hppa))
  66. // aCC 6 appears to do "#define fpclassify fpclassify" which messes us up a bit!
  67. #  define BOOST_FPCLASSIFY_PREFIX ::
  68. #else
  69. #  define BOOST_FPCLASSIFY_PREFIX
  70. #endif
  71.  
  72. #ifdef __MINGW32__
  73. #  undef BOOST_HAS_FPCLASSIFY
  74. #endif
  75.  
  76. #endif
  77.  
  78.  
  79. //------------------------------------------------------------------------------
  80.  
  81. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  82. namespace math {
  83. namespace detail {
  84.  
  85. //------------------------------------------------------------------------------
  86.  
  87. /*
  88. The following classes are used to tag the different methods that are used
  89. for floating point classification
  90. */
  91.  
  92. struct native_tag {};
  93. template <bool has_limits>
  94. struct generic_tag {};
  95. struct ieee_tag {};
  96. struct ieee_copy_all_bits_tag : public ieee_tag {};
  97. struct ieee_copy_leading_bits_tag : public ieee_tag {};
  98.  
  99. #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  100. //
  101. // These helper functions are used only when numeric_limits<>
  102. // members are not compile time constants:
  103. //
  104. inline bool is_generic_tag_false(const generic_tag<false>*)
  105. {
  106.    return true;
  107. }
  108. inline bool is_generic_tag_false(const void*)
  109. {
  110.    return false;
  111. }
  112. #endif
  113.  
  114. //------------------------------------------------------------------------------
  115.  
  116. /*
  117. Most processors support three different floating point precisions:
  118. single precision (32 bits), double precision (64 bits)
  119. and extended double precision (80 - 128 bits, depending on the processor)
  120.  
  121. Note that the C++ type long double can be implemented
  122. both as double precision and extended double precision.
  123. */
  124.  
  125. struct unknown_precision{};
  126. struct single_precision {};
  127. struct double_precision {};
  128. struct extended_double_precision {};
  129.  
  130. // native_tag version --------------------------------------------------------------
  131.  
  132. template<class T> struct fp_traits_native
  133. {
  134.     typedef native_tag method;
  135. };
  136.  
  137. // generic_tag version -------------------------------------------------------------
  138.  
  139. template<class T, class U> struct fp_traits_non_native
  140. {
  141. #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  142.    typedef generic_tag<std::numeric_limits<T>::is_specialized> method;
  143. #else
  144.    typedef generic_tag<false> method;
  145. #endif
  146. };
  147.  
  148. // ieee_tag versions ---------------------------------------------------------------
  149.  
  150. /*
  151. These specializations of fp_traits_non_native contain information needed
  152. to "parse" the binary representation of a floating point number.
  153.  
  154. Typedef members:
  155.  
  156.   bits -- the target type when copying the leading bytes of a floating
  157.       point number. It is a typedef for uint32_t or uint64_t.
  158.  
  159.   method -- tells us whether all bytes are copied or not.
  160.       It is a typedef for ieee_copy_all_bits_tag or ieee_copy_leading_bits_tag.
  161.  
  162. Static data members:
  163.  
  164.   sign, exponent, flag, significand -- bit masks that give the meaning of the
  165.   bits in the leading bytes.
  166.  
  167. Static function members:
  168.  
  169.   get_bits(), set_bits() -- provide access to the leading bytes.
  170.  
  171. */
  172.  
  173. // ieee_tag version, float (32 bits) -----------------------------------------------
  174.  
  175. #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
  176.  
  177. template<> struct fp_traits_non_native<float, single_precision>
  178. {
  179.     typedef ieee_copy_all_bits_tag method;
  180.  
  181.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  182.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7f800000);
  183.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
  184.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x007fffff);
  185.  
  186.     typedef uint32_t bits;
  187.     static void get_bits(float x, uint32_t& a) { std::memcpy(&a, &x, 4); }
  188.     static void set_bits(float& x, uint32_t a) { std::memcpy(&x, &a, 4); }
  189. };
  190.  
  191. // ieee_tag version, double (64 bits) ----------------------------------------------
  192.  
  193. #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) \
  194.    || defined(__BORLANDC__) || defined(__CODEGEAR__)
  195.  
  196. template<> struct fp_traits_non_native<double, double_precision>
  197. {
  198.     typedef ieee_copy_leading_bits_tag method;
  199.  
  200.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  201.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
  202.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0);
  203.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
  204.  
  205.     typedef uint32_t bits;
  206.  
  207.     static void get_bits(double x, uint32_t& a)
  208.     {
  209.         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
  210.     }
  211.  
  212.     static void set_bits(double& x, uint32_t a)
  213.     {
  214.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
  215.     }
  216.  
  217. private:
  218.  
  219. #if defined(BOOST_BIG_ENDIAN)
  220.     BOOST_STATIC_CONSTANT(int, offset_ = 0);
  221. #elif defined(BOOST_LITTLE_ENDIAN)
  222.     BOOST_STATIC_CONSTANT(int, offset_ = 4);
  223. #else
  224.     BOOST_STATIC_ASSERT(false);
  225. #endif
  226. };
  227.  
  228. //..............................................................................
  229.  
  230. #else
  231.  
  232. template<> struct fp_traits_non_native<double, double_precision>
  233. {
  234.     typedef ieee_copy_all_bits_tag method;
  235.  
  236.     static const uint64_t sign     = ((uint64_t)0x80000000u) << 32;
  237.     static const uint64_t exponent = ((uint64_t)0x7ff00000) << 32;
  238.     static const uint64_t flag     = 0;
  239.     static const uint64_t significand
  240.         = (((uint64_t)0x000fffff) << 32) + ((uint64_t)0xffffffffu);
  241.  
  242.     typedef uint64_t bits;
  243.     static void get_bits(double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
  244.     static void set_bits(double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
  245. };
  246.  
  247. #endif
  248.  
  249. #endif  // #ifndef BOOST_FPCLASSIFY_VAX_FORMAT
  250.  
  251. // long double (64 bits) -------------------------------------------------------
  252.  
  253. #if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)\
  254.    || defined(__BORLANDC__) || defined(__CODEGEAR__)
  255.  
  256. template<> struct fp_traits_non_native<long double, double_precision>
  257. {
  258.     typedef ieee_copy_leading_bits_tag method;
  259.  
  260.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  261.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
  262.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0);
  263.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
  264.  
  265.     typedef uint32_t bits;
  266.  
  267.     static void get_bits(long double x, uint32_t& a)
  268.     {
  269.         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
  270.     }
  271.  
  272.     static void set_bits(long double& x, uint32_t a)
  273.     {
  274.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
  275.     }
  276.  
  277. private:
  278.  
  279. #if defined(BOOST_BIG_ENDIAN)
  280.     BOOST_STATIC_CONSTANT(int, offset_ = 0);
  281. #elif defined(BOOST_LITTLE_ENDIAN)
  282.     BOOST_STATIC_CONSTANT(int, offset_ = 4);
  283. #else
  284.     BOOST_STATIC_ASSERT(false);
  285. #endif
  286. };
  287.  
  288. //..............................................................................
  289.  
  290. #else
  291.  
  292. template<> struct fp_traits_non_native<long double, double_precision>
  293. {
  294.     typedef ieee_copy_all_bits_tag method;
  295.  
  296.     static const uint64_t sign     = (uint64_t)0x80000000u << 32;
  297.     static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
  298.     static const uint64_t flag     = 0;
  299.     static const uint64_t significand
  300.         = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffffu;
  301.  
  302.     typedef uint64_t bits;
  303.     static void get_bits(long double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
  304.     static void set_bits(long double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
  305. };
  306.  
  307. #endif
  308.  
  309.  
  310. // long double (>64 bits), x86 and x64 -----------------------------------------
  311.  
  312. #if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
  313.     || defined(__amd64) || defined(__amd64__)  || defined(_M_AMD64) \
  314.     || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)
  315.  
  316. // Intel extended double precision format (80 bits)
  317.  
  318. template<>
  319. struct fp_traits_non_native<long double, extended_double_precision>
  320. {
  321.     typedef ieee_copy_leading_bits_tag method;
  322.  
  323.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  324.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
  325.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00008000);
  326.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
  327.  
  328.     typedef uint32_t bits;
  329.  
  330.     static void get_bits(long double x, uint32_t& a)
  331.     {
  332.         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
  333.     }
  334.  
  335.     static void set_bits(long double& x, uint32_t a)
  336.     {
  337.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
  338.     }
  339. };
  340.  
  341.  
  342. // long double (>64 bits), Itanium ---------------------------------------------
  343.  
  344. #elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
  345.  
  346. // The floating point format is unknown at compile time
  347. // No template specialization is provided.
  348. // The generic_tag definition is used.
  349.  
  350. // The Itanium supports both
  351. // the Intel extended double precision format (80 bits) and
  352. // the IEEE extended double precision format with 15 exponent bits (128 bits).
  353.  
  354. #elif defined(__GNUC__) && (LDBL_MANT_DIG == 106)
  355.  
  356. //
  357. // Define nothing here and fall though to generic_tag:
  358. // We have GCC's "double double" in effect, and any attempt
  359. // to handle it via bit-fiddling is pretty much doomed to fail...
  360. //
  361.  
  362. // long double (>64 bits), PowerPC ---------------------------------------------
  363.  
  364. #elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
  365.     || defined(__ppc) || defined(__ppc__) || defined(__PPC__)
  366.  
  367. // PowerPC extended double precision format (128 bits)
  368.  
  369. template<>
  370. struct fp_traits_non_native<long double, extended_double_precision>
  371. {
  372.     typedef ieee_copy_leading_bits_tag method;
  373.  
  374.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  375.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7ff00000);
  376.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
  377.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x000fffff);
  378.  
  379.     typedef uint32_t bits;
  380.  
  381.     static void get_bits(long double x, uint32_t& a)
  382.     {
  383.         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
  384.     }
  385.  
  386.     static void set_bits(long double& x, uint32_t a)
  387.     {
  388.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
  389.     }
  390.  
  391. private:
  392.  
  393. #if defined(BOOST_BIG_ENDIAN)
  394.     BOOST_STATIC_CONSTANT(int, offset_ = 0);
  395. #elif defined(BOOST_LITTLE_ENDIAN)
  396.     BOOST_STATIC_CONSTANT(int, offset_ = 12);
  397. #else
  398.     BOOST_STATIC_ASSERT(false);
  399. #endif
  400. };
  401.  
  402.  
  403. // long double (>64 bits), Motorola 68K ----------------------------------------
  404.  
  405. #elif defined(__m68k) || defined(__m68k__) \
  406.     || defined(__mc68000) || defined(__mc68000__) \
  407.  
  408. // Motorola extended double precision format (96 bits)
  409.  
  410. // It is the same format as the Intel extended double precision format,
  411. // except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
  412. // 3) the flag bit is not set for infinity
  413.  
  414. template<>
  415. struct fp_traits_non_native<long double, extended_double_precision>
  416. {
  417.     typedef ieee_copy_leading_bits_tag method;
  418.  
  419.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  420.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
  421.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00008000);
  422.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x00007fff);
  423.  
  424.     // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
  425.  
  426.     typedef uint32_t bits;
  427.  
  428.     static void get_bits(long double x, uint32_t& a)
  429.     {
  430.         std::memcpy(&a, &x, 2);
  431.         std::memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
  432.                reinterpret_cast<const unsigned char*>(&x) + 4, 2);
  433.     }
  434.  
  435.     static void set_bits(long double& x, uint32_t a)
  436.     {
  437.         std::memcpy(&x, &a, 2);
  438.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
  439.                reinterpret_cast<const unsigned char*>(&a) + 2, 2);
  440.     }
  441. };
  442.  
  443.  
  444. // long double (>64 bits), All other processors --------------------------------
  445.  
  446. #else
  447.  
  448. // IEEE extended double precision format with 15 exponent bits (128 bits)
  449.  
  450. template<>
  451. struct fp_traits_non_native<long double, extended_double_precision>
  452. {
  453.     typedef ieee_copy_leading_bits_tag method;
  454.  
  455.     BOOST_STATIC_CONSTANT(uint32_t, sign        = 0x80000000u);
  456.     BOOST_STATIC_CONSTANT(uint32_t, exponent    = 0x7fff0000);
  457.     BOOST_STATIC_CONSTANT(uint32_t, flag        = 0x00000000);
  458.     BOOST_STATIC_CONSTANT(uint32_t, significand = 0x0000ffff);
  459.  
  460.     typedef uint32_t bits;
  461.  
  462.     static void get_bits(long double x, uint32_t& a)
  463.     {
  464.         std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
  465.     }
  466.  
  467.     static void set_bits(long double& x, uint32_t a)
  468.     {
  469.         std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
  470.     }
  471.  
  472. private:
  473.  
  474. #if defined(BOOST_BIG_ENDIAN)
  475.     BOOST_STATIC_CONSTANT(int, offset_ = 0);
  476. #elif defined(BOOST_LITTLE_ENDIAN)
  477.     BOOST_STATIC_CONSTANT(int, offset_ = 12);
  478. #else
  479.     BOOST_STATIC_ASSERT(false);
  480. #endif
  481. };
  482.  
  483. #endif
  484.  
  485. //------------------------------------------------------------------------------
  486.  
  487. // size_to_precision is a type switch for converting a C++ floating point type
  488. // to the corresponding precision type.
  489.  
  490. template<int n, bool fp> struct size_to_precision
  491. {
  492.    typedef unknown_precision type;
  493. };
  494.  
  495. template<> struct size_to_precision<4, true>
  496. {
  497.     typedef single_precision type;
  498. };
  499.  
  500. template<> struct size_to_precision<8, true>
  501. {
  502.     typedef double_precision type;
  503. };
  504.  
  505. template<> struct size_to_precision<10, true>
  506. {
  507.     typedef extended_double_precision type;
  508. };
  509.  
  510. template<> struct size_to_precision<12, true>
  511. {
  512.     typedef extended_double_precision type;
  513. };
  514.  
  515. template<> struct size_to_precision<16, true>
  516. {
  517.     typedef extended_double_precision type;
  518. };
  519.  
  520. //------------------------------------------------------------------------------
  521. //
  522. // Figure out whether to use native classification functions based on
  523. // whether T is a built in floating point type or not:
  524. //
  525. template <class T>
  526. struct select_native
  527. {
  528.     typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::mars_boost::is_floating_point<T>::value>::type precision;
  529.     typedef fp_traits_non_native<T, precision> type;
  530. };
  531. template<>
  532. struct select_native<float>
  533. {
  534.     typedef fp_traits_native<float> type;
  535. };
  536. template<>
  537. struct select_native<double>
  538. {
  539.     typedef fp_traits_native<double> type;
  540. };
  541. template<>
  542. struct select_native<long double>
  543. {
  544.     typedef fp_traits_native<long double> type;
  545. };
  546.  
  547. //------------------------------------------------------------------------------
  548.  
  549. // fp_traits is a type switch that selects the right fp_traits_non_native
  550.  
  551. #if (defined(BOOST_MATH_USE_C99) && !(defined(__GNUC__) && (__GNUC__ < 4))) \
  552.    && !defined(__hpux) \
  553.    && !defined(__DECCXX)\
  554.    && !defined(__osf__) \
  555.    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\
  556.    && !defined(__FAST_MATH__)\
  557.    && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\
  558.    && !defined(BOOST_INTEL)\
  559.    && !defined(sun)
  560. #  define BOOST_MATH_USE_STD_FPCLASSIFY
  561. #endif
  562.  
  563. template<class T> struct fp_traits
  564. {
  565.     typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::mars_boost::is_floating_point<T>::value>::type precision;
  566. #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
  567.     typedef typename select_native<T>::type type;
  568. #else
  569.     typedef fp_traits_non_native<T, precision> type;
  570. #endif
  571.     typedef fp_traits_non_native<T, precision> sign_change_type;
  572. };
  573.  
  574. //------------------------------------------------------------------------------
  575.  
  576. }   // namespace detail
  577. }   // namespace math
  578. }   // namespace mars_boost
  579.  
  580. #endif
  581.  
downloadfp_traits.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top