Perguntas[c++](coding)

usando o seguinte código

template <typename T>
concept SomeConcept = requires(T t) {
    { t++ } -> std::convertible_to<T>;
};

O conceito SomeConceptgarante que o tipo Ttenha sobrecarregado o operator++(int)e o tipo de resultado seja conversível para T. E std::convertible_to recebe 2 parâmetros, o primeiro é From, e o segundo é To.

Então minha pergunta é: qual parâmetro recebe o resultado da expressão e por quê? E com essa resposta, por que ele Té passado como o outro parâmetro e não o contrário?

Por favor, forneça uma referência adequada para respaldar a resposta, de preferência do rascunho padrão, se possível.

desde já, obrigado

usingdeclaração é comum e funciona para outros métodos de membros, incluindo construtor, mas para operador de conversão não parece tão simples. GCC tem sintaxe using base::operator basepara introduzir, que é negada por Clang. Declarar uma função forward é aceito por ambos os compiladores, mas é um pouco complicado na minha opinião.

exemplo foi testado com gcc 14.2.0 e clang 19.1.7, std=c++20. Herança SFINAE rejeitada por 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

Eu estava tentando medir o custo de uma indireção, já que empilhar indireções umas sobre as outras pode degradar o desempenho específico que estou tentando medir.

1. Chamada de função direta (chamar função na mesma DLL diretamente, provavelmente em linha)
2. Chamada de função indireta (chama uma função em outra DLL por meio de um ponteiro, não embutido)
3. chamada de função virtual.
4. chamada de função virtual e, em seguida, uma chamada de função indireta (uma classe polimórfica que contém um ponteiro de função).

Para evitar que o compilador faça qualquer inlining, eu o dividi em um exee umdll

código executável

#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;
}

código 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;
}

elas são compiladas no modo de lançamento, então /O2, o benchmark é construído de uma forma que evita qualquer perda de cache, e provavelmente permite que a CPU preveja para onde todas as funções apontarão, já que não estou interessado no custo de uma previsão incorreta de ramificação ou uma perda de cache, além disso, a função não é trivial, mas suficientemente pequena, e eu verifiquei o assembly e nada está embutido como esperado.

resultado:

3058[ms] Direct
8279[ms] Indirect
9109[ms] Virtual
7340[ms] Virtual + Indirect
nanoseconds per iteration = 3.85521

Uma função virtual é um pouco mais lenta que uma chamada indireta, como esperado, mas uma chamada virtual + indireta é mais rápida que qualquer uma delas... isso não faz sentido.

Minha pergunta é: por que a função virtual + indireção é mais rápida do que qualquer uma delas sozinha? E eu deveria esperar que o custo dessa indireção em cascata aumentasse?

Não é incomum ter uma API C++ com funções virtuais encapsulando uma API C que está em outra DLL, então este benchmark é o mais próximo possível do mundo real.

trocar a ordem das chamadas não muda nada, elas também são longas o suficiente para que qualquer fator como aumento de velocidade da CPU, superaquecimento e agendador não afete o benchmark.

Editar: parece que as verificações de estouro de buffer distorceram um pouco os resultados. Agora, esses são os resultados mais recentes, sem essas verificações extras.

3051[ms] Direct
6182[ms] Indirect
8002[ms] Virtual
7616[ms] Virtual + Indirect
nanoseconds per iteration = 2.87872

ainda virtual + Indireto é mais rápido que apenas virtual, o que é muito estranho.

Criei um aplicativo de console C++ simples para Windows no Visual Studio 2019 e quero que ele possa ser executado em máquinas com Windows 8 (não 8.1).

Baixei e instalei o Windows 8 SDK do Microsoft's Windows SDK Archive . Posso ver que ele está claramente instalado junto com os SDKs 8.1 e 10:

Agora, quando vou para as propriedades do meu projeto no Visual Studio, não tenho a opção de selecionar o SDK do Windows 8:

Tentei inserir manualmente "8.0" na versão do Windows SDK e então apontar tudo para os diretórios do Windows 8 SDK:

Mas ao compilar eu recebo:

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".

O que eu quero fazer

Estou trabalhando em um pequeno bot do Discord para lidar com apostas amigáveis ​​em partidas de ESport com meus amigos. Ultimamente, tenho tentado adicionar a data e o horário das partidas para:

1. Exibir apenas as próximas partidas
2. Não permitir a adição de novas correspondências com datas passadas
3. Exibir como uma string a data e os horários das partidas

O que eu fiz

Então pesquisei no Google como fazer isso e acabei com essa classe muito simples:

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;
};

O problema

Por algum motivo, com a mesma string como entrada, não tenho o mesmo resultado, dependendo se estou executando meus testes de unidade ou o próprio bot.

Os testes unitários:

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");
}

Todos os resultados são verdes, então funciona bem.

Mas se eu executar meu comando do Discord com a data "01-01-2028 18:00" recebo esta mensagem de erro (meu erro ao informar uma data passada):

