usearch 0.2.0 → 0.2.3

package/.github/workflows/release.yml

@@ -130,6 +130,17 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  publish_swift:
+    name: Publish ObjC & Swift
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - name: Build
+      run: swift build
+    - name: Run tests
+      run: swift test
+
   deploy_docs:
     name: Deploy Docs
     environment: 

package/.vscode/launch.json

@@ -36,18 +36,19 @@
             }
         },
         {
-            "name": "Debug C++ Bench on Text-to-Image 1M @Cos",
+            "name": "Debug C++ Bench on Text-to-Image 1B @Cos",
             "type": "cppdbg",
             "request": "launch",
             "program": "${workspaceFolder}/build_debug/bench",
             "cwd": "${workspaceFolder}",
             "args": [
                 "--vectors",
-                "datasets/t2i_1M/base.1M.fbin",
+                "datasets/t2i_1B/base.1B.fbin",
                 "--queries",
-                "datasets/t2i_1M/query.public.100K.fbin",
+                "datasets/t2i_1B/query.public.100K.fbin",
                 "--neighbors",
-                "datasets/t2i_1M/groundtruth.public.100K.ibin",
+                "datasets/t2i_1B/groundtruth.public.100K.ibin",
+                "--cos"
             ],
             "environment": [
                 {

package/.vscode/settings.json

@@ -97,7 +97,8 @@
         "__memory": "cpp",
         "filesystem": "cpp",
         "__availability": "cpp",
-        "version": "cpp"
+        "version": "cpp",
+        "future": "cpp"
     },
     "cSpell.words": [
         "astype",

package/CMakeLists.txt

@@ -17,22 +17,18 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -pg -g")
-
 # List of all possible compiler IDs:
 # https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-conversion -Wno-unknown-pragmas")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wno-conversion -Wno-unknown-pragmas")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmax-errors=1")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wfatal-errors")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wfatal-errors")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
 
@@ -46,6 +42,15 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ferror-limit=1")
+
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DEBUG")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /O2 /DEBUG")
+else()
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -pg -g")
 endif()
 
 if(APPLE)

package/CMakeListsInstructions.md

@@ -12,6 +12,7 @@ git submodule update --init --recursive
 
 ```sh
 cmake -B ./build_release \
+    -DCMAKE_CXX_COMPILER="g++-12" \
     -DCMAKE_BUILD_TYPE=Release \
     -DUSEARCH_USE_SIMD=1 \
     -DUSEARCH_USE_OPENMP=1 \
@@ -24,6 +25,14 @@ cmake -B ./build_release \
     --queries datasets/wiki_1M/query.public.100K.fbin \
     --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin
 
+# Large benchmark on a 1TB dataset:
+./build_release/bench \
+    --vectors datasets/t2i_1B/base.1B.fbin \
+    --queries datasets/t2i_1B/query.public.100K.fbin \
+    --neighbors datasets/t2i_1B/groundtruth.public.100K.ibin \
+    --output datasets/t2i_1B/index.usearch \
+    --cos
+
 # To benchmark in Python:
 python python/bench.py \
     --vectors datasets/wiki_1M/base.1M.fbin \
@@ -110,44 +119,57 @@ brew install --cask wolfram-engine
 BigANN benchmark is a good starting point, if you are searching for large collections of high-dimensional vectors.
 Those often come with precomputed ground-truth neighbors, which is handy for recall evaluation.
 
-| Dataset                         | Scalar Type | Dimensions | Metric |  Size  |
-| :------------------------------ | :---------: | :--------: | :----: | :----: |
-| [Microsoft SPACEV][spacev]      |    int8     |    100     |   L2   | 93 GB  |
-| [Microsoft Turing-ANNS][turing] |   float32   |    100     |   L2   | 373 GB |
-| [Yandex Deep1B][deep]           |   float32   |     96     |   L2   | 358 GB |
-| [Yandex Text-to-Image][t2i]     |   float32   |    200     |  Cos   | 750 GB |
+| Dataset                                 | Scalar Type | Dimensions | Metric |   Size    |
+| :-------------------------------------- | :---------: | :--------: | :----: | :-------: |
+| [Unum UForm Wiki][unum-wiki]            |   float32   |    256     |   IP   |   1 GB    |
+| [Yandex Text-to-Image Sample][unum-t2i] |   float32   |    200     |  Cos   |   1 GB    |
+|                                         |             |            |        |           |
+| [Microsoft SPACEV][spacev]              |    int8     |    100     |   L2   |   93 GB   |
+| [Microsoft Turing-ANNS][turing]         |   float32   |    100     |   L2   |  373 GB   |
+| [Yandex Deep1B][deep]                   |   float32   |     96     |   L2   |  358 GB   |
+| [Yandex Text-to-Image][t2i]             |   float32   |    200     |  Cos   |  750 GB   |
+|                                         |             |            |        |           |
+| [ViT-L/12 LAION][laion]                 |   float32   |    2048    |  Cos   | 2 - 10 TB |
 
 Luckily, smaller samples of those datasets are available.
 
+[unum-wiki]: https://huggingface.co/datasets/unum-cloud/ann-wiki-1m
+[unum-t2i]: https://huggingface.co/datasets/unum-cloud/ann-t2i-1m
 [spacev]: https://github.com/microsoft/SPTAG/tree/main/datasets/SPACEV1B
 [turing]: https://learning2hash.github.io/publications/microsoftturinganns1B/
 [t2i]: https://research.yandex.com/blog/benchmarks-for-billion-scale-similarity-search
 [deep]: https://research.yandex.com/blog/benchmarks-for-billion-scale-similarity-search
+[laion]: https://laion.ai/blog/laion-5b/#download-the-data
 
-### Yandex Deep1B
-
-There is a 10M subset available.
+### Unum UForm Wiki
 
 ```sh
-mkdir -p datasets/deep/ && \
-    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.1B.fbin -P datasets/deep_1B/ &&
-    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.10M.fbin -P datasets/deep_1B/ &&
-    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/query.public.10K.fbin -P datasets/deep_1B/ &&
-    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/groundtruth.public.10K.ibin -P datasets/deep_1B/
+mkdir -p datasets/wiki_1M/ && \
+    wget -nc https://huggingface.co/datasets/unum-cloud/ann-wiki-1m/resolve/main/base.1M.fbin -P datasets/wiki_1M/ &&
+    wget -nc https://huggingface.co/datasets/unum-cloud/ann-wiki-1m/resolve/main/query.public.100K.fbin -P datasets/wiki_1M/ &&
+    wget -nc https://huggingface.co/datasets/unum-cloud/ann-wiki-1m/resolve/main/groundtruth.public.100K.ibin -P datasets/wiki_1M/
 ```
 
 ### Yandex Text-to-Image
 
-There is a 1M subset available.
-
 ```sh
-mkdir -p datasets/t2i/ && \
+mkdir -p datasets/t2i_1B/ && \
     wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/base.1B.fbin -P datasets/t2i_1B/ &&
     wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/base.1M.fbin -P datasets/t2i_1B/ &&
     wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/query.public.100K.fbin -P datasets/t2i_1B/ &&
     wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/groundtruth.public.100K.ibin -P datasets/t2i_1B/
 ```
 
+### Yandex Deep1B
+
+```sh
+mkdir -p datasets/deep_1B/ && \
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.1B.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.10M.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/query.public.10K.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/groundtruth.public.10K.ibin -P datasets/deep_1B/
+```
+
 ### Profiling
 
 With `perf`:

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "0.2.0"
+version = "0.2.3"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/Package.swift

@@ -0,0 +1,40 @@
+// swift-tools-version:5.3
+
+import PackageDescription
+
+let package = Package(
+    name: "USearch",
+    products: [
+        .library(
+            name: "USearch",
+            targets: ["USearchObjective", "USearch"]
+        )
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "USearchObjective",
+            path: "objc",
+            sources: ["USearchObjective.mm"],
+            cxxSettings: [
+                .headerSearchPath("../include/"),
+                .headerSearchPath("../src/"),
+                .headerSearchPath("../fp16/include/"),
+                .headerSearchPath("../simismd/include/")
+            ]
+        ),
+        .target(
+            name: "USearch",
+            dependencies: ["USearchObjective"],
+            path: "swift",
+            sources: ["USearch.swift", "Index+Sugar.swift"]
+        ),
+        .testTarget(
+            name: "USearchTests",
+            dependencies: ["USearch"],
+            path: "swift",
+            sources: ["Test.swift"]
+        )
+    ],
+    cxxLanguageStandard: CXXLanguageStandard.cxx11
+)

package/README.md

@@ -17,30 +17,33 @@ Vector Search Engine<br/>
 <a href="https://github.com/unum-cloud/usearch"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/github.svg" alt="GitHub"></a>
 </p>
 
+<p align="center">
+Euclidean • Angular • Jaccard • Hamming • Haversine • User-Defined Metrics
+<br/>
+<a href="#c++">C++11</a> •
+<a href="#python">Python</a> •
+<a href="#javascript">JavaScript</a> •
+<a href="#java">Java</a> •
+<a href="#rust">Rust</a> •
+<a href="#objective-c">Objective-C</a> •
+<a href="#swift">Swift</a> •
+<a href="#golang">GoLang</a> •
+<a href="#wolfram">Wolfram</a>
+<br/>
+Linux • MacOS • Windows
+</p>
+
 - [x] [Single C++11 header][usearch-header] implementation, easily extendible.
 - [x] [4B+](#go-beyond-4b-entries) sized space efficient point-clouds with `uint40_t`.
-- [x] [Half-precision](#quantize-on-the-fly) support with [`maratyszcza/fp16`](https://github.com/maratyszcza/fp16).
+- [x] [Half-precision](#quantize-on-the-fly) support with [`fp16`](https://github.com/maratyszcza/fp16).
 - [x] [View from disk](#view-larger-indexes-from-disk), without loading into RAM.
-- [x] [Any metric](#define-custom-metrics), includes: 
-  - [x] Euclidean, Dot-product, Cosine,
-  - [x] Jaccard, Hamming, Haversine.
-  - [x] Hardware-accelerated [`ashvardanian/simsimd`](https://github.com/ashvardanian/simsimd). 
+- [x] [User-defined](#define-custom-metrics) and hardware-accelerated metrics with [`simsimd`](https://github.com/ashvardanian/simsimd). 
 - [x] Variable dimensionality vectors.
 - [x] Don't copy vectors if not needed.
 - [x] [Bring your threads](#bring-your-threads), like OpenMP.
 - [x] Multiple vectors per label.
-- [x] [Python](#python) bindings: `pip install usearch`.
-- [x] [JavaScript](#java) bindings: `npm install usearch`.
-- [x] [Rust](#rust) bindings: `cargo add usearch`.
-- [x] [Java](#java) bindings: `cloud.unum:usearch` on GitHub.
-- [ ] GoLang bindings.
-- [x] Wolfram language bindings.
-- [x] For Linux: GCC, Clang.
-- [x] For MacOS: Apple Clang.
-- [ ] For Windows.
-- [ ] Multi-index lookups in Python.
 - [ ] Thread-safe `reserve`.
-- [ ] Distributed construction with MPI.
+- [x] Compatible with Linux, MacOS, and Windows.
 - [x] AI + Vector Search = Semantic Search.
 
 [usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/usearch.hpp
@@ -108,7 +111,7 @@ So, if you are working on large datasets, but don't need the in-RAM throughput,
 ### Quantize on the Fly
 
 Most modern CPU have at least partial support for `half`-precision `f16_t` arithmetic.
-USearch supports automatic down-casting and up-casting between `f32_t`, `f16_t`, `f64_t`, and `i8q100_t` representations.
+USearch supports automatic down-casting and up-casting between `f32_t`, `f16_t`, `f64_t`, and `f8_t` representations.
 
 > Making vectors smaller will help pack more of them in-memory, while also increasing performance on CPUs implementing native support for target type.
 
@@ -160,7 +163,7 @@ That can be one of the following templates:
 
 - `cos_gt<float>` for "Cosine" or "Angular" distance.
 - `ip_gt<float>` for "Inner Product" or "Dot Product" distance.
-- `l2_squared_gt<float>` for the squared "L2" or "Euclidean" distance.
+- `l2sq_gt<float>` for the squared "L2" or "Euclidean" distance.
 - `jaccard_gt<int>` for "Jaccard" distance between two ordered sets of unique elements.
 - `bit_hamming_gt<uint>` for "Hamming" distance, as the number of shared bits in hashes.
 - `pearson_correlation_gt<float>` for "Pearson" correlation between probability distributions.
@@ -209,19 +212,21 @@ struct custom_metric_t {
 
 ### Python
 
+```sh
+pip install usearch
+```
+
 Python bindings are implemented with [`pybind/pybind11`](https://github.com/pybind/pybind11).
 Assuming the presence of Global Interpreter Lock in Python, on large insertions we spawn threads in the C++ layer.
 
 ```python
-$ pip install usearch
-
 import numpy as np
-import usearch
+from usearch.index import Index
 
-index = usearch.Index(
+index = Index(
     ndim=256, # Define the number of dimensions in input vectors
     metric='cos', # Choose the "metric" or "distance", default = 'ip', optional
-    dtype='f32', # Quantize to 'f16' or 'i8q100' if needed, default = 'f32', optional
+    dtype='f32', # Quantize to 'f16' or 'f8' if needed, default = 'f32', optional
     connectivity=16, # How frequent should the connections in the graph be, optional
     expansion_add=128, # Control the recall of indexing, optional
     expansion_search=64, # Control the quality of search, optional
@@ -232,6 +237,8 @@ index.add(42, vector)
 matches, distances, count = index.search(vector, 10)
 ```
 
+#### Batch Operations
+
 Same can be done with batches, rather than single entries.
 Under the hood, worker threads will be spawned, to parallelize the procedure.
 
@@ -240,17 +247,31 @@ n = 100
 labels = np.array(range(n), dtype=np.longlong)
 vectors = np.random.uniform(0, 0.3, (n, index.ndim)).astype(np.float32)
 
-# You can avoid copying the data
-# Handy when build 1B+ indexes of memory-mapped files
-index.add(labels, vectors, copy=True)
+index.add(labels, vectors)
 matches, distances, counts = index.search(vectors, 10)
 ```
 
+#### Performance
+
+To maximize performance, you can:
+
+- adjust the number of threads passed to `index.add(threads=)`.
+- downcast to half-precision with `Index(accuracy=)`.
+- JIT-compile your metrics for hardware and pass to `Index(matric_pointer=)`.
+
+For a dataset with 1 Million 256-dimensional embeddings at single precision, the performance would be:
+
+- FAISS: 77'563 vectors/s.
+- USearch precompiled for old hardware: 53'198 vectors/s (-32%).
+- USearch with Numba JIT for target hardware: 88'658 vectors/s (+14%).
+
 ### JavaScript
 
-```js
-// npm install usearch
+```sh
+npm install usearch
+```
 
+```js
 var index = new usearch.Index({ metric: 'cos', connectivity: 16, dimensions: 2 })
 assert.equal(index.connectivity(), 16)
 assert.equal(index.dimensions(), 2)
@@ -266,14 +287,16 @@ assert.deepEqual(results.distances, new Float32Array([45, 130]))
 
 ### Rust
 
+```sh
+cargo add usearch
+```
+
 Being a systems-programming language, Rust has better control over memory management and concurrency, but lacks function overloading.
 Aside from the `add` and `search`, it also provides `add_in_thread` and `search_in_thread` which let users identify the calling thread to use underlying temporary memory more efficiently.
 
 ```rust
-// cargo add usearch
-
 let quant: &str = "f16";
-let index = new_ip(5,  &quant, 0, 0, 0).unwrap();
+let index = new_ip(5, &quant, 0, 0, 0).unwrap();
 
 assert!(index.reserve(10).is_ok());
 assert!(index.capacity() >= 10);
@@ -298,13 +321,23 @@ assert!(index.load("index.usearch").is_ok());
 assert!(index.view("index.usearch").is_ok());
 
 // There are more "metrics" available
-assert!(new_l2(5,  &quant, 0, 0, 0).is_ok());
-assert!(new_cos(5,  &quant, 0, 0, 0).is_ok());
+assert!(new_l2(5, &quant, 0, 0, 0).is_ok());
+assert!(new_cos(5, &quant, 0, 0, 0).is_ok());
 assert!(new_haversine(&quant, 0, 0, 0).is_ok());
 ```
 
 ### Java
 
+```xml
+<dependency>
+  <groupId>cloud.unum.usearch</groupId>
+  <artifactId>usearch</artifactId>
+  <version>0.2.3</version>
+</dependency>
+```
+
+Add that snippet to your `pom.xml` and hit `mvn install`.
+
 ```java
 Index index = new Index.Config().metric("cos").dimensions(2).build();
 float vec[] = {10, 20};
@@ -312,6 +345,19 @@ index.add(42, vec);
 int[] labels = index.search(vec, 5);
 ```
 
+### Swift
+
+```swift
+let index = Index.l2(dimensions: 4, connectivity: 8)
+let vectorA: [Float32] = [0.3, 0.5, 1.2, 1.4]
+let vectorB: [Float32] = [0.4, 0.2, 1.2, 1.1]
+index.add(label: 42, vector: vectorA[...])
+index.add(label: 43, vector: vectorB[...])
+
+let results = index.search(vector: vectorA[...], count: 10)
+assert(results.0[0] == 42)
+```
+
 ### GoLang
 
 ### Wolfram
@@ -400,14 +446,14 @@ One can take an encoder model, like the multi-modal UForm, and a web-programming
 ```python
 import ucall.rich_posix as ucall
 import uform
-import usearch
+from usearch.index import Index
 
 import numpy as np
 from PIL import Image
 
 server = ucall.Server()
 model = uform.get_model('unum-cloud/uform-vl-multilingual')
-index = usearch.Index(ndim=256)
+index = Index(ndim=256)
 
 @server
 def add(label: int, photo: Image.Image):

package/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.3

package/build.gradle

@@ -56,11 +56,15 @@ model {
                 if (targetPlatform.operatingSystem.linux) {
                     cppCompiler.args '-I', "${Jvm.current().javaHome}/include/linux"
                     cppCompiler.args '-D_FILE_OFFSET_BITS=64'
+                    cppCompiler.args '-std=c++11'
                 } else if (targetPlatform.operatingSystem.macOsX) {
                     cppCompiler.args '-I', "${Jvm.current().javaHome}/include/darwin"
                     cppCompiler.args '-D_FILE_OFFSET_BITS=64'
+                    cppCompiler.args '-std=c++11'
+                } else if (targetPlatform.operatingSystem.windows){
+                    cppCompiler.args "-I${Jvm.current().javaHome}/include/win32"
+                    cppCompiler.args '/std:c++11'
                 }
-                cppCompiler.args '-std=c++11'
             }
         }
     }

package/cmake/jemalloc.cmake

@@ -76,5 +76,3 @@ else()
         JEMALLOC_INCLUDE_DIR
     )
 endif()
-
-message("JEMALLOC_LIBRARIES:" ${JEMALLOC_LIBRARIES})

package/conanfile.py

@@ -0,0 +1,19 @@
+from conans import ConanFile
+
+
+class USearchConan(ConanFile):
+
+    name = 'USearch'
+    version = '0.2.3'
+    license = 'Apache 2.0'
+    url = 'https://github.com/unum-cloud/usearch'
+    description = 'Smaller & Faster Single-File Vector Search Engine from Unum'
+
+    # No settings/options are necessary, this is header only
+    # Potentially add unit-tests in the future:
+    # https://docs.conan.io/1/howtos/header_only.html#with-unit-tests
+    exports_sources = 'include/*'
+    no_copy_source = True
+
+    def package(self):
+        self.copy('*.h')