Set precision cmake

.devcontainer/gpu/devcontainer.json

@@ -31,10 +31,10 @@
 				"python.terminal.activateEnvironment": false,
 				// CAVEAT: you need to restart after building scaluq to take effect.
 				"C_Cpp.default.includePath": [
-					"scaluq",
+					"include",
 					"/usr/local/include/kokkos",
-					"build/_deps/eigen_fetch-src",
-					"build/_deps/googletest_fetch-src/googletest/include",
+					"build/_deps/eigen-src",
+					"build/_deps/googletest-src/googletest/include",
 					"~/.local/lib/python3.10/site-packages/nanobind/include",
 					"/usr/include/python3.10"
 				],

.github/workflows/install.yml

@@ -0,0 +1,160 @@
+name: Install to System
+
+on:
+  push:
+    paths-ignore:
+      - ".devcontainer/**"
+      - ".vscode/**"
+      - "doc/**"
+      - "*.md"
+  pull_request:
+    paths-ignore:
+      - ".devcontainer/**"
+      - ".vscode/**"
+      - "doc/**"
+      - "*.md"
+
+jobs:
+  library:
+    name: Install Library
+    strategy:
+      matrix:
+        os: ["linux", "macos"]
+        architecture: ["x86_64", "arm64"]
+        device: ["cpu", "cuda"]
+        python-version: ["3.10"]
+        exclude:
+          - os: "macos"
+            device: "cuda"
+          # currently ARM runner is not supported
+          - os: "linux"
+            architecture: "arm64"
+        include:
+          - os: "linux"
+            architecture: "x86_64"
+            runs-on: "ubuntu-22.04"
+          - os: "macos"
+            architecture: "x86_64"
+            runs-on: "macos-13"
+          - os: "macos"
+            architecture: "arm64"
+            runs-on: "macos-14"
+    runs-on: ${{ matrix.runs-on }}
+    env:
+      CMAKE_C_COMPILER: ${{ matrix.runs-on == 'macos-13' && '/usr/local/opt/ccache/libexec/gcc-14'|| matrix.runs-on == 'macos-14' && '/opt/homebrew/opt/ccache/libexec/gcc-14' || '/usr/lib/ccache/gcc' }}
+      CMAKE_CXX_COMPILER: ${{ matrix.runs-on == 'macos-13' && '/usr/local/opt/ccache/libexec/g++-14'|| matrix.runs-on == 'macos-14' && '/opt/homebrew/opt/ccache/libexec/g++-14' || '/usr/lib/ccache/g++' }}
+      SCALUQ_USE_CUDA: ${{ matrix.device == 'cuda' && 'ON' || 'OFF' }}
+      SCALUQ_CUDA_ARCH: "PASCAL61"
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Ninja
+        if: ${{ matrix.os == 'linux' }}
+        run: sudo apt update && sudo apt install ninja-build
+
+      - name: Install Ninja
+        if: ${{ matrix.os == 'macos' }}
+        run: brew install ninja
+
+      - name: Setup ccache
+        uses: hendrikmuhs/[email protected]
+        with:
+          key: "${{ github.job }}-${{ matrix.os }}-${{ matrix.architecture }}-${{ matrix.device }}"
+          verbose: 2
+
+      - name: Install CUDA toolkit
+        if: ${{ matrix.device == 'cuda' }}
+        uses: Jimver/[email protected]
+        with:
+          cuda: "12.2.0"
+          method: "network"
+
+      - name: Show installed Compiler version
+        run: |
+          [ $SCALUQ_USE_CUDA = 'ON' ] && nvcc --version
+          ccache --version
+          $CMAKE_C_COMPILER --version
+          $CMAKE_CXX_COMPILER --version
+          cmake --version
+          ninja --version
+
+      - name: Configure
+        run: ./script/configure
+
+      - name: Install to system
+        run: sudo ninja -C build install
+
+      - name: Build and Run other project
+        run: |
+          cd example_project/
+          cmake -B build/ -D "CMAKE_C_COMPILER=$CMAKE_C_COMPILER" -D "CMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER"
+          make -C build
+          if [ "$SCALUQ_USE_CUDA" != 'ON']; then
+            build/main
+          fi
+
+  python:
+    name: Install Python package
+    strategy:
+      matrix:
+        os: ["linux", "macos"]
+        architecture: ["x86_64", "arm64"]
+        device: ["cpu", "cuda"]
+        python-version: ["3.10"]
+        exclude:
+          - os: "macos"
+            device: "cuda"
+          # currently ARM runner is not supported
+          - os: "linux"
+            architecture: "arm64"
+        include:
+          - os: "linux"
+            architecture: "x86_64"
+            runs-on: "ubuntu-22.04"
+          - os: "macos"
+            architecture: "x86_64"
+            runs-on: "macos-13"
+          - os: "macos"
+            architecture: "arm64"
+            runs-on: "macos-14"
+    runs-on: ${{ matrix.runs-on }}
+    env:
+      CMAKE_C_COMPILER: ${{ matrix.runs-on == 'macos-13' && '/usr/local/opt/ccache/libexec/gcc-14'|| matrix.runs-on == 'macos-14' && '/opt/homebrew/opt/ccache/libexec/gcc-14' || '/usr/lib/ccache/gcc' }}
+      CMAKE_CXX_COMPILER: ${{ matrix.runs-on == 'macos-13' && '/usr/local/opt/ccache/libexec/g++-14'|| matrix.runs-on == 'macos-14' && '/opt/homebrew/opt/ccache/libexec/g++-14' || '/usr/lib/ccache/g++' }}
+      SCALUQ_USE_CUDA: ${{ matrix.device == 'cuda' && 'ON' || 'OFF' }}
+      SCALUQ_CUDA_ARCH: "PASCAL61"
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup ccache
+        uses: hendrikmuhs/[email protected]
+        with:
+          key: "${{ github.job }}-${{ matrix.os }}-${{ matrix.architecture }}-${{ matrix.device }}"
+          verbose: 2
+
+      - name: Install CUDA toolkit
+        if: ${{ matrix.device == 'cuda' }}
+        uses: Jimver/[email protected]
+        with:
+          cuda: "12.2.0"
+          method: "network"
+
+      - name: Show installed Compiler version
+        run: |
+          [ $SCALUQ_USE_CUDA = 'ON' ] && nvcc --version
+          ccache --version
+          $CMAKE_C_COMPILER --version
+          $CMAKE_CXX_COMPILER --version
+
+      - name: Install mypy
+        run: pip install mypy
+
+      - name: Install to system
+        run: pip install .
+
+      - name: Run / Test stub
+        if: ${{ matrix.device == 'cpu' }} # currently GPU runner is not supported
+        run: |
+          echo -e "from scaluq import StateVector, gate\nstate = StateVector(2)\nx = gate.X(0)\nx.update_quantum_state(state)\nprint(state.get_amplitudes())" > /tmp/sample.py
+          python3 /tmp/sample.py
+          mypy /tmp/sample.py