Erro do usuário: A data fornecida [12-10-2000 16:42] está no passado.

Como você pode ver, não é a data que informei.

Depuração

No começo, pensei que tinha um problema entre o comando e o construtor DateTime, como se algo estivesse alterando a string de entrada. Mas quando verifico adicionar um ponto de interrupção no construtor, a string de entrada está correta. Então, devo admitir que não entendo realmente o que está acontecendo.

O código abaixo sempre imprime "Olá do início" antes de qualquer outra coisa, e "Olá do fim" depois de qualquer outra coisa. Por que isso?

Código:

#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;
}

Saída:

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

Eu me deparei com um desafio estranho ao tentar definir um tipo com base em uma matriz enquanto escrevia um código de vinculação de biblioteca.

Considere uma enumeração como a seguinte:

enum class MyTypes
{
    UInt,
    Int,
    Float
}

Com algumas características de tipo, posso converter um valor da enumeração em um tipo:

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;

Para ajudar com a vinculação, também tenho isso (porque C++ não tem reflexão):

inline static constexpr std::array KnownTypes 
{ 
    std::pair{"UInt", MyTypes::UInt},
    std::pair{"Int", MyTypes::Int},
    std::pair{"Float", MyTypes::Float}
};

A partir daqui, quero definir um std::variantcom base nos meus tipos conhecidos.

Com 3 valores, o óbvio é escrever a variante assim:

std::variant<unsigned int, int, float>

Mas, na minha situação, tenho mais de 50 tipos. Então, eu gostaria de uma maneira de gerar automaticamente a definição de tipo para o std::variantfrom the array of KnownTypese o typeify_ttype trait.

Acho que cheguei perto com o seguinte, mas fiquei bloqueado por não conseguir dar um valor padrão a um parâmetro de modelo variádico:

template <template <typename T, T ... Idx> class temp = std::make_index_sequence<KnownTypes.size()>>
using AnyKnownType = std::variant<typeify_t<KnownTypes[Idx].second>, ...>;

Preciso interagir com uma função С, mas esse código não compila.

// 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 imprime um erro:

 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]

Quando o tipo de retorno de c_func() é int ou algum outro tipo diferente de enum, isso funciona

Como fazer isso funcionar?

Semelhante ao exemplo da std::aligned_storagepágina aqui , imagine que eu tenho o seguinte:

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];
};

Tem algum UB aqui?

A allocfunção membro é o posicionamento-novo padrão e a freesobrecarga da função membro com um parâmetro de índice é std::laundercoisa de livro didático. A aritmética de ponteiro é bem definida. A parte que é mais difícil de verificar é o reinterpret_casttipo de armazenamento subjacente. Fora de alguns casos extremos com matrizes, há muitas indicações de que o tipo de ponteiro do posicionamento novo deve ser o mesmo endereço. Além disso, o resultado da conversão claramente tem o mesmo alinhamento e, na verdade, aponta para algo na matriz.

Certamente, tudo isso pressupõe que o usuário não passe nenhum ponteiro aleatório T*, mas apenas ponteiros retornados de alloc.

Estou com problemas para passar uma matriz .row(i)como uma referência lvalue. Acho que isso deve ser solucionável com Eigen::Ref<>, mas estou com dificuldades.

O grande bloco de código na parte inferior deste post funciona atualmente. Um perfil deste código se parece com isto:

 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

Acredito que isso Eigen::internal::dense_assignment_loop::runseja causado pelo temporário and copy no for-loop na rotina final do bloco de código. (Se eu estiver errado sobre isso, qualquer ajuda para otimizar este código será apreciada.)

(Posso estar errado, pois não parece que essa linha deveria ser tão ruim. tmpNão é grande (3x1 duplo), mas a cópia/atribuição acontece muito. Estou focado nessa cópia porque não vejo mais nada que fbatchpareça que isso seria acionado 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;
    }

Gostaria de eliminar o temporário e copiar alterando este código para

    for ( index_type i = 0; i <= n; ++i )
    {
      de_casteljau( temp_cp.row( i ), B_v[ i ], v );
    }

No entanto, isso requer passar .row( i )como uma referência lvalue. clang reclama com algo assim...

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)

Em uma tentativa simples de aplicar Eigen::Ref, tento alterar a primeira declaração de função de:

template < typename Derived1, typename Derived2 >
void de_casteljau( Eigen::MatrixBase < Derived1 > & p, const Eigen::MatrixBase < Derived2 > & cp, const typename Derived2::Scalar & t )

para

template < typename Derived1, typename Derived2 >
void de_casteljau( Eigen::Ref < Eigen::MatrixBase < Derived1 > > p, const Eigen::MatrixBase < Derived2 > & cp, const typename Derived2::Scalar & t )

O que me dá um erro como:

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)

Esse erro ocorre muito antes no programa. Idealmente, eu gostaria de consertar isso de_casteljaude uma forma que seus muitos sites de chamada não precisem ser modificados.

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 );
    }
  }
}