Array3d Analysis::getParticleFluxKy(int sp)
{
Array3d G(RFields, RkyLD, RsLD); G = 0.;
Array3z V2(RxLD, RkyLD, RzLD); V2 = 0.;
Array3z W2(RxLD, RkyLD, RzLD); W2 = 0.;
for(int s = NsLlD; s <= NsLuD; s++) {
const double d6Z = M_PI * plasma->species(s).n0 * plasma->species(s).T0 * plasma->B0 * dv * dm * scaleXYZ;
for(int m=NmLlD; m<= NmLuD;m++ ) { for(int z=NzLlD; z<= NzLuD;z++){
// multiply in real-space
for(int x=NxLlD; x <= NxLuD ; x++) { for(int y_k=NkyLlD; y_k<= NkyLuD;y_k++) {
const cmplxd ky=cmplxd(0.,-fft->ky(y_k));
V2(x,y_k,z) = ky * fields->phi(x,y_k,z,m,s);
// integrate over velocity space
W2(x,y_k,z) = sum(vlasov->f(x, y_k, z, RvLD, m, s)) * d6Z;
}}
// V2(RxLD, RkyLD, RzLD) =
fft->multiply(V2, W2, A_xyz);
// sum over x and z
for(int x=NxLlD; x <= NxLuD ; x++) { G(Field::phi, RkyLD, s) += abs(A_xyz(x, RkyLD,z)) ; }
} }
}
return parallel->collect(G);
};
static void
initialize_data(uint32_t memsize,
uint32_t num_particles_x, uint32_t num_particles_y,
uint32_t num_levels, uint32_t num_coeffs)
{
uint32_t num_particles = num_particles_x * num_particles_y;
memory.free_memory = (uint8_t*)calloc(memsize, 1);
memory.free_memory_size = memsize;
data.positions = push_array(v2, num_particles);
data.velocities = push_array(v2, num_particles);
data.forces = push_array(v2, num_particles);
data.num_particles = num_particles;
/* initialize equidistant grid */
v2 min_corner = V2(0, 0);
v2 max_corner = V2(1, 1);
v2 dim = max_corner - min_corner;
float dx = dim.x / num_particles_x;
float dy = dim.y / num_particles_y;
uint32_t idx = 0;
for(uint32_t j = 0; j < num_particles_y; j++) {
for(uint32_t i = 0; i < num_particles_x; i++) {
data.positions[idx] =
min_corner + V2(i * dx, j * dy);
data.velocities[idx] = V2(0,0);
idx++;
}
}
data.dim = dim;
data.num_levels = num_levels;
data.num_coeffs = num_coeffs;
v2 half_dim = 0.5f * data.dim;
initialize_quad_tree(&data.root_cell, half_dim, half_dim,
num_levels, num_coeffs);
}
//**********************************************************************************
//
//**********************************************************************************
void CMessageBox::SetText( const CString & text )
{
m_pText->SetText( text );
V2 text_size( m_pText->GetSize() + ( 2.f * BOX_BORDER ) );
if ( text_size.x < CFont::GetDefaultFont()->GetStringSize( m_szTitle ).x + ( 2.f * BOX_BORDER.x ) )
{
text_size.x = CFont::GetDefaultFont()->GetStringSize( m_szTitle ).x + ( 2.f * BOX_BORDER.x );
}
SetPos( V2( 0.5f * ( CGfx::s_ScreenWidth - text_size.x ), 0.5f * ( CGfx::s_ScreenHeight - text_size.y ) ) );
SetSize( text_size );
}
/**
* Display options menu.
* Menu will be centred on screen.
*/
void
MenuOptions::own_resumeState()
{
int contentW = m_container->getW();
int contentH = m_container->getH();
OptionAgent *options = OptionAgent::agent();
int screenW = options->getAsInt("screen_width");
int screenH = options->getAsInt("screen_height");
/*FFNG*///FFNGApp::setGameState(FFNGApp::GAMESTATE_OPTIONS); until I figure out how to get it back to previous state
m_container->setShift(
V2((screenW - contentW) / 2, (screenH - contentH) / 2));
}
bool TestParserStmt::TestClassVariable() {
V("<?php class Test { public $data;}",
"class Test {\npublic $data;\n}\n");
V("<?php class Test { protected $data;}",
"class Test {\nprotected $data;\n}\n");
V("<?php class Test { private $data;}",
"class Test {\nprivate $data;\n}\n");
V("<?php class Test { static $data;}",
"class Test {\npublic static $data;\n}\n");
V("<?php class Test { private static $data;}",
"class Test {\nprivate static $data;\n}\n");
V("<?php class Test { private static $data=2;}",
"class Test {\nprivate static $data = 2;\n}\n");
V2("<?php class Test { var $data,$data2;}",
"class Test {\npublic $data, $data2;\n}\n",
"class Test {\npublic $data;\npublic $data2;\n}\n");
V2("<?php class Test { var $data,$data2=2;}",
"class Test {\npublic $data, $data2 = 2;\n}\n",
"class Test {\npublic $data;\npublic $data2 = 2;\n}\n");
V2("<?php class Test { var $data=2,$data2;}",
"class Test {\npublic $data = 2, $data2;\n}\n",
"class Test {\npublic $data = 2;\npublic $data2;\n}\n");
V2("<?php class Test { var $data=2,$data2=3;}",
"class Test {\npublic $data = 2, $data2 = 3;\n}\n",
"class Test {\npublic $data = 2;\npublic $data2 = 3;\n}\n");
return true;
}
//-----------------------------------------------------------------
void
InputAgent::installHandler(InputHandler *handler)
{
if (m_handler) {
m_handler->takePressed(NULL);
m_handler->mouseState(V2(-1, -1), 0);
}
m_handler = handler;
if (m_handler) {
m_handler->takePressed(m_keys);
Uint8 buttons;
V2 mouseLoc = getMouseState(&buttons);
m_handler->mouseState(mouseLoc, buttons);
}
}
void test_op()
{
Point_E3d P1(3.0,4.0,5.0);
Point_E3d P2(4.0,7.0,9.0);
Vector_E3d V1(8.0,4.0,2.0);
Point_E3d A1 = P1;
A1 += V1;
assert( Point_E3d(11.0,8.0,7.0) == A1 );
A1 -= V1;
assert( P1 == A1 );
Vector_E3d V2(P1, P2);
assert( Vector_E3d(1.0, 3.0, 4.0) == V2 );
}
// note the hear flux rate have to be calculted after getkinetic energy
// this should go hand-in-hand with the temperature calculation
Array4z Analysis::getHeatFlux(int sp)
{
A4_z = 0.;
Array3z V2(RxLD, RkyLD, RzLD);
Array3z W2(RxLD, RkyLD, RzLD);
//for(int s = ((sp == TOTAL) ? NsLlD : sp); s <= NsLuD && ((sp != TOTAL) ? s == sp : true) ; s++) {
// for(int s = ((sp == TOTAL) ? NsLlD : sp); (s <= ((sp == TOTAL) ? NsLuD : sp)) && ( (sp >= NsLlD) && (sp <= NsLuD)) ; s++) {
for(int s = NsLlD; s <= NsLuD; s++) {
const double d6Z = M_PI * plasma->species(s).n0 * plasma->species(s).T0 * plasma->B0 * dv * dm * scaleXYZ;
for(int m=NmLlD; m<= NmLuD;m++ ) {
V2 = 0.; W2 = 0.;
// multiply in real-space
for(int z=NzLlD; z<= NzLuD;z++){ for(int x=NxLlD; x <= NxLuD ; x++) { for(int y_k=NkyLlD; y_k<= NkyLuD;y_k++) {
const cmplxd ky=cmplxd(0.,-fft->ky(y_k));
V2(x,y_k,z) = ky * fields->phi(x,y_k,z,m,s);
// integrate over velocity space
for(int v=NvLlD; v<= NvLuD;v++) W2(x,y_k,z) += (pow2(V(v)) + M(m) * plasma->B0) * vlasov->f(x, y_k, z, v, m, s) * d6Z;
}}}
A4_z(RxLD, RkyLD, RzLD,s) = fft->multiply(V2, W2, A_xyz);
} }
return parallel->collect(A4_z, OP_SUM, DIR_VM);
};
static void
reset_leave_nodes(struct cell *this_)
{
if(this_ == 0)
return;
else if(this_->childs[0] == 0) {
for(uint32_t i = 0; i < data.num_coeffs; i++) {
this_->a[i] = V2(0,0);
}
}
for(uint32_t i = 0; i < 4; i++) {
reset_leave_nodes(this_->childs[i]);
}
}
// preserve orientation of the most anisotropic metric !!!
SMetric3 intersection_conserve_mostaniso (const SMetric3 &m1, const SMetric3 &m2)
{
fullMatrix<double> V1(3,3);
fullVector<double> S1(3);
m1.eig(V1,S1,true);
double ratio1 = fabs(S1(0)/S1(2)); // Minimum ratio because we take sorted eigenvalues
fullMatrix<double> V2(3,3);
fullVector<double> S2(3);
m2.eig(V2,S2,true);
double ratio2 = fabs(S2(0)/S2(2)); // Minimum ratio because we take sorted eigenvalues
if (ratio1 < ratio2)
return intersection_conserveM1(m1, m2);
else
return intersection_conserveM1(m2, m1);
}
static Standard_Boolean TriangleIsValid(const gp_Pnt& P1, const gp_Pnt& P2, const gp_Pnt& P3)
{
gp_Vec V1(P1,P2);
gp_Vec V2(P2,P3);
gp_Vec V3(P3,P1);
if ((V1.SquareMagnitude() > 1.e-10) && (V2.SquareMagnitude() > 1.e-10) && (V3.SquareMagnitude() > 1.e-10)) {
V1.Cross(V2);
if (V1.SquareMagnitude() > 1.e-10)
return Standard_True;
else
return Standard_False;
}
else
return Standard_False;
}
Standard_Boolean Surface::triangleIsValid(const gp_Pnt& P1, const gp_Pnt& P2, const gp_Pnt& P3)
{
gp_Vec V1(P1,P2); // V1=(P1,P2)
gp_Vec V2(P2,P3); // V2=(P2,P3)
gp_Vec V3(P3,P1); // V3=(P3,P1)
if ((V1.SquareMagnitude() > 1.e-10) && (V2.SquareMagnitude() > 1.e-10) && (V3.SquareMagnitude() > 1.e-10))
{
gp_Vec normal = V1.Crossed(V2) + V2.Crossed(V3) + V3.Crossed(V1);
if (normal.SquareMagnitude() > 1.e-10)
return Standard_True;
else
return Standard_False;
}
return Standard_False;
}
void SmtWater::UpdateNormal()
{
//new mem
Vector3 *pNormals = new Vector3[CST_INT_GRID_SIZE];
//calculator normal
for( int iY=0; iY<CST_INT_GRID_HEIGHT - 1; iY++ )
{
for(int iX=0; iX<CST_INT_GRID_WIDTH - 1; iX++ )
{
int P1,P2,P3,P4;
P1 = (iY * CST_INT_GRID_WIDTH) + iX;
P2 = ((iY + 1) * CST_INT_GRID_WIDTH) + iX;
P3 = P1 + 1;
P4 = P2 + 1;
Vector4 V1(wvertex[P1].x,wvertex[P1].y,wvertex[P1].z),
V2(wvertex[P2].x,wvertex[P2].y,wvertex[P2].z),
V3(wvertex[P3].x,wvertex[P3].y,wvertex[P3].z),
V4(wvertex[P4].x,wvertex[P4].y,wvertex[P4].z);
Vector4 nor1 = GalcTriangleNormal(V1, V3, V2);
Vector4 nor2 = GalcTriangleNormal(V3, V4, V2);
pNormals[P1] += nor1;
pNormals[P2] += nor1;
pNormals[P3] += nor1;
pNormals[P2] += nor2;
pNormals[P3] += nor2;
pNormals[P4] += nor2;
}
}
//normalize
for(long i=0; i < CST_INT_GRID_SIZE; i++)
{
pNormals[i].Normalize();
wvertex[i].nx = pNormals[i].x;
wvertex[i].ny = pNormals[i].y;
wvertex[i].nz = pNormals[i].z;
}
SMT_SAFE_DELETE_A(pNormals);
}
internal void
DEBUGTextLine(char *String) {
debug_state *DebugState = DEBUGGetState();
if (DebugState) {
render_group *RenderGroup = DebugState->RenderGroup;
loaded_font *Font = PushFont(RenderGroup, DebugState->FontID);
if (Font) {
hha_font *Info = GetFontInfo(RenderGroup->Assets, DebugState->FontID);
DEBUGTextOutAt(V2(DebugState->LeftEdge,
DebugState->AtY - DebugState->FontScale * GetStartingBaselineY(DebugState->DebugFontInfo)), String);
DebugState->AtY -= GetLineAdvanceFor(Info) * DebugState->FontScale;
} else {
}
}
}
void testgammagap()
{
unsigned int n = 512*1024+199481101;
std::vector<uint64_t> V (n);
std::vector<uint64_t> V2(n);
for ( uint64_t i = 0; i < V.size(); ++i )
{
V[i] = i & 0xFFull;
V2[i] = rand() % 0xFFull;
}
std::string const fn("tmpfile");
std::string const fn2("tmpfile2");
std::string const fnm("tmpfile.merged");
::libmaus::util::TempFileRemovalContainer::setup();
::libmaus::util::TempFileRemovalContainer::addTempFile(fn);
::libmaus::util::TempFileRemovalContainer::addTempFile(fn2);
::libmaus::util::TempFileRemovalContainer::addTempFile(fnm);
::libmaus::gamma::GammaGapEncoder GGE(fn);
GGE.encode(V.begin(),V.end());
::libmaus::gamma::GammaGapEncoder GGE2(fn2);
GGE2.encode(V2.begin(),V2.end());
::libmaus::huffman::IndexDecoderData IDD(fn);
::libmaus::gamma::GammaGapDecoder GGD(std::vector<std::string>(1,fn));
bool ok = true;
for ( uint64_t i = 0; i < n; ++i )
{
uint64_t const v = GGD.decode();
ok = ok && (v == V[i]);
}
std::cout << "decoding " << (ok ? "ok" : "fail") << std::endl;
std::vector < std::vector<std::string> > merin;
merin.push_back(std::vector<std::string>(1,fn));
merin.push_back(std::vector<std::string>(1,fn2));
::libmaus::gamma::GammaGapEncoder::merge(merin,fnm);
}
/*!
* Добавление в базу информации о версии, в будущем эта информация может быть использована для автоматического обновления схемы базы данных.
*/
void HistoryDB::version()
{
QSqlQuery query(QSqlDatabase::database(m_id));
query.exec(LS("PRAGMA user_version"));
if (!query.first())
return;
qint64 version = query.value(0).toLongLong();
if (!version) {
query.exec(LS("PRAGMA user_version = 4"));
version = 4;
return;
}
query.finish();
if (version == 1) version = V2();
if (version == 2) version = V3();
if (version == 3) version = V4();
}
void dataset::calc_dist(REALNUM_TYPE rtDef, REALNUM_TYPE metricV, UNSIGNED_1B_TYPE metricKind)
//metricKind: 0 - Euclidean, 1 - Cosine-based, 2 - Correlation coff, 3 - Tanimoto
//all coefficients are turned into distances in a way of = 1 - (coff)^metricV
{
UNSIGNED_4B_TYPE i, i1, j, N = patt.RowNO(), D = patt.ColNO();
dist.SetSize(N, N);
apvector<REALNUM_TYPE> V1(D), V2(D);
for (i = 0; i < N; i++)
{
for (j = 0; j < D; j++) V1[j] = patt(i, j);
dist(i,i) = rtDef;
for (i1 = i + 1; i1 < N; i1++)
{
for (j = 0; j < D; j++) V2[j] = patt(i1, j);
dist(i, i1) = dist(i1, i) = getMetricDistance(V1, V2, metricV, metricKind);
}//for i1
}//for i
calc_dist_pars();
}
int main() {
// refaire les tests de Darray
// Test de Dvector par héritage
Dvector V1(5, 3.0);
std::cout << "V1" << std::endl;
V1.display(std::cout);
Dvector V2(V1);
std::cout << "V2" << std::endl;
V2.display(std::cout);
Dvector V3(5);
std::cout << "V3" << std::endl;
V3.display(std::cout);
Dvector V4;
std::cout << "V4" << std::endl;
V4.display(std::cout);
double d = V1*V3;
std::cout << "d = " << d << std::endl;
}
int get_block_size()
{
char buf[255];
int len,lba=0,bsize=0;
read_capacity(&lba,&bsize);
len=255;
if (mode_sense(buf,&len)==0 && buf[3]>=8) {
return V3(&buf[4+5]);
}
if (mode_sense10(buf,&len)==0 && V2(&buf[6])>=8) {
return V3(&buf[8+5]);
}
if (read_capacity(&lba,&bsize)==0) {
return bsize;
}
return -1;
}
//**********************************************************************************
//
//**********************************************************************************
void CBackground::Render()
{
if ( s_bPBPFadeIn == true )
{
s_PBPFadeAlpha += 8;
SETMAX( s_PBPFadeAlpha, 0xff );
}
else
{
s_PBPFadeAlpha -= 8;
if ( s_PBPFadeAlpha < 0 )
{
SAFE_DELETE( s_pPBPIconTexture );
}
SETMIN( s_PBPFadeAlpha, 0x00 );
}
if ( s_pPBPIconTexture != NULL )
{
CGfx::DrawQuad( s_pPBPIconTexture, V2( 0.f, 0.f ), V2( CGfx::s_ScreenWidth, CGfx::s_ScreenHeight ), ARGB( s_PBPFadeAlpha, 0x80, 0x80, 0x80 ) );
}
CTexture * p_background_texture( s_pBackgroundTexture );
if ( CSkinManager::GetComponent( CSkinManager::SC_BACKGROUND )->GetTexture() != NULL )
{
p_background_texture = CSkinManager::GetComponent( CSkinManager::SC_BACKGROUND )->GetTexture();
}
if ( p_background_texture == NULL )
{
CGfx::DrawQuad( V2( 0.f, 0.f ), V2( CGfx::s_ScreenWidth, CGfx::s_ScreenHeight ), 0x00000000 );
}
else
{
CGfx::DrawQuad( p_background_texture, V2( 0.f, 0.f ), V2( CGfx::s_ScreenWidth, CGfx::s_ScreenHeight ), ARGB( 0xff - s_PBPFadeAlpha, 0xff, 0xff, 0xff ) );
}
for ( u32 i = 0; i < NUM_STRIPS; ++i )
{
RenderStrip( s_StripInfo[ i ] );
}
}
/*
* NOTE: When this function returns, we have multipole moments for all
* cells in the tree.
*/
static void
calculate_multipoles()
{
/*
* TODO: Clear all a to (0,0). We are doing this for all
* non-leaf nodes in the upward pass already. We need a good way to do this
* efficiently - maybe in the downward pass? For now we just use a little
* helper function.
*/
reset_leave_nodes(&data.root_cell);
for(uint32_t i = 0; i < data.num_particles; i++) {
v2 pos = data.positions[i];
struct cell *residence = find_residence(&data.root_cell, pos);
residence->a[0] += V2(1, 0);
for(uint32_t k = 1; k < data.num_coeffs; k++) {
/* TODO: make this faster (don't use pow, precompute 1/k) */
residence->a[k] -= pow(pos - residence->center, k) / (float)k;
}
}
accumulate_cell_multipoles(&data.root_cell);
}
int main(int argc, char *argv[])
{
std::cout << "///////////////////// POINT //////////////////////////////////" << std::endl;
Point newPoint(0,1,2);
std::cout << "x : " << newPoint.x() << std::endl;
std::cout << "y : " << newPoint.y() << std::endl;
std::cout << "z : " << newPoint.z() << std::endl;
newPoint.setY(5);
Point pointB;
std::cout << "y : " << pointB.y() << std::endl;
if (! newPoint.isNotEqual(pointB))
std::cout << "equal" << std::endl;
else
std::cout << "nonEqual" << std::endl;
std::cout << "///////////////////// VECTOR //////////////////////////////////" << std::endl;
Vector newVector, vect;
newVector.setCoordonne(-8.0, 5.0, 6.0);
Vector vec2(newPoint, pointB);
Vector vec3(newVector, vec2);
std::cout << "x2 : " << vec2.x() << std::endl;
std::cout << "y2 : " << vec2.y() << std::endl;
std::cout << "z2 : " << vec2.z() << std::endl;
if (vect.vecteurNull())
std::cout << "vec Null" << std::endl;
else
std::cout << "vec Non NUll" << std::endl;
if (newVector.vecteurNull())
std::cout << "newVector Null" << std::endl;
else
std::cout << "newVector Non NUll" << std::endl;
std::cout << "dot => " << newVector.dot(vec2) << std::endl;
std::cout << "x3 : " << vec3.x() << std::endl;
std::cout << "y3 : " << vec3.y() << std::endl;
std::cout << "z3 : " << vec3.z() << std::endl;
std::cout << "///////////////////// RAY //////////////////////////////////" << std::endl;
Ray newRay(pointB,newPoint);
std::cout << "origine : " << newRay.P0().x() << ", " << newRay.P0().y() << ", " << newRay.P0().z()<< std::endl;
std::cout << "direction : " << newRay.P1().x() << ", " << newRay.P1().y() << ", " << newRay.P1().z() << std::endl;
std::cout << "///////////////////// Triangle //////////////////////////////////" << std::endl;
Point pointC(6,8,5);
Point V2(0,-1,-10);
Point V0(5,-50,59);
Point V1(9,0,-25);
Triangle newTriangle(V0,V1,V2);
std::cout << "coordonnee : " << newTriangle.V0().x() << ", " << newTriangle.V1().y() << ", "<< newTriangle.V2().z() << std::endl;
std::cout << "///////////////////// Point/Triangle //////////////////////////////////" << std::endl;
Point I;
std::cout << newRay.P0().x() + 6 * newVector.x() << std::endl;
std::cout << newRay.P0().y() + 6 * newVector.y() << std::endl;
std::cout << newRay.P0().z() + 6 * newVector.z() << std::endl;
I.setCoordonne(newRay.P0().x() + 6 * newVector.x(), newRay.P0().y() + 6 * newVector.y(), newRay.P0().z() + 6 * newVector.z());
std::cout << "coucou" << std::endl;
std::cout << "///////////////////// test intersect //////////////////////////////////" << std::endl;
int test;
test = intersect3D_RayTriangle(newRay, newTriangle, I);
std::cout << "I : " << I.x() << ", " << I.y() <<", "<< I.z() << "\n test : " << test << std::endl;
std::cout << "///////////////////// VECTOR/Triangle //////////////////////////////////" << std::endl;
Vector newVector2(newTriangle.V0(), newTriangle.V1());
std::cout << "x : " << newVector2.x() << std::endl;
std::cout << "y : " << newVector2.y() << std::endl;
std::cout << "z : " << newVector2.z() << std::endl;
return 0;
}
int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX window_class = {};
window_class.cbSize = sizeof(window_class);
window_class.style = CS_HREDRAW | CS_VREDRAW;
window_class.lpfnWndProc = WindowCallback;
window_class.hInstance = hInstance;
window_class.hCursor = LoadCursor(NULL, IDC_ARROW);
window_class.lpszClassName = "WCPetroCanada";
RegisterClassEx(&window_class);
HWND window = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, "WCPetroCanada", "Game :)", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
1280, 720,
NULL, NULL, hInstance, NULL);
ShowWindow(window, nCmdShow);
UpdateWindow(window);
RECT client_rect = {};
GetClientRect(window, &client_rect);
Framebuffer backbuffer = {};
backbuffer.width = client_rect.right;
backbuffer.height = client_rect.bottom;
backbuffer.pixels = (uint32_t *)VirtualAlloc(NULL, backbuffer.width * backbuffer.height * sizeof(uint32_t ), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
HDC window_context = GetDC(window);
BITMAPINFO bitmap_info = {};
bitmap_info.bmiHeader.biSize = sizeof(bitmap_info);
bitmap_info.bmiHeader.biWidth = backbuffer.width;
bitmap_info.bmiHeader.biHeight = backbuffer.height;
bitmap_info.bmiHeader.biPlanes = 1;
bitmap_info.bmiHeader.biBitCount = 32;
bitmap_info.bmiHeader.biCompression = BI_RGB;
LoadedBitmap player_head = LoadBitmap("petro.bmp");
MSG message;
bool open = true;
Vector2 velocity = V2(0, 0);
Vector2 position = V2(200, 200);
float timestep = 1.0f; //TODO proper timestep
EntityArray entities = {};
Entity *player_entity = MakeEntity(&entities, EntityType_Player, V2(200, 200), player_head.width, player_head.height, V2(10, 10));
MakeEntity(&entities, EntityType_Box, V2(50, 50), 100, 100);
bool w_down = false;
bool a_down = false;
bool s_down = false;
bool d_down = false;
bool q_down = false;
while(open)
{
while(PeekMessage(&message, NULL, 0,
0, PM_REMOVE))
{
if(message.message == WM_QUIT)
{
open = false;
}
else if(message.message == WM_KEYDOWN)
{
if(message.wParam == W_KEY_CODE)
{
w_down = true;
}
else if(message.wParam == S_KEY_CODE)
{
s_down = true;
}
else if(message.wParam == D_KEY_CODE)
{
d_down = true;
}
else if(message.wParam == A_KEY_CODE)
{
a_down = true;
}
else if(message.wParam == Q_KEY_CODE)
{
q_down = true;
}
}
else if(message.message == WM_KEYUP)
{
if(message.wParam == W_KEY_CODE)
{
w_down = false;
}
else if(message.wParam == S_KEY_CODE)
{
s_down = false;
}
else if(message.wParam == D_KEY_CODE)
{
d_down = false;
}
else if(message.wParam == A_KEY_CODE)
{
a_down = false;
}
else if(message.wParam == Q_KEY_CODE)
{
q_down = false;
}
}
TranslateMessage(&message);
DispatchMessage(&message);
}
DrawRectangle(0, 0, backbuffer.width, backbuffer.height, backbuffer, V4(0.0f, 0.0f, 0.0f, 1.0f));
DrawRectangle(100, 100, 100, 100, backbuffer, V4(position.x / (float)backbuffer.width, position.y / (float)backbuffer.height, 0.0f, 1.0f));
DrawRectangle(100, 100, 150, 150, backbuffer, V4(0.0f, 1.0f, 0.0f, 0.25f));
for(int i = 0; i < entities.count; i++)
{
Entity *entity = entities.entities + i;
if(entity->type != EntityType_Invalid)
{
Vector2 acceleration = V2(0, 0);
if(entity == player_entity)
{
float multiplier = 1.0f;
if(w_down)
{
acceleration = acceleration + V2(0, 1);
}
if(s_down)
{
acceleration = acceleration + V2(0, -1);
}
if(d_down)
{
acceleration = acceleration + V2(1, 0);
}
if(a_down)
{
acceleration = acceleration + V2(-1, 0);
}
if(q_down)
{
multiplier = 5.0f;
}
if(Length(acceleration) > 0)
{
acceleration = Normalize(acceleration) * multiplier;
}
}
acceleration = acceleration - (entity->velocity * 0.05f);
Vector2 new_velocity = (acceleration * timestep) + entity->velocity;
Vector2 new_position = (acceleration * 0.5f * timestep * timestep) + (new_velocity * timestep) + GetCenter(entity->bounds);
Rect2 collision_box = RectPosSize(new_position.x, new_position.y, GetWidth(entity->bounds), GetHeight(entity->bounds));
bool intersects = false;
for(int j = 0; j < entities.count; j++)
{
if(j != i)
{
Entity *other_entity = entities.entities + j;
intersects = intersects || Intersect(other_entity->bounds, collision_box);
}
}
if(!intersects)
{
entity->velocity = new_velocity;
entity->bounds = RectPosSize(new_position.x, new_position.y, GetWidth(entity->bounds), GetHeight(entity->bounds));
}
else
{
entity->velocity = V2(0, 0);
}
switch(entity->type)
{
case EntityType_Box:
{
DrawRectangle(entity->bounds.min.x, entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, V4(1.0f, 0.0f, 0.0f, 1.0f));
}
break;
case EntityType_Player:
{
float angle = GetAngle(entity->velocity);
Direction direction = AngleToDirection(angle);
Vector4 color = V4(1.0f, 1.0f, 1.0f, 0.0f);
if(direction == Direction_Up)
{
color = V4(1.0f, 0.0f, 0.0f, 1.0f);
}
else if(direction == Direction_Down)
{
color = V4(1.0f, 1.0f, 0.0f, 1.0f);
}
else if(direction == Direction_Left)
{
color = V4(0.0f, 1.0f, 1.0f, 1.0f);
}
else if(direction == Direction_Right)
{
color = V4(0.0f, 1.0f, 0.0f, 1.0f);
}
char output[255];
sprintf(output, "%f\n", angle);
OutputDebugStringA(output);
DrawRectangle(300,
300,
10, 10,
backbuffer, color);
DrawRectangle(entity->bounds.min.x,
entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, intersects ? V4(0.5f, 0.0f, 0.0f, 0.5f) : V4(0.5f, 0.5f, 0.5f, 0.5f));
DrawBitmap(entity->bounds.min.x,
entity->bounds.min.y,
GetWidth(entity->bounds), GetHeight(entity->bounds),
backbuffer, player_head);
}
break;
}
}
}
StretchDIBits(window_context,
0, 0, backbuffer.width, backbuffer.height,
0, 0, backbuffer.width, backbuffer.height,
backbuffer.pixels, &bitmap_info, DIB_RGB_COLORS, SRCCOPY);
}
return 0;
}
Vector2 GetCenter(Rect2 rect)
{
return V2(rect.min.x + 0.5f * GetWidth(rect), rect.min.y + 0.5f * GetHeight(rect));
}
void
Scaler::ScaleBilinearFP(intType fromRow, int32 toRow)
{
BBitmap* src;
BBitmap* dest;
intType srcW, srcH;
intType destW, destH;
intType x, y, i;
ColumnDataFP* columnData;
ColumnDataFP* cd;
const uchar* srcBits;
uchar* destBits;
intType srcBPR, destBPR;
const uchar* srcData;
uchar* destDataRow;
uchar* destData;
const int32 kBPP = 4;
src = GetSrcImage();
dest = fScaledImage;
srcW = src->Bounds().IntegerWidth();
srcH = src->Bounds().IntegerHeight();
destW = dest->Bounds().IntegerWidth();
destH = dest->Bounds().IntegerHeight();
srcBits = (uchar*)src->Bits();
destBits = (uchar*)dest->Bits();
srcBPR = src->BytesPerRow();
destBPR = dest->BytesPerRow();
fixed_point fpSrcW = to_fixed_point(srcW);
fixed_point fpDestW = to_fixed_point(destW);
fixed_point fpSrcH = to_fixed_point(srcH);
fixed_point fpDestH = to_fixed_point(destH);
columnData = new ColumnDataFP[destW];
cd = columnData;
for (i = 0; i < destW; i ++, cd++) {
fixed_point column = to_fixed_point(i) * (long_fixed_point)fpSrcW / fpDestW;
cd->srcColumn = from_fixed_point(column);
cd->alpha1 = tail_value(column); // weigth for left pixel value
cd->alpha0 = kFPOne - cd->alpha1; // weigth for right pixel value
}
destDataRow = destBits + fromRow * destBPR;
for (y = fromRow; IsRunning() && y <= toRow; y ++, destDataRow += destBPR) {
fixed_point row;
intType srcRow;
fixed_point alpha0, alpha1;
if (fpDestH == 0) {
row = 0;
} else {
row = to_fixed_point(y) * (long_fixed_point)fpSrcH / fpDestH;
}
srcRow = from_fixed_point(row);
alpha1 = tail_value(row); // weight for row y+1
alpha0 = kFPOne - alpha1; // weight for row y
srcData = srcBits + srcRow * srcBPR;
destData = destDataRow;
// Need mult_correction for "outer" multiplication only
#define I4(i) from_fixed_point(mult_correction(\
(a[i] * a0 + b[i] * a1) * alpha0 + \
(c[i] * a0 + d[i] * a1) * alpha1))
#define V2(i) from_fixed_point(a[i] * alpha0 + c[i] * alpha1);
#define H2(i) from_fixed_point(a[i] * a0 + b[i] * a1);
if (y < destH) {
fixed_point a0, a1;
const uchar *a, *b, *c, *d;
for (x = 0; x < destW; x ++, destData += kBPP) {
a = srcData + columnData[x].srcColumn * kBPP;
b = a + kBPP;
c = a + srcBPR;
d = c + kBPP;
a0 = columnData[x].alpha0;
a1 = columnData[x].alpha1;
destData[0] = I4(0);
destData[1] = I4(1);
destData[2] = I4(2);
destData[3] = I4(3);
}
// right column
a = srcData + srcW * kBPP;
c = a + srcBPR;
destData[0] = V2(0);
destData[1] = V2(1);
destData[2] = V2(2);
destData[3] = V2(3);
} else {
fixed_point a0, a1;
const uchar *a, *b;
for (x = 0; x < destW; x ++, destData += kBPP) {
a = srcData + columnData[x].srcColumn * kBPP;
b = a + kBPP;
a0 = columnData[x].alpha0;
a1 = columnData[x].alpha1;
destData[0] = H2(0);
destData[1] = H2(1);
destData[2] = H2(2);
destData[3] = H2(3);
}
// bottom, right pixel
a = srcData + srcW * kBPP;
destData[0] = a[0];
destData[1] = a[1];
destData[2] = a[2];
destData[3] = a[3];
}
}
delete[] columnData;
}
void testgammarl()
{
srand(time(0));
unsigned int n = 128*1024*1024;
unsigned int n2 = 64*1024*1024;
std::vector<uint64_t> V (n);
std::vector<uint64_t> V2 (n2);
std::vector<uint64_t> Vcat;
unsigned int const albits = 3;
uint64_t const almask = (1ull << albits)-1;
for ( uint64_t i = 0; i < V.size(); ++i )
{
V[i] = rand() & almask;
Vcat.push_back(V[i]);
}
for ( uint64_t i = 0; i < V2.size(); ++i )
{
V2[i] = rand() & almask;
Vcat.push_back(V2[i]);
}
std::string const fn("tmpfile");
std::string const fn2("tmpfile2");
std::string const fn3("tmpfile3");
::libmaus::util::TempFileRemovalContainer::setup();
::libmaus::util::TempFileRemovalContainer::addTempFile(fn);
::libmaus::util::TempFileRemovalContainer::addTempFile(fn2);
::libmaus::util::TempFileRemovalContainer::addTempFile(fn3);
::libmaus::gamma::GammaRLEncoder GE(fn,albits,V.size(),256*1024);
for ( uint64_t i = 0; i < V.size(); ++i )
GE.encode(V[i]);
GE.flush();
::libmaus::gamma::GammaRLEncoder GE2(fn2,albits,V2.size(),256*1024);
for ( uint64_t i = 0; i < V2.size(); ++i )
GE2.encode(V2[i]);
GE2.flush();
#if 0
::libmaus::huffman::IndexDecoderData IDD(fn);
for ( uint64_t i = 0; i < IDD.numentries+1; ++i )
std::cerr << IDD.readEntry(i) << std::endl;
#endif
::libmaus::gamma::GammaRLDecoder GD(std::vector<std::string>(1,fn));
assert ( GD.getN() == n );
for ( uint64_t i = 0; i < n; ++i )
assert ( GD.decode() == static_cast<int64_t>(V[i]) );
uint64_t const off = n / 2 + 1031;
::libmaus::gamma::GammaRLDecoder GD2(std::vector<std::string>(1,fn),off);
for ( uint64_t i = off; i < n; ++i )
assert ( GD2.decode() == static_cast<int64_t>(V[i]) );
std::vector<std::string> fnv;
fnv.push_back(fn);
fnv.push_back(fn2);
::libmaus::gamma::GammaRLEncoder::concatenate(fnv,fn3);
for ( uint64_t off = 0; off < Vcat.size(); off += 18521 )
{
::libmaus::gamma::GammaRLDecoder GD3(std::vector<std::string>(1,fn3),off);
assert ( GD3.getN() == Vcat.size() );
for ( uint64_t i = 0; i < std::min(static_cast<uint64_t>(1024ull),Vcat.size()-off); ++i )
assert ( GD3.decode() == static_cast<int64_t>(Vcat[off+i]) );
}
remove ( fn.c_str() );
remove ( fn2.c_str() );
remove ( fn3.c_str() );
}
//=======================================================================
//function : HasIntersection3
//purpose : Auxilare for HasIntersection()
// find intersection point between triangle (P1,P2,P3)
// and segment [PC,P]
//=======================================================================
static bool HasIntersection3(const gp_Pnt& P, const gp_Pnt& PC, gp_Pnt& Pint,
const gp_Pnt& P1, const gp_Pnt& P2, const gp_Pnt& P3)
{
//cout<<"HasIntersection3"<<endl;
//cout<<" PC("<<PC.X()<<","<<PC.Y()<<","<<PC.Z()<<")"<<endl;
//cout<<" P("<<P.X()<<","<<P.Y()<<","<<P.Z()<<")"<<endl;
//cout<<" P1("<<P1.X()<<","<<P1.Y()<<","<<P1.Z()<<")"<<endl;
//cout<<" P2("<<P2.X()<<","<<P2.Y()<<","<<P2.Z()<<")"<<endl;
//cout<<" P3("<<P3.X()<<","<<P3.Y()<<","<<P3.Z()<<")"<<endl;
gp_Vec VP1(P1,P2);
gp_Vec VP2(P1,P3);
IntAna_Quadric IAQ(gp_Pln(P1,VP1.Crossed(VP2)));
IntAna_IntConicQuad IAICQ(gp_Lin(PC,gp_Dir(gp_Vec(PC,P))),IAQ);
if(IAICQ.IsDone()) {
if( IAICQ.IsInQuadric() )
return false;
if( IAICQ.NbPoints() == 1 ) {
gp_Pnt PIn = IAICQ.Point(1);
double preci = 1.e-6;
// check if this point is internal for segment [PC,P]
bool IsExternal =
( (PC.X()-PIn.X())*(P.X()-PIn.X()) > preci ) ||
( (PC.Y()-PIn.Y())*(P.Y()-PIn.Y()) > preci ) ||
( (PC.Z()-PIn.Z())*(P.Z()-PIn.Z()) > preci );
if(IsExternal) {
return false;
}
// check if this point is internal for triangle (P1,P2,P3)
gp_Vec V1(PIn,P1);
gp_Vec V2(PIn,P2);
gp_Vec V3(PIn,P3);
if( V1.Magnitude()<preci || V2.Magnitude()<preci ||
V3.Magnitude()<preci ) {
Pint = PIn;
return true;
}
gp_Vec VC1 = V1.Crossed(V2);
gp_Vec VC2 = V2.Crossed(V3);
gp_Vec VC3 = V3.Crossed(V1);
if(VC1.Magnitude()<preci) {
if(VC2.IsOpposite(VC3,preci)) {
return false;
}
}
else if(VC2.Magnitude()<preci) {
if(VC1.IsOpposite(VC3,preci)) {
return false;
}
}
else if(VC3.Magnitude()<preci) {
if(VC1.IsOpposite(VC2,preci)) {
return false;
}
}
else {
if( VC1.IsOpposite(VC2,preci) || VC1.IsOpposite(VC3,preci) ||
VC2.IsOpposite(VC3,preci) ) {
return false;
}
}
Pint = PIn;
return true;
}
}
return false;
}
void
RTriangleMesh::init(const std::tr1::shared_ptr<magnet::thread::TaskQueue>& systemQueue)
{
RTriangles::init(systemQueue);
//Send the data we already have
setGLPositions(_vertices);
setGLElements(_elements);
{//Calculate the normal vectors
std::vector<float> VertexNormals(_vertices.size(), 0);
//For every triangle, add the cross product of the two edges. We
//then renormalize the normal to get a
//"weighted-by-the-triangle-size" normal.
for (size_t triangle(0); triangle < _elements.size() / 3; ++triangle)
{
//Grab the vertex IDs
size_t v1(_elements[3 * triangle + 0]),
v2(_elements[3 * triangle + 1]),
v3(_elements[3 * triangle + 2]);
Vector V1(_vertices[3 * v1 + 0],
_vertices[3 * v1 + 1],
_vertices[3 * v1 + 2]),
V2(_vertices[3 * v2 + 0],
_vertices[3 * v2 + 1],
_vertices[3 * v2 + 2]),
V3(_vertices[3 * v3 + 0],
_vertices[3 * v3 + 1],
_vertices[3 * v3 + 2]);
Vector norm = (V2-V1)^(V3-V2);
for (size_t i(0); i < 3; ++i)
{
VertexNormals[3 * v1 + i] += norm[i];
VertexNormals[3 * v2 + i] += norm[i];
VertexNormals[3 * v3 + i] += norm[i];
}
}
//Now normalize those vertices
for (size_t vert(0); vert < _vertices.size() / 3; ++vert)
{
double norm
= VertexNormals[3 * vert + 0] * VertexNormals[3 * vert + 0]
+ VertexNormals[3 * vert + 1] * VertexNormals[3 * vert + 1]
+ VertexNormals[3 * vert + 2] * VertexNormals[3 * vert + 2];
if (norm)
{
double factor = 1 / std::sqrt(norm);
VertexNormals[3 * vert + 0] *= factor;
VertexNormals[3 * vert + 1] *= factor;
VertexNormals[3 * vert + 2] *= factor;
}
else
{
VertexNormals[3 * vert + 0] = 1;
VertexNormals[3 * vert + 1] = 0;
VertexNormals[3 * vert + 2] = 0;
}
}
setGLNormals(VertexNormals);
}
//Reclaim some memory
_vertices.clear();
_elements.clear();
}
template<typename MT, typename VT> class mat_vec_mul_lazy;
///
template<typename MT, typename VT> mat_vec_mul_lazy<MT,VT> mat_vec_mul (MT const & a, VT const & b) { return mat_vec_mul_lazy<MT,VT>(a,b); }
// ----------------- implementation -----------------------------------------
template<typename MT, typename VT>
class mat_vec_mul_lazy : TRIQS_MODEL_CONCEPT(ImmutableVector) {
typedef typename MT::value_type V1;
typedef typename VT::value_type V2;
static_assert((boost::is_same<V1,V2>::value),"Different values : not implemented");
public:
typedef BOOST_TYPEOF_TPL( V1() * V2()) value_type;
typedef typename VT::domain_type domain_type;
typedef typename const_view_type_if_exists_else_type<MT>::type M_type;
typedef typename const_view_type_if_exists_else_type<VT>::type V_type;
const M_type M; const V_type V;
private:
typedef vector<value_type> vector_type;
struct internal_data {
vector_type R;
internal_data(mat_vec_mul_lazy const & P): R( P.a.size(), P.b.dim1()) {
const_qcache<M_type> Cm(P.M); const_qcache<V_type> Cv(P.V);
boost::numeric::bindings::blas::gemv(1, Cm(), Cv(), 0, R);
}
};
Basis_HDIV_TRI_In_FEM<Scalar,ArrayScalar>::Basis_HDIV_TRI_In_FEM( const int n ,
const EPointType pointType ):
Phis( n ),
coeffs( (n+1)*(n+2) , n*(n+2) )
{
const int N = n*(n+2);
this -> basisCardinality_ = N;
this -> basisDegree_ = n;
this -> basisCellTopology_ = shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() );
this -> basisType_ = BASIS_FEM_FIAT;
this -> basisCoordinates_ = COORDINATES_CARTESIAN;
this -> basisTagsAreSet_ = false;
const int littleN = n*(n+1); // dim of (P_{n-1})^2 -- smaller space
const int bigN = (n+1)*(n+2); // dim of (P_{n})^2 -- larger space
const int scalarSmallestN = (n-1)*n / 2;
const int scalarLittleN = littleN/2;
const int scalarBigN = bigN/2;
// first, need to project the basis for RT space onto the
// orthogonal basis of degree n
// get coefficients of PkHx
Teuchos::SerialDenseMatrix<int,Scalar> V1(bigN, N);
// basis for the space is
// { (phi_i,0) }_{i=0}^{scalarLittleN-1} ,
// { (0,phi_i) }_{i=0}^{scalarLittleN-1} ,
// { (x,y) . phi_i}_{i=scalarLittleN}^{scalarBigN-1}
// columns of V1 are expansion of this basis in terms of the basis
// for P_{n}^2
// these two loops get the first two sets of basis functions
for (int i=0;i<scalarLittleN;i++) {
V1(i,i) = 1.0;
V1(scalarBigN+i,scalarLittleN+i) = 1.0;
}
// now I need to integrate { (x,y) phi } against the big basis
// first, get a cubature rule.
CubatureDirectTriDefault<Scalar,ArrayScalar > myCub( 2 * n );
ArrayScalar cubPoints( myCub.getNumPoints() , 2 );
ArrayScalar cubWeights( myCub.getNumPoints() );
myCub.getCubature( cubPoints , cubWeights );
// tabulate the scalar orthonormal basis at cubature points
ArrayScalar phisAtCubPoints( scalarBigN , myCub.getNumPoints() );
Phis.getValues( phisAtCubPoints , cubPoints , OPERATOR_VALUE );
// now do the integration
for (int i=0;i<n;i++) {
for (int j=0;j<scalarBigN;j++) { // int (x,y) phi_i \cdot (phi_j,0)
V1(j,littleN+i) = 0.0;
for (int k=0;k<myCub.getNumPoints();k++) {
V1(j,littleN+i) +=
cubWeights(k) * cubPoints(k,0)
* phisAtCubPoints(scalarSmallestN+i,k)
* phisAtCubPoints(j,k);
}
}
for (int j=0;j<scalarBigN;j++) { // int (x,y) phi_i \cdot (0,phi_j)
V1(j+scalarBigN,littleN+i) = 0.0;
for (int k=0;k<myCub.getNumPoints();k++) {
V1(j+scalarBigN,littleN+i) +=
cubWeights(k) * cubPoints(k,1)
* phisAtCubPoints(scalarSmallestN+i,k)
* phisAtCubPoints(j,k);
}
}
}
//std::cout << V1 << "\n";
// next, apply the RT nodes (rows) to the basis for (P_n)^2 (columns)
Teuchos::SerialDenseMatrix<int,Scalar> V2(N , bigN);
// first 3 * degree nodes are normals at each edge
// get the points on the line
ArrayScalar linePts( n , 1 );
if (pointType == POINTTYPE_WARPBLEND) {
CubatureDirectLineGauss<Scalar> edgeRule( n );
ArrayScalar edgeCubWts( n );
edgeRule.getCubature( linePts , edgeCubWts );
}
else if (pointType == POINTTYPE_EQUISPACED ) {
shards::CellTopology linetop(shards::getCellTopologyData<shards::Line<2> >() );
PointTools::getLattice<Scalar,ArrayScalar >( linePts ,
linetop ,
n+1 , 1 ,
POINTTYPE_EQUISPACED );
}
// holds the image of the line points
ArrayScalar edgePts( n , 2 );
ArrayScalar phisAtEdgePoints( scalarBigN , n );
// these are scaled by the appropriate edge lengths.
const Scalar nx[] = {0.0,1.0,-1.0};
const Scalar ny[] = {-1.0,1.0,0.0};
for (int i=0;i<3;i++) { // loop over edges
CellTools<Scalar>::mapToReferenceSubcell( edgePts ,
linePts ,
1 ,
i ,
this->basisCellTopology_ );
Phis.getValues( phisAtEdgePoints , edgePts , OPERATOR_VALUE );
// loop over points (rows of V2)
for (int j=0;j<n;j++) {
// loop over orthonormal basis functions (columns of V2)
for (int k=0;k<scalarBigN;k++) {
V2(n*i+j,k) = nx[i] * phisAtEdgePoints(k,j);
V2(n*i+j,k+scalarBigN) = ny[i] * phisAtEdgePoints(k,j);
}
}
}
// next map the points to each edge
// remaining nodes are divided into two pieces: point value of x
// components and point values of y components. These are
// evaluated at the interior of a lattice of degree + 1, For then
// the degree == 1 space corresponds classicaly to RT0 and so gets
// no internal nodes, and degree == 2 corresponds to RT1 and needs
// one internal node per vector component.
const int numInternalPoints = PointTools::getLatticeSize( this->getBaseCellTopology() ,
n + 1 ,
1 );
if (numInternalPoints > 0) {
ArrayScalar internalPoints( numInternalPoints , 2 );
PointTools::getLattice<Scalar,ArrayScalar >( internalPoints ,
this->getBaseCellTopology() ,
n + 1 ,
1 ,
pointType );
ArrayScalar phisAtInternalPoints( scalarBigN , numInternalPoints );
Phis.getValues( phisAtInternalPoints , internalPoints , OPERATOR_VALUE );
// copy values into right positions of V2
for (int i=0;i<numInternalPoints;i++) {
for (int j=0;j<scalarBigN;j++) {
// x component
V2(3*n+i,j) = phisAtInternalPoints(j,i);
// y component
V2(3*n+numInternalPoints+i,scalarBigN+j) = phisAtInternalPoints(j,i);
}
}
}
// std::cout << "Nodes on big basis\n";
// std::cout << V2 << "\n";
// std::cout << "End nodes\n";
Teuchos::SerialDenseMatrix<int,Scalar> Vsdm( N , N );
// multiply V2 * V1 --> V
Vsdm.multiply( Teuchos::NO_TRANS , Teuchos::NO_TRANS , 1.0 , V2 , V1 , 0.0 );
// std::cout << "Vandermonde:\n";
// std::cout << Vsdm << "\n";
// std::cout << "End Vandermonde\n";
Teuchos::SerialDenseSolver<int,Scalar> solver;
solver.setMatrix( rcp( &Vsdm , false ) );
solver.invert( );
Teuchos::SerialDenseMatrix<int,Scalar> Csdm( bigN , N );
Csdm.multiply( Teuchos::NO_TRANS , Teuchos::NO_TRANS , 1.0 , V1 , Vsdm , 0.0 );
// std::cout << Csdm << "\n";
for (int i=0;i<bigN;i++) {
for (int j=0;j<N;j++) {
coeffs(i,j) = Csdm(i,j);
}
}
}