.gitignore

@@ -43,3 +43,4 @@
 /doc/build/
 /python/scaluq/_version.py
 /kokkos-tools
+/example_project/build/

CMakeLists.txt

@@ -12,10 +12,10 @@ if(NOT DEFINED SCALUQ_USE_CUDA)
     set(SCALUQ_USE_CUDA OFF)
 endif(NOT DEFINED SCALUQ_USE_CUDA)
 if(NOT DEFINED SCALUQ_USE_TEST)
-    set(SCALUQ_USE_TEST ON)
+    set(SCALUQ_USE_TEST OFF)
 endif(NOT DEFINED SCALUQ_USE_TEST)
 if(NOT DEFINED SCALUQ_USE_EXE)
-    set(SCALUQ_USE_EXE ON)
+    set(SCALUQ_USE_EXE OFF)
 endif(NOT DEFINED SCALUQ_USE_EXE)
 
 message(STATUS "SKBUILD = ${SKBUILD}")
@@ -135,7 +135,7 @@ if ((${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") OR (${CMAKE_CXX_COMPILER_ID} STREQ
 endif()
 
 ### Add subdirectories ###
-add_subdirectory(scaluq)
+add_subdirectory(src)
 if(SKBUILD)
     add_subdirectory(python)
 endif(SKBUILD)

example_project/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.21)
+
+project(example)
+
+find_package(scaluq)
+find_package(OpenMP)
+add_executable(main main.cpp)
+target_include_directories(main PUBLIC /usr/local/include/scaluq)
+target_include_directories(main PUBLIC /usr/local/include/kokkos)
+target_include_directories(main PUBLIC /usr/local/include/eigen3)
+target_compile_features(main PUBLIC cxx_std_20)
+target_compile_options(main PUBLIC -fopenmp)
+target_compile_definitions(main PUBLIC OPENMP)
+target_link_libraries(main PUBLIC scaluq::scaluq)
+

example_project/main.cpp

@@ -0,0 +1,10 @@
+#include <scaluq/state/state_vector.hpp>
+
+int main() {
+    scaluq::initialize();
+    {
+        scaluq::StateVector<double> state(2);
+        std::cout << state << std::endl;
+    }
+    scaluq::finalize();
+}

exe/CMakeLists.txt

@@ -10,7 +10,7 @@ function(exe name)
     if (SCALUQ_USE_TEST)
         target_link_libraries(${name} PRIVATE GTest::gtest_main)
     endif(SCALUQ_USE_TEST)
-    target_include_directories(${name} PRIVATE ${PROJECT_SOURCE_DIR}/scaluq)
+    target_include_directories(${name} PRIVATE ${PROJECT_SOURCE_DIR}/include)
 endfunction()
 
 # exe({file}) を追加すると、{file}.cpp をコンパイルして実行ファイルを build/exe/{file} として生成する

exe/main.cpp

@@ -2,13 +2,12 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <scaluq/state/state_vector.hpp>
 #include <sstream>
 #include <stdexcept>
 #include <type_traits>
 #include <vector>
 
-#include "gate/gate_factory.hpp"
-
 using Fp = float;
 
 int main() {
@@ -17,12 +16,14 @@ int main() {
         std::uint64_t n_qubits = 3;
         scaluq::StateVector<Fp> state(n_qubits);
         state.load({0, 1, 2, 3, 4, 5, 6, 7});
+        /*
         auto x_gate = scaluq::gate::X<Fp>(1, {0, 2});
         x_gate->update_quantum_state(state);
         auto sqrtx_gate = scaluq::gate::SqrtX<Fp>(1, {0});
         sqrtx_gate->update_quantum_state(state);
         auto sqrtxdag_gate = scaluq::gate::SqrtXdag<Fp>(0);
         sqrtxdag_gate->update_quantum_state(state);
+        */
 
         std::cout << state << std::endl;
     }

scaluq/all.hpp → include/scaluq/all.hpp

@@ -4,11 +4,9 @@
 #include "constant.hpp"
 #include "gate/gate.hpp"
 #include "gate/gate_factory.hpp"
-#include "gate/merge_gate.hpp"
 #include "gate/param_gate.hpp"
 #include "gate/param_gate_factory.hpp"
-#include "gate/update_ops.hpp"
-#include "operator/apply_pauli.hpp"
+#include "kokkos.hpp"
 #include "operator/operator.hpp"
 #include "operator/pauli_operator.hpp"
 #include "state/state_vector.hpp"