Merge pull request #553 from Cytnx-dev/haoti/pre-releasev1.0.0

Fix macos building error.

CMakeLists.txt

@@ -96,7 +96,13 @@ project(CYTNX VERSION ${CYTNX_VERSION} LANGUAGES CXX C)
 
 # C++ uses link-time optimization anyway; this enables additionally -flto=auto,
 # for parallel compilation
-set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+# It cannot enable on MacOS since it cuase bulding error when linking the library libcytnx.a.
+# Error message: Error running link command: no such file or directorymake[2]: *** [CMakeFiles/cytnx.dir/build.make:3109: libcytnx.a]
+IF (APPLE)
+  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)
+ELSE ()
+  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+ENDIF ()
 
 add_library(cytnx STATIC)
 set_property(TARGET cytnx PROPERTY C_VISIBILITY_PRESET hidden)

Readme.md

@@ -89,7 +89,7 @@ Available types are :
 ```c++
 Storage A(400,Type.Double);
 for(int i=0;i<400;i++)
-A.at<double>(i) = i;
+  A.at<double>(i) = i;
 
 Storage B = A; // A and B share same memory, this is similar to Python
 

include/Type.hpp

@@ -134,9 +134,9 @@ namespace cytnx {
     // type_size returns the sizeof(T) for the supported types. This is the same as
     // sizeof(T), except that size_type<void> is 0.
     template <typename T>
-    constexpr int type_size = sizeof(T);
+    inline constexpr int type_size = sizeof(T);
     template <>
-    constexpr int type_size<void> = 0;
+    inline constexpr int type_size<void> = 0;
   }  // namespace internal
 
   // the list of supported types. The dtype() of an object is an index into this list.
@@ -160,59 +160,59 @@ namespace cytnx {
 
   // The friendly name of each type
   template <typename T>
-  constexpr char* Type_names = nullptr;
+  inline constexpr char* Type_names = nullptr;
   template <>
-  constexpr const char* Type_names<void> = "Void";
+  inline constexpr const char* Type_names<void> = "Void";
   template <>
-  constexpr const char* Type_names<cytnx_complex128> = "Complex Double (Complex Float64)";
+  inline constexpr const char* Type_names<cytnx_complex128> = "Complex Double (Complex Float64)";
   template <>
-  constexpr const char* Type_names<cytnx_complex64> = "Complex Float (Complex Float32)";
+  inline constexpr const char* Type_names<cytnx_complex64> = "Complex Float (Complex Float32)";
   template <>
-  constexpr const char* Type_names<cytnx_double> = "Double (Float64)";
+  inline constexpr const char* Type_names<cytnx_double> = "Double (Float64)";
   template <>
-  constexpr const char* Type_names<cytnx_float> = "Float (Float32)";
+  inline constexpr const char* Type_names<cytnx_float> = "Float (Float32)";
   template <>
-  constexpr const char* Type_names<cytnx_int64> = "Int64";
+  inline constexpr const char* Type_names<cytnx_int64> = "Int64";
   template <>
-  constexpr const char* Type_names<cytnx_uint64> = "Uint64";
+  inline constexpr const char* Type_names<cytnx_uint64> = "Uint64";
   template <>
-  constexpr const char* Type_names<cytnx_int32> = "Int32";
+  inline constexpr const char* Type_names<cytnx_int32> = "Int32";
   template <>
-  constexpr const char* Type_names<cytnx_uint32> = "Uint32";
+  inline constexpr const char* Type_names<cytnx_uint32> = "Uint32";
   template <>
-  constexpr const char* Type_names<cytnx_int16> = "Int16";
+  inline constexpr const char* Type_names<cytnx_int16> = "Int16";
   template <>
-  constexpr const char* Type_names<cytnx_uint16> = "Uint16";
+  inline constexpr const char* Type_names<cytnx_uint16> = "Uint16";
   template <>
-  constexpr const char* Type_names<cytnx_bool> = "Bool";
+  inline constexpr const char* Type_names<cytnx_bool> = "Bool";
 
   // The corresponding Python enumeration name
   template <typename T>
-  constexpr char* Type_enum_name = nullptr;
+  inline constexpr char* Type_enum_name = nullptr;
   template <>
-  constexpr const char* Type_enum_name<void> = "Void";
+  inline constexpr const char* Type_enum_name<void> = "Void";
   template <>
-  constexpr const char* Type_enum_name<cytnx_complex128> = "ComplexDouble";
+  inline constexpr const char* Type_enum_name<cytnx_complex128> = "ComplexDouble";
   template <>
-  constexpr const char* Type_enum_name<cytnx_complex64> = "ComplexFloat";
+  inline constexpr const char* Type_enum_name<cytnx_complex64> = "ComplexFloat";
   template <>
-  constexpr const char* Type_enum_name<cytnx_double> = "Double";
+  inline constexpr const char* Type_enum_name<cytnx_double> = "Double";
   template <>
-  constexpr const char* Type_enum_name<cytnx_float> = "Float";
+  inline constexpr const char* Type_enum_name<cytnx_float> = "Float";
   template <>
-  constexpr const char* Type_enum_name<cytnx_int64> = "Int64";
+  inline constexpr const char* Type_enum_name<cytnx_int64> = "Int64";
   template <>
-  constexpr const char* Type_enum_name<cytnx_uint64> = "Uint64";
+  inline constexpr const char* Type_enum_name<cytnx_uint64> = "Uint64";
   template <>
-  constexpr const char* Type_enum_name<cytnx_int32> = "Int32";
+  inline constexpr const char* Type_enum_name<cytnx_int32> = "Int32";
   template <>
-  constexpr const char* Type_enum_name<cytnx_uint32> = "Uint32";
+  inline constexpr const char* Type_enum_name<cytnx_uint32> = "Uint32";
   template <>
-  constexpr const char* Type_enum_name<cytnx_int16> = "Int16";
+  inline constexpr const char* Type_enum_name<cytnx_int16> = "Int16";
   template <>
-  constexpr const char* Type_enum_name<cytnx_uint16> = "Uint16";
+  inline constexpr const char* Type_enum_name<cytnx_uint16> = "Uint16";
   template <>
-  constexpr const char* Type_enum_name<cytnx_bool> = "Bool";
+  inline constexpr const char* Type_enum_name<cytnx_bool> = "Bool";
 
   struct Type_struct {
     const char* name;  // char* is OK here, it is only ever initialized from a string literal

src/random/uniform_.cpp

@@ -39,7 +39,7 @@ namespace cytnx {
         if (Tin.dtype() == Type.ComplexDouble) {
           Tin += cytnx_complex128{low, low};
         } else if (Tin.dtype() == Type.ComplexFloat) {
-          Tin += cytnx_complex64{low, low};
+          Tin += cytnx_complex64{static_cast<float>(low), static_cast<float>(low)};
         } else if (Tin.dtype() == Type.Double) {
           Tin += low;
         } else if (Tin.dtype() == Type.Float) {