使用以下代码
template <typename T>
concept SomeConcept = requires(T t) {
{ t++ } -> std::convertible_to<T>;
};
该概念SomeConcept确保类型T已重载operator++(int)并且结果类型可转换为T。并std::convertible_to 采用 2 个参数，第一个是From，第二个是To。
所以我的问题是，哪个参数接受表达式的结果以及为什么？根据这个答案，为什么将其T作为另一个参数传递而不是相反？
请提供合适的参考资料来支持答案，最好是来自标准草案。
提前致谢
using声明很常见，适用于包括构造函数在内的其他成员方法，但对于转换运算符来说，似乎不那么简单。GCC 有语法using base::operator base需要介绍，但 Clang 拒绝了。两个编译器都接受声明前向函数，但在我看来这有点复杂。
示例使用 gcc 14.2.0 和 clang 19.1.7、std=c++20 进行了测试。SFINAE 继承被 clang 拒绝。
struct base {
template <typename T> requires (std::is_integral_v<T>)
operator T() const { printf("to int\n"); return 0; }
};
struct derived: base {
//using base::operator; // denied by clang & gcc
//using base::operator base; // denied by clang
template <typename T> requires (std::is_floating_point_v<T>)
operator T() const { printf("to float\n"); return 0; }
// both accept
template <typename T> requires requires { (T) std::declval<base>(); }
operator T() const { return base::operator T(); }
};
derived D;
(int) D; // -> to int
(float) D; // -> to float
我试图测量间接的成本，因为将间接堆叠在一起会降低我试图测量的性能。
为了防止编译器进行任何内联，我将其拆分exe为dll
可执行代码
#include <limits.h>
#include <vector>
#include <chrono>
#include <iostream>
#include <span>
static int foo(int a, std::vector<int>& v) {
v.push_back(a);
if (v.size() > 2)
{
v.clear();
}
return a;
}
struct IFooable
{
virtual int foo(int a) = 0;
};
__declspec(dllimport) int foo2(int a, std::vector<int>& v);
__declspec(dllimport) int direct_version(std::vector<int>& v);
__declspec(dllimport) int indirect_version(int (*fn)(int, void*), void* p);
__declspec(dllimport) int indirect_Interface(IFooable& f);
struct MyFoo final: public IFooable
{
int foo(int a) override
{
return ::foo(a, v);
}
MyFoo(std::vector<int>& v) : v{ v } {}
std::vector<int>& v;
};
struct MyFoo2 final : public IFooable
{
using functype = int (*)(int, std::vector<int>&);
int foo(int a) override
{
return f(a, v);
}
MyFoo2(std::vector<int>& v, functype f) : v{ v }, f{ f } {}
std::vector<int>& v;
functype f;
};
int main(int argc, char* argv[]) {
std::vector<int> v;
for (int i = 0; i < 20; i++)
{
foo(i, v);
}
std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
direct_version(v);
std::chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();
indirect_version([](int a, void* p) {return foo(a, *reinterpret_cast<std::vector<int>*>(p)); }, reinterpret_cast<void*>(&v));
std::chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();
MyFoo ff{ v };
indirect_Interface(ff);
std::chrono::steady_clock::time_point end3 = std::chrono::steady_clock::now();
MyFoo2 ff2{ v, foo2 };
indirect_Interface(ff2);
std::chrono::steady_clock::time_point end4 = std::chrono::steady_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end1 - begin).count() << "[ms] " << "Direct" << std::endl;
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end2 - end1).count() << "[ms] " << "Indirect" << std::endl;
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end3 - end2).count() << "[ms] " << "Virtual" << std::endl;
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end4 - end3).count() << "[ms] " << "Virtual + Indirect" << std::endl;
double micros_count = std::chrono::duration_cast<std::chrono::milliseconds>(end2 - end1).count();
double iterations = INT_MAX;
std::cout << "nanoseconds per iteration = " << (micros_count / iterations) * 1000000 << '\n';
return 0;
}
dll代码
// dllmain.cpp : Defines the entry point for the DLL application.
#include "pch.h"
#include <vector>
#include <span>
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
struct IFooable
{
virtual int foo(int a) = 0;
};
static int foo(int a, std::vector<int>& v) {
v.push_back(a);
if (v.size() > 2)
{
v.clear();
}
return a;
}
__declspec(dllexport) int foo2(int a, std::vector<int>& v) {
v.push_back(a);
if (v.size() > 2)
{
v.clear();
}
return a;
}
__declspec(dllexport) int direct_version(std::vector<int>& v) {
int i, b = 0;
for (i = 0; i < INT_MAX; ++i) {
b = foo(b, v);
}
return b;
}
__declspec(dllexport) int indirect_version(int (*fn)(int, void*), void* p) {
int i, b = 0;
for (i = 0; i < INT_MAX; ++i) {
b = fn(b, p);
}
return b;
}
__declspec(dllexport) int indirect_Interface(IFooable& f) {
int i, b = 0;
for (i = 0; i < INT_MAX; ++i) {
b = f.foo(b);
}
return b;
}
它们是在发布模式下编译的，因此/O2，基准测试的构建方式可以避免任何缓存未命中，并且可能允许 CPU 预测所有函数将指向的位置，因为我对分支预测错误或缓存未命中的成本不感兴趣，而且该函数并不简单，但足够小，并且我已经检查了汇编代码，没有任何内容按预期内联。
结果：
3058[ms] Direct
8279[ms] Indirect
9109[ms] Virtual
7340[ms] Virtual + Indirect
nanoseconds per iteration = 3.85521
正如预期的那样，虚拟函数比间接调用稍微慢一些，但是虚拟+间接调用比任何一个都快......这没有意义。
我的问题是，为什么虚拟函数 + 间接寻址比单独使用任何一个都快？我是否应该实际预期这种级联间接寻址的成本会增加？
使用具有虚函数的 C++ API 包装另一个 DLL 中的 C API 的情况并不少见，因此这个基准尽可能接近现实世界。
交换调用的顺序不会改变任何东西，它们也足够长，以至于任何诸如 CPU 加速和过热以及调度程序之类的因素都不会影响基准。
编辑：看起来缓冲区溢出检查稍微歪曲了结果，这是现在没有那些额外检查的较新的结果。
3051[ms] Direct
6182[ms] Indirect
8002[ms] Virtual
7616[ms] Virtual + Indirect
nanoseconds per iteration = 2.87872
虚拟+间接仍然比仅虚拟更快，这非常奇怪。
我已经在 Visual Studio 2019 中为 Windows 创建了一个简单的 C++ 控制台应用程序，我希望它能够在 Windows 8（不是 8.1）机器上运行。
我已经从Microsoft 的 Windows SDK Archive下载并安装了 Windows 8 SDK 。我可以看到它显然与 8.1 和 10 SDK 一起安装：
现在，当我转到 Visual Studio 中的项目属性时，我没有选择 Windows 8 SDK 的选项：
我尝试在 Windows SDK 版本中手动输入“8.0”，然后将所有内容指向 Windows 8 SDK 目录：
但在编译时我得到：
Error (active) E1696 cannot open source file "stddef.h"
Error (active) E1696 cannot open source file "stdio.h"
Error (active) E1696 cannot open source file "math.h"
(...lots of similar errors...)
Error MSB8036 The Windows SDK version 8.0 was not found. Install the required version of Windows SDK or change the SDK version in the project property pages or by right-clicking the solution and selecting "Retarget solution".
我正在开发一个小型 discord 机器人来处理我和朋友们对电子竞技比赛的友好下注。最近我一直在尝试将比赛的日期和时间添加到：
因此我在 Google 上查找如何做到这一点，最后我得到了一个非常简单的类：
class DateAndTime
{
public:
explicit DateAndTime(const std::string& timeAsString)
{
std::istringstream timeAsStream{ timeAsString };
timeAsStream >> std::get_time(&m_Time, std::string{ DATE_TIME_FORMAT }.c_str());
if (timeAsStream.fail())
{
throw InvalidDateFormat(timeAsString);
}
}
[[nodiscard]] std::string ToString() const noexcept
{
std::stringstream resultAsStream;
resultAsStream << std::put_time(&m_Time, std::string{DATE_TIME_FORMAT}.c_str());
return resultAsStream.str();
}
[[nodiscard]] bool IsInFuture() noexcept
{
const std::time_t dateInSeconds = std::mktime(&m_Time);
const std::chrono::time_point now = std::chrono::system_clock::now();
const std::time_t nowAsSeconds = std::chrono::system_clock::to_time_t(now);
return dateInSeconds > nowAsSeconds;
}
private:
static constexpr std::string_view DATE_TIME_FORMAT = "%d-%m-%Y %H:%M";
std::tm m_Time;
};
由于某种原因，使用相同的字符串作为输入，我不会得到相同的结果，这取决于我是否执行单元测试或机器人本身。
单元测试：
TEST(DateAndTime_Tests, ToString)
{
const DateAndTime test{ "10-01-1995 18:00" };
EXPECT_EQ(test.ToString(), "10-01-1995 18:00");
const DateAndTime test2{ "10-01-1995 18:00:00" };
EXPECT_EQ(test2.ToString(), "10-01-1995 18:00");
const DateAndTime test3{ "01-01-2028 18:00" };
EXPECT_EQ(test3.ToString(), "01-01-2028 18:00");
}
所有结果都是绿色，因此工作正常。
但是，如果我使用日期“01-01-2028 18:00”执行我的 Discord 命令，我会收到此错误消息（提供过去日期时出现的错误）：
用户错误：给定的日期 [12-10-2000 16:42] 是过去的日期。
如您所见，这不是我输入的日期。
起初我以为命令和 DateTime 的构造函数之间出了问题，好像有什么东西改变了输入字符串。但是当我在构造函数中添加断点并检查时，输入字符串是正确的。所以我必须承认我真的不明白发生了什么。
下面的代码总是在任何其他内容之前打印出“Hello from the start”，而在任何其他内容之后打印出“Hello from the end”，这是为什么呢？
代码：
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
__global__ void add1InGPU( int *devArr, int n, int nx )
{
int ix = blockIdx.x * blockDim.x + threadIdx.x;
int iy = blockIdx.y * blockDim.y + threadIdx.y;
int id = nx * iy + ix;
int whateverNum = 5;
if (id == whateverNum) printf("Hello from the start\n");
if ( id < n ) {
devArr[id] += 1;
printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, processing index %d\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y, id );
}
else {
printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, skipped\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y);
}
if (id == whateverNum) printf("Hello from the end\n");
}
int main(void)
{
int* d_arr = NULL;
cudaMalloc(&d_arr, 16 * sizeof(int));
cudaMemset(d_arr, 0, 16 * sizeof(int));
int nElem = 16;
dim3 block( 2, 2 );
dim3 grid( 2, 2 );
// dim3 grid( ( nElem + block.x - 1 ) / block.x );
add1InGPU<<<grid, block>>> ( d_arr, nElem, 4 );
cudaDeviceSynchronize();
int *h_arr = (int*)malloc(16 * sizeof(int));
cudaMemcpy(h_arr, d_arr, 10 * sizeof(int), cudaMemcpyDeviceToHost);
cudaFree(d_arr);
volatile int _ = 0;
for (int i = 0; i < 10; i++) {
_ += h_arr[i];
}
cudaDeviceReset();
return 0;
}
输出：
Hello from the start
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 2
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 3
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 6
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 7
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 8
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 9
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 12
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 13
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 10
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 11
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 14
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 15
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 0
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 1
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 4
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 5
Hello from the end
在编写一些库绑定代码时，我尝试定义基于数组的类型，遇到了一个奇怪的挑战。
考虑如下的枚举：
enum class MyTypes
{
UInt,
Int,
Float
}
利用某些类型特征，我可以将枚举值转换为类型：
template <MyTypes Ty> struct typeify;
template <> struct typeify<MyTypes::UInt> { using type = unsigned int; };
template <> struct typeify<MyTypes::Int> { using type = int; };
template <> struct typeify<MyTypes::Float> { using type = float; };
template <MyTypes Ty> using typeify_t = typename typeify<Ty>::type;
为了帮助绑定，我还有这个（因为 C++ 没有反射）：
inline static constexpr std::array KnownTypes
{
std::pair{"UInt", MyTypes::UInt},
std::pair{"Int", MyTypes::Int},
std::pair{"Float", MyTypes::Float}
};
从这里，我想std::variant根据已知的类型定义一个。
有了 3 个值，显然只需像这样写出变量：
std::variant<unsigned int, int, float>
std::variant但在我的情况中，我有 50 多种类型。因此，我希望有一种方法可以从数组KnownTypes和类型特征中自动生成类型定义typeify_t。
我认为我已经接近以下内容，但由于无法为可变模板参数提供默认值，我受到了困扰：
template <template <typename T, T ... Idx> class temp = std::make_index_sequence<KnownTypes.size()>>
using AnyKnownType = std::variant<typeify_t<KnownTypes[Idx].second>, ...>;
我必须与 С 函数交互，但是此代码无法编译。
// c_enum.h
#pragma once
typedef enum { val1 = 0 } c_style_enum_t;
c_style_enum_t c_func();
// my_class.hpp
#pragma once
extern "С" {
#include "c_enum.h"
}
class my_class {
public:
private:
friend c_style_enum_t ::c_func();
};
Gcc 打印错误：
error: 'enum c_style_enum ' is not a class or namespace
142 | friend c_style_enum ::c_func();
error: ISO C++ forbids declaration of 'c_func' with no type [-fpermissive]
当 c_func() 的返回类型是 int 或除枚举类型之外的其他类型时，此方法有效
如何实现这个功能？
与此处std::aligned_storage页面的示例类似，假设我有以下内容：
template <typename T, std::size_t N>
class SlotArray {
static_assert(!std::is_array_v<T>);
static_assert(!std::is_void_v<T>);
using StorageType = std::aligned_storage_t<sizeof(T), alignof(T)>;
public:
template<typename ...Args>
T* alloc(Args... args) {
std::size_t index = claimIndex();
return ::new(&slots[index]) T(std::forward<Args>(args)...);
}
void free(T* value) {
static_assert(sizeof(std::ptrdiff_t) <= sizeof(std::size_t));
StorageType* storagePtr = reinterpret_cast<StorageType*>(value);
free(storagePtr - slots);
}
void free(std::size_t index) {
std::destroy_at(std::launder(reinterpret_cast<T*>(&slots[index])));
freeIndex(index);
}
private:
std::size_t claimIndex() {
// Get a unique index, doesn't matter here how (say, bitset + throw if empty)
...
}
void freeIndex(std::size_t index) {
...
}
class alignas(T) Storage {
std::byte buffer[sizeof(T)];
};
StorageType slots[N];
};
这里有UB 吗？
成员函数alloc是标准的placement-new，free带有索引参数的成员函数重载是教科书上的std::launder东西。指针算法定义明确。更难验证的部分是reinterpret_cast底层存储类型。除了数组的一些极端情况外，有很多迹象表明placement new的指针类型应该是相同的地址。此外，强制转换的结果显然具有相同的对齐方式，并且实际上指向数组中的某个对象。
当然，这一切都假设用户不会传递一些随机数T*，而只传递从返回的指针alloc。
我在将矩阵.row(i)作为左值引用传递时遇到问题。我认为这应该可以用来解决Eigen::Ref<>，但我遇到了困难。
这篇文章底部的大代码块目前可以正常工作。此代码的概要如下所示：
100% fbatch
47.1% void de_casteljau
44.8% Eigen::internal::dense_assignment_loop::run
4.9% libsystem_malloc.dylib`_free
1.1% libsystem_malloc.dylib`_nanov2_free
< 1% DYLD-STUB$$free
< 1% Eigen::DenseStorage::resize
我相信这Eigen::internal::dense_assignment_loop::run是由代码块最后一个例程中的 for 循环中的临时和复制引起的。（如果我错了，任何优化此代码的帮助都将不胜感激。）
（我很可能是错的，因为这条线似乎不应该这么糟糕。 tmp并不大（3x1 双倍），但复制/分配确实发生了很多。我专注于这个副本，因为我没有看到任何其他fbatch看起来会触发的东西Eigen::internal::dense_assignment_loop::run）
for ( index_type i = 0; i <= n; ++i )
{
de_casteljau( tmp, B_v[ i ], v );
temp_cp.row( i ) = tmp;
}
我想通过将此代码更改为来消除临时和复制
for ( index_type i = 0; i <= n; ++i )
{
de_casteljau( temp_cp.row( i ), B_v[ i ], v );
}
但是，这需要.row( i )作为左值引用传递。clang 抱怨这样的事情......
error: no matching function for call to 'de_casteljau'
note: candidate function [with Derived1 = Eigen::Block<Eigen::Matrix<double, -1, 3>, 1, 3>, Derived2 = Eigen::Map<Eigen::Matrix<double, -1, 3>, 0, Eigen::Stride<1, -1>>] not viable: expects an lvalue for 1st argument
27 | void de_casteljau(Eigen::MatrixBase<Derived1> &p, const Eigen::MatrixBase<Derived2> &cp, const typename Derived2::Scalar &t)
在简单应用时Eigen::Ref，我尝试将第一个函数声明从：
template < typename Derived1, typename Derived2 >
void de_casteljau( Eigen::MatrixBase < Derived1 > & p, const Eigen::MatrixBase < Derived2 > & cp, const typename Derived2::Scalar & t )
到
template < typename Derived1, typename Derived2 >
void de_casteljau( Eigen::Ref < Eigen::MatrixBase < Derived1 > > p, const Eigen::MatrixBase < Derived2 > & cp, const typename Derived2::Scalar & t )
这给了我一个错误，例如：
error: no matching function for call to 'de_casteljau'
note: candidate template ignored: could not match 'Ref' against 'Matrix'
27 | void de_casteljau(Eigen::Ref < Eigen::MatrixBase<Derived1> > p, const Eigen::MatrixBase<Derived2> &cp, const typename Derived2::Scalar &t)
此错误在程序中出现得非常早。理想情况下，我希望以一种de_casteljau不需要修改其许多调用站点的方式修复它。
template < typename Derived1, typename Derived2 >
void de_casteljau( Eigen::MatrixBase < Derived1 > & p, const Eigen::MatrixBase < Derived2 > & cp, const typename Derived2::Scalar & t )
{
// do some checks on incoming matrix dimensions
assert( p.cols() == cp.cols() );
Eigen::Matrix < typename Derived2::Scalar, Eigen::Dynamic, Eigen::Dynamic > Q( cp );
typename Derived2::Scalar oneminust( 1 - t );
typename Derived2::Index k, i;
for ( k = 1; k < Q.rows(); ++k )
{
// Q.topRows( Q.rows() - k ) = oneminust * Q.topRows( Q.rows() - k ) + t * Q.middleRows( 1, Q.rows() - k );
// This for-loop is about 10% faster than equivalent one-liner above.
for ( i = 0; i < Q.rows() - k; ++i )
{
Q.row( i ) = oneminust * Q.row( i ) + t * Q.row( i + 1 );
}
}
p = Q.row( 0 );
}
typedef Eigen::Matrix < data_type, 1, dim__ > point_type;
typedef typename point_type::Index index_type;
typedef Eigen::Map < Eigen::Matrix < data_type, Eigen::Dynamic, dim__ >,
Eigen::Unaligned,
Eigen::Stride < 1, dim__ > > control_point_matrix_type;
typedef Eigen::Map < Eigen::Matrix<data_type, Eigen::Dynamic, dim__ >,
Eigen::Unaligned,
Eigen::Stride < 1, Eigen::Dynamic > > v_dir_control_point_matrix_type;
typedef std::vector < data_type > control_point_container;
typedef std::vector < control_point_matrix_type > u_control_point_matrix_container;
typedef std::vector < v_dir_control_point_matrix_type > v_control_point_matrix_container;
control_point_container point_data; /** raw control points stored in vector. The order is {x,y...}_(0,0) {x,y...}_(1,0) ... {x,y...}_(n,0) {x,y...}_(0,1) {x,y...}_(1,1) ... {x,y...}_(n,1) ... {x,y...}_(n,m) */
u_control_point_matrix_container B_u; /** vector of u-direction, i.e. direction where v is constant, curve control points in point_data */
v_control_point_matrix_container B_v; /** vector of v-direction, i.e. direction where u is constant, curve control points in point_data */
static void resize( u_control_point_matrix_container &uvec, v_control_point_matrix_container &vvec, control_point_container &data, const index_type &u_dim, const index_type &v_dim )
{
// allocate the control points
data.resize( dim__ * ( u_dim + 1 ) * ( v_dim + 1 ) );
// set the B_u and B_v maps
set_Bs( uvec, vvec, data, u_dim, v_dim);
}
static void set_Bs( u_control_point_matrix_container &uvec, v_control_point_matrix_container &vvec, control_point_container &data, index_type n, index_type m )
{
// allocate vectors of control point maps
uvec.resize( m + 1, control_point_matrix_type( nullptr, m + 1, dim__, Eigen::Stride < 1, dim__ > () ) );
for ( index_type j = 0; j <= m; ++j )
{
new ( uvec.data() + j ) control_point_matrix_type( data.data() + j * ( n + 1 ) * dim__, n + 1, dim__, Eigen::Stride < 1, dim__ > () ) ;
}
vvec.resize( n + 1, v_dir_control_point_matrix_type( nullptr, n + 1, dim__, Eigen::Stride < 1, Eigen::Dynamic > ( 1, ( n + 1 ) * dim__ ) ) );
for ( index_type i = 0; i <= n; ++i )
{
new ( vvec.data() + i ) v_dir_control_point_matrix_type( data.data() + i * dim__, m + 1, dim__, Eigen::Stride < 1, Eigen::Dynamic > ( 1, ( n + 1 ) * dim__ ) );
}
}
void set_Bs( index_type n, index_type m )
{
set_Bs( B_u, B_v, point_data, n, m );
}
void fbatch( index_type i0, index_type j0, index_type nu, index_type nv, const std::vector < data_type > &uvec, const std::vector < data_type > &vvec, std::vector < std::vector < point_type > > &ptmat ) const
{
point_type ans, tmp;
Eigen::Matrix < data_type, Eigen::Dynamic, dim__ > temp_cp;
index_type n( degree_u() ), m( degree_v() );
// check to make sure have valid curve
assert( n >= 0 );
assert( m >= 0 );
temp_cp.resize( n + 1, dim__ );
for ( index_type j = 0; j < nv; j++ )
{
data_type v = vvec[ j0 + j ];
// check to make sure given valid parametric value
assert( ( v >= 0 ) && ( v <= 1 ) );
// build the temporary control points
for ( index_type i = 0; i <= n; ++i )
{
de_casteljau( tmp, B_v[ i ], v );
temp_cp.row( i ) = tmp;
}
for (index_type i = 0; i < nu; i++ )
{
data_type u = uvec[ i0 + i ];
// check to make sure given valid parametric value
assert( ( u >= 0 ) && ( u <= 1 ) );
de_casteljau( ptmat[ i + i0 ][ j0 + j ], temp_cp, u );
}
}
}