hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9cc2e24bf7b5e3b4ed7273dc58aa9e325c66ed91 | 1,671 | hpp | C++ | io/PVPFile.hpp | PetaVision/ObsoletePV | e99a42bf4292e944b252e144b5e07442b0715697 | [
"MIT"
] | null | null | null | io/PVPFile.hpp | PetaVision/ObsoletePV | e99a42bf4292e944b252e144b5e07442b0715697 | [
"MIT"
] | null | null | null | io/PVPFile.hpp | PetaVision/ObsoletePV | e99a42bf4292e944b252e144b5e07442b0715697 | [
"MIT"
] | null | null | null | /*
* PVPFile.hpp
*
* Created on: Jun 4, 2014
* Author: pschultz
*
* The goal of the PVPFile class is to encapsulate all interaction with
* PVPFiles---opening and closing, reading and writing, gathering and
* scattering---into a form where, even in the MPI context, all processes
* call the same public methods at the same time.
*
* All interaction with a PVP file from outside this class should use
* this class to work with the file.
*/
#ifndef PVPFILE_HPP_
#define PVPFILE_HPP_
#include <assert.h>
#include <sys/stat.h>
#include "../columns/InterColComm.hpp"
#include "fileio.hpp"
#include "io.h"
#define PVPFILE_SIZEOF_INT 4
#define PVPFILE_SIZEOF_LONG 8
#define PVPFILE_SIZEOF_SHORT 2
#define PVPFILE_SIZEOF_DOUBLE 8
#define PVPFILE_SIZEOF_FLOAT 4
enum PVPFileMode { PVPFILE_READ, PVPFILE_WRITE, PVPFILE_WRITE_READBACK, PVPFILE_APPEND };
namespace PV {
class PVPFile {
// Member functions
public:
PVPFile(const char * path, enum PVPFileMode mode, int pvpfileType, InterColComm * icComm);
int rank() { return icComm->commRank(); }
int rootProc() { return 0; }
bool isRoot() { return rank()==rootProc(); }
~PVPFile();
protected:
PVPFile();
int initialize(const char * path, enum PVPFileMode mode, int pvpfileType, InterColComm * icComm);
int initfile(const char * path, enum PVPFileMode mode, InterColComm * icComm);
private:
int initialize_base();
// Member variables
private:
int PVPFileType;
enum PVPFileMode mode;
int numFrames;
int currentFrame;
InterColComm * icComm;
int * header;
double headertime;
PV_Stream * stream;
};
} /* namespace PV */
#endif /* PVPFILE_HPP_ */
| 24.217391 | 100 | 0.715739 | PetaVision |
9cc3b7753bcf17838c04abb48065fe9452d89026 | 12,129 | cpp | C++ | parrlibdx/Texture.cpp | AlessandroParrotta/parrlibdx | 0b3cb26358f7831c6043ebc3ce0893b3a5fadcfe | [
"MIT"
] | null | null | null | parrlibdx/Texture.cpp | AlessandroParrotta/parrlibdx | 0b3cb26358f7831c6043ebc3ce0893b3a5fadcfe | [
"MIT"
] | null | null | null | parrlibdx/Texture.cpp | AlessandroParrotta/parrlibdx | 0b3cb26358f7831c6043ebc3ce0893b3a5fadcfe | [
"MIT"
] | null | null | null | #include "Texture.h"
#include <SOIL/SOIL.h>
#include "common.h"
#include "debug.h"
#include "util.h"
namespace prb {
void Texture::defInit(unsigned char* data) {
D3D11_TEXTURE2D_DESC tdesc;
// ...
// Fill out width, height, mip levels, format, etc...
// ...
tdesc.Width = width;
tdesc.Height = height;
tdesc.MipLevels = 1;
tdesc.SampleDesc.Count = 1; //how many textures
tdesc.SampleDesc.Quality = 0;
tdesc.ArraySize = 1; //number of textures
tdesc.Format = format;
tdesc.Usage = D3D11_USAGE_DYNAMIC;
tdesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; // Add D3D11_BIND_RENDER_TARGET if you want to go
// with the auto-generate mips route.
tdesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
tdesc.MiscFlags = 0; // or D3D11_RESOURCE_MISC_GENERATE_MIPS for auto-mip gen.
D3D11_SUBRESOURCE_DATA srd; // (or an array of these if you have more than one mip level)
srd.pSysMem = data; // This data should be in raw pixel format
srd.SysMemPitch = linesize != 0 && linesize != width ? linesize : tdesc.Width * 4; // Sometimes pixel rows may be padded so this might not be as simple as width * pixel_size_in_bytes.
srd.SysMemSlicePitch = 0; // tdesc.Width* tdesc.Height * 4;
ThrowIfFailed(dev->CreateTexture2D(&tdesc, &srd, &texture));
D3D11_SHADER_RESOURCE_VIEW_DESC srDesc;
srDesc.Format = format;
srDesc.ViewDimension = viewDimension; //D3D11_SRV_DIMENSION_TEXTURE2D;
srDesc.Texture2D.MostDetailedMip = 0;
srDesc.Texture2D.MostDetailedMip = 0;
srDesc.Texture2D.MipLevels = 1;
ThrowIfFailed(dev->CreateShaderResourceView(texture, &srDesc, &resView));
//devcon->GenerateMips(resView);
D3D11_SAMPLER_DESC samplerDesc;
// Create a texture sampler state description.
//samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
//samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.Filter = filtering;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
ThrowIfFailed(dev->CreateSamplerState(&samplerDesc, &sampler));
}
void Texture::init(unsigned char* data, vec2 size) {
this->width = size.x;
this->height = size.y;
defInit(data);
}
Texture::Texture() {}
Texture::Texture(std::wstring const& path) {
std::wstring ppath = strup::fallbackPath(path);
this->path = ppath;
unsigned char* data = SOIL_load_image(deb::toutf8(ppath).c_str(), &width, &height, &channels, SOIL_LOAD_RGBA);
if (data) defInit(data);
else deb::pr("could not load texture '", ppath, "'\n('", deb::toutf8(ppath).c_str(),"')\n");
delete[] data;
}
Texture::Texture(std::string const& path) : Texture(deb::tos(path)) {}
Texture::Texture(unsigned char* data, vec2 size) {
this->width = size.x;
this->height = size.y;
defInit(data);
}
Texture::Texture(unsigned char* data, vec2 size, int linesize) {
if (linesize == width) linesize *= 4;
this->width = size.x;
this->height = size.y;
this->linesize = linesize;
defInit(data);
//TODO right now the texture is uploaded twice in this constructor
D3D11_MAPPED_SUBRESOURCE mappedResource;
ThrowIfFailed(devcon->Map(texture, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource));
unsigned char* tdata = data;
BYTE* mappedData = reinterpret_cast<BYTE*>(mappedResource.pData);
for (UINT i = 0; i < height; i++)
{
memcpy(mappedData, tdata, linesize);
mappedData += mappedResource.RowPitch;
tdata += linesize;
}
devcon->Unmap(texture, 0);
}
Texture::Texture(vec2 size) {
this->linesize = size.x;
unsigned char* sData = new unsigned char[size.x * size.y * 4];
memset(sData, 0, size.x * size.y * 4);
init(sData, size);
delete[] sData;
}
Texture::Texture(vec2 size, int linesize, DXGI_FORMAT format, D3D_SRV_DIMENSION viewDimension) {
if (linesize == (int)size.x) linesize *= 4;
this->linesize = size.x;
this->format = format;
this->viewDimension = viewDimension;
unsigned char* sData = new unsigned char[linesize * size.y];
memset(sData, 0, linesize * size.y);
init(sData, size);
delete[] sData;
}
Texture::Texture(vec2 size, int linesize) : Texture(size, linesize, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_SRV_DIMENSION_TEXTURE2D) {}
bool Texture::operator==(Texture const& ot) const {
return this->texture == ot.texture &&
this->resView == ot.resView &&
this->sampler == ot.sampler &&
this->width == ot.width &&
this->height == ot.height &&
this->channels == ot.channels &&
this->linesize == ot.linesize;
}
bool Texture::operator!=(Texture const& ot) const { return !(*this == ot); }
bool Texture::null() const { return !texture || !resView || !sampler; }
vec2 Texture::getSize() const { return { (float)width, (float)height }; }
vec2 Texture::size() const { return getSize(); }
void Texture::setData(unsigned char* data, vec2 size, int linesize) {
if (linesize == width) linesize *= 4;
this->width = size.x;
this->height = size.y;
this->linesize = linesize;
D3D11_MAPPED_SUBRESOURCE mappedResource;
ThrowIfFailed(devcon->Map(texture, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource));
unsigned char* tdata = data;
BYTE* mappedData = reinterpret_cast<BYTE*>(mappedResource.pData);
for (UINT i = 0; i < height; i++)
{
memcpy(mappedData, tdata, linesize);
mappedData += mappedResource.RowPitch;
tdata += linesize;
}
devcon->Unmap(texture, 0);
}
void Texture::setData(unsigned char* data, vec2 size) {
this->width = size.x;
this->height = size.y;
D3D11_MAPPED_SUBRESOURCE mappedResource;
ThrowIfFailed(devcon->Map(texture, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource));
memcpy(mappedResource.pData, data, height * width * 4);
devcon->Unmap(texture, 0);
}
void Texture::setData(vec4 data) {
if (width <= 0 || height <= 0) return;
//data.clamp(0.f, 1.f);
unsigned char* ndata = new unsigned char[this->width * this->height * 4];
for(int i=0; i< this->width * this->height * 4; i+=4){
ndata[i + 0] = (unsigned char)(data.x*255.f);
ndata[i + 1] = (unsigned char)(data.y*255.f);
ndata[i + 2] = (unsigned char)(data.z*255.f);
ndata[i + 3] = (unsigned char)(data.w*255.f);
}
setData(ndata, vec2(width, height));
delete[] ndata;
}
D3D11_FILTER Texture::getFromFiltering(TEXTURE_FILTERING min, TEXTURE_FILTERING mag, TEXTURE_FILTERING mip) const {
return prb::getFromFiltering(min, mag, mip);
}
void Texture::calcMinMagMip(D3D11_FILTER filter) {
std::tuple<TEXTURE_FILTERING, TEXTURE_FILTERING, TEXTURE_FILTERING> ret = prb::calcMinMagMip(filter);
min = std::get<0>(ret); mag = std::get<1>(ret); mip = std::get<2>(ret);
}
void Texture::setFiltering(D3D11_FILTER filter) {
this->filtering = filter;
if (!texture || !resView || !sampler) return;
calcMinMagMip(filter);
if (sampler) { sampler->Release(); sampler = NULL; }
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = filtering;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
ThrowIfFailed(dev->CreateSamplerState(&samplerDesc, &sampler));
}
void Texture::setFiltering(TEXTURE_FILTERING min, TEXTURE_FILTERING mag, TEXTURE_FILTERING mip) { this->min = min; this->mag = mag; this->mip = mip; setFiltering(getFromFiltering(min, mag, mip)); }
void Texture::setFiltering(TEXTURE_FILTERING min, TEXTURE_FILTERING mag) { this->min = min; this->mag = mag; mip = mag; setFiltering(getFromFiltering(min, mag, mip)); }
void Texture::setFiltering(TEXTURE_FILTERING filter) { min = mag = mip = filter; setFiltering(getFromFiltering(min, mag, mip)); }
void Texture::drawImmediate(std::vector<float> const& verts) const {
util::drawTexture(*this, verts);
}
void Texture::drawImmediate(vec2 pos, vec2 size) const {
vec2 start = pos, end = pos + size;
std::vector<float> verts = { //clockwise order
start.x,start.y, 1.f,1.f,1.f,1.f, 0.f,1.f,
start.x,end.y, 1.f,1.f,1.f,1.f, 0.f,0.f,
end.x,end.y, 1.f,1.f,1.f,1.f, 1.f,0.f,
end.x,end.y, 1.f,1.f,1.f,1.f, 1.f,0.f,
end.x,start.y, 1.f,1.f,1.f,1.f, 1.f,1.f,
start.x,start.y, 1.f,1.f,1.f,1.f, 0.f,1.f,
};
drawImmediate(verts);
}
void Texture::bind() const {
devcon->PSSetShaderResources(0, 1, &resView);
devcon->PSSetSamplers(0, 1, &sampler);
}
void Texture::dispose() {
if(resView) resView->Release();
if(texture) texture->Release();
if(sampler) sampler->Release();
}
}
///////////////////////////////////////
//OLD DRAWTEXTURE
////create a temporary vertex buffer
//ID3D11Buffer* tempVBuffer = NULL;
//// create the vertex buffer
//D3D11_BUFFER_DESC bd;
//ZeroMemory(&bd, sizeof(bd));
//bd.Usage = D3D11_USAGE_DYNAMIC; // write access access by CPU and GPU
//bd.ByteWidth = sizeof(float) * verts.size(); // size is the VERTEX struct * 3
//bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // use as a vertex buffer
//bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // allow CPU to write in buffer
//dev->CreateBuffer(&bd, NULL, &tempVBuffer); // create the buffer
//// copy the vertices into the buffer
//D3D11_MAPPED_SUBRESOURCE ms;
//devcon->Map(tempVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
//memcpy(ms.pData, &verts[0], sizeof(float) * verts.size());
//devcon->Unmap(tempVBuffer, NULL);
//devcon->PSSetShaderResources(0, 1, &resView);
//devcon->PSSetSamplers(0, 1, &sampler);
//// select which vertex buffer to display
//UINT stride = sizeof(float) * 2 + sizeof(float) * 4 + sizeof(float) * 2;
//UINT offset = 0;
//devcon->IASetVertexBuffers(0, 1, &tempVBuffer, &stride, &offset);
//// select which primtive type we are using
//devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//// draw the vertex buffer to the back buffer
//devcon->Draw(6, 0);
////release the temporary buffer
//tempVBuffer->Release(); | 36.314371 | 202 | 0.608294 | AlessandroParrotta |
9cc603ec457fa5a3c9cea08bc0b1c62763431e92 | 1,566 | cpp | C++ | src/Grid.cpp | perezite/o2-blocks | c021f9eaddfefe619d3e41508c0fbdb81a95c276 | [
"MIT"
] | null | null | null | src/Grid.cpp | perezite/o2-blocks | c021f9eaddfefe619d3e41508c0fbdb81a95c276 | [
"MIT"
] | null | null | null | src/Grid.cpp | perezite/o2-blocks | c021f9eaddfefe619d3e41508c0fbdb81a95c276 | [
"MIT"
] | null | null | null | #include "Grid.h"
#include "DrawTarget.h"
namespace blocks {
void Grid::computeLine(const sb::Vector2f& start, const sb::Vector2f& end) {
Line line(_thickness, _color);
line.addPoint(start);
line.addPoint(end);
_vertices.insert(_vertices.end(), line.getVertices().begin(), line.getVertices().end());
}
void Grid::computeVerticalLines() {
sb::Vector2f size = getSize();
sb::Vector2f halfSize = 0.5f * size;
float delta = size.x / _gridSize.x;
for (int i = 0; i <= _gridSize.x; i++) {
sb::Vector2f start(i * delta - halfSize.x, -halfSize.y);
sb::Vector2f end(i * delta - halfSize.x, +halfSize.y);
computeLine(start, end);
}
}
void Grid::computeHorizontalLines() {
sb::Vector2f size = getSize();
sb::Vector2f halfSize = 0.5f * size;
float delta = size.y / _gridSize.y;
for (int i = 0; i <= _gridSize.y; i++) {
sb::Vector2f start(-halfSize.x, i * delta - halfSize.y);
sb::Vector2f end(+halfSize.x, i * delta - halfSize.y);
computeLine(start, end);
}
}
void Grid::computeLines() {
_vertices.clear();
sb::Vector2f delta(1.f / _gridSize.x, 1.f / _gridSize.y);
computeVerticalLines();
computeHorizontalLines();
}
Grid::Grid(sb::Vector2i gridSize, float thickness, const sb::Color& color)
: _gridSize(gridSize), _thickness(thickness), _color(color)
{
computeLines();
}
void Grid::draw(sb::DrawTarget& target, sb::DrawStates states) {
states.transform *= getTransform();
target.draw(_vertices, sb::PrimitiveType::TriangleStrip, states);
}
}
| 29.54717 | 91 | 0.646232 | perezite |
9cc80e7d11b7225ad9f738f0d2e4c04c0ca96330 | 716 | cpp | C++ | test/main.cpp | mbeckh/code-quality-actions | b58b6ee06589f68fa0fea550a7852e66c1b12246 | [
"Apache-2.0"
] | null | null | null | test/main.cpp | mbeckh/code-quality-actions | b58b6ee06589f68fa0fea550a7852e66c1b12246 | [
"Apache-2.0"
] | 28 | 2021-05-09T20:54:00.000Z | 2022-03-28T02:12:47.000Z | test/main.cpp | mbeckh/code-quality-actions | b58b6ee06589f68fa0fea550a7852e66c1b12246 | [
"Apache-2.0"
] | null | null | null | //
// Test Object which contains:
// - Two errors to be found by clang-tidy.
// - Test coverage for all lines except the ones marked with 'no coverage'.
//
int called_always() {
#ifdef _DEBUG
const char sz[] = "Debug"; // testing: deliberate error for clang-tidy
#else
const char sz[] = "Release"; // testing: deliberate error for clang-tidy
#endif
return sz[0];
}
int called_optional() { // testing: no coverage
return 1; // testing: no coverage
} // testing: no coverage
int main(int argc, char**) {
int result = called_always() == 'Z' ? 1 : 0;
if (argc > 1) {
result += called_optional(); // testing: no coverage
}
return result;
}
| 26.518519 | 76 | 0.601955 | mbeckh |
9cca2064ad3f216a6de0e346f3f9674514489d0e | 591 | cpp | C++ | Plugin/abci/Foundation/aiLogger.cpp | afterwise/AlembicForUnity | c6aa8478f7f5e9278350f29dcbffdaa8422028be | [
"MIT"
] | null | null | null | Plugin/abci/Foundation/aiLogger.cpp | afterwise/AlembicForUnity | c6aa8478f7f5e9278350f29dcbffdaa8422028be | [
"MIT"
] | null | null | null | Plugin/abci/Foundation/aiLogger.cpp | afterwise/AlembicForUnity | c6aa8478f7f5e9278350f29dcbffdaa8422028be | [
"MIT"
] | null | null | null | #include "pch.h"
#include <cstdarg>
void aiLogPrint(const char* fmt, ...)
{
va_list vl;
va_start(vl, fmt);
#ifdef _WIN32
char buf[2048];
vsprintf(buf, fmt, vl);
::OutputDebugStringA(buf);
::OutputDebugStringA("\n");
#else
vprintf(fmt, vl);
#endif
va_end(vl);
}
void aiLogPrint(const wchar_t* fmt, ...)
{
va_list vl;
va_start(vl, fmt);
#ifdef _WIN32
wchar_t buf[2048];
vswprintf(buf, fmt, vl);
::OutputDebugStringW(buf);
::OutputDebugStringW(L"\n");
#else
vwprintf(fmt, vl);
#endif
va_end(vl);
}
| 17.909091 | 41 | 0.582064 | afterwise |
9ccc275048bdc734f411beaf2d3e1821e45320d2 | 421 | hpp | C++ | book/cpp_templates/tmplbook/basics/stack8decl.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | book/cpp_templates/tmplbook/basics/stack8decl.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | book/cpp_templates/tmplbook/basics/stack8decl.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | template<typename T,
template<typename Elem> class Cont = std::deque>
class Stack {
private:
Cont<T> elems; // elements
public:
void push(T const&); // push element
void pop(); // pop element
T const& top() const; // return top element
bool empty() const { // return whether the stack is empty
return elems.empty();
}
//...
};
| 26.3125 | 67 | 0.534442 | houruixiang |
9ccd0a2ec195ccb9022d296b0c3adb82d940a1f2 | 4,580 | cpp | C++ | Controls4U/SplitterButton.cpp | XOULID/Anboto | 2743b066f23bf2db9cc062d3adedfd044bc69ec1 | [
"Apache-2.0"
] | null | null | null | Controls4U/SplitterButton.cpp | XOULID/Anboto | 2743b066f23bf2db9cc062d3adedfd044bc69ec1 | [
"Apache-2.0"
] | null | null | null | Controls4U/SplitterButton.cpp | XOULID/Anboto | 2743b066f23bf2db9cc062d3adedfd044bc69ec1 | [
"Apache-2.0"
] | null | null | null | #include <CtrlLib/CtrlLib.h>
#include "SplitterButton.h"
namespace Upp {
SplitterButton::SplitterButton() {
Add(splitter.SizePos());
Add(button1.LeftPosZ(80, 10).TopPosZ(30, 40));
Add(button2.LeftPosZ(80, 10).TopPosZ(30, 40));
splitter.WhenLayout = THISBACK(OnLayout);
button1.WhenAction = THISBACK1(SetButton, 0);
button2.WhenAction = THISBACK1(SetButton, 1);
movingRight = true;
buttonWidth = int(2.5*splitter.GetSplitWidth());
positionId = 0;
SetButtonNumber(2);
splitter.SetPos(5000);
}
SplitterButton& SplitterButton::Horz(Ctrl &left, Ctrl &right) {
splitter.Horz(left, right);
SetPositions(0, 5000, 10000);
SetInitialPositionId(1);
SetArrows();
return *this;
}
SplitterButton& SplitterButton::Vert(Ctrl& top, Ctrl& bottom) {
splitter.Vert(top, bottom);
SetPositions(0, 5000, 10000);
SetInitialPositionId(1);
SetArrows();
return *this;
}
SplitterButton &SplitterButton::SetPositions(const Vector<int> &_positions) {
positions = clone(_positions);
Sort(positions);
if (positionId >= positions.GetCount() || positionId < 0)
positionId = 0;
splitter.SetPos(positions[positionId]);
return *this;
}
SplitterButton &SplitterButton::SetPositions(int pos1) {
Vector<int> pos;
pos << pos1;
SetPositions(pos);
return *this;
}
SplitterButton &SplitterButton::SetPositions(int pos1, int pos2) {
Vector<int> pos;
pos << pos1 << pos2;
SetPositions(pos);
return *this;
}
SplitterButton &SplitterButton::SetPositions(int pos1, int pos2, int pos3) {
Vector<int> pos;
pos << pos1 << pos2 << pos3;
SetPositions(pos);
return *this;
}
SplitterButton &SplitterButton::SetInitialPositionId(int id) {
positionId = id;
splitter.SetPos(positions[positionId]);
SetArrows();
return *this;
}
void SplitterButton::OnLayout(int pos) {
int cwidth, cheight;
if (splitter.IsVert()) {
cwidth = GetSize().cy;
cheight = GetSize().cx;
} else {
cwidth = GetSize().cx;
cheight = GetSize().cy;
}
int posx = max(0, pos - buttonWidth/2);
posx = min(cwidth - buttonWidth, posx);
int posy = (2*cheight)/5;
int widthy;
if (buttonNumber == 1)
widthy = cheight/5;
else
widthy = cheight/8;
if (splitter.IsVert()) {
if (buttonNumber == 1)
button1.SetPos(PosLeft(posy, widthy), PosTop(posx, buttonWidth));
else {
button1.SetPos(PosLeft(posy - widthy/2, widthy), PosTop(posx, buttonWidth));
button2.SetPos(PosLeft(posy + widthy/2, widthy), PosTop(posx, buttonWidth));
}
} else {
if (buttonNumber == 1)
button1.SetPos(PosLeft(posx, buttonWidth), PosTop(posy, widthy));
else {
button1.SetPos(PosLeft(posx, buttonWidth), PosTop(posy - widthy/2, widthy));
button2.SetPos(PosLeft(posx, buttonWidth), PosTop(posy + widthy/2, widthy));
}
}
WhenAction();
}
void SplitterButton::SetButton(int id) {
ASSERT(positions.GetCount() > 1);
int pos = splitter.GetPos();
int closerPositionId = Null;
int closerPosition = 10000;
for (int i = 0; i < positions.GetCount(); ++i)
if (abs(positions[i] - pos) < closerPosition) {
closerPosition = abs(positions[i] - pos);
closerPositionId = i;
}
//bool arrowRight;
if (buttonNumber == 1) {
if (movingRight) {
if (closerPositionId == (positions.GetCount() - 1)) {
movingRight = false;
positionId = positions.GetCount() - 2;
} else
positionId = closerPositionId + 1;
} else {
if (closerPositionId == 0) {
movingRight = true;
positionId = 1;
} else
positionId = closerPositionId - 1;
}
} else {
if (id == 1) {
if (positionId < positions.GetCount() - 1)
positionId++;
} else {
if (positionId > 0)
positionId--;
}
}
splitter.SetPos(positions[positionId]);
SetArrows();
WhenAction();
}
void SplitterButton::SetArrows() {
if (buttonNumber == 1) {
bool arrowRight = movingRight;
if (positionId == (positions.GetCount() - 1))
arrowRight = false;
if (positionId == 0)
arrowRight = true;
if (arrowRight)
button1.SetImage(splitter.IsVert() ? CtrlImg::smalldown() : CtrlImg::smallright());
else
button1.SetImage(splitter.IsVert() ? CtrlImg::smallup() : CtrlImg::smallleft());
} else {
button1.SetImage(splitter.IsVert() ? CtrlImg::smallup() : CtrlImg::smallleft());
button2.SetImage(splitter.IsVert() ? CtrlImg::smalldown() : CtrlImg::smallright());
}
}
CH_STYLE(Box, Style, StyleDefault) {
width = Ctrl::HorzLayoutZoom(2);
vert[0] = horz[0] = SColorFace();
vert[1] = horz[1] = GUI_GlobalStyle() >= GUISTYLE_XP ? Blend(SColorHighlight, SColorFace)
: SColorShadow();
dots = false;
}
} | 23.608247 | 90 | 0.667904 | XOULID |
9cd069d0706763fea075a2cff1e7ea529f888998 | 774 | cpp | C++ | src/NoOpReply.cpp | mikz/capybara-webkit | 1ffa80566570cdb33ef17fd197575c07842e51de | [
"MIT"
] | 37 | 2015-01-28T07:34:34.000Z | 2021-06-14T02:17:51.000Z | src/NoOpReply.cpp | mikz/capybara-webkit | 1ffa80566570cdb33ef17fd197575c07842e51de | [
"MIT"
] | 18 | 2015-01-28T08:26:55.000Z | 2018-02-20T14:04:58.000Z | src/NoOpReply.cpp | mikz/capybara-webkit | 1ffa80566570cdb33ef17fd197575c07842e51de | [
"MIT"
] | 36 | 2015-01-29T09:42:47.000Z | 2021-01-22T11:45:43.000Z | #include <QTimer>
#include "NoOpReply.h"
NoOpReply::NoOpReply(QNetworkRequest &request, QObject *parent) : QNetworkReply(parent) {
open(ReadOnly | Unbuffered);
setAttribute(QNetworkRequest::HttpStatusCodeAttribute, 200);
setHeader(QNetworkRequest::ContentLengthHeader, QVariant(0));
setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString("text/plain")));
setUrl(request.url());
QTimer::singleShot( 0, this, SIGNAL(readyRead()) );
QTimer::singleShot( 0, this, SIGNAL(finished()) );
}
void NoOpReply::abort() {
// NO-OP
}
qint64 NoOpReply::bytesAvailable() const {
return 0;
}
bool NoOpReply::isSequential() const {
return true;
}
qint64 NoOpReply::readData(char *data, qint64 maxSize) {
Q_UNUSED(data);
Q_UNUSED(maxSize);
return 0;
}
| 23.454545 | 89 | 0.726098 | mikz |
9cd2f3499185401f61ebc61e59f089ba8c9ff59f | 161 | hpp | C++ | win32/include/swt/graphics/Resource.hpp | deianvn/swt-plus-plus | e85236e8279b4e6f5993d94d1bd14e6fc7e1dd1b | [
"Apache-2.0"
] | null | null | null | win32/include/swt/graphics/Resource.hpp | deianvn/swt-plus-plus | e85236e8279b4e6f5993d94d1bd14e6fc7e1dd1b | [
"Apache-2.0"
] | null | null | null | win32/include/swt/graphics/Resource.hpp | deianvn/swt-plus-plus | e85236e8279b4e6f5993d94d1bd14e6fc7e1dd1b | [
"Apache-2.0"
] | null | null | null | #ifndef SWT_PLUS_PLUS_RESOURCE_H
#define SWT_PLUS_PLUS_RESOURCE_H
namespace swt
{
class Resource {
public:
};
}
#endif //SWT_PLUS_PLUS_RESOURCE_H
| 12.384615 | 33 | 0.745342 | deianvn |
9cd339c28828916e740dc3b0c182a88726a87240 | 1,949 | hpp | C++ | tests/system/test_boost_parts/sources_changed/interprocess/sync/windows/named_recursive_mutex.hpp | iazarov/metrixplusplus | 322777cba4e089502dd6053749b07a7be9da65b2 | [
"MIT"
] | 198 | 2015-01-13T05:47:18.000Z | 2022-03-09T04:46:46.000Z | tests/system/test_boost_parts/sources_changed/interprocess/sync/windows/named_recursive_mutex.hpp | iazarov/metrixplusplus | 322777cba4e089502dd6053749b07a7be9da65b2 | [
"MIT"
] | 197 | 2017-07-06T16:53:59.000Z | 2019-05-31T17:57:51.000Z | tests/system/test_boost_parts/sources_changed/interprocess/sync/windows/named_recursive_mutex.hpp | iazarov/metrixplusplus | 322777cba4e089502dd6053749b07a7be9da65b2 | [
"MIT"
] | 139 | 2015-01-15T20:09:31.000Z | 2022-01-31T15:21:16.000Z | //////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2011-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_WINDOWS_RECURSIVE_NAMED_MUTEX_HPP
#define BOOST_INTERPROCESS_WINDOWS_RECURSIVE_NAMED_MUTEX_HPP
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
#include <boost/interprocess/sync/windows/named_mutex.hpp>
namespace boost {
namespace interprocess {
namespace ipcdetail {
class windows_named_recursive_mutex
//Windows mutexes based on CreateMutex are already recursive...
: public windows_named_mutex
{
/// @cond
//Non-copyable
windows_named_recursive_mutex();
windows_named_recursive_mutex(const windows_named_mutex &);
windows_named_recursive_mutex &operator=(const windows_named_mutex &);
/// @endcond
public:
windows_named_recursive_mutex(create_only_t, const char *name, const permissions &perm = permissions())
: windows_named_mutex(create_only_t(), name, perm)
{}
windows_named_recursive_mutex(open_or_create_t, const char *name, const permissions &perm = permissions())
: windows_named_mutex(open_or_create_t(), name, perm)
{}
windows_named_recursive_mutex(open_only_t, const char *name)
: windows_named_mutex(open_only_t(), name)
{}
};
} //namespace ipcdetail {
} //namespace interprocess {
} //namespace boost {
#include <boost/interprocess/detail/config_end.hpp>
#endif //BOOST_INTERPROCESS_WINDOWS_RECURSIVE_NAMED_MUTEX_HPP
| 33.033898 | 110 | 0.680862 | iazarov |
9cd3490cce2905d6bc02a256eaa3c48c8bb088aa | 6,506 | hpp | C++ | libraries/chain/include/enumivo/chain/database_utils.hpp | TP-Lab/enumivo | 76d81a36d2db8cea93fb54cd95a6ec5f6c407f97 | [
"MIT"
] | null | null | null | libraries/chain/include/enumivo/chain/database_utils.hpp | TP-Lab/enumivo | 76d81a36d2db8cea93fb54cd95a6ec5f6c407f97 | [
"MIT"
] | null | null | null | libraries/chain/include/enumivo/chain/database_utils.hpp | TP-Lab/enumivo | 76d81a36d2db8cea93fb54cd95a6ec5f6c407f97 | [
"MIT"
] | null | null | null | /**
* @file
* @copyright defined in enumivo/LICENSE
*/
#pragma once
#include <enumivo/chain/types.hpp>
#include <fc/io/raw.hpp>
#include <softfloat.hpp>
namespace enumivo { namespace chain {
template<typename ...Indices>
class index_set;
template<typename Index>
class index_utils {
public:
using index_t = Index;
template<typename F>
static void walk( const chainbase::database& db, F function ) {
auto const& index = db.get_index<Index>().indices();
const auto& first = index.begin();
const auto& last = index.end();
for (auto itr = first; itr != last; ++itr) {
function(*itr);
}
}
template<typename Secondary, typename Key, typename F>
static void walk_range( const chainbase::database& db, const Key& begin_key, const Key& end_key, F function ) {
const auto& idx = db.get_index<Index, Secondary>();
auto begin_itr = idx.lower_bound(begin_key);
auto end_itr = idx.lower_bound(end_key);
for (auto itr = begin_itr; itr != end_itr; ++itr) {
function(*itr);
}
}
template<typename Secondary, typename Key>
static size_t size_range( const chainbase::database& db, const Key& begin_key, const Key& end_key ) {
const auto& idx = db.get_index<Index, Secondary>();
auto begin_itr = idx.lower_bound(begin_key);
auto end_itr = idx.lower_bound(end_key);
size_t res = 0;
while (begin_itr != end_itr) {
res++; ++begin_itr;
}
return res;
}
template<typename F>
static void create( chainbase::database& db, F cons ) {
db.create<typename index_t::value_type>(cons);
}
};
template<typename Index>
class index_set<Index> {
public:
static void add_indices( chainbase::database& db ) {
db.add_index<Index>();
}
template<typename F>
static void walk_indices( F function ) {
function( index_utils<Index>() );
}
};
template<typename FirstIndex, typename ...RemainingIndices>
class index_set<FirstIndex, RemainingIndices...> {
public:
static void add_indices( chainbase::database& db ) {
index_set<FirstIndex>::add_indices(db);
index_set<RemainingIndices...>::add_indices(db);
}
template<typename F>
static void walk_indices( F function ) {
index_set<FirstIndex>::walk_indices(function);
index_set<RemainingIndices...>::walk_indices(function);
}
};
template<typename DataStream>
DataStream& operator << ( DataStream& ds, const shared_blob& b ) {
fc::raw::pack(ds, static_cast<const shared_string&>(b));
return ds;
}
template<typename DataStream>
DataStream& operator >> ( DataStream& ds, shared_blob& b ) {
fc::raw::unpack(ds, static_cast<shared_string &>(b));
return ds;
}
} }
namespace fc {
// overloads for to/from_variant
template<typename OidType>
void to_variant( const chainbase::oid<OidType>& oid, variant& v ) {
v = variant(oid._id);
}
template<typename OidType>
void from_variant( const variant& v, chainbase::oid<OidType>& oid ) {
from_variant(v, oid._id);
}
inline
void to_variant( const float64_t& f, variant& v ) {
v = variant(*reinterpret_cast<const double*>(&f));
}
inline
void from_variant( const variant& v, float64_t& f ) {
from_variant(v, *reinterpret_cast<double*>(&f));
}
inline
void to_variant( const float128_t& f, variant& v ) {
v = variant(*reinterpret_cast<const uint128_t*>(&f));
}
inline
void from_variant( const variant& v, float128_t& f ) {
from_variant(v, *reinterpret_cast<uint128_t*>(&f));
}
inline
void to_variant( const enumivo::chain::shared_string& s, variant& v ) {
v = variant(std::string(s.begin(), s.end()));
}
inline
void from_variant( const variant& v, enumivo::chain::shared_string& s ) {
string _s;
from_variant(v, _s);
s = enumivo::chain::shared_string(_s.begin(), _s.end(), s.get_allocator());
}
inline
void to_variant( const enumivo::chain::shared_blob& b, variant& v ) {
v = variant(base64_encode(b.data(), b.size()));
}
inline
void from_variant( const variant& v, enumivo::chain::shared_blob& b ) {
string _s = base64_decode(v.as_string());
b = enumivo::chain::shared_blob(_s.begin(), _s.end(), b.get_allocator());
}
inline
void to_variant( const blob& b, variant& v ) {
v = variant(base64_encode(b.data.data(), b.data.size()));
}
inline
void from_variant( const variant& v, blob& b ) {
string _s = base64_decode(v.as_string());
b.data = std::vector<char>(_s.begin(), _s.end());
}
template<typename T>
void to_variant( const enumivo::chain::shared_vector<T>& sv, variant& v ) {
to_variant(std::vector<T>(sv.begin(), sv.end()), v);
}
template<typename T>
void from_variant( const variant& v, enumivo::chain::shared_vector<T>& sv ) {
std::vector<T> _v;
from_variant(v, _v);
sv = enumivo::chain::shared_vector<T>(_v.begin(), _v.end(), sv.get_allocator());
}
}
namespace chainbase {
// overloads for OID packing
template<typename DataStream, typename OidType>
DataStream& operator << ( DataStream& ds, const oid<OidType>& oid ) {
fc::raw::pack(ds, oid._id);
return ds;
}
template<typename DataStream, typename OidType>
DataStream& operator >> ( DataStream& ds, oid<OidType>& oid ) {
fc::raw::unpack(ds, oid._id);
return ds;
}
}
// overloads for softfloat packing
template<typename DataStream>
DataStream& operator << ( DataStream& ds, const float64_t& v ) {
fc::raw::pack(ds, *reinterpret_cast<const double *>(&v));
return ds;
}
template<typename DataStream>
DataStream& operator >> ( DataStream& ds, float64_t& v ) {
fc::raw::unpack(ds, *reinterpret_cast<double *>(&v));
return ds;
}
template<typename DataStream>
DataStream& operator << ( DataStream& ds, const float128_t& v ) {
fc::raw::pack(ds, *reinterpret_cast<const enumivo::chain::uint128_t*>(&v));
return ds;
}
template<typename DataStream>
DataStream& operator >> ( DataStream& ds, float128_t& v ) {
fc::raw::unpack(ds, *reinterpret_cast<enumivo::chain::uint128_t*>(&v));
return ds;
}
| 29.707763 | 120 | 0.618352 | TP-Lab |
9cd3dda963caab637c859dd1c34fc157105b11fc | 3,411 | cpp | C++ | tests/test_coefficient_ops.cpp | PayasR/DwellRegions-open | 72d8c4a7a5e6d2981005b2ac1182441e227d7314 | [
"BSD-3-Clause"
] | null | null | null | tests/test_coefficient_ops.cpp | PayasR/DwellRegions-open | 72d8c4a7a5e6d2981005b2ac1182441e227d7314 | [
"BSD-3-Clause"
] | null | null | null | tests/test_coefficient_ops.cpp | PayasR/DwellRegions-open | 72d8c4a7a5e6d2981005b2ac1182441e227d7314 | [
"BSD-3-Clause"
] | null | null | null | #include "../include/coefficient.hpp"
#include <iostream>
#include <random>
#include <vector>
using DwellRegions::Coefficient;
auto
generate_random_coefficients(size_t num_points)
{
std::random_device rd; // Will be used to obtain a seed for the random number engine
std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
std::uniform_real_distribution<> distribution(0.0, 180.0);
std::vector<Coefficient> coefficients;
coefficients.reserve(num_points);
for (size_t i = 0; i < num_points; i++) {
// Use dis to transform the random unsigned int generated by gen into a
// double in [1, 2). Each call to dis(gen) generates a new random double
coefficients.emplace_back(DwellRegions::Coefficient::from_double(distribution(gen)));
}
return coefficients;
}
void
print_coefficients(const std::vector<Coefficient>& coefficients)
{
for (const auto& c : coefficients) {
std::cout << c.val() << " " << c.as_float() << std::endl;
}
}
// Pairwise subtract the coefficients
void
subtraction_test(const std::vector<Coefficient>& coefficients)
{
std::cout << "---------- Subtraction test--------------" << std::endl;
for (size_t i = 1; i < coefficients.size(); i++) {
std::cout << coefficients[i - 1].as_float() << " - " << coefficients[i].as_float() << " = ";
const auto res = (coefficients[i - 1] - coefficients[i]).as_float();
const auto float_res = coefficients[i - 1].as_float() - coefficients[i].as_float();
if (res != float_res) {
std::cout << "Error: mismatch! res = " << res << " \t Float res = " << float_res << std::endl;
} else {
std::cout << "Ok." << std::endl;
}
}
}
// Pairwise multiply the coefficients
void
multiplication_test(const std::vector<Coefficient>& coefficients)
{
std::cout << "---------- Multiplication test--------------" << std::endl;
for (size_t i = 1; i < coefficients.size(); i++) {
std::cout << coefficients[i - 1].as_float() << " * " << coefficients[i].as_float() << " = ";
const auto res = (coefficients[i - 1] * coefficients[i]).as_float();
const auto float_res = coefficients[i - 1].as_float() * coefficients[i].as_float();
if (res != float_res) {
std::cout << "Error: mismatch! res = " << res << " \t Float res = " << float_res << std::endl;
} else {
std::cout << "Ok." << std::endl;
}
}
}
// Pairwise divide the coefficients
void
division_test(const std::vector<Coefficient>& coefficients)
{
std::cout << "---------- Division test--------------" << std::endl;
for (size_t i = 1; i < coefficients.size(); i++) {
std::cout << coefficients[i - 1].as_float() << " / " << coefficients[i].as_float() << " = ";
const auto res = (coefficients[i - 1] / coefficients[i]).as_float();
const auto float_res = coefficients[i - 1].as_float() / coefficients[i].as_float();
if (res != float_res) {
std::cout << "Error: mismatch! res = " << res << " \t Float res = " << float_res << std::endl;
} else {
std::cout << "Ok." << std::endl;
}
}
}
int
main()
{
const size_t num_coefficients = 10;
const auto coefficients = generate_random_coefficients(num_coefficients);
std::cout << "---------- Original Coefficients --------------" << std::endl;
print_coefficients(coefficients);
subtraction_test(coefficients);
multiplication_test(coefficients);
division_test(coefficients);
return 0;
} | 34.11 | 100 | 0.623864 | PayasR |
9cd59c8ea20b2758e329764ff335fff9e25608ed | 658 | cc | C++ | test/sync_call.cc | shayanalia/msgpack-rpc-cpp | 3fd73f9a58b899774dca13a1c478fad7924dd8fd | [
"Apache-2.0"
] | 28 | 2015-01-15T13:50:05.000Z | 2022-03-01T13:41:33.000Z | test/sync_call.cc | shayanalia/msgpack-rpc-cpp | 3fd73f9a58b899774dca13a1c478fad7924dd8fd | [
"Apache-2.0"
] | 1 | 2016-10-03T22:45:49.000Z | 2016-10-04T01:11:57.000Z | test/sync_call.cc | shayanalia/msgpack-rpc-cpp | 3fd73f9a58b899774dca13a1c478fad7924dd8fd | [
"Apache-2.0"
] | 13 | 2015-11-27T15:30:59.000Z | 2020-09-30T20:43:00.000Z | #include "echo_server.h"
#include <msgpack/rpc/server.h>
#include <msgpack/rpc/client.h>
#include <cclog/cclog.h>
#include <cclog/cclog_tty.h>
int main(void)
{
cclog::reset(new cclog_tty(cclog::TRACE, std::cout));
signal(SIGPIPE, SIG_IGN);
// run server {
rpc::server svr;
std::auto_ptr<rpc::dispatcher> dp(new myecho);
svr.serve(dp.get());
svr.listen("0.0.0.0", 18811);
svr.start(4);
// }
// create client
rpc::client cli("127.0.0.1", 18811);
// call
std::string msg("MessagePack-RPC");
std::string ret = cli.call("echo", msg).get<std::string>();
std::cout << "call: echo(\"MessagePack-RPC\") = " << ret << std::endl;
return 0;
}
| 18.277778 | 71 | 0.641337 | shayanalia |
9cd6c31f764122214136fff6589293c7a8c871b9 | 3,148 | cpp | C++ | src/Shader.cpp | the13fools/fieldgen | 6b1757e1a75cd65b73526aa9c200303fbee4d669 | [
"Unlicense",
"MIT"
] | 93 | 2019-06-04T06:56:49.000Z | 2022-03-30T08:44:58.000Z | src/Shader.cpp | the13fools/fieldgen | 6b1757e1a75cd65b73526aa9c200303fbee4d669 | [
"Unlicense",
"MIT"
] | 1 | 2020-02-06T14:56:41.000Z | 2020-07-15T17:31:29.000Z | src/Shader.cpp | the13fools/fieldgen | 6b1757e1a75cd65b73526aa9c200303fbee4d669 | [
"Unlicense",
"MIT"
] | 11 | 2019-06-06T21:11:29.000Z | 2021-08-14T05:06:16.000Z | #include "Shader.h"
#include <fstream>
#include <iostream>
using namespace std;
namespace DDG
{
Shader::Shader( void )
// constructor -- shader is initially invalid
: vertexShader( 0 ),
fragmentShader( 0 ),
geometryShader( 0 ),
program( 0 ),
linked( false )
{}
Shader::~Shader( void )
{
if( program ) glDeleteProgram( program );
if( vertexShader ) glDeleteShader( vertexShader );
if( fragmentShader ) glDeleteShader( fragmentShader );
if( geometryShader ) glDeleteShader( geometryShader );
}
void Shader::loadVertex( const char* filename )
{
load( GL_VERTEX_SHADER, filename, vertexShader );
}
void Shader::loadFragment( const char* filename )
{
load( GL_FRAGMENT_SHADER, filename, fragmentShader );
}
void Shader::loadGeometry( const char* filename )
{
#ifdef GL_GEOMETRY_SHADER_EXT
load( GL_GEOMETRY_SHADER_EXT, filename, geometryShader );
#else
cerr << "Error: geometry shaders not supported!" << endl;
#endif
}
void Shader::enable( void )
{
if( !linked )
{
glLinkProgram( program );
linked = true;
}
glUseProgram( program );
}
void Shader::disable( void ) const
{
glUseProgram( 0 );
}
Shader::operator GLuint( void ) const
{
return program;
}
void Shader::load( GLenum shaderType, const char* filename, GLuint& shader )
// read vertex shader from GLSL source file, compile, and attach to program
{
string source;
if( !readSource( filename, source ))
{
return;
}
if( program == 0 )
{
program = glCreateProgram();
}
if( shader != 0 )
{
glDetachShader( program, shader );
}
shader = glCreateShader( shaderType );
const char* source_c_str = source.c_str();
glShaderSource( shader, 1, &(source_c_str), NULL );
glCompileShader( shader );
GLint compileStatus;
glGetShaderiv( shader, GL_COMPILE_STATUS, &compileStatus );
if( compileStatus == GL_TRUE )
{
glAttachShader( program, shader );
linked = false;
}
else
{
GLsizei maxLength = 0;
glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &maxLength );
if( maxLength > 0 )
{
GLchar* infoLog = new char[ maxLength ];
GLsizei length;
glGetShaderInfoLog( shader, maxLength, &length, infoLog );
cerr << "GLSL Error: " << infoLog << endl;
delete[] infoLog;
}
}
}
bool Shader::readSource( const char* filename, std::string& source )
// reads GLSL source file into a string
{
source = "";
ifstream in( filename );
if( !in.is_open() )
{
cerr << "Error: could not open shader file ";
cerr << filename;
cerr << " for input!" << endl;
return false;
}
string line;
while( getline( in, line ))
{
source += line;
}
return true;
}
}
| 22.013986 | 79 | 0.558132 | the13fools |
9cd9ec1315f44ba17406216a8e849bbde7e6f376 | 1,263 | cpp | C++ | Stack/Check for redundent braces.cpp | Dharaneeshwar/DataStructures | 9fab95b8d58c39cb3bb9cd6d635f2f5d4fdec9df | [
"MIT"
] | 11 | 2020-09-12T03:05:30.000Z | 2020-11-12T00:18:08.000Z | Stack/Check for redundent braces.cpp | g-o-l-d-y/DataStructures | 7049c6d0e7e3d54bad3b380d8048c5215698c78e | [
"MIT"
] | 1 | 2020-10-19T10:10:08.000Z | 2020-10-19T10:10:08.000Z | Stack/Check for redundent braces.cpp | g-o-l-d-y/DataStructures | 7049c6d0e7e3d54bad3b380d8048c5215698c78e | [
"MIT"
] | 1 | 2020-10-19T06:48:16.000Z | 2020-10-19T06:48:16.000Z | #include <iostream>
#include <cstring>
using namespace std;
// class declaration
class Node
{
public:
char data;
Node *next;
} *head = NULL;
void append(char data)
{
// adds the element to the top of Stack
Node *newnode = new Node();
newnode->data = data;
newnode->next = NULL;
if (head == NULL)
{
head = newnode;
}
else
{
newnode->next = head;
head = newnode;
}
}
char poptop()
{
// removes and returns the top of stack
char val = head->data;
Node *temp = head;
head = head->next;
temp->next = NULL;
free(temp);
return val;
}
int main()
{
string s;
cin >> s;
for (char a : s)
{
if (a == ')')
{
int flag = 0;
char t = poptop();
while (t != '(')
{
// removes all character till opening paranthesis
if (strchr("+-*/", t))
{
flag = 1;
}
t = poptop();
}
if (flag == 0)
{
cout << "Yes";
return 0;
}
}
else
{
append(a);
}
}
cout << "No";
return 0;
} | 17.30137 | 65 | 0.409343 | Dharaneeshwar |
9cdbfd728fbd218182b08609f6be804d202a8279 | 9,495 | hxx | C++ | src/libserver/html/html_block.hxx | msuslu/rspamd | 95764f816a9e1251a755c6edad339637345cfe28 | [
"Apache-2.0"
] | 1 | 2017-10-24T22:23:44.000Z | 2017-10-24T22:23:44.000Z | src/libserver/html/html_block.hxx | msuslu/rspamd | 95764f816a9e1251a755c6edad339637345cfe28 | [
"Apache-2.0"
] | null | null | null | src/libserver/html/html_block.hxx | msuslu/rspamd | 95764f816a9e1251a755c6edad339637345cfe28 | [
"Apache-2.0"
] | 1 | 2022-02-20T17:41:48.000Z | 2022-02-20T17:41:48.000Z | /*-
* Copyright 2021 Vsevolod Stakhov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RSPAMD_HTML_BLOCK_HXX
#define RSPAMD_HTML_BLOCK_HXX
#pragma once
#include "libserver/css/css_value.hxx"
#include <cmath>
namespace rspamd::html {
/*
* Block tag definition
*/
struct html_block {
rspamd::css::css_color fg_color;
rspamd::css::css_color bg_color;
std::int16_t height;
std::int16_t width;
rspamd::css::css_display_value display;
std::int8_t font_size;
unsigned fg_color_mask : 2;
unsigned bg_color_mask : 2;
unsigned height_mask : 2;
unsigned width_mask : 2;
unsigned font_mask : 2;
unsigned display_mask : 2;
unsigned visibility_mask : 2;
constexpr static const auto unset = 0;
constexpr static const auto inherited = 1;
constexpr static const auto implicit = 1;
constexpr static const auto set = 3;
constexpr static const auto invisible_flag = 1;
constexpr static const auto transparent_flag = 2;
/* Helpers to set mask when setting the elements */
auto set_fgcolor(const rspamd::css::css_color &c, int how = html_block::set) -> void {
fg_color = c;
fg_color_mask = how;
}
auto set_bgcolor(const rspamd::css::css_color &c, int how = html_block::set) -> void {
bg_color = c;
bg_color_mask = how;
}
auto set_height(float h, bool is_percent = false, int how = html_block::set) -> void {
h = is_percent ? (-h) : h;
if (h < INT16_MIN) {
/* Negative numbers encode percents... */
height = -100;
}
else if (h > INT16_MAX) {
height = INT16_MAX;
}
else {
height = h;
}
height_mask = how;
}
auto set_width(float w, bool is_percent = false, int how = html_block::set) -> void {
w = is_percent ? (-w) : w;
if (w < INT16_MIN) {
width = INT16_MIN;
}
else if (w > INT16_MAX) {
width = INT16_MAX;
}
else {
width = w;
}
width_mask = how;
}
auto set_display(bool v, int how = html_block::set) -> void {
if (v) {
display = rspamd::css::css_display_value::DISPLAY_INLINE;
}
else {
display = rspamd::css::css_display_value::DISPLAY_HIDDEN;
}
display_mask = how;
}
auto set_display(rspamd::css::css_display_value v, int how = html_block::set) -> void {
display = v;
display_mask = how;
}
auto set_font_size(float fs, bool is_percent = false, int how = html_block::set) -> void {
fs = is_percent ? (-fs) : fs;
if (fs < INT8_MIN) {
font_size = -100;
}
else if (fs > INT8_MAX) {
font_size = INT8_MAX;
}
else {
font_size = fs;
}
font_mask = how;
}
private:
template<typename T, typename MT>
static constexpr auto simple_prop(MT mask_val, MT other_mask, T &our_val,
T other_val) -> MT
{
if (other_mask && other_mask > mask_val) {
our_val = other_val;
mask_val = html_block::inherited;
}
return mask_val;
}
/* Sizes propagation logic
* We can have multiple cases:
* 1) Our size is > 0 and we can use it as is
* 2) Parent size is > 0 and our size is undefined, so propagate parent
* 3) Parent size is < 0 and our size is undefined - propagate parent
* 4) Parent size is > 0 and our size is < 0 - multiply parent by abs(ours)
* 5) Parent size is undefined and our size is < 0 - tricky stuff, assume some defaults
*/
template<typename T, typename MT>
static constexpr auto size_prop (MT mask_val, MT other_mask, T &our_val,
T other_val, T default_val) -> MT
{
if (mask_val) {
/* We have our value */
if (our_val < 0) {
if (other_mask > 0) {
if (other_val >= 0) {
our_val = other_val * (-our_val / 100.0);
}
else {
our_val *= (-other_val / 100.0);
}
}
else {
/* Parent value is not defined and our value is relative */
our_val = default_val * (-our_val / 100.0);
}
}
else if (other_mask && other_mask > mask_val) {
our_val = other_val;
mask_val = html_block::inherited;
}
}
else {
/* We propagate parent if defined */
if (other_mask && other_mask > mask_val) {
our_val = other_val;
mask_val = html_block::inherited;
}
/* Otherwise do nothing */
}
return mask_val;
}
public:
/**
* Propagate values from the block if they are not defined by the current block
* @param other
* @return
*/
auto propagate_block(const html_block &other) -> void {
fg_color_mask = html_block::simple_prop(fg_color_mask, other.fg_color_mask,
fg_color, other.fg_color);
bg_color_mask = html_block::simple_prop(bg_color_mask, other.bg_color_mask,
bg_color, other.bg_color);
display_mask = html_block::simple_prop(display_mask, other.display_mask,
display, other.display);
height_mask = html_block::size_prop(height_mask, other.height_mask,
height, other.height, static_cast<std::int16_t>(800));
width_mask = html_block::size_prop(width_mask, other.width_mask,
width, other.width, static_cast<std::int16_t>(1024));
font_mask = html_block::size_prop(font_mask, other.font_mask,
font_size, other.font_size, static_cast<std::int8_t>(10));
}
/*
* Set block overriding all inherited values
*/
auto set_block(const html_block &other) -> void {
constexpr auto set_value = [](auto mask_val, auto other_mask, auto &our_val,
auto other_val) constexpr -> int {
if (other_mask && mask_val != html_block::set) {
our_val = other_val;
mask_val = other_mask;
}
return mask_val;
};
fg_color_mask = set_value(fg_color_mask, other.fg_color_mask, fg_color, other.fg_color);
bg_color_mask = set_value(bg_color_mask, other.bg_color_mask, bg_color, other.bg_color);
display_mask = set_value(display_mask, other.display_mask, display, other.display);
height_mask = set_value(height_mask, other.height_mask, height, other.height);
width_mask = set_value(width_mask, other.width_mask, width, other.width);
font_mask = set_value(font_mask, other.font_mask, font_size, other.font_size);
}
auto compute_visibility(void) -> void {
if (display_mask) {
if (display == css::css_display_value::DISPLAY_HIDDEN) {
visibility_mask = html_block::invisible_flag;
return;
}
}
if (font_mask) {
if (font_size == 0) {
visibility_mask = html_block::invisible_flag;
return;
}
}
auto is_similar_colors = [](const rspamd::css::css_color &fg, const rspamd::css::css_color &bg) -> bool {
constexpr const auto min_visible_diff = 0.1f;
auto diff_r = ((float)fg.r - bg.r);
auto diff_g = ((float)fg.g - bg.g);
auto diff_b = ((float)fg.b - bg.b);
auto ravg = ((float)fg.r + bg.r) / 2.0f;
/* Square diffs */
diff_r *= diff_r;
diff_g *= diff_g;
diff_b *= diff_b;
auto diff = std::sqrt(2.0f * diff_r + 4.0f * diff_g + 3.0f * diff_b +
(ravg * (diff_r - diff_b) / 256.0f)) / 256.0f;
return diff < min_visible_diff;
};
/* Check if we have both bg/fg colors */
if (fg_color_mask && bg_color_mask) {
if (fg_color.alpha < 10) {
/* Too transparent */
visibility_mask = html_block::transparent_flag;
return;
}
if (bg_color.alpha > 10) {
if (is_similar_colors(fg_color, bg_color)) {
visibility_mask = html_block::transparent_flag;
return;
}
}
}
else if (fg_color_mask) {
/* Merely fg color */
if (fg_color.alpha < 10) {
/* Too transparent */
visibility_mask = html_block::transparent_flag;
return;
}
/* Implicit fg color */
if (is_similar_colors(fg_color, rspamd::css::css_color::white())) {
visibility_mask = html_block::transparent_flag;
return;
}
}
else if (bg_color_mask) {
if (bg_color.alpha > 10) {
if (is_similar_colors(rspamd::css::css_color::black(), bg_color)) {
visibility_mask = html_block::transparent_flag;
return;
}
}
}
visibility_mask = html_block::unset;
}
constexpr auto is_visible(void) const -> bool {
return visibility_mask == html_block::unset;
}
constexpr auto is_transparent(void) const -> bool {
return visibility_mask == html_block::transparent_flag;
}
constexpr auto has_display(int how = html_block::set) const -> bool {
return display_mask >= how;
}
/**
* Returns a default html block for root HTML element
* @return
*/
static auto default_html_block(void) -> html_block {
return html_block{.fg_color = rspamd::css::css_color::black(),
.bg_color = rspamd::css::css_color::white(),
.height = 0,
.width = 0,
.display = rspamd::css::css_display_value::DISPLAY_INLINE,
.font_size = 12,
.fg_color_mask = html_block::inherited,
.bg_color_mask = html_block::inherited,
.height_mask = html_block::unset,
.width_mask = html_block::unset,
.font_mask = html_block::unset,
.display_mask = html_block::inherited,
.visibility_mask = html_block::unset};
}
/**
* Produces html block with no defined values allocated from the pool
* @param pool
* @return
*/
static auto undefined_html_block_pool(rspamd_mempool_t *pool) -> html_block* {
auto *bl = rspamd_mempool_alloc0_type(pool, html_block);
return bl;
}
};
}
#endif //RSPAMD_HTML_BLOCK_HXX
| 27.763158 | 107 | 0.67288 | msuslu |
9cdcb7d8b7ee69bc1dedd8cda1a889a343814e31 | 41,185 | cpp | C++ | tests/unit/TAO/API/tokens.cpp | cyptoman/LLL-TAO | dfaad5497e280df576b6d2e7959f82874c42fe3e | [
"MIT"
] | null | null | null | tests/unit/TAO/API/tokens.cpp | cyptoman/LLL-TAO | dfaad5497e280df576b6d2e7959f82874c42fe3e | [
"MIT"
] | null | null | null | tests/unit/TAO/API/tokens.cpp | cyptoman/LLL-TAO | dfaad5497e280df576b6d2e7959f82874c42fe3e | [
"MIT"
] | null | null | null | /*__________________________________________________________________________________________
(c) Hash(BEGIN(Satoshi[2010]), END(Sunny[2012])) == Videlicet[2014] ++
(c) Copyright The Nexus Developers 2014 - 2019
Distributed under the MIT software license, see the accompanying
file COPYING or http://www.opensource.org/licenses/mit-license.php.
"ad vocem populi" - To the Voice of the People
____________________________________________________________________________________________*/
#include "util.h"
#include <LLC/include/random.h>
#include <unit/catch2/catch.hpp>
#include <LLD/include/global.h>
#include <TAO/Ledger/types/transaction.h>
#include <TAO/Ledger/include/chainstate.h>
#include <TAO/Operation/include/enum.h>
#include <TAO/Operation/include/execute.h>
#include <TAO/Register/include/create.h>
#include <TAO/API/types/names.h>
TEST_CASE( "Test Tokens API - create token", "[tokens/create/token]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" + std::to_string(LLC::GetRand());
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* tokens/create/token fail with missing pin (only relevant for multiuser)*/
if(config::fMultiuser.load())
{
/* Build the parameters to pass to the API */
params.clear();
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -129);
}
/* tokens/create/token fail with missing session (only relevant for multiuser)*/
if(config::fMultiuser.load())
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -12);
}
/* tokens/create/token fail with missing supply */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -119);
}
/* tokens/create/token success */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
}
}
TEST_CASE( "Test Tokens API - debit token", "[tokens/debit/token]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* Create Token */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
}
/* Test fail with missing amount */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -46);
}
/* Test fail with missing name / address*/
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["address_to"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -33);
}
/* Test fail with invalid name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["name_to"] = "random";
params["name"] = "random";
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Test fail with invalid address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["address_to"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
params["address"] = TAO::Register::Address(TAO::Register::Address::TOKEN).ToString();
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -122);
}
/* Test fail with missing name_to / address_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["amount"] = "100";
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -64);
}
/* Test fail with invalid name_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["amount"] = "100";
params["name_to"] = "random";
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Create an account to send to */
std::string strAccountAddress;
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = "main";
params["token_name"] = strToken;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
strAccountAddress = result["address"].get<std::string>();
}
/* Test success case by name_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["amount"] = "100";
params["name_to"] = "main";
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
REQUIRE(result.find("txid") != result.end());
}
/* Test success case by address_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["amount"] = "100";
params["address_to"] = strAccountAddress;
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
REQUIRE(result.find("txid") != result.end());
}
}
TEST_CASE( "Test Tokens API - credit token", "[tokens/credit/token]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
std::string strTXID;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* Create Token to debit and then credit*/
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
}
/* Create debit transaction to random address (we will be crediting it back to ourselves so it doesn't matter where it goes) */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["amount"] = "100";
params["address_to"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
/* Invoke the API */
ret = APICall("tokens/debit/token", params);
REQUIRE(result.find("txid") != result.end());
strTXID = result["txid"].get<std::string>();
}
/* Test fail with missing txid */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/credit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -50);
}
/* Test fail with invalid txid */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["txid"] = LLC::GetRand256().GetHex();
/* Invoke the API */
ret = APICall("tokens/credit/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -40);
}
/* Test success case */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["txid"] = strTXID;
/* Invoke the API */
ret = APICall("tokens/credit/token", params);
REQUIRE(result.find("txid") != result.end());
}
}
TEST_CASE( "Test Tokens API - get token", "[tokens/get/token]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
std::string strTokenAddress;
std::string strTXID;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* Create Token to retrieve */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
strTokenAddress = result["address"].get<std::string>();
}
/* Test fail with missing name / address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/get/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -33);
}
/* Test fail with invalid name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = "asdfsdfsdf";
/* Invoke the API */
ret = APICall("tokens/get/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Test fail with invalid address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = TAO::Register::Address(TAO::Register::Address::TOKEN).ToString();
/* Invoke the API */
ret = APICall("tokens/get/token", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -122);
}
/* Test successful get by name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
/* Invoke the API */
ret = APICall("tokens/get/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("owner") != result.end());
REQUIRE(result.find("created") != result.end());
REQUIRE(result.find("modified") != result.end());
REQUIRE(result.find("name") != result.end());
REQUIRE(result.find("address") != result.end());
REQUIRE(result.find("balance") != result.end());
REQUIRE(result.find("maxsupply") != result.end());
REQUIRE(result.find("currentsupply") != result.end());
REQUIRE(result.find("decimals") != result.end());
}
/* Test successful get by address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = strTokenAddress;
/* Invoke the API */
ret = APICall("tokens/get/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("owner") != result.end());
REQUIRE(result.find("created") != result.end());
REQUIRE(result.find("modified") != result.end());
REQUIRE(result.find("name") != result.end());
REQUIRE(result.find("address") != result.end());
REQUIRE(result.find("balance") != result.end());
REQUIRE(result.find("maxsupply") != result.end());
REQUIRE(result.find("currentsupply") != result.end());
REQUIRE(result.find("decimals") != result.end());
}
}
TEST_CASE( "Test Tokens API - create account", "[tokens/create/account]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
std::string strTokenAddress;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* create token to create account for */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
strTokenAddress = result["address"].get<std::string>();
}
/* tokens/create/account fail with missing pin (only relevant for multiuser)*/
if(config::fMultiuser.load())
{
/* Build the parameters to pass to the API */
params.clear();
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -129);
}
/* tokens/create/account fail with missing session (only relevant for multiuser)*/
if(config::fMultiuser.load())
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -12);
}
/* tokens/create/account fail with missing token name / address*/
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -37);
}
/* tokens/create/account by token name success */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["token_name"] = strToken;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
}
/* tokens/create/account by token address success */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["token"] = strTokenAddress;
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
}
}
TEST_CASE( "Test Tokens API - debit account", "[tokens/debit/account]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
TAO::Register::Address hashToken = TAO::Register::Address(TAO::Register::Address::TOKEN);
std::string strAccount = "ACCOUNT" +std::to_string(LLC::GetRand());
TAO::Register::Address hashAccount = TAO::Register::Address(TAO::Register::Address::ACCOUNT);
uint512_t hashDebitTx;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* create token to create account for */
{
//create the transaction object
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 0;
tx.nTimestamp = runtime::timestamp();
//create object
TAO::Register::Object token = TAO::Register::CreateToken(hashToken, 1000000, 2);
//payload
tx[0] << uint8_t(TAO::Operation::OP::CREATE) << hashToken << uint8_t(TAO::Register::REGISTER::OBJECT) << token.GetState();
//create name
tx[1] = TAO::API::Names::CreateName(GENESIS1, strToken, "", hashToken);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
//commit to disk
REQUIRE(Execute(tx[1], TAO::Ledger::FLAGS::BLOCK));
}
/* create account to debit */
{
//create the transaction object
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 1;
tx.nTimestamp = runtime::timestamp();
//create object
TAO::Register::Object account = TAO::Register::CreateAccount(hashToken);
//payload
tx[0] << uint8_t(TAO::Operation::OP::CREATE) << hashAccount << uint8_t(TAO::Register::REGISTER::OBJECT) << account.GetState();
//create name
tx[1] = TAO::API::Names::CreateName(GENESIS1, strAccount, "", hashAccount);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
//commit to disk
REQUIRE(Execute(tx[1], TAO::Ledger::FLAGS::BLOCK));
}
/* Test fail with missing amount */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -46);
}
/* Test fail with missing name / address*/
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["address_to"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -33);
}
/* Test fail with invalid name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["name_to"] = "random";
params["name"] = "random";
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Test fail with invalid address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["amount"] = "100";
params["address_to"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
params["address"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -122);
}
/* Test fail with missing name_to / address_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = hashAccount.ToString();
params["amount"] = "100";
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -64);
}
/* Test fail with invalid name_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = hashAccount.ToString();
params["amount"] = "100";
params["name_to"] = "random";
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Test fail with insufficient funds */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = hashAccount.ToString();
params["amount"] = "100";
params["address_to"] = hashToken.ToString();
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -69);
}
/* Debit the token and credit the account so that we have some funds to debit */
{
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 0;
tx.nTimestamp = runtime::timestamp();
//payload
tx[0] << uint8_t(TAO::Operation::OP::DEBIT) << hashToken << hashAccount << uint64_t(100000) << uint64_t(0);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//write transaction
REQUIRE(LLD::Ledger->WriteTx(tx.GetHash(), tx));
REQUIRE(LLD::Ledger->IndexBlock(tx.GetHash(), TAO::Ledger::ChainState::Genesis()));
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
hashDebitTx = tx.GetHash();
}
{
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 1;
tx.nTimestamp = runtime::timestamp();
//payload
tx[0] << uint8_t(TAO::Operation::OP::CREDIT) << hashDebitTx << uint32_t(0) << hashAccount << hashToken << uint64_t(100000);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//write transaction
REQUIRE(LLD::Ledger->WriteTx(tx.GetHash(), tx));
REQUIRE(LLD::Ledger->IndexBlock(tx.GetHash(), TAO::Ledger::ChainState::Genesis()));
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
}
/* Test success case by name_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strAccount;
params["amount"] = "100";
params["name_to"] = strToken;
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
}
/* Test success case by address_to */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = hashAccount.ToString();
params["amount"] = "100";
params["address_to"] = hashToken.ToString();
/* Invoke the API */
ret = APICall("tokens/debit/account", params);
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
}
}
TEST_CASE( "Test Tokens API - credit account", "[tokens/credit/account]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" + std::to_string(LLC::GetRand());
TAO::Register::Address hashToken = TAO::Register::Address(TAO::Register::Address::TOKEN);
std::string strAccount = "ACCOUNT" + std::to_string(LLC::GetRand());
TAO::Register::Address hashAccount = TAO::Register::Address(TAO::Register::Address::ACCOUNT);
std::string strTXID;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* create token to create account for */
{
//create the transaction object
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 0;
tx.nTimestamp = runtime::timestamp();
//create object
TAO::Register::Object token = TAO::Register::CreateToken(hashToken, 10000, 2);
//payload
tx[0] << uint8_t(TAO::Operation::OP::CREATE) << hashToken << uint8_t(TAO::Register::REGISTER::OBJECT) << token.GetState();
//create name
tx[1] = TAO::API::Names::CreateName(GENESIS1, strToken, "", hashToken);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
//commit to disk
REQUIRE(Execute(tx[1], TAO::Ledger::FLAGS::BLOCK));
}
/* create account to debit */
{
//create the transaction object
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 1;
tx.nTimestamp = runtime::timestamp();
//create object
TAO::Register::Object account = TAO::Register::CreateAccount(hashToken);
//create name
TAO::Register::Object name = TAO::Register::CreateName("", strToken, hashAccount);
//payload
tx[0] << uint8_t(TAO::Operation::OP::CREATE) << hashAccount << uint8_t(TAO::Register::REGISTER::OBJECT) << account.GetState();
//create name
tx[1] = TAO::API::Names::CreateName(GENESIS1, strAccount, "", hashAccount);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
//commit to disk
REQUIRE(Execute(tx[1], TAO::Ledger::FLAGS::BLOCK));
}
/* Debit the token and credit the account so that we have some funds to debit */
{
TAO::Ledger::Transaction tx;
tx.hashGenesis = GENESIS1;
tx.nSequence = 2;
tx.nTimestamp = runtime::timestamp();
//payload
tx[0] << uint8_t(TAO::Operation::OP::DEBIT) << hashToken << hashAccount << uint64_t(1000) << uint64_t(0);
//generate the prestates and poststates
REQUIRE(tx.Build());
//verify the prestates and poststates
REQUIRE(tx.Verify());
//write transaction
REQUIRE(LLD::Ledger->WriteTx(tx.GetHash(), tx));
REQUIRE(LLD::Ledger->IndexBlock(tx.GetHash(), TAO::Ledger::ChainState::Genesis()));
//commit to disk
REQUIRE(Execute(tx[0], TAO::Ledger::FLAGS::BLOCK));
strTXID = tx.GetHash().GetHex();
}
/* Test fail with missing txid */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/credit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -50);
}
/* Test fail with invalid txid */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["txid"] = LLC::GetRand256().GetHex();
/* Invoke the API */
ret = APICall("tokens/credit/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -40);
}
/* Test success case */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["txid"] = strTXID;
/* Invoke the API */
ret = APICall("tokens/credit/account", params);
/* Check the result */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
}
}
TEST_CASE( "Test Tokens API - get account", "[tokens/get/account]")
{
/* Declare variables shared across test cases */
json::json params;
json::json ret;
json::json result;
json::json error;
/* Generate random token name */
std::string strToken = "TOKEN" +std::to_string(LLC::GetRand());
TAO::Register::Address hashToken = TAO::Register::Address(TAO::Register::Address::TOKEN);
std::string strAccount = "ACCOUNT" +std::to_string(LLC::GetRand());
TAO::Register::Address hashAccount = TAO::Register::Address(TAO::Register::Address::ACCOUNT);
std::string strTXID;
/* Ensure user is created and logged in for testing */
InitializeUser(USERNAME1, PASSWORD, PIN, GENESIS1, SESSION1);
/* create token to create account for */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strToken;
params["supply"] = "10000";
params["decimals"] = "2";
/* Invoke the API */
ret = APICall("tokens/create/token", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
hashToken.SetBase58( result["address"].get<std::string>());
}
/* tokens/create/account by token address success */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strAccount;
params["token"] = hashToken.ToString();
/* Invoke the API */
ret = APICall("tokens/create/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("txid") != result.end());
REQUIRE(result.find("address") != result.end());
hashAccount.SetBase58( result["address"].get<std::string>());
}
/* Test fail with missing name / address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
/* Invoke the API */
ret = APICall("tokens/get/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -33);
}
/* Test fail with invalid name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = "asdfsdfsdf";
/* Invoke the API */
ret = APICall("tokens/get/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -101);
}
/* Test fail with invalid address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = TAO::Register::Address(TAO::Register::Address::ACCOUNT).ToString();
/* Invoke the API */
ret = APICall("tokens/get/account", params);
/* Check response is an error and validate error code */
REQUIRE(ret.find("error") != ret.end());
REQUIRE(ret["error"]["code"].get<int32_t>() == -122);
}
/* Test successful get by name */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["name"] = strAccount;
/* Invoke the API */
ret = APICall("tokens/get/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("owner") != result.end());
REQUIRE(result.find("created") != result.end());
REQUIRE(result.find("modified") != result.end());
REQUIRE(result.find("name") != result.end());
REQUIRE(result.find("address") != result.end());
REQUIRE(result.find("token_name") != result.end());
REQUIRE(result.find("token") != result.end());
REQUIRE(result.find("balance") != result.end());
}
/* Test successful get by address */
{
/* Build the parameters to pass to the API */
params.clear();
params["pin"] = PIN;
params["session"] = SESSION1;
params["address"] = hashAccount.ToString();
/* Invoke the API */
ret = APICall("tokens/get/account", params);
/* Check that the result is as we expect it to be */
REQUIRE(ret.find("result") != ret.end());
result = ret["result"];
REQUIRE(result.find("owner") != result.end());
REQUIRE(result.find("created") != result.end());
REQUIRE(result.find("modified") != result.end());
REQUIRE(result.find("name") != result.end());
REQUIRE(result.find("address") != result.end());
REQUIRE(result.find("token_name") != result.end());
REQUIRE(result.find("token") != result.end());
REQUIRE(result.find("balance") != result.end());
}
}
| 31.705158 | 134 | 0.566808 | cyptoman |
9cdcee2c61b64c8f4d0e8d25efdd8f038d2a1ed0 | 3,040 | cpp | C++ | Source/Engine/ING/Source/ING/Rendering/Pipeline/Pipeline.cpp | n-c0d3r/ING | f858c973e1b31ffc6deb324fa52eda6323d2c165 | [
"MIT"
] | 2 | 2022-01-21T04:03:55.000Z | 2022-03-19T08:54:00.000Z | Source/Engine/ING/Source/ING/Rendering/Pipeline/Pipeline.cpp | n-c0d3r/ING | f858c973e1b31ffc6deb324fa52eda6323d2c165 | [
"MIT"
] | null | null | null | Source/Engine/ING/Source/ING/Rendering/Pipeline/Pipeline.cpp | n-c0d3r/ING | f858c973e1b31ffc6deb324fa52eda6323d2c165 | [
"MIT"
] | null | null | null |
/**
* Include Header
*/
#include "Pipeline.h"
/**
* Include Camera
*/
#include <ING/Camera/Camera.h>
/**
* Include Renderer
*/
#include <ING/Rendering/Renderer/Renderer.h>
/**
* Include Rendering API
*/
#include <ING/Rendering/API/API.h>
/**
* Include Rendering Device Context
*/
#include <ING/Rendering/API/Device/Context/Context.h>
/**
* Include Rendering Device
*/
#include <ING/Rendering/API/Device/Device.h>
/**
* Include Rendering Pass
*/
#include <ING/Rendering/Pass/Pass.h>
namespace ING {
namespace Rendering {
/**IIDeviceContext
* Constructors And Destructor
*/
IPipeline::IPipeline (const String& name) :
renderer(0)
{
this->name = name;
isRendering = false;
}
IPipeline::~IPipeline () {
}
/**
* Release Methods
*/
void IPipeline::Release() {
for (unsigned int i = 0; i < passVector.size(); ++i) {
passVector[i]->Release();
}
passVector.clear();
for (Camera* camera : CameraManager::GetInstance()->GetCameraList()) {
if (camera->GetRenderingPipeline() == this) {
ClearCameraData(camera);
camera->SetRenderingPipeline(0);
}
}
delete this;
}
/**
* Methods
*/
void IPipeline::AddPass(IPass* pass) {
AddPass(pass, passVector.size());
}
void IPipeline::AddPass(IPass* pass, unsigned int index) {
if (passVector.size() == index) {
passVector.push_back(pass);
}
else {
passVector.insert(passVector.begin() + index, pass);
unsigned int passCount = passVector.size();
for (unsigned int i = index + 1; i < passCount; ++i) {
name2PassIndex[passVector[i]->GetName()]++;
}
}
name2PassIndex[pass->GetName()] = index;
pass->parent = 0;
pass->SetPipeline(this);
}
void IPipeline::RemovePass(unsigned int index) {
String passName = GetPass(index)->GetName();
GetPass(index)->SetPipeline(0);
passVector.erase(passVector.begin() + index);
unsigned int passCount = passVector.size();
for (unsigned int i = index + 1; i < passCount; ++i) {
name2PassIndex[passVector[i]->GetName()]--;
}
name2PassIndex.erase(passName);
}
void IPipeline::RemovePass(const String& name) {
RemovePass(name2PassIndex[name]);
}
void IPipeline::RemovePass(IPass* pass) {
RemovePass(pass->GetName());
}
void IPipeline::SetupCamera (IDeviceContext* context, Camera* camera) {
}
void IPipeline::ClearCameraData(Camera* camera) {
camera->SetRenderingData(0);
}
bool IPipeline::Render (IDeviceContext* context) {
BeginRender(context);
EndRender(context);
return true;
}
void IPipeline::BeginRender(IDeviceContext* context) {
isRendering = true;
for (Camera* camera : CameraManager::GetInstance()->GetCameraList()) {
if (camera->GetRenderingPipeline() == this && camera->GetRenderingData() == 0) {
SetupCamera(context, camera);
}
}
}
void IPipeline::EndRender(IDeviceContext* context) {
isRendering = false;
}
}
} | 13.755656 | 84 | 0.630921 | n-c0d3r |
9ce4ebac3eb6cf5e5f748d0e54b3afb8a9f0a016 | 9,147 | cpp | C++ | src/qt/src/gui/widgets/qradiobutton.cpp | martende/phantomjs | 5cecd7dde7b8fd04ad2c036d16f09a8d2a139854 | [
"BSD-3-Clause"
] | 1 | 2015-03-16T20:49:09.000Z | 2015-03-16T20:49:09.000Z | src/qt/src/gui/widgets/qradiobutton.cpp | firedfox/phantomjs | afb0707c9db7b5e693ad1b216a50081565c08ebb | [
"BSD-3-Clause"
] | null | null | null | src/qt/src/gui/widgets/qradiobutton.cpp | firedfox/phantomjs | afb0707c9db7b5e693ad1b216a50081565c08ebb | [
"BSD-3-Clause"
] | null | null | null | /****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qradiobutton.h"
#include "qapplication.h"
#include "qbitmap.h"
#include "qbuttongroup.h"
#include "qstylepainter.h"
#include "qstyle.h"
#include "qstyleoption.h"
#include "qevent.h"
#include "private/qabstractbutton_p.h"
QT_BEGIN_NAMESPACE
class QRadioButtonPrivate : public QAbstractButtonPrivate
{
Q_DECLARE_PUBLIC(QRadioButton)
public:
QRadioButtonPrivate() : QAbstractButtonPrivate(QSizePolicy::RadioButton), hovering(true) {}
void init();
uint hovering : 1;
};
/*
Initializes the radio button.
*/
void QRadioButtonPrivate::init()
{
Q_Q(QRadioButton);
q->setCheckable(true);
q->setAutoExclusive(true);
q->setMouseTracking(true);
q->setForegroundRole(QPalette::WindowText);
setLayoutItemMargins(QStyle::SE_RadioButtonLayoutItem);
}
/*!
\class QRadioButton
\brief The QRadioButton widget provides a radio button with a text label.
\ingroup basicwidgets
A QRadioButton is an option button that can be switched on (checked) or
off (unchecked). Radio buttons typically present the user with a "one
of many" choice. In a group of radio buttons only one radio button at
a time can be checked; if the user selects another button, the
previously selected button is switched off.
Radio buttons are autoExclusive by default. If auto-exclusive is
enabled, radio buttons that belong to the same parent widget
behave as if they were part of the same exclusive button group. If
you need multiple exclusive button groups for radio buttons that
belong to the same parent widget, put them into a QButtonGroup.
Whenever a button is switched on or off it emits the toggled() signal.
Connect to this signal if you want to trigger an action each time the
button changes state. Use isChecked() to see if a particular button is
selected.
Just like QPushButton, a radio button displays text, and
optionally a small icon. The icon is set with setIcon(). The text
can be set in the constructor or with setText(). A shortcut key
can be specified by preceding the preferred character with an
ampersand in the text. For example:
\snippet doc/src/snippets/code/src_gui_widgets_qradiobutton.cpp 0
In this example the shortcut is \e{Alt+c}. See the \l
{QShortcut#mnemonic}{QShortcut} documentation for details (to
display an actual ampersand, use '&&').
Important inherited members: text(), setText(), text(),
setDown(), isDown(), autoRepeat(), group(), setAutoRepeat(),
toggle(), pressed(), released(), clicked(), and toggled().
\table 100%
\row \o \inlineimage plastique-radiobutton.png Screenshot of a Plastique radio button
\o A radio button shown in the \l{Plastique Style Widget Gallery}{Plastique widget style}.
\row \o \inlineimage windows-radiobutton.png Screenshot of a Windows XP radio button
\o A radio button shown in the \l{Windows XP Style Widget Gallery}{Windows XP widget style}.
\row \o \inlineimage macintosh-radiobutton.png Screenshot of a Macintosh radio button
\o A radio button shown in the \l{Macintosh Style Widget Gallery}{Macintosh widget style}.
\endtable
\sa QPushButton, QToolButton, QCheckBox, {fowler}{GUI Design Handbook: Radio Button},
{Group Box Example}
*/
/*!
Constructs a radio button with the given \a parent, but with no text or
pixmap.
The \a parent argument is passed on to the QAbstractButton constructor.
*/
QRadioButton::QRadioButton(QWidget *parent)
: QAbstractButton(*new QRadioButtonPrivate, parent)
{
Q_D(QRadioButton);
d->init();
}
/*!
Constructs a radio button with the given \a parent and a \a text string.
The \a parent argument is passed on to the QAbstractButton constructor.
*/
QRadioButton::QRadioButton(const QString &text, QWidget *parent)
: QAbstractButton(*new QRadioButtonPrivate, parent)
{
Q_D(QRadioButton);
d->init();
setText(text);
}
/*!
Initialize \a option with the values from this QRadioButton. This method is useful
for subclasses when they need a QStyleOptionButton, but don't want to fill
in all the information themselves.
\sa QStyleOption::initFrom()
*/
void QRadioButton::initStyleOption(QStyleOptionButton *option) const
{
if (!option)
return;
Q_D(const QRadioButton);
option->initFrom(this);
option->text = d->text;
option->icon = d->icon;
option->iconSize = iconSize();
if (d->down)
option->state |= QStyle::State_Sunken;
option->state |= (d->checked) ? QStyle::State_On : QStyle::State_Off;
if (testAttribute(Qt::WA_Hover) && underMouse()) {
if (d->hovering)
option->state |= QStyle::State_MouseOver;
else
option->state &= ~QStyle::State_MouseOver;
}
}
/*!
\reimp
*/
QSize QRadioButton::sizeHint() const
{
Q_D(const QRadioButton);
if (d->sizeHint.isValid())
return d->sizeHint;
ensurePolished();
QStyleOptionButton opt;
initStyleOption(&opt);
QSize sz = style()->itemTextRect(fontMetrics(), QRect(), Qt::TextShowMnemonic,
false, text()).size();
if (!opt.icon.isNull())
sz = QSize(sz.width() + opt.iconSize.width() + 4, qMax(sz.height(), opt.iconSize.height()));
d->sizeHint = (style()->sizeFromContents(QStyle::CT_RadioButton, &opt, sz, this).
expandedTo(QApplication::globalStrut()));
return d->sizeHint;
}
/*!
\reimp
\since 4.8
*/
QSize QRadioButton::minimumSizeHint() const
{
return sizeHint();
}
/*!
\reimp
*/
bool QRadioButton::hitButton(const QPoint &pos) const
{
QStyleOptionButton opt;
initStyleOption(&opt);
return style()->subElementRect(QStyle::SE_RadioButtonClickRect, &opt, this).contains(pos);
}
/*!
\reimp
*/
void QRadioButton::mouseMoveEvent(QMouseEvent *e)
{
Q_D(QRadioButton);
if (testAttribute(Qt::WA_Hover)) {
bool hit = false;
if (underMouse())
hit = hitButton(e->pos());
if (hit != d->hovering) {
update();
d->hovering = hit;
}
}
QAbstractButton::mouseMoveEvent(e);
}
/*!\reimp
*/
void QRadioButton::paintEvent(QPaintEvent *)
{
QStylePainter p(this);
QStyleOptionButton opt;
initStyleOption(&opt);
p.drawControl(QStyle::CE_RadioButton, opt);
}
/*! \reimp */
bool QRadioButton::event(QEvent *e)
{
Q_D(QRadioButton);
if (e->type() == QEvent::StyleChange
#ifdef Q_WS_MAC
|| e->type() == QEvent::MacSizeChange
#endif
)
d->setLayoutItemMargins(QStyle::SE_RadioButtonLayoutItem);
return QAbstractButton::event(e);
}
#ifdef QT3_SUPPORT
/*!
Use one of the constructors that doesn't take the \a name
argument and then use setObjectName() instead.
*/
QRadioButton::QRadioButton(QWidget *parent, const char* name)
: QAbstractButton(*new QRadioButtonPrivate, parent)
{
Q_D(QRadioButton);
d->init();
setObjectName(QString::fromAscii(name));
}
/*!
Use one of the constructors that doesn't take the \a name
argument and then use setObjectName() instead.
*/
QRadioButton::QRadioButton(const QString &text, QWidget *parent, const char* name)
: QAbstractButton(*new QRadioButtonPrivate, parent)
{
Q_D(QRadioButton);
d->init();
setObjectName(QString::fromAscii(name));
setText(text);
}
#endif
QT_END_NAMESPACE
| 30.694631 | 101 | 0.682738 | martende |
9ce7ea7fb4855c7e3170a351895aa88d36813e37 | 10,616 | cpp | C++ | src/objects/smoke/SmokeIcon-gen.cpp | steptosky/3DsMax-X-Obj-Exporter | c70f5a60056ee71aba1569f1189c38b9e01d2f0e | [
"BSD-3-Clause"
] | 20 | 2017-07-07T06:07:30.000Z | 2022-03-09T12:00:57.000Z | src/objects/smoke/SmokeIcon-gen.cpp | steptosky/3DsMax-X-Obj-Exporter | c70f5a60056ee71aba1569f1189c38b9e01d2f0e | [
"BSD-3-Clause"
] | 28 | 2017-07-07T06:08:27.000Z | 2022-03-09T12:09:23.000Z | src/objects/smoke/SmokeIcon-gen.cpp | steptosky/3DsMax-X-Obj-Exporter | c70f5a60056ee71aba1569f1189c38b9e01d2f0e | [
"BSD-3-Clause"
] | 7 | 2018-01-24T19:43:22.000Z | 2020-01-06T00:05:40.000Z | #include "SmokeIcon-gen.h"
#pragma warning(push, 0)
#include <max.h>
#pragma warning(pop)
/* Auto-generated file */
void SmokeIcon::fillMesh(Mesh & outMesh, const float scale) {
outMesh.setNumVerts(48);
outMesh.setNumFaces(42);
outMesh.verts[0].x = scale * 0.500000f;
outMesh.verts[0].y = scale * 0.000000f;
outMesh.verts[0].z = scale * 0.000000f;
outMesh.verts[1].x = scale * 0.460672f;
outMesh.verts[1].y = scale * 0.194517f;
outMesh.verts[1].z = scale * 0.000000f;
outMesh.verts[2].x = scale * 0.353460f;
outMesh.verts[2].y = scale * 0.353460f;
outMesh.verts[2].z = scale * 0.000000f;
outMesh.verts[3].x = scale * 0.194517f;
outMesh.verts[3].y = scale * 0.460672f;
outMesh.verts[3].z = scale * 0.000000f;
outMesh.verts[4].x = scale * -0.000000f;
outMesh.verts[4].y = scale * 0.500000f;
outMesh.verts[4].z = scale * 0.000000f;
outMesh.verts[5].x = scale * -0.194517f;
outMesh.verts[5].y = scale * 0.460672f;
outMesh.verts[5].z = scale * 0.000000f;
outMesh.verts[6].x = scale * -0.353460f;
outMesh.verts[6].y = scale * 0.353460f;
outMesh.verts[6].z = scale * 0.000000f;
outMesh.verts[7].x = scale * -0.460672f;
outMesh.verts[7].y = scale * 0.194517f;
outMesh.verts[7].z = scale * 0.000000f;
outMesh.verts[8].x = scale * -0.500000f;
outMesh.verts[8].y = scale * -0.000000f;
outMesh.verts[8].z = scale * 0.000000f;
outMesh.verts[9].x = scale * -0.460672f;
outMesh.verts[9].y = scale * -0.194517f;
outMesh.verts[9].z = scale * 0.000000f;
outMesh.verts[10].x = scale * -0.353460f;
outMesh.verts[10].y = scale * -0.353460f;
outMesh.verts[10].z = scale * 0.000000f;
outMesh.verts[11].x = scale * -0.194517f;
outMesh.verts[11].y = scale * -0.460672f;
outMesh.verts[11].z = scale * 0.000000f;
outMesh.verts[12].x = scale * 0.000000f;
outMesh.verts[12].y = scale * -0.500000f;
outMesh.verts[12].z = scale * 0.000000f;
outMesh.verts[13].x = scale * 0.194517f;
outMesh.verts[13].y = scale * -0.460672f;
outMesh.verts[13].z = scale * 0.000000f;
outMesh.verts[14].x = scale * 0.353460f;
outMesh.verts[14].y = scale * -0.353460f;
outMesh.verts[14].z = scale * 0.000000f;
outMesh.verts[15].x = scale * 0.460672f;
outMesh.verts[15].y = scale * -0.194517f;
outMesh.verts[15].z = scale * 0.000000f;
outMesh.verts[16].x = scale * 0.500000f;
outMesh.verts[16].y = scale * 0.000000f;
outMesh.verts[16].z = scale * 0.000000f;
outMesh.verts[17].x = scale * 0.460672f;
outMesh.verts[17].y = scale * -0.000000f;
outMesh.verts[17].z = scale * 0.194517f;
outMesh.verts[18].x = scale * 0.353460f;
outMesh.verts[18].y = scale * -0.000000f;
outMesh.verts[18].z = scale * 0.353460f;
outMesh.verts[19].x = scale * 0.194517f;
outMesh.verts[19].y = scale * -0.000000f;
outMesh.verts[19].z = scale * 0.460672f;
outMesh.verts[20].x = scale * -0.000000f;
outMesh.verts[20].y = scale * -0.000000f;
outMesh.verts[20].z = scale * 0.500000f;
outMesh.verts[21].x = scale * -0.194517f;
outMesh.verts[21].y = scale * -0.000000f;
outMesh.verts[21].z = scale * 0.460672f;
outMesh.verts[22].x = scale * -0.353460f;
outMesh.verts[22].y = scale * -0.000000f;
outMesh.verts[22].z = scale * 0.353460f;
outMesh.verts[23].x = scale * -0.460672f;
outMesh.verts[23].y = scale * -0.000000f;
outMesh.verts[23].z = scale * 0.194517f;
outMesh.verts[24].x = scale * -0.500000f;
outMesh.verts[24].y = scale * 0.000000f;
outMesh.verts[24].z = scale * -0.000000f;
outMesh.verts[25].x = scale * -0.460672f;
outMesh.verts[25].y = scale * 0.000000f;
outMesh.verts[25].z = scale * -0.194517f;
outMesh.verts[26].x = scale * -0.353460f;
outMesh.verts[26].y = scale * 0.000000f;
outMesh.verts[26].z = scale * -0.353460f;
outMesh.verts[27].x = scale * -0.194517f;
outMesh.verts[27].y = scale * 0.000000f;
outMesh.verts[27].z = scale * -0.460672f;
outMesh.verts[28].x = scale * 0.000000f;
outMesh.verts[28].y = scale * 0.000000f;
outMesh.verts[28].z = scale * -0.500000f;
outMesh.verts[29].x = scale * 0.194517f;
outMesh.verts[29].y = scale * 0.000000f;
outMesh.verts[29].z = scale * -0.460672f;
outMesh.verts[30].x = scale * 0.353460f;
outMesh.verts[30].y = scale * 0.000000f;
outMesh.verts[30].z = scale * -0.353460f;
outMesh.verts[31].x = scale * 0.460672f;
outMesh.verts[31].y = scale * 0.000000f;
outMesh.verts[31].z = scale * -0.194517f;
outMesh.verts[32].x = scale * -0.000000f;
outMesh.verts[32].y = scale * -0.500000f;
outMesh.verts[32].z = scale * 0.000000f;
outMesh.verts[33].x = scale * -0.000000f;
outMesh.verts[33].y = scale * -0.460672f;
outMesh.verts[33].z = scale * 0.194517f;
outMesh.verts[34].x = scale * -0.000000f;
outMesh.verts[34].y = scale * -0.353460f;
outMesh.verts[34].z = scale * 0.353460f;
outMesh.verts[35].x = scale * -0.000000f;
outMesh.verts[35].y = scale * -0.194517f;
outMesh.verts[35].z = scale * 0.460672f;
outMesh.verts[36].x = scale * -0.000000f;
outMesh.verts[36].y = scale * 0.000000f;
outMesh.verts[36].z = scale * 0.500000f;
outMesh.verts[37].x = scale * -0.000000f;
outMesh.verts[37].y = scale * 0.194517f;
outMesh.verts[37].z = scale * 0.460672f;
outMesh.verts[38].x = scale * 0.000000f;
outMesh.verts[38].y = scale * 0.353460f;
outMesh.verts[38].z = scale * 0.353460f;
outMesh.verts[39].x = scale * 0.000000f;
outMesh.verts[39].y = scale * 0.460672f;
outMesh.verts[39].z = scale * 0.194517f;
outMesh.verts[40].x = scale * 0.000000f;
outMesh.verts[40].y = scale * 0.500000f;
outMesh.verts[40].z = scale * -0.000000f;
outMesh.verts[41].x = scale * 0.000000f;
outMesh.verts[41].y = scale * 0.460672f;
outMesh.verts[41].z = scale * -0.194517f;
outMesh.verts[42].x = scale * 0.000000f;
outMesh.verts[42].y = scale * 0.353460f;
outMesh.verts[42].z = scale * -0.353460f;
outMesh.verts[43].x = scale * 0.000000f;
outMesh.verts[43].y = scale * 0.194517f;
outMesh.verts[43].z = scale * -0.460672f;
outMesh.verts[44].x = scale * 0.000000f;
outMesh.verts[44].y = scale * -0.000000f;
outMesh.verts[44].z = scale * -0.500000f;
outMesh.verts[45].x = scale * 0.000000f;
outMesh.verts[45].y = scale * -0.194517f;
outMesh.verts[45].z = scale * -0.460672f;
outMesh.verts[46].x = scale * 0.000000f;
outMesh.verts[46].y = scale * -0.353460f;
outMesh.verts[46].z = scale * -0.353460f;
outMesh.verts[47].x = scale * -0.000000f;
outMesh.verts[47].y = scale * -0.460672f;
outMesh.verts[47].z = scale * -0.194517f;
outMesh.faces[0].setVerts(11, 12, 13);
outMesh.faces[0].setEdgeVisFlags(1, 2, 0);
outMesh.faces[1].setVerts(11, 13, 14);
outMesh.faces[1].setEdgeVisFlags(0, 2, 0);
outMesh.faces[2].setVerts(10, 11, 14);
outMesh.faces[2].setEdgeVisFlags(1, 0, 0);
outMesh.faces[3].setVerts(10, 14, 15);
outMesh.faces[3].setEdgeVisFlags(0, 2, 0);
outMesh.faces[4].setVerts(10, 15, 0);
outMesh.faces[4].setEdgeVisFlags(0, 2, 0);
outMesh.faces[5].setVerts(10, 0, 1);
outMesh.faces[5].setEdgeVisFlags(0, 2, 0);
outMesh.faces[6].setVerts(10, 1, 2);
outMesh.faces[6].setEdgeVisFlags(0, 2, 0);
outMesh.faces[7].setVerts(10, 2, 3);
outMesh.faces[7].setEdgeVisFlags(0, 2, 0);
outMesh.faces[8].setVerts(10, 3, 4);
outMesh.faces[8].setEdgeVisFlags(0, 2, 0);
outMesh.faces[9].setVerts(10, 4, 5);
outMesh.faces[9].setEdgeVisFlags(0, 2, 0);
outMesh.faces[10].setVerts(10, 5, 6);
outMesh.faces[10].setEdgeVisFlags(0, 2, 0);
outMesh.faces[11].setVerts(10, 6, 7);
outMesh.faces[11].setEdgeVisFlags(0, 2, 0);
outMesh.faces[12].setVerts(10, 7, 8);
outMesh.faces[12].setEdgeVisFlags(0, 2, 0);
outMesh.faces[13].setVerts(10, 8, 9);
outMesh.faces[13].setEdgeVisFlags(0, 2, 4);
outMesh.faces[14].setVerts(27, 28, 29);
outMesh.faces[14].setEdgeVisFlags(1, 2, 0);
outMesh.faces[15].setVerts(27, 29, 30);
outMesh.faces[15].setEdgeVisFlags(0, 2, 0);
outMesh.faces[16].setVerts(26, 27, 30);
outMesh.faces[16].setEdgeVisFlags(1, 0, 0);
outMesh.faces[17].setVerts(26, 30, 31);
outMesh.faces[17].setEdgeVisFlags(0, 2, 0);
outMesh.faces[18].setVerts(26, 31, 16);
outMesh.faces[18].setEdgeVisFlags(0, 2, 0);
outMesh.faces[19].setVerts(26, 16, 17);
outMesh.faces[19].setEdgeVisFlags(0, 2, 0);
outMesh.faces[20].setVerts(26, 17, 18);
outMesh.faces[20].setEdgeVisFlags(0, 2, 0);
outMesh.faces[21].setVerts(26, 18, 19);
outMesh.faces[21].setEdgeVisFlags(0, 2, 0);
outMesh.faces[22].setVerts(26, 19, 20);
outMesh.faces[22].setEdgeVisFlags(0, 2, 0);
outMesh.faces[23].setVerts(26, 20, 21);
outMesh.faces[23].setEdgeVisFlags(0, 2, 0);
outMesh.faces[24].setVerts(26, 21, 22);
outMesh.faces[24].setEdgeVisFlags(0, 2, 0);
outMesh.faces[25].setVerts(26, 22, 23);
outMesh.faces[25].setEdgeVisFlags(0, 2, 0);
outMesh.faces[26].setVerts(26, 23, 24);
outMesh.faces[26].setEdgeVisFlags(0, 2, 0);
outMesh.faces[27].setVerts(26, 24, 25);
outMesh.faces[27].setEdgeVisFlags(0, 2, 4);
outMesh.faces[28].setVerts(43, 44, 45);
outMesh.faces[28].setEdgeVisFlags(1, 2, 0);
outMesh.faces[29].setVerts(43, 45, 46);
outMesh.faces[29].setEdgeVisFlags(0, 2, 0);
outMesh.faces[30].setVerts(42, 43, 46);
outMesh.faces[30].setEdgeVisFlags(1, 0, 0);
outMesh.faces[31].setVerts(42, 46, 47);
outMesh.faces[31].setEdgeVisFlags(0, 2, 0);
outMesh.faces[32].setVerts(42, 47, 32);
outMesh.faces[32].setEdgeVisFlags(0, 2, 0);
outMesh.faces[33].setVerts(42, 32, 33);
outMesh.faces[33].setEdgeVisFlags(0, 2, 0);
outMesh.faces[34].setVerts(42, 33, 34);
outMesh.faces[34].setEdgeVisFlags(0, 2, 0);
outMesh.faces[35].setVerts(42, 34, 35);
outMesh.faces[35].setEdgeVisFlags(0, 2, 0);
outMesh.faces[36].setVerts(42, 35, 36);
outMesh.faces[36].setEdgeVisFlags(0, 2, 0);
outMesh.faces[37].setVerts(42, 36, 37);
outMesh.faces[37].setEdgeVisFlags(0, 2, 0);
outMesh.faces[38].setVerts(42, 37, 38);
outMesh.faces[38].setEdgeVisFlags(0, 2, 0);
outMesh.faces[39].setVerts(42, 38, 39);
outMesh.faces[39].setEdgeVisFlags(0, 2, 0);
outMesh.faces[40].setVerts(42, 39, 40);
outMesh.faces[40].setEdgeVisFlags(0, 2, 0);
outMesh.faces[41].setVerts(42, 40, 41);
outMesh.faces[41].setEdgeVisFlags(0, 2, 4);
outMesh.InvalidateGeomCache();
}
| 43.330612 | 61 | 0.62905 | steptosky |
9ce801751ff185cf1c4837105a9b4cdeb1187ecc | 6,460 | cpp | C++ | Tests/LibC/strlcpy-correctness.cpp | shubhdev/serenity | 9321d9d83d366ad4cf686c856063ff9ac97c18a4 | [
"BSD-2-Clause"
] | 4 | 2021-02-23T05:35:25.000Z | 2021-06-08T06:11:06.000Z | Tests/LibC/strlcpy-correctness.cpp | shubhdev/serenity | 9321d9d83d366ad4cf686c856063ff9ac97c18a4 | [
"BSD-2-Clause"
] | 4 | 2021-04-27T20:44:44.000Z | 2021-06-30T18:07:10.000Z | Tests/LibC/strlcpy-correctness.cpp | shubhdev/serenity | 9321d9d83d366ad4cf686c856063ff9ac97c18a4 | [
"BSD-2-Clause"
] | 1 | 2022-01-10T08:02:34.000Z | 2022-01-10T08:02:34.000Z | /*
* Copyright (c) 2020, Ben Wiederhake <[email protected]>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibTest/TestCase.h>
#include <AK/ByteBuffer.h>
#include <AK/Random.h>
#include <AK/StringBuilder.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
struct Testcase {
const char* dest;
size_t dest_n;
const char* src;
size_t src_n;
const char* dest_expected;
size_t dest_expected_n; // == dest_n
};
static String show(const ByteBuffer& buf)
{
StringBuilder builder;
for (size_t i = 0; i < buf.size(); ++i) {
builder.appendff("{:02x}", buf[i]);
}
builder.append(' ');
builder.append('(');
for (size_t i = 0; i < buf.size(); ++i) {
if (isprint(buf[i]))
builder.append(buf[i]);
else
builder.append('_');
}
builder.append(')');
return builder.build();
}
static bool test_single(const Testcase& testcase)
{
constexpr size_t SANDBOX_CANARY_SIZE = 8;
// Preconditions:
if (testcase.dest_n != testcase.dest_expected_n) {
warnln("dest length {} != expected dest length {}? Check testcase! (Probably miscounted.)", testcase.dest_n, testcase.dest_expected_n);
return false;
}
if (testcase.src_n != strlen(testcase.src)) {
warnln("src length {} != actual src length {}? src can't contain NUL bytes!", testcase.src_n, strlen(testcase.src));
return false;
}
// Setup
ByteBuffer actual = ByteBuffer::create_uninitialized(SANDBOX_CANARY_SIZE + testcase.dest_n + SANDBOX_CANARY_SIZE);
fill_with_random(actual.data(), actual.size());
ByteBuffer expected = actual;
VERIFY(actual.offset_pointer(0) != expected.offset_pointer(0));
actual.overwrite(SANDBOX_CANARY_SIZE, testcase.dest, testcase.dest_n);
expected.overwrite(SANDBOX_CANARY_SIZE, testcase.dest_expected, testcase.dest_expected_n);
// "unsigned char" != "char", so we have to convince the compiler to allow this.
char* dst = reinterpret_cast<char*>(actual.offset_pointer(SANDBOX_CANARY_SIZE));
// The actual call:
size_t actual_return = strlcpy(dst, testcase.src, testcase.dest_n);
// Checking the results:
bool return_ok = actual_return == testcase.src_n;
bool canary_1_ok = actual.slice(0, SANDBOX_CANARY_SIZE) == expected.slice(0, SANDBOX_CANARY_SIZE);
bool main_ok = actual.slice(SANDBOX_CANARY_SIZE, testcase.dest_n) == expected.slice(SANDBOX_CANARY_SIZE, testcase.dest_n);
bool canary_2_ok = actual.slice(SANDBOX_CANARY_SIZE + testcase.dest_n, SANDBOX_CANARY_SIZE) == expected.slice(SANDBOX_CANARY_SIZE + testcase.dest_n, SANDBOX_CANARY_SIZE);
bool buf_ok = actual == expected;
// Evaluate gravity:
if (buf_ok && (!canary_1_ok || !main_ok || !canary_2_ok)) {
warnln("Internal error! ({} != {} | {} | {})", buf_ok, canary_1_ok, main_ok, canary_2_ok);
buf_ok = false;
}
if (!canary_1_ok) {
warnln("Canary 1 overwritten: Expected canary {}\n"
" instead got {}",
show(expected.slice(0, SANDBOX_CANARY_SIZE)),
show(actual.slice(0, SANDBOX_CANARY_SIZE)));
}
if (!main_ok) {
warnln("Wrong output: Expected {}\n"
" instead got {}",
show(expected.slice(SANDBOX_CANARY_SIZE, testcase.dest_n)),
show(actual.slice(SANDBOX_CANARY_SIZE, testcase.dest_n)));
}
if (!canary_2_ok) {
warnln("Canary 2 overwritten: Expected {}\n"
" instead got {}",
show(expected.slice(SANDBOX_CANARY_SIZE + testcase.dest_n, SANDBOX_CANARY_SIZE)),
show(actual.slice(SANDBOX_CANARY_SIZE + testcase.dest_n, SANDBOX_CANARY_SIZE)));
}
if (!return_ok) {
warnln("Wrong return value: Expected {}, got {} instead!", testcase.src_n, actual_return);
}
return buf_ok && return_ok;
}
// Drop the NUL terminator added by the C++ compiler.
#define LITERAL(x) x, (sizeof(x) - 1)
//static Testcase TESTCASES[] = {
// // Golden path:
// // Hitting the border:
// // Too long:
// { LITERAL("Hello World!\0"), LITERAL("Hello Friend!"), LITERAL("Hello Friend\0") },
// { LITERAL("Hello World!\0"), LITERAL("This source is just *way* too long!"), LITERAL("This source \0") },
// { LITERAL("x"), LITERAL("This source is just *way* too long!"), LITERAL("\0") },
// // Other special cases:
// { LITERAL(""), LITERAL(""), LITERAL("") },
// { LITERAL(""), LITERAL("Empty test"), LITERAL("") },
// { LITERAL("x"), LITERAL(""), LITERAL("\0") },
// { LITERAL("xx"), LITERAL(""), LITERAL("\0x") },
// { LITERAL("xxx"), LITERAL(""), LITERAL("\0xx") },
//};
TEST_CASE(golden_path)
{
EXPECT(test_single({ LITERAL("Hello World!\0\0\0"), LITERAL("Hello Friend!"), LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single({ LITERAL("Hello World!\0\0\0"), LITERAL("Hello Friend!"), LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single({ LITERAL("aaaaaaaaaa"), LITERAL("whf"), LITERAL("whf\0aaaaaa") }));
}
TEST_CASE(exact_fit)
{
EXPECT(test_single({ LITERAL("Hello World!\0\0"), LITERAL("Hello Friend!"), LITERAL("Hello Friend!\0") }));
EXPECT(test_single({ LITERAL("AAAA"), LITERAL("aaa"), LITERAL("aaa\0") }));
}
TEST_CASE(off_by_one)
{
EXPECT(test_single({ LITERAL("AAAAAAAAAA"), LITERAL("BBBBB"), LITERAL("BBBBB\0AAAA") }));
EXPECT(test_single({ LITERAL("AAAAAAAAAA"), LITERAL("BBBBBBBCC"), LITERAL("BBBBBBBCC\0") }));
EXPECT(test_single({ LITERAL("AAAAAAAAAA"), LITERAL("BBBBBBBCCX"), LITERAL("BBBBBBBCC\0") }));
EXPECT(test_single({ LITERAL("AAAAAAAAAA"), LITERAL("BBBBBBBCCXY"), LITERAL("BBBBBBBCC\0") }));
}
TEST_CASE(nearly_empty)
{
EXPECT(test_single({ LITERAL(""), LITERAL(""), LITERAL("") }));
EXPECT(test_single({ LITERAL(""), LITERAL("Empty test"), LITERAL("") }));
EXPECT(test_single({ LITERAL("x"), LITERAL(""), LITERAL("\0") }));
EXPECT(test_single({ LITERAL("xx"), LITERAL(""), LITERAL("\0x") }));
EXPECT(test_single({ LITERAL("x"), LITERAL("y"), LITERAL("\0") }));
}
static char* const POISON = (char*)1;
TEST_CASE(to_nullptr)
{
EXPECT_EQ(0u, strlcpy(POISON, "", 0));
EXPECT_EQ(1u, strlcpy(POISON, "x", 0));
EXPECT(test_single({ LITERAL("Hello World!\0\0\0"), LITERAL("Hello Friend!"), LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single({ LITERAL("aaaaaaaaaa"), LITERAL("whf"), LITERAL("whf\0aaaaaa") }));
}
| 39.151515 | 174 | 0.632353 | shubhdev |
9ce809c9485d906290ddf8e8833099a7a8f05573 | 2,623 | cpp | C++ | bootloader/bootloader32/src/RealMode.cpp | Rzuwik/FunnyOS | a93a45babf575d08cf2704a8394ac1455f3ad4db | [
"MIT"
] | null | null | null | bootloader/bootloader32/src/RealMode.cpp | Rzuwik/FunnyOS | a93a45babf575d08cf2704a8394ac1455f3ad4db | [
"MIT"
] | null | null | null | bootloader/bootloader32/src/RealMode.cpp | Rzuwik/FunnyOS | a93a45babf575d08cf2704a8394ac1455f3ad4db | [
"MIT"
] | null | null | null | #include "RealMode.hpp"
#include <FunnyOS/Hardware/Interrupts.hpp>
// Defined in real_mode.asm
extern FunnyOS::Bootloader32::Registers32 g_savedRegisters;
extern uint8_t g_realBuffer;
extern uint8_t g_realBufferTop;
F_CDECL extern void do_real_mode_interrupt();
namespace FunnyOS::Bootloader32 {
using namespace Stdlib;
constexpr static uint32_t MAX_REAL_MODE_ADDR = 0xFFFF * 16 + 0xFFFF;
Memory::SizedBuffer<uint8_t>& GetRealModeBuffer() {
static Memory::SizedBuffer<uint8_t> c_realModeBuffer{
&g_realBuffer, reinterpret_cast<size_t>(&g_realBufferTop) - reinterpret_cast<size_t>(&g_realBuffer)};
return c_realModeBuffer;
}
void GetRealModeAddress(void* address, uint16_t& segment, uint16_t& offset) {
GetRealModeAddress(reinterpret_cast<uint32_t>(address), segment, offset);
}
void GetRealModeAddress(uint32_t address, uint16_t& segment, uint16_t& offset) {
F_ASSERT(address < MAX_REAL_MODE_ADDR, "address >= MAX_REAL_MODE_ADDR");
segment = static_cast<uint16_t>((address & 0xF0000) >> 4);
offset = static_cast<uint16_t>(address & 0xFFFF);
}
void GetRealModeBufferAddress(uint16_t& segment, uint16_t& offset) {
auto address = reinterpret_cast<uintptr_t>(GetRealModeBuffer().Data);
GetRealModeAddress(address, segment, offset);
}
void RealModeInt(uint8_t interrupt, Registers32& registers) {
HW::NoInterruptsBlock noInterrupts;
Memory::Copy(static_cast<void*>(&g_savedRegisters), static_cast<void*>(®isters), sizeof(Registers32));
#ifdef __GNUC__
asm(
// Save state
"pushfl \n"
"pushal \n"
"pushw %%es \n"
"pushw %%fs \n"
"pushw %%gs \n"
// Push interrupt number and call do_real_mode_interrupt
"pushl %[int_number] \n"
"call do_real_mode_interrupt \n"
"add $4, %%esp \n"
// Restore state
"popw %%gs \n"
"popw %%fs \n"
"popw %%es \n"
"popal \n"
"popfl \n"
:
: [ int_number ] "a"(static_cast<uintmax_t>(interrupt))
: "memory");
#endif
Memory::Copy(static_cast<void*>(®isters), static_cast<void*>(&g_savedRegisters), sizeof(Registers32));
}
} // namespace FunnyOS::Bootloader32 | 36.430556 | 113 | 0.581014 | Rzuwik |
9ce835cce2288e438bee59f8376b8331e6e442ab | 831 | hpp | C++ | libs/core/include/fcppt/string_literal.hpp | pmiddend/fcppt | 9f437acbb10258e6df6982a550213a05815eb2be | [
"BSL-1.0"
] | null | null | null | libs/core/include/fcppt/string_literal.hpp | pmiddend/fcppt | 9f437acbb10258e6df6982a550213a05815eb2be | [
"BSL-1.0"
] | null | null | null | libs/core/include/fcppt/string_literal.hpp | pmiddend/fcppt | 9f437acbb10258e6df6982a550213a05815eb2be | [
"BSL-1.0"
] | null | null | null | // Copyright Carl Philipp Reh 2009 - 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef FCPPT_STRING_LITERAL_HPP_INCLUDED
#define FCPPT_STRING_LITERAL_HPP_INCLUDED
#include <fcppt/detail/string_literal.hpp>
/**
\brief A char or wchar_t string literal depending on a type.
\ingroup fcpptvarious
If \a _type is char, then the literal will be of type <code>char const *</code>.
If \a _type is wchar_t, then the literal will be of type <code>wchar_t const *</code>.
\param _type Must be char or wchar_t.
\param _literal Must be a string literal.
*/
#define FCPPT_STRING_LITERAL(\
_type,\
_literal\
)\
fcppt::detail::string_literal<\
_type\
>(\
_literal, \
L ## _literal \
)
#endif
| 23.083333 | 86 | 0.724428 | pmiddend |
9ce97fa30f1816d72221b1abc841dfdf364782c0 | 630 | hpp | C++ | engine/Component.hpp | shenchi/gllab | 5d8fe33cd763d5fe5033da106b715751ae2e87ef | [
"MIT"
] | null | null | null | engine/Component.hpp | shenchi/gllab | 5d8fe33cd763d5fe5033da106b715751ae2e87ef | [
"MIT"
] | null | null | null | engine/Component.hpp | shenchi/gllab | 5d8fe33cd763d5fe5033da106b715751ae2e87ef | [
"MIT"
] | null | null | null | #ifndef COMPONENT_H
#define COMPONENT_H
#include "Object.hpp"
class SceneObject;
class Component : public Object
{
public:
enum Type
{
TYPE_UNKNOWN = -1,
TYPE_MESHFILTER,
TYPE_MESHRENDERER,
};
public:
Component( int type ) : m_enabled( true ), m_type( type ), m_owner( 0 ) {}
virtual ~Component() {}
int getType() const { return m_type; }
SceneObject* getOwner() { return m_owner; }
void setOwner( SceneObject* owner ) { m_owner = owner; }
virtual bool onAddToOwner( SceneObject* owner ) { return true; }
protected:
bool m_enabled;
int m_type;
SceneObject* m_owner;
};
#endif // COMPONENT_H | 16.578947 | 75 | 0.687302 | shenchi |
9cea5ca39c94fb894f7d3142ad95c0b527c50fdc | 6,890 | cpp | C++ | waf/src/v20180125/model/CreateAttackDownloadTaskRequest.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | 43 | 2019-08-14T08:14:12.000Z | 2022-03-30T12:35:09.000Z | waf/src/v20180125/model/CreateAttackDownloadTaskRequest.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | 12 | 2019-07-15T10:44:59.000Z | 2021-11-02T12:35:00.000Z | waf/src/v20180125/model/CreateAttackDownloadTaskRequest.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | 28 | 2019-07-12T09:06:22.000Z | 2022-03-30T08:04:18.000Z | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <tencentcloud/waf/v20180125/model/CreateAttackDownloadTaskRequest.h>
#include <tencentcloud/core/utils/rapidjson/document.h>
#include <tencentcloud/core/utils/rapidjson/writer.h>
#include <tencentcloud/core/utils/rapidjson/stringbuffer.h>
using namespace TencentCloud::Waf::V20180125::Model;
using namespace std;
CreateAttackDownloadTaskRequest::CreateAttackDownloadTaskRequest() :
m_domainHasBeenSet(false),
m_fromTimeHasBeenSet(false),
m_toTimeHasBeenSet(false),
m_nameHasBeenSet(false),
m_riskLevelHasBeenSet(false),
m_statusHasBeenSet(false),
m_ruleIdHasBeenSet(false),
m_attackIpHasBeenSet(false),
m_attackTypeHasBeenSet(false)
{
}
string CreateAttackDownloadTaskRequest::ToJsonString() const
{
rapidjson::Document d;
d.SetObject();
rapidjson::Document::AllocatorType& allocator = d.GetAllocator();
if (m_domainHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "Domain";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_domain.c_str(), allocator).Move(), allocator);
}
if (m_fromTimeHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "FromTime";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_fromTime.c_str(), allocator).Move(), allocator);
}
if (m_toTimeHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "ToTime";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_toTime.c_str(), allocator).Move(), allocator);
}
if (m_nameHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "Name";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_name.c_str(), allocator).Move(), allocator);
}
if (m_riskLevelHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "RiskLevel";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, m_riskLevel, allocator);
}
if (m_statusHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "Status";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, m_status, allocator);
}
if (m_ruleIdHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "RuleId";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, m_ruleId, allocator);
}
if (m_attackIpHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "AttackIp";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_attackIp.c_str(), allocator).Move(), allocator);
}
if (m_attackTypeHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "AttackType";
iKey.SetString(key.c_str(), allocator);
d.AddMember(iKey, rapidjson::Value(m_attackType.c_str(), allocator).Move(), allocator);
}
rapidjson::StringBuffer buffer;
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
d.Accept(writer);
return buffer.GetString();
}
string CreateAttackDownloadTaskRequest::GetDomain() const
{
return m_domain;
}
void CreateAttackDownloadTaskRequest::SetDomain(const string& _domain)
{
m_domain = _domain;
m_domainHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::DomainHasBeenSet() const
{
return m_domainHasBeenSet;
}
string CreateAttackDownloadTaskRequest::GetFromTime() const
{
return m_fromTime;
}
void CreateAttackDownloadTaskRequest::SetFromTime(const string& _fromTime)
{
m_fromTime = _fromTime;
m_fromTimeHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::FromTimeHasBeenSet() const
{
return m_fromTimeHasBeenSet;
}
string CreateAttackDownloadTaskRequest::GetToTime() const
{
return m_toTime;
}
void CreateAttackDownloadTaskRequest::SetToTime(const string& _toTime)
{
m_toTime = _toTime;
m_toTimeHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::ToTimeHasBeenSet() const
{
return m_toTimeHasBeenSet;
}
string CreateAttackDownloadTaskRequest::GetName() const
{
return m_name;
}
void CreateAttackDownloadTaskRequest::SetName(const string& _name)
{
m_name = _name;
m_nameHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::NameHasBeenSet() const
{
return m_nameHasBeenSet;
}
uint64_t CreateAttackDownloadTaskRequest::GetRiskLevel() const
{
return m_riskLevel;
}
void CreateAttackDownloadTaskRequest::SetRiskLevel(const uint64_t& _riskLevel)
{
m_riskLevel = _riskLevel;
m_riskLevelHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::RiskLevelHasBeenSet() const
{
return m_riskLevelHasBeenSet;
}
uint64_t CreateAttackDownloadTaskRequest::GetStatus() const
{
return m_status;
}
void CreateAttackDownloadTaskRequest::SetStatus(const uint64_t& _status)
{
m_status = _status;
m_statusHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::StatusHasBeenSet() const
{
return m_statusHasBeenSet;
}
uint64_t CreateAttackDownloadTaskRequest::GetRuleId() const
{
return m_ruleId;
}
void CreateAttackDownloadTaskRequest::SetRuleId(const uint64_t& _ruleId)
{
m_ruleId = _ruleId;
m_ruleIdHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::RuleIdHasBeenSet() const
{
return m_ruleIdHasBeenSet;
}
string CreateAttackDownloadTaskRequest::GetAttackIp() const
{
return m_attackIp;
}
void CreateAttackDownloadTaskRequest::SetAttackIp(const string& _attackIp)
{
m_attackIp = _attackIp;
m_attackIpHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::AttackIpHasBeenSet() const
{
return m_attackIpHasBeenSet;
}
string CreateAttackDownloadTaskRequest::GetAttackType() const
{
return m_attackType;
}
void CreateAttackDownloadTaskRequest::SetAttackType(const string& _attackType)
{
m_attackType = _attackType;
m_attackTypeHasBeenSet = true;
}
bool CreateAttackDownloadTaskRequest::AttackTypeHasBeenSet() const
{
return m_attackTypeHasBeenSet;
}
| 25.518519 | 95 | 0.723077 | suluner |
9cee429080c82d731cdcf91453ceee424a088661 | 150 | hpp | C++ | src/events/interactions/delete-entity.hpp | guillaume-haerinck/imac-tower-defense | 365a32642ea0d3ad8b2b7d63347d585c44d9f670 | [
"MIT"
] | 44 | 2019-06-06T21:33:30.000Z | 2022-03-26T06:18:23.000Z | src/events/interactions/delete-entity.hpp | guillaume-haerinck/imac-tower-defense | 365a32642ea0d3ad8b2b7d63347d585c44d9f670 | [
"MIT"
] | 1 | 2019-09-27T12:04:52.000Z | 2019-09-29T13:30:42.000Z | src/events/interactions/delete-entity.hpp | guillaume-haerinck/imac-tower-defense | 365a32642ea0d3ad8b2b7d63347d585c44d9f670 | [
"MIT"
] | 8 | 2019-07-26T16:44:26.000Z | 2020-11-24T17:56:18.000Z | #pragma once
namespace evnt {
struct DeleteEntity {
DeleteEntity(std::uint32_t entityId) : entityId(entityId) {}
std::uint32_t entityId;
};
}
| 15 | 62 | 0.713333 | guillaume-haerinck |
9ceef42127f999b3cd649487f49ef5175eee3fc0 | 2,149 | cpp | C++ | src/CppUtil/Basic/StrAPI/StrAPI.cpp | huangx916/RenderLab | a0059705d5694146bbe51442e0cabdcbcd750fe7 | [
"MIT"
] | 1 | 2019-09-20T03:04:12.000Z | 2019-09-20T03:04:12.000Z | src/CppUtil/Basic/StrAPI/StrAPI.cpp | huangx916/RenderLab | a0059705d5694146bbe51442e0cabdcbcd750fe7 | [
"MIT"
] | null | null | null | src/CppUtil/Basic/StrAPI/StrAPI.cpp | huangx916/RenderLab | a0059705d5694146bbe51442e0cabdcbcd750fe7 | [
"MIT"
] | null | null | null | #include <CppUtil/Basic/StrAPI.h>
#include <cassert>
#include <algorithm>
using namespace CppUtil::Basic;
using namespace std;
const string StrAPI::Head(const string & str, int n) {
assert(n >= 0);
return str.substr(0, std::min(static_cast<size_t>(n), str.size()));
}
const string StrAPI::Tail(const string & str, int n) {
assert(n >= 0);
return str.substr(str.size() - n, n);
}
const string StrAPI::TailAfter(const string & str, char c) {
auto idx = str.find_last_of(c);
if (idx == string::npos)
return "";
return str.substr(idx + 1);
}
bool StrAPI::IsBeginWith(const string & str, const string & suffix) {
return Head(str, static_cast<int>(suffix.size())) == suffix;
}
bool StrAPI::IsEndWith(const string & str, const string & postfix) {
return Tail(str, static_cast<int>(postfix.size())) == postfix;
}
const vector<string> StrAPI::Spilt(const string & str, const string & separator) {
vector<string> rst;
if (separator.empty())
return rst;
size_t beginIdx = 0;
while(true){
size_t targetIdx = str.find(separator, beginIdx);
if (targetIdx == string::npos) {
rst.push_back(str.substr(beginIdx, str.size() - beginIdx));
break;
}
rst.push_back(str.substr(beginIdx, targetIdx - beginIdx));
beginIdx = targetIdx + separator.size();
}
return rst;
}
const string StrAPI::Join(const vector<string> & strs, const string & separator) {
string rst;
for (size_t i = 0; i < strs.size()-1; i++) {
rst += strs[i];
rst += separator;
}
rst += strs.back();
return rst;
}
const string StrAPI::Replace(const string & str, const string & orig, const string & target) {
return Join(Spilt(str, orig), target);
}
const std::string StrAPI::DelTailAfter(const std::string & str, char c) {
for (size_t i = str.size() - 1; i >= 0; i--) {
if (str[i] == c)
return str.substr(0, i);
}
return str;
}
const string StrAPI::Between(const string & str, char left, char right) {
auto start = str.find_first_of(left, 0);
if (start == string::npos)
return "";
auto end = str.find_last_of(right);
if (end == string::npos || end == start)
return "";
return str.substr(start + 1, end - (start + 1));
}
| 23.107527 | 94 | 0.658911 | huangx916 |
9cef88cd9b8cdde8848478b889a98ca49fb44843 | 9,530 | cpp | C++ | libs/obs/src/CSimpleMap.cpp | feroze/mrpt-shivang | 95bf524c5e10ed2e622bd199f1b0597951b45370 | [
"BSD-3-Clause"
] | 2 | 2017-03-25T18:09:17.000Z | 2017-05-22T08:14:48.000Z | libs/obs/src/CSimpleMap.cpp | feroze/mrpt-shivang | 95bf524c5e10ed2e622bd199f1b0597951b45370 | [
"BSD-3-Clause"
] | null | null | null | libs/obs/src/CSimpleMap.cpp | feroze/mrpt-shivang | 95bf524c5e10ed2e622bd199f1b0597951b45370 | [
"BSD-3-Clause"
] | 1 | 2018-07-29T09:40:46.000Z | 2018-07-29T09:40:46.000Z | /* +---------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| http://www.mrpt.org/ |
| |
| Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
| See: http://www.mrpt.org/Authors - All rights reserved. |
| Released under BSD License. See details in http://www.mrpt.org/License |
+---------------------------------------------------------------------------+ */
#include "obs-precomp.h" // Precompiled headers
#include <mrpt/maps/CSimpleMap.h>
#include <mrpt/utils/CFileGZInputStream.h>
#include <mrpt/utils/CFileGZOutputStream.h>
#include <mrpt/utils/CStream.h>
using namespace mrpt::obs;
using namespace mrpt::maps;
using namespace mrpt::utils;
using namespace mrpt::poses;
using namespace mrpt::poses;
using namespace std;
#include <mrpt/utils/metaprogramming.h>
using namespace mrpt::utils::metaprogramming;
IMPLEMENTS_SERIALIZABLE(CSimpleMap, CSerializable,mrpt::maps)
/*---------------------------------------------------------------
Constructor
---------------------------------------------------------------*/
CSimpleMap::CSimpleMap() : m_posesObsPairs()
{
}
/*---------------------------------------------------------------
Copy
---------------------------------------------------------------*/
CSimpleMap::CSimpleMap( const CSimpleMap &o ) :
m_posesObsPairs( o.m_posesObsPairs )
{
for_each( m_posesObsPairs.begin(), m_posesObsPairs.end(), ObjectPairMakeUnique() );
}
/*---------------------------------------------------------------
Copy
---------------------------------------------------------------*/
CSimpleMap & CSimpleMap::operator = ( const CSimpleMap& o)
{
MRPT_START
//TPosePDFSensFramePair pair;
if (this == &o) return *this; // It may be used sometimes
m_posesObsPairs = o.m_posesObsPairs;
for_each( m_posesObsPairs.begin(), m_posesObsPairs.end(), ObjectPairMakeUnique() );
return *this;
MRPT_END
}
/*---------------------------------------------------------------
size
---------------------------------------------------------------*/
size_t CSimpleMap::size() const
{
return m_posesObsPairs.size();
}
bool CSimpleMap::empty() const {
return m_posesObsPairs.empty();
}
/*---------------------------------------------------------------
clear
---------------------------------------------------------------*/
void CSimpleMap::clear()
{
m_posesObsPairs.clear();
}
/*---------------------------------------------------------------
Destructor
---------------------------------------------------------------*/
CSimpleMap::~CSimpleMap()
{
clear();
}
/*---------------------------------------------------------------
get const
---------------------------------------------------------------*/
void CSimpleMap::get(
size_t index,
CPose3DPDFPtr &out_posePDF,
CSensoryFramePtr &out_SF ) const
{
if (index>=m_posesObsPairs.size())
THROW_EXCEPTION("Index out of bounds");
out_posePDF = m_posesObsPairs[index].first;
out_SF = m_posesObsPairs[index].second;
}
/*---------------------------------------------------------------
remove
---------------------------------------------------------------*/
void CSimpleMap::remove(size_t index)
{
MRPT_START
if (index>=m_posesObsPairs.size())
THROW_EXCEPTION("Index out of bounds");
m_posesObsPairs.erase( m_posesObsPairs.begin() + index );
MRPT_END
}
/*---------------------------------------------------------------
set
---------------------------------------------------------------*/
void CSimpleMap::set(
size_t index,
const CPose3DPDFPtr &in_posePDF,
const CSensoryFramePtr & in_SF )
{
MRPT_START
if (index>=m_posesObsPairs.size())
THROW_EXCEPTION("Index out of bounds");
if (in_posePDF) m_posesObsPairs[index].first = in_posePDF;
if (in_SF) m_posesObsPairs[index].second = in_SF;
MRPT_END
}
/*---------------------------------------------------------------
set 2D
---------------------------------------------------------------*/
void CSimpleMap::set(
size_t index,
const CPosePDFPtr &in_posePDF,
const CSensoryFramePtr &in_SF )
{
MRPT_START
if (index>=m_posesObsPairs.size())
THROW_EXCEPTION("Index out of bounds");
if (in_posePDF) m_posesObsPairs[index].first = CPose3DPDFPtr( CPose3DPDF::createFrom2D( *in_posePDF ) );
if (in_SF) m_posesObsPairs[index].second = in_SF;
MRPT_END
}
/*---------------------------------------------------------------
insert
---------------------------------------------------------------*/
void CSimpleMap::insert( const CPose3DPDF *in_posePDF, const CSensoryFramePtr &in_SF )
{
MRPT_START
TPosePDFSensFramePair pair;
pair.second = in_SF;
pair.first = CPose3DPDFPtr( static_cast<CPose3DPDF*>(in_posePDF->duplicate()) );
m_posesObsPairs.push_back( pair );
MRPT_END
}
/*---------------------------------------------------------------
insert
---------------------------------------------------------------*/
void CSimpleMap::insert(
const CPose3DPDFPtr &in_posePDF,
const CSensoryFramePtr &in_SF )
{
MRPT_START
TPosePDFSensFramePair pair;
pair.second = in_SF;
pair.first = in_posePDF;
m_posesObsPairs.push_back( pair );
MRPT_END
}
/*---------------------------------------------------------------
insert
---------------------------------------------------------------*/
void CSimpleMap::insert( const CPose3DPDF *in_posePDF, const CSensoryFrame &in_SF )
{
MRPT_START
TPosePDFSensFramePair pair;
pair.second = CSensoryFramePtr( new CSensoryFrame(in_SF) );
pair.first = CPose3DPDFPtr( static_cast<CPose3DPDF*>(in_posePDF->duplicate()) );
m_posesObsPairs.push_back( pair );
MRPT_END
}
/*---------------------------------------------------------------
insert
---------------------------------------------------------------*/
void CSimpleMap::insert( const CPosePDF *in_posePDF, const CSensoryFrame &in_SF )
{
MRPT_START
TPosePDFSensFramePair pair;
pair.second = CSensoryFramePtr( new CSensoryFrame(in_SF) );
pair.first = CPose3DPDFPtr( static_cast<CPose3DPDF*>(in_posePDF->duplicate()) );
m_posesObsPairs.push_back( pair );
MRPT_END
}
/*---------------------------------------------------------------
insert
---------------------------------------------------------------*/
void CSimpleMap::insert( const CPosePDF *in_posePDF, const CSensoryFramePtr &in_SF )
{
MRPT_START
TPosePDFSensFramePair pair;
pair.second = in_SF;
pair.first = CPose3DPDFPtr( static_cast<CPose3DPDF*>(in_posePDF->duplicate()) );
m_posesObsPairs.push_back( pair );
MRPT_END
}
/*---------------------------------------------------------------
insert 2D
---------------------------------------------------------------*/
void CSimpleMap::insert(
const CPosePDFPtr &in_posePDF,
const CSensoryFramePtr &in_SF )
{
insert( CPose3DPDFPtr( CPose3DPDF::createFrom2D( *in_posePDF ) ) ,in_SF);
}
/*---------------------------------------------------------------
writeToStream
Implements the writing to a CStream capability of
CSerializable objects
---------------------------------------------------------------*/
void CSimpleMap::writeToStream(mrpt::utils::CStream &out,int *version) const
{
if (version)
*version = 1;
else
{
uint32_t i,n;
n = m_posesObsPairs.size();
out << n;
for (i=0;i<n;i++)
out << *m_posesObsPairs[i].first << *m_posesObsPairs[i].second;
}
}
/*---------------------------------------------------------------
readFromStream
---------------------------------------------------------------*/
void CSimpleMap::readFromStream(mrpt::utils::CStream &in, int version)
{
switch(version)
{
case 1:
{
uint32_t i,n;
clear();
in >> n;
m_posesObsPairs.resize(n);
for (i=0;i<n;i++)
in >> m_posesObsPairs[i].first >> m_posesObsPairs[i].second;
} break;
case 0:
{
// There are 2D poses PDF instead of 3D: transform them:
uint32_t i,n;
clear();
in >> n;
m_posesObsPairs.resize(n);
for (i=0;i<n;i++)
{
CPosePDFPtr aux2Dpose;
in >> aux2Dpose >> m_posesObsPairs[i].second;
m_posesObsPairs[i].first = CPose3DPDFPtr( CPose3DPDF::createFrom2D( *aux2Dpose ) );
}
} break;
default:
MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
};
}
/*---------------------------------------------------------------
changeCoordinatesOrigin
---------------------------------------------------------------*/
void CSimpleMap::changeCoordinatesOrigin( const CPose3D &newOrigin )
{
for (TPosePDFSensFramePairList::iterator it=m_posesObsPairs.begin(); it!=m_posesObsPairs.end(); ++it)
it->first->changeCoordinatesReference(newOrigin);
}
/** Save this object to a .simplemap binary file (compressed with gzip)
* \sa loadFromFile
* \return false on any error.
*/
bool CSimpleMap::saveToFile(const std::string &filName) const
{
try
{
mrpt::utils::CFileGZOutputStream f(filName);
f << *this;
return true;
}
catch (...)
{
return false;
}
}
/** Load the contents of this object from a .simplemap binary file (possibly compressed with gzip)
* \sa saveToFile
* \return false on any error.
*/
bool CSimpleMap::loadFromFile(const std::string &filName)
{
try
{
mrpt::utils::CFileGZInputStream f(filName);
f >> *this;
return true;
}
catch (...)
{
return false;
}
}
| 26.545961 | 106 | 0.495173 | feroze |
9cf11266dce10f9681f3b02109fbecfdde39a2af | 78,227 | cpp | C++ | bench/ml2cpp-demo/XGBClassifier/BreastCancer/ml2cpp-demo_XGBClassifier_BreastCancer.cpp | antoinecarme/ml2cpp | 2b241d44de00eafda620c2b605690276faf5f8fb | [
"BSD-3-Clause"
] | null | null | null | bench/ml2cpp-demo/XGBClassifier/BreastCancer/ml2cpp-demo_XGBClassifier_BreastCancer.cpp | antoinecarme/ml2cpp | 2b241d44de00eafda620c2b605690276faf5f8fb | [
"BSD-3-Clause"
] | 33 | 2020-09-13T09:55:01.000Z | 2022-01-06T11:53:55.000Z | bench/ml2cpp-demo/XGBClassifier/BreastCancer/ml2cpp-demo_XGBClassifier_BreastCancer.cpp | antoinecarme/ml2cpp | 2b241d44de00eafda620c2b605690276faf5f8fb | [
"BSD-3-Clause"
] | 1 | 2021-01-26T14:41:58.000Z | 2021-01-26T14:41:58.000Z | // ********************************************************
// This C++ code was automatically generated by ml2cpp (development version).
// Copyright 2020
// https://github.com/antoinecarme/ml2cpp
// Model : XGBClassifier
// Dataset : BreastCancer
// This CPP code can be compiled using any C++-17 compiler.
// g++ -Wall -Wno-unused-function -std=c++17 -g -o ml2cpp-demo_XGBClassifier_BreastCancer.exe ml2cpp-demo_XGBClassifier_BreastCancer.cpp
// Model deployment code
// ********************************************************
#include "../../Generic.i"
namespace {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
namespace XGB_Tree_0_0 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 3 , {0.577859819 }} ,
{ 4 , {0.104347833 }} ,
{ 5 , {-0.381818205 }} ,
{ 6 , {-0.578181803 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_27 < 0.145449996 ) ? ( ( Feature_22 < 105.850006 ) ? ( 3 ) : ( 4 ) ) : ( ( Feature_0 < 15.2600002 ) ? ( 5 ) : ( 6 ) );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_0
namespace XGB_Tree_0_1 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 2 , {-0.443791091 }} ,
{ 3 , {0.452014327 }} ,
{ 4 , {0.0273430217 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_22 < 114.399994 ) ? ( ( Feature_7 < 0.0489199981 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_1
namespace XGB_Tree_0_2 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 3 , {0.396163613 }} ,
{ 4 , {0.0294305328 }} ,
{ 5 , {-0.232830554 }} ,
{ 6 , {-0.411204338 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_27 < 0.145449996 ) ? ( ( Feature_13 < 32.8499985 ) ? ( 3 ) : ( 4 ) ) : ( ( Feature_21 < 26.2200012 ) ? ( 5 ) : ( 6 ) );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_2
namespace XGB_Tree_0_3 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 2 , {-0.369929641 }} ,
{ 3 , {0.352983713 }} ,
{ 4 , {0.0058717085 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_22 < 117.449997 ) ? ( ( Feature_27 < 0.122299999 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_3
namespace XGB_Tree_0_4 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 3 , {0.331853092 }} ,
{ 4 , {0.0621976517 }} ,
{ 5 , {-0.196852133 }} ,
{ 6 , {-0.360705614 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_20 < 16.7950001 ) ? ( ( Feature_7 < 0.0447399989 ) ? ( 3 ) : ( 4 ) ) : ( ( Feature_1 < 20.2350006 ) ? ( 5 ) : ( 6 ) );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_4
namespace XGB_Tree_0_5 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 2 , {-0.299602687 }} ,
{ 3 , {0.323272616 }} ,
{ 4 , {-0.00179177092 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_27 < 0.150749996 ) ? ( ( Feature_13 < 29.3899994 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_5
namespace XGB_Tree_0_6 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 2 , {-0.257835239 }} ,
{ 3 , {0.318035483 }} ,
{ 4 , {0.0797671974 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_22 < 113.149994 ) ? ( ( Feature_21 < 25.1800003 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_6
namespace XGB_Tree_0_7 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 2 , {-0.183022752 }} ,
{ 3 , {0.148378 }} ,
{ 4 , {0.320678353 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_7 < 0.0489199981 ) ? ( ( Feature_15 < 0.0144750001 ) ? ( 3 ) : ( 4 ) ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_7
namespace XGB_Tree_0_8 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.26075694 }} ,
{ 2 , {-0.140906826 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_23 < 739.199951 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_8
namespace XGB_Tree_0_9 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.257348537 }} ,
{ 2 , {-0.121567562 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_26 < 0.224800006 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_9
namespace XGB_Tree_0_10 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.271092504 }} ,
{ 2 , {-0.100576989 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_21 < 23.0250015 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_10
namespace XGB_Tree_0_11 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.172649145 }} ,
{ 2 , {-0.193059087 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_13 < 34.4049988 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_11
namespace XGB_Tree_0_12 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.181349665 }} ,
{ 2 , {-0.152797535 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_27 < 0.130999997 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_12
namespace XGB_Tree_0_13 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.153317034 }} ,
{ 2 , {-0.155450851 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_23 < 822.849976 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_13
namespace XGB_Tree_0_14 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.153998569 }} ,
{ 2 , {-0.142487958 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_1 < 19.4699993 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_14
namespace XGB_Tree_0_15 {
std::vector<std::any> get_classes(){
std::vector<std::any> lClasses = { 0, 1 };
return lClasses;
}
typedef std::vector<double> tNodeData;
std::map<int, tNodeData> Decision_Tree_Node_data = {
{ 1 , {0.141609788 }} ,
{ 2 , {-0.121677577 }}
};
int get_decision_tree_node_index(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
int lNodeIndex = ( Feature_27 < 0.130999997 ) ? ( 1 ) : ( 2 );
return lNodeIndex;
}
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
int lNodeIndex = get_decision_tree_node_index(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29);
std::vector<double> lNodeValue = Decision_Tree_Node_data[ lNodeIndex ];
tTable lTable;
lTable["Score"] = {
lNodeValue [0],
1.0 - lNodeValue [0]
} ;
lTable["Proba"] = {
std::any(),
std::any()
} ;
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace XGB_Tree_0_15
std::vector<std::string> get_input_names(){
std::vector<std::string> lFeatures = { "Feature_0", "Feature_1", "Feature_2", "Feature_3", "Feature_4", "Feature_5", "Feature_6", "Feature_7", "Feature_8", "Feature_9", "Feature_10", "Feature_11", "Feature_12", "Feature_13", "Feature_14", "Feature_15", "Feature_16", "Feature_17", "Feature_18", "Feature_19", "Feature_20", "Feature_21", "Feature_22", "Feature_23", "Feature_24", "Feature_25", "Feature_26", "Feature_27", "Feature_28", "Feature_29" };
return lFeatures;
}
std::vector<std::string> get_output_names(){
std::vector<std::string> lOutputs = {
"Score_0", "Score_1",
"Proba_0", "Proba_1",
"LogProba_0", "LogProba_1",
"Decision", "DecisionProba" };
return lOutputs;
}
tTable compute_classification_scores(std::any Feature_0, std::any Feature_1, std::any Feature_2, std::any Feature_3, std::any Feature_4, std::any Feature_5, std::any Feature_6, std::any Feature_7, std::any Feature_8, std::any Feature_9, std::any Feature_10, std::any Feature_11, std::any Feature_12, std::any Feature_13, std::any Feature_14, std::any Feature_15, std::any Feature_16, std::any Feature_17, std::any Feature_18, std::any Feature_19, std::any Feature_20, std::any Feature_21, std::any Feature_22, std::any Feature_23, std::any Feature_24, std::any Feature_25, std::any Feature_26, std::any Feature_27, std::any Feature_28, std::any Feature_29) {
auto lClasses = get_classes();
std::vector<tTable> lTreeScores = {
XGB_Tree_0_0::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_1::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_2::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_3::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_4::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_5::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_6::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_7::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_8::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_9::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_10::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_11::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_12::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_13::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_14::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29),
XGB_Tree_0_15::compute_classification_scores(Feature_0, Feature_1, Feature_2, Feature_3, Feature_4, Feature_5, Feature_6, Feature_7, Feature_8, Feature_9, Feature_10, Feature_11, Feature_12, Feature_13, Feature_14, Feature_15, Feature_16, Feature_17, Feature_18, Feature_19, Feature_20, Feature_21, Feature_22, Feature_23, Feature_24, Feature_25, Feature_26, Feature_27, Feature_28, Feature_29)
};
tTable lAggregatedTable = aggregate_xgb_scores(lTreeScores, {"Score"});
tTable lTable;
lTable["Score"] = {
std::any(),
std::any()
} ;
lTable["Proba"] = {
1.0 - logistic(lAggregatedTable["Score"][0]),
logistic(lAggregatedTable["Score"][0])
} ;
int lBestClass = get_arg_max( lTable["Proba"] );
auto lDecision = lClasses[lBestClass];
lTable["Decision"] = { lDecision } ;
lTable["DecisionProba"] = { lTable["Proba"][lBestClass] };
recompute_log_probas( lTable );
return lTable;
}
tTable compute_model_outputs_from_table( tTable const & iTable) {
tTable lTable = compute_classification_scores(iTable.at("Feature_0")[0], iTable.at("Feature_1")[0], iTable.at("Feature_2")[0], iTable.at("Feature_3")[0], iTable.at("Feature_4")[0], iTable.at("Feature_5")[0], iTable.at("Feature_6")[0], iTable.at("Feature_7")[0], iTable.at("Feature_8")[0], iTable.at("Feature_9")[0], iTable.at("Feature_10")[0], iTable.at("Feature_11")[0], iTable.at("Feature_12")[0], iTable.at("Feature_13")[0], iTable.at("Feature_14")[0], iTable.at("Feature_15")[0], iTable.at("Feature_16")[0], iTable.at("Feature_17")[0], iTable.at("Feature_18")[0], iTable.at("Feature_19")[0], iTable.at("Feature_20")[0], iTable.at("Feature_21")[0], iTable.at("Feature_22")[0], iTable.at("Feature_23")[0], iTable.at("Feature_24")[0], iTable.at("Feature_25")[0], iTable.at("Feature_26")[0], iTable.at("Feature_27")[0], iTable.at("Feature_28")[0], iTable.at("Feature_29")[0]);
return lTable;
}
} // eof namespace
int main() {
score_csv_file("outputs/ml2cpp-demo/datasets/BreastCancer.csv");
return 0;
}
| 63.495942 | 879 | 0.705294 | antoinecarme |
9cf1ff5ce94f952820716473210d2675e3b89cc1 | 543 | cpp | C++ | Day-08/Day-08-CodeForces/492B-VanyaAndLanterns.cpp | LawranceMichaelite/100-Days-of-Code | de80015c2ab7c94956d4fe39f6e143627cdd7bc9 | [
"Apache-2.0"
] | null | null | null | Day-08/Day-08-CodeForces/492B-VanyaAndLanterns.cpp | LawranceMichaelite/100-Days-of-Code | de80015c2ab7c94956d4fe39f6e143627cdd7bc9 | [
"Apache-2.0"
] | null | null | null | Day-08/Day-08-CodeForces/492B-VanyaAndLanterns.cpp | LawranceMichaelite/100-Days-of-Code | de80015c2ab7c94956d4fe39f6e143627cdd7bc9 | [
"Apache-2.0"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
int main()
{
int num , atMost ;
cin >> num >> atMost ;
vector<double>ans(num , 0.0);
for(int i = 0; i < num ; i++)
{
cin >> ans[i];
}
sort(ans.begin(),ans.end());
double max_dist = 0.0;
for(int i = 0 ; i < num-1 ; i++)
{
if(ans[i+1]-ans[i] > max_dist)
max_dist = ans[i+1]-ans[i];
}
max_dist = max(max_dist/2 , max(ans[0]-0 , atMost-ans[num-1]));
cout << fixed << setprecision(10) << max_dist << endl;
return 0;
}
| 22.625 | 67 | 0.499079 | LawranceMichaelite |
9cf4f4d54a34373d40e5e0a366a6396a2e2110f4 | 2,608 | cpp | C++ | src/game/shared/cstrike/hegrenade_projectile.cpp | DeadZoneLuna/csso-src | 6c978ea304ee2df3796bc9c0d2916bac550050d5 | [
"Unlicense"
] | 3 | 2020-12-15T23:09:28.000Z | 2022-01-13T15:55:04.000Z | src/game/shared/cstrike/hegrenade_projectile.cpp | DeadZoneLuna/csso-src | 6c978ea304ee2df3796bc9c0d2916bac550050d5 | [
"Unlicense"
] | null | null | null | src/game/shared/cstrike/hegrenade_projectile.cpp | DeadZoneLuna/csso-src | 6c978ea304ee2df3796bc9c0d2916bac550050d5 | [
"Unlicense"
] | 2 | 2021-12-30T02:28:31.000Z | 2022-03-05T08:34:15.000Z | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "hegrenade_projectile.h"
#include "soundent.h"
#include "cs_player.h"
#include "KeyValues.h"
#include "weapon_csbase.h"
#define GRENADE_MODEL "models/weapons/w_eq_fraggrenade_thrown.mdl"
LINK_ENTITY_TO_CLASS( hegrenade_projectile, CHEGrenadeProjectile );
PRECACHE_WEAPON_REGISTER( hegrenade_projectile );
CHEGrenadeProjectile* CHEGrenadeProjectile::Create(
const Vector &position,
const QAngle &angles,
const Vector &velocity,
const AngularImpulse &angVelocity,
CBaseCombatCharacter *pOwner,
float timer )
{
CHEGrenadeProjectile *pGrenade = (CHEGrenadeProjectile*)CBaseEntity::Create( "hegrenade_projectile", position, angles, pOwner );
// Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
// one second before detonation.
pGrenade->SetDetonateTimerLength( 1.5 );
pGrenade->SetAbsVelocity( velocity );
pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
pGrenade->SetThrower( pOwner );
pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
pGrenade->m_flDamage = 100;
pGrenade->m_DmgRadius = pGrenade->m_flDamage * 3.5f;
pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
// make NPCs afaid of it while in the air
pGrenade->SetThink( &CHEGrenadeProjectile::DangerSoundThink );
pGrenade->SetNextThink( gpGlobals->curtime );
pGrenade->m_pWeaponInfo = GetWeaponInfo( WEAPON_HEGRENADE );
return pGrenade;
}
void CHEGrenadeProjectile::Spawn()
{
SetModel( GRENADE_MODEL );
BaseClass::Spawn();
}
void CHEGrenadeProjectile::Precache()
{
PrecacheModel( GRENADE_MODEL );
PrecacheScriptSound( "HEGrenade.Bounce" );
BaseClass::Precache();
}
void CHEGrenadeProjectile::BounceSound( void )
{
EmitSound( "HEGrenade.Bounce" );
}
void CHEGrenadeProjectile::Detonate()
{
BaseClass::Detonate();
// tell the bots an HE grenade has exploded
CCSPlayer *player = ToCSPlayer(GetThrower());
if ( player )
{
IGameEvent * event = gameeventmanager->CreateEvent( "hegrenade_detonate" );
if ( event )
{
event->SetInt( "userid", player->GetUserID() );
event->SetFloat( "x", GetAbsOrigin().x );
event->SetFloat( "y", GetAbsOrigin().y );
event->SetFloat( "z", GetAbsOrigin().z );
gameeventmanager->FireEvent( event );
}
}
}
| 27.452632 | 129 | 0.716641 | DeadZoneLuna |
9cf6c32549d863e360858d3e90445c96c91a2ac7 | 2,417 | cpp | C++ | examples/priority-schedule.cpp | dan65prc/conduit | 6f73416c8b5526a84a21415d5079bb2b61772144 | [
"BSD-3-Clause"
] | 5 | 2018-08-01T02:52:11.000Z | 2020-09-19T08:12:07.000Z | examples/priority-schedule.cpp | dan65prc/conduit | 6f73416c8b5526a84a21415d5079bb2b61772144 | [
"BSD-3-Clause"
] | null | null | null | examples/priority-schedule.cpp | dan65prc/conduit | 6f73416c8b5526a84a21415d5079bb2b61772144 | [
"BSD-3-Clause"
] | 1 | 2021-12-02T21:05:35.000Z | 2021-12-02T21:05:35.000Z |
#include <fmt/format.h>
#define CONDUIT_NO_LUA
#define CONDUIT_NO_PYTHON
#include <conduit/conduit.h>
#include <conduit/function.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <queue>
#include <random>
struct QueueEntry
{
int priority;
conduit::Function<void()> event;
friend bool operator <(const QueueEntry &lhs, const QueueEntry &rhs)
{
return lhs.priority < rhs.priority;
}
};
int main(int argc, char const *argv[])
{
conduit::Registrar reg("reg", nullptr);
// This example uses 2 channels to demonstrate how our queue can hold
// channels of any signature.
auto int_print = reg.lookup<void(int, int)>("int print channel");
auto float_print = reg.lookup<void(int, int, float)>("float print channel");
reg.lookup<void(int, int)>("int print channel").hook([] (int i, int priority) {
fmt::print("{} was inserted with priority {}\n", i, priority);
});
reg.lookup<void(int, int, float)>("float print channel").hook([] (int i, int priority, float value) {
fmt::print("{} was inserted with priority {} and with float value {}\n", i, priority, value);
});
// A priority queue of events. Each QueueEntry has a priority and a function
// wrapper holding the actual work to perform. The function wrapper can hold
// anything that can be called without arguments (QueueEntry::event is a
// nullary type erased function adapter).
std::priority_queue<QueueEntry> queue;
// Get our random number generator ready
std::random_device rd;
std::mt19937 eng(rd());
std::uniform_int_distribution<> dist(0, 100);
// Queue messages on either the int_print or float_print channels.
// conduit::make_delayed pairs a callable (in this case our channel) with its
// arguments and saves it for later. See below where we apply the arguments
// to the channel to send a message on the channel.
for (int i = 0; i < 10; ++i) {
auto r = dist(eng);
if (r & 1) {
queue.push(QueueEntry{r, conduit::make_delayed(int_print, i, r)});
} else {
queue.push(QueueEntry{r, conduit::make_delayed(float_print, i, r, static_cast<float>(i) / r)});
}
}
// Now that we have events in our priority_queue, execute them in priority
// order.
while (!queue.empty()) {
queue.top().event();
queue.pop();
}
}
| 34.042254 | 107 | 0.651634 | dan65prc |
9cf902b5780c0c03d9ad6e467919623831347b35 | 1,595 | cpp | C++ | AsyncTaskMsg.cpp | xaviarmengol/ESP32-Canyon | 2d2c876afa6c4b8f8a47e4f80c99d106754ac716 | [
"MIT"
] | null | null | null | AsyncTaskMsg.cpp | xaviarmengol/ESP32-Canyon | 2d2c876afa6c4b8f8a47e4f80c99d106754ac716 | [
"MIT"
] | null | null | null | AsyncTaskMsg.cpp | xaviarmengol/ESP32-Canyon | 2d2c876afa6c4b8f8a47e4f80c99d106754ac716 | [
"MIT"
] | null | null | null | #include "AsyncTaskMsg.hpp"
AsyncTaskMsg::AsyncTaskMsg(taskNames_t myTaskName) {
_myTaskName = myTaskName;
_taskId = static_cast<int>(myTaskName);
}
void AsyncTaskMsg::update(){
_ptrAsyncTask = &(tasksManager[_taskId]);
taskNames_t taskFrom = _ptrAsyncTask->getMsgTaskFrom();
asyncMsg_t msg = _ptrAsyncTask->getMsgName();
int index = _ptrAsyncTask->getMsgIndex();
int value = _ptrAsyncTask->getMsgValue();
if (msg == AsyncMsg::WRITE_VAR) {
_asyncValues.at(index) = value;
} else if (msg == AsyncMsg::READ_VAR) {
//Answer with specific message, and with the same index, and with the READ value
tasksManager[(int)taskFrom].sendMessage(
AsyncMsg::ANSWER_READ_VAR, (taskNames_t)_taskId, index, _asyncValues.at(index));
} else if (msg == AsyncMsg::ANSWER_READ_VAR) {
_asyncValuesRead.at(index) = value;
}
}
int AsyncTaskMsg::getLocalValue(int index) {
return(_asyncValues.at(index));
}
void AsyncTaskMsg::setLocalValue(int index, int value) {
_asyncValues.at(index) = value;
}
int AsyncTaskMsg::getLastRemoteValue(int index) {
return(_asyncValuesRead.at(index));
}
void AsyncTaskMsg::readRemoteValue(taskNames_t taskName, int index) {
tasksManager[(int)taskName].sendMessage(AsyncMsg::READ_VAR, _myTaskName, index, 0);
}
void AsyncTaskMsg::writeRemoteValue(taskNames_t taskName, int index, int value) {
tasksManager[(int)taskName].sendMessage(AsyncMsg::WRITE_VAR, _myTaskName, index, value);
}
AsyncTaskMsg::~AsyncTaskMsg() {
}
| 30.673077 | 93 | 0.689655 | xaviarmengol |
9cfc7e33fccde3331d93c8a5618e718bc8dfc5c5 | 3,051 | cpp | C++ | share/src/policy/packages.cpp | MrCryptoBeast/WWW | 857e860df0aa1bc7fde2ee6f5918ff32933beeb3 | [
"MIT"
] | null | null | null | share/src/policy/packages.cpp | MrCryptoBeast/WWW | 857e860df0aa1bc7fde2ee6f5918ff32933beeb3 | [
"MIT"
] | null | null | null | share/src/policy/packages.cpp | MrCryptoBeast/WWW | 857e860df0aa1bc7fde2ee6f5918ff32933beeb3 | [
"MIT"
] | null | null | null | // Copyright (c) 2021 The worldwideweb Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <consensus/validation.h>
#include <policy/packages.h>
#include <primitives/transaction.h>
#include <uint256.h>
#include <util/hasher.h>
#include <numeric>
#include <unordered_set>
bool CheckPackage(const Package& txns, PackageValidationState& state)
{
const unsigned int package_count = txns.size();
if (package_count > MAX_PACKAGE_COUNT) {
return state.Invalid(PackageValidationResult::PCKG_POLICY, "package-too-many-transactions");
}
const int64_t total_size = std::accumulate(txns.cbegin(), txns.cend(), 0,
[](int64_t sum, const auto& tx) { return sum + GetVirtualTransactionSize(*tx); });
// If the package only contains 1 tx, it's better to report the policy violation on individual tx size.
if (package_count > 1 && total_size > MAX_PACKAGE_SIZE * 1000) {
return state.Invalid(PackageValidationResult::PCKG_POLICY, "package-too-large");
}
// Require the package to be sorted in order of dependency, i.e. parents appear before children.
// An unsorted package will fail anyway on missing-inputs, but it's better to quit earlier and
// fail on something less ambiguous (missing-inputs could also be an orphan or trying to
// spend nonexistent coins).
std::unordered_set<uint256, SaltedTxidHasher> later_txids;
std::transform(txns.cbegin(), txns.cend(), std::inserter(later_txids, later_txids.end()),
[](const auto& tx) { return tx->GetHash(); });
for (const auto& tx : txns) {
for (const auto& input : tx->vin) {
if (later_txids.find(input.prevout.hash) != later_txids.end()) {
// The parent is a subsequent transaction in the package.
return state.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-sorted");
}
}
later_txids.erase(tx->GetHash());
}
// Don't allow any conflicting transactions, i.e. spending the same inputs, in a package.
std::unordered_set<COutPoint, SaltedOutpointHasher> inputs_seen;
for (const auto& tx : txns) {
for (const auto& input : tx->vin) {
if (inputs_seen.find(input.prevout) != inputs_seen.end()) {
// This input is also present in another tx in the package.
return state.Invalid(PackageValidationResult::PCKG_POLICY, "conflict-in-package");
}
}
// Batch-add all the inputs for a tx at a time. If we added them 1 at a time, we could
// catch duplicate inputs within a single tx. This is a more severe, consensus error,
// and we want to report that from CheckTransaction instead.
std::transform(tx->vin.cbegin(), tx->vin.cend(), std::inserter(inputs_seen, inputs_seen.end()),
[](const auto& input) { return input.prevout; });
}
return true;
}
| 48.428571 | 113 | 0.662078 | MrCryptoBeast |
9cfd319e71a48e152b4d8594b26db33988f7eed0 | 2,045 | cpp | C++ | src/problems/151-200/151/problem151.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | 1 | 2019-12-25T10:17:15.000Z | 2019-12-25T10:17:15.000Z | src/problems/151-200/151/problem151.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | null | null | null | src/problems/151-200/151/problem151.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | null | null | null | //
// Created by Alex Beccaro on 03/08/2021.
//
#include "problem151.hpp"
#include "generics.hpp"
#include <numeric>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using std::vector;
using std::unordered_map;
using std::unordered_set;
using generics::digits;
using std::accumulate;
namespace problems {
double problem151::solve() {
// states are represented as a number where each digit, in order, represents the quantity of A2, A3, A4 and A5
// sheets in the envelope
unordered_map<uint32_t, double> p = {{1111, 1}};
vector<uint32_t> current = {1111};
unordered_set<uint32_t> next;
for (uint32_t batch = 2; batch <= 16; batch++) {
for (const auto& state : current) {
vector<uint32_t> d = digits(state);
uint32_t total = accumulate(d.begin(), d.end(), 0u); // total number of sheets in the envelope
// each mask represents a possible format (A2, A3, A4 or A5)
for (uint32_t mask = 1000; mask > 0; mask /= 10) {
uint32_t n = state % (mask * 10) / mask; // number of sheets of the mask format
if (n == 0)
continue;
// apply cuts to generate the new state and add it to the set for next batch
uint32_t to_add = 0;
for (uint32_t i = 1; i < mask; i *= 10)
to_add += i;
uint32_t new_state = state - mask + to_add;
next.insert(new_state);
// update probability of new state
double p_next = p[state] * n / total;
if (p.find(new_state) != p.end())
p[new_state] += p_next;
else
p.insert({new_state, p_next});
}
}
current.assign(next.begin(), next.end());
next.clear();
}
return p[1000] + p[100] + p[10];
}
} | 33.52459 | 118 | 0.51687 | abeccaro |
9cfd5987f8ad19c1b35cc090c3a5a954bce01e18 | 317 | cpp | C++ | Codeforces/ProblemSet/4C.cpp | Binary-bug/CP | f9f356d36bd252c71ee3ed2d0585cc372f2baf5e | [
"MIT"
] | null | null | null | Codeforces/ProblemSet/4C.cpp | Binary-bug/CP | f9f356d36bd252c71ee3ed2d0585cc372f2baf5e | [
"MIT"
] | null | null | null | Codeforces/ProblemSet/4C.cpp | Binary-bug/CP | f9f356d36bd252c71ee3ed2d0585cc372f2baf5e | [
"MIT"
] | null | null | null | #include<iostream>
#include<string>
#include<map>
using namespace std;
int main(){
int n;
string s;
map<string,int> ber;
cin >> n;
while(n--){
cin >> s;
if(ber.find(s) == ber.end()) cout << "OK" << endl , ber[s]++;
else{
s = s + to_string(ber[s]++);
cout << s << endl;
}
}
return 0;
}
| 12.192308 | 63 | 0.526814 | Binary-bug |
9cfd69060a1eec602154533c0f5d2678a13d4ee8 | 2,000 | cpp | C++ | src/common/osWrappersInitFunc.cpp | GPUOpen-Tools/common-src-AMDTOSWrappers | 80f8902c78d52435ac04f66ac190d689e5badbc1 | [
"MIT"
] | 2 | 2017-01-28T14:11:35.000Z | 2018-02-01T08:22:03.000Z | src/common/osWrappersInitFunc.cpp | GPUOpen-Tools/common-src-AMDTOSWrappers | 80f8902c78d52435ac04f66ac190d689e5badbc1 | [
"MIT"
] | null | null | null | src/common/osWrappersInitFunc.cpp | GPUOpen-Tools/common-src-AMDTOSWrappers | 80f8902c78d52435ac04f66ac190d689e5badbc1 | [
"MIT"
] | 2 | 2018-02-01T08:22:04.000Z | 2019-11-01T23:00:21.000Z | //=====================================================================
// Copyright 2016 (c), Advanced Micro Devices, Inc. All rights reserved.
//
/// \author AMD Developer Tools Team
/// \file osWrappersInitFunc.cpp
///
//=====================================================================
//------------------------------ osWrappersInitFunc.cpp ------------------------------
// Local:
#include <AMDTOSWrappers/Include/osTransferableObjectCreator.h>
#include <AMDTOSWrappers/Include/osTransferableObjectCreatorsManager.h>
#include <AMDTOSWrappers/Include/osFilePath.h>
#include <AMDTOSWrappers/Include/osDirectory.h>
#include <AMDTOSWrappers/Include/osWrappersInitFunc.h>
// ---------------------------------------------------------------------------
// Name: apiClassesInitFunc
// Description: Initialization function for the GROSWrappers library.
// Return Val: bool - Success / failure.
// Author: AMD Developer Tools Team
// Date: 2/6/2004
// Implementation Notes:
// Registeres all the GROSWrappers transferable objects in the transferable
// objects creator manager.
// ---------------------------------------------------------------------------
bool osWrappersInitFunc()
{
// Verify that this function code is executed only once:
static bool wasThisFunctionCalled = false;
if (!wasThisFunctionCalled)
{
wasThisFunctionCalled = true;
// Get the osTransferableObjectCreatorsManager single instance:
osTransferableObjectCreatorsManager& theTransfetableObsCreatorsManager = osTransferableObjectCreatorsManager::instance();
// ----------- Register transferable objects creators -----------
osTransferableObjectCreator<osFilePath> osFilePathCreator;
theTransfetableObsCreatorsManager.registerCreator(osFilePathCreator);
osTransferableObjectCreator<osDirectory> osDirectoryCreator;
theTransfetableObsCreatorsManager.registerCreator(osDirectoryCreator);
}
return true;
}
| 36.363636 | 129 | 0.614 | GPUOpen-Tools |
9cfe59c2dad23c25e0f625bfe2d9dfda0a011759 | 5,163 | hpp | C++ | include/GTGE/SceneStateStackStagingArea.hpp | mackron/GTGameEngine | 380d1e01774fe6bc2940979e4e5983deef0bf082 | [
"BSD-3-Clause"
] | 31 | 2015-03-19T08:44:48.000Z | 2021-12-15T20:52:31.000Z | include/GTGE/SceneStateStackStagingArea.hpp | mackron/GTGameEngine | 380d1e01774fe6bc2940979e4e5983deef0bf082 | [
"BSD-3-Clause"
] | 19 | 2015-07-09T09:02:44.000Z | 2016-06-09T03:51:03.000Z | include/GTGE/SceneStateStackStagingArea.hpp | mackron/GTGameEngine | 380d1e01774fe6bc2940979e4e5983deef0bf082 | [
"BSD-3-Clause"
] | 3 | 2017-10-04T23:38:18.000Z | 2022-03-07T08:27:13.000Z | // Copyright (C) 2011 - 2014 David Reid. See included LICENCE.
#ifndef GT_SceneStateStackStagingArea
#define GT_SceneStateStackStagingArea
#include "SceneStateStackRestoreCommands.hpp"
#include "Serialization.hpp"
namespace GT
{
class Scene;
class SceneStateStackBranch;
/// Class representing the staging area.
class SceneStateStackStagingArea
{
public:
/// Constructor.
SceneStateStackStagingArea(SceneStateStackBranch &branch);
/// Destructor.
~SceneStateStackStagingArea();
/// Retrieves a reference to the branch that owns this staging area.
SceneStateStackBranch & GetBranch() { return this->branch; }
const SceneStateStackBranch & GetBranch() const { return this->branch; }
/// Retrieves a reference to the relevant scene.
Scene & GetScene();
const Scene & GetScene() const;
/// Stages an insert command of the given scene node.
///
/// @param sceneNodeID [in] The ID of the scene node that was inserted.
void StageInsert(uint64_t sceneNodeID);
/// Stages a delete command of the given scene node.
///
/// @param sceneNodeID [in] The ID of the scene node that was deleted.
void StageDelete(uint64_t sceneNodeID);
/// Stages an update command of the given scene node.
///
/// @param sceneNodeID [in] The ID of the scene node that was updated.
void StageUpdate(uint64_t sceneNodeID);
/// Clears the staging area.
void Clear();
/// Retrieves a reference to the insert commands.
Vector<uint64_t> & GetInserts() { return this->inserts; }
const Vector<uint64_t> & GetInserts() const { return this->inserts; }
/// Retrieves a reference to the delete commands.
Map<uint64_t, BasicSerializer*> & GetDeletes() { return this->deletes; }
const Map<uint64_t, BasicSerializer*> & GetDeletes() const { return this->deletes; }
/// Retrieves a reference to the update commands.
Vector<uint64_t> & GetUpdates() { return this->updates; }
const Vector<uint64_t> & GetUpdates() const { return this->updates; }
/// Retrieves a reference to the hierarchy.
Map<uint64_t, uint64_t> & GetHierarchy() { return this->hierarchy; }
const Map<uint64_t, uint64_t> & GetHierarchy() const { return this->hierarchy; }
/// Retrieves the set of commands to use to revert the scene from the changes in the staging area.
///
/// @param commands [out] A reference to the object that will receive the restore commands.
void GetRevertCommands(SceneStateStackRestoreCommands &commands);
/// Retrieves a set of commands that can be used to put the scene into a state as currently defined by the staging area.
///
/// @param commands [out] A reference to the object that will receive the restore commands.
void GetRestoreCommands(SceneStateStackRestoreCommands &commands);
/////////////////////////////////////////////////
// Serialization/Deserialization
/// Serializes the state stack staging area.
void Serialize(Serializer &serializer) const;
/// Deserializes the state stack staging area.
void Deserialize(Deserializer &deserializer);
private:
/// Adds the given scene node to the hierarchy.
///
/// @param sceneNodeID [in] The ID of the scene node that is being added to the hierarchy.
///
/// @remarks
/// This does nothing if the scene node does not have a parent.
void AddToHierarchy(uint64_t sceneNodeID);
/// Removes the given scene node from the hierarchy.
///
/// @param sceneNodeID [in] The ID of the scene node that is being removed from the hierarchy.
void RemoveFromHierarchy(uint64_t sceneNodeID);
/// Retrieves the ID of the parent node from the hierarchy, or 0 if it does not have a parent.
///
/// @param childSceneNodeID [in] The ID of the scene node whose parent ID is being retrieved.
uint64_t GetParentSceneNodeIDFromHierarchy(uint64_t childSceneNodeID) const;
private:
/// The branch that owns this staging area.
SceneStateStackBranch &branch;
/// The list of scene node ID's of newly inserted scene nodes in the staging area.
Vector<uint64_t> inserts;
/// The list of scene node ID's of newly deleted scene nodes in the staging area. We need to keep track of the serialized data
/// because the scene will want to delete the node, after which point we won't be able to retrieve the data.
Map<uint64_t, BasicSerializer*> deletes;
/// The list of scene node ID's of newly updated scene nodes in the staging area.
Vector<uint64_t> updates;
/// The hierarchy of the nodes containined in the staging area. The key is the child node ID and the value is the parent node ID.
Map<uint64_t, uint64_t> hierarchy;
};
}
#endif
| 36.617021 | 137 | 0.643812 | mackron |
1401ec61770b1f679360d68dc86f07046f28f7b1 | 1,573 | hpp | C++ | include/tao/pq/parameter_traits_aggregate.hpp | huzaifanazir/taopq | 8f939d33840f14d7c08311729745fe7bb8cd9898 | [
"BSL-1.0"
] | 69 | 2016-08-05T19:16:04.000Z | 2018-11-24T15:13:46.000Z | include/tao/pq/parameter_traits_aggregate.hpp | huzaifanazir/taopq | 8f939d33840f14d7c08311729745fe7bb8cd9898 | [
"BSL-1.0"
] | 13 | 2016-11-24T16:42:28.000Z | 2018-09-11T18:55:40.000Z | include/tao/pq/parameter_traits_aggregate.hpp | huzaifanazir/taopq | 8f939d33840f14d7c08311729745fe7bb8cd9898 | [
"BSL-1.0"
] | 13 | 2016-09-22T17:31:10.000Z | 2018-10-18T02:56:49.000Z | // Copyright (c) 2020-2022 Daniel Frey and Dr. Colin Hirsch
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
#ifndef TAO_PQ_PARAMETER_TRAITS_AGGREGATE_HPP
#define TAO_PQ_PARAMETER_TRAITS_AGGREGATE_HPP
#include <tao/pq/internal/aggregate.hpp>
#include <tao/pq/is_aggregate.hpp>
#include <tao/pq/parameter_traits.hpp>
namespace tao::pq
{
namespace internal
{
template< typename T >
struct parameter_tie_aggregate
{
using result_t = decltype( internal::tie_aggregate( std::declval< const T& >() ) );
const result_t result;
explicit parameter_tie_aggregate( const T& t ) noexcept
: result( internal::tie_aggregate( t ) )
{}
};
} // namespace internal
template< typename T >
struct parameter_traits< T, std::enable_if_t< is_aggregate_parameter< T > > >
: private internal::parameter_tie_aggregate< T >,
public parameter_traits< typename internal::parameter_tie_aggregate< T >::result_t >
{
using typename internal::parameter_tie_aggregate< T >::result_t;
explicit parameter_traits( const T& t ) noexcept( noexcept( internal::parameter_tie_aggregate< T >( t ),
parameter_traits< result_t >( std::declval< result_t >() ) ) )
: internal::parameter_tie_aggregate< T >( t ),
parameter_traits< result_t >( this->result )
{}
};
} // namespace tao::pq
#endif
| 34.195652 | 128 | 0.655435 | huzaifanazir |
14057d3d9f7402d8601ce38a4d90ad7bb0d277ec | 9,905 | cpp | C++ | src/game/Object/Corpse.cpp | Zilvereyes/ServerOne | 92a792c4c5b9a5128e0086b5af21b51c214bb6a6 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/game/Object/Corpse.cpp | Zilvereyes/ServerOne | 92a792c4c5b9a5128e0086b5af21b51c214bb6a6 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/game/Object/Corpse.cpp | Zilvereyes/ServerOne | 92a792c4c5b9a5128e0086b5af21b51c214bb6a6 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | /**
* MaNGOS is a full featured server for World of Warcraft, supporting
* the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
*
* Copyright (C) 2005-2016 MaNGOS project <https://getmangos.eu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* World of Warcraft, and all World of Warcraft or Warcraft art, images,
* and lore are copyrighted by Blizzard Entertainment, Inc.
*/
#include "Corpse.h"
#include "Player.h"
#include "UpdateMask.h"
#include "ObjectAccessor.h"
#include "ObjectGuid.h"
#include "Database/DatabaseEnv.h"
#include "Opcodes.h"
#include "GossipDef.h"
#include "World.h"
#include "ObjectMgr.h"
Corpse::Corpse(CorpseType type) : WorldObject(),
loot(this),
lootRecipient(NULL),
lootForBody(false)
{
m_objectType |= TYPEMASK_CORPSE;
m_objectTypeId = TYPEID_CORPSE;
// 2.3.2 - 0x58
m_updateFlag = (UPDATEFLAG_LOWGUID | UPDATEFLAG_HIGHGUID | UPDATEFLAG_HAS_POSITION);
m_valuesCount = CORPSE_END;
m_type = type;
m_time = time(NULL);
}
Corpse::~Corpse()
{
}
void Corpse::AddToWorld()
{
///- Register the corpse for guid lookup
if (!IsInWorld())
{ sObjectAccessor.AddObject(this); }
Object::AddToWorld();
}
void Corpse::RemoveFromWorld()
{
///- Remove the corpse from the accessor
if (IsInWorld())
{ sObjectAccessor.RemoveObject(this); }
Object::RemoveFromWorld();
}
bool Corpse::Create(uint32 guidlow)
{
Object::_Create(guidlow, 0, HIGHGUID_CORPSE);
return true;
}
bool Corpse::Create(uint32 guidlow, Player* owner)
{
MANGOS_ASSERT(owner);
WorldObject::_Create(guidlow, HIGHGUID_CORPSE);
Relocate(owner->GetPositionX(), owner->GetPositionY(), owner->GetPositionZ(), owner->GetOrientation());
// we need to assign owner's map for corpse
// in other way we will get a crash in Corpse::SaveToDB()
SetMap(owner->GetMap());
if (!IsPositionValid())
{
sLog.outError("Corpse (guidlow %d, owner %s) not created. Suggested coordinates isn't valid (X: %f Y: %f)",
guidlow, owner->GetName(), owner->GetPositionX(), owner->GetPositionY());
return false;
}
SetObjectScale(DEFAULT_OBJECT_SCALE);
SetFloatValue(CORPSE_FIELD_POS_X, GetPositionX());
SetFloatValue(CORPSE_FIELD_POS_Y, GetPositionY());
SetFloatValue(CORPSE_FIELD_POS_Z, GetPositionZ());
SetFloatValue(CORPSE_FIELD_FACING, GetOrientation());
SetGuidValue(CORPSE_FIELD_OWNER, owner->GetObjectGuid());
m_grid = MaNGOS::ComputeGridPair(GetPositionX(), GetPositionY());
return true;
}
void Corpse::SaveToDB()
{
// bones should not be saved to DB (would be deleted on startup anyway)
MANGOS_ASSERT(GetType() != CORPSE_BONES);
// prevent DB data inconsistence problems and duplicates
CharacterDatabase.BeginTransaction();
DeleteFromDB();
std::ostringstream ss;
ss << "INSERT INTO corpse (guid,player,position_x,position_y,position_z,orientation,map,time,corpse_type,instance) VALUES ("
<< GetGUIDLow() << ", "
<< GetOwnerGuid().GetCounter() << ", "
<< GetPositionX() << ", "
<< GetPositionY() << ", "
<< GetPositionZ() << ", "
<< GetOrientation() << ", "
<< GetMapId() << ", "
<< uint64(m_time) << ", "
<< uint32(GetType()) << ", "
<< int(GetInstanceId()) << ")";
CharacterDatabase.Execute(ss.str().c_str());
CharacterDatabase.CommitTransaction();
}
void Corpse::DeleteBonesFromWorld()
{
MANGOS_ASSERT(GetType() == CORPSE_BONES);
Corpse* corpse = GetMap()->GetCorpse(GetObjectGuid());
if (!corpse)
{
sLog.outError("Bones %u not found in world.", GetGUIDLow());
return;
}
AddObjectToRemoveList();
}
void Corpse::DeleteFromDB()
{
// bones should not be saved to DB (would be deleted on startup anyway)
MANGOS_ASSERT(GetType() != CORPSE_BONES);
// all corpses (not bones)
static SqlStatementID id;
SqlStatement stmt = CharacterDatabase.CreateStatement(id, "DELETE FROM corpse WHERE player = ? AND corpse_type <> '0'");
stmt.PExecute(GetOwnerGuid().GetCounter());
}
bool Corpse::LoadFromDB(uint32 lowguid, Field* fields)
{
//// 0 1 2 3 4 5 6
// QueryResult *result = CharacterDatabase.Query("SELECT corpse.guid, player, corpse.position_x, corpse.position_y, corpse.position_z, corpse.orientation, corpse.map,"
//// 7 8 9 10 11 12 13 14 15 16 17
// "time, corpse_type, instance, gender, race, class, playerBytes, playerBytes2, equipmentCache, guildId, playerFlags FROM corpse"
uint32 playerLowGuid = fields[1].GetUInt32();
float positionX = fields[2].GetFloat();
float positionY = fields[3].GetFloat();
float positionZ = fields[4].GetFloat();
float orientation = fields[5].GetFloat();
uint32 mapid = fields[6].GetUInt32();
Object::_Create(lowguid, 0, HIGHGUID_CORPSE);
m_time = time_t(fields[7].GetUInt64());
m_type = CorpseType(fields[8].GetUInt32());
if (m_type >= MAX_CORPSE_TYPE)
{
sLog.outError("%s Owner %s have wrong corpse type (%i), not load.", GetGuidStr().c_str(), GetOwnerGuid().GetString().c_str(), m_type);
return false;
}
uint32 instanceid = fields[9].GetUInt32();
uint8 gender = fields[10].GetUInt8();
uint8 race = fields[11].GetUInt8();
uint8 _class = fields[12].GetUInt8();
uint32 playerBytes = fields[13].GetUInt32();
uint32 playerBytes2 = fields[14].GetUInt32();
uint32 guildId = fields[16].GetUInt32();
uint32 playerFlags = fields[17].GetUInt32();
ObjectGuid guid = ObjectGuid(HIGHGUID_CORPSE, lowguid);
ObjectGuid playerGuid = ObjectGuid(HIGHGUID_PLAYER, playerLowGuid);
// overwrite possible wrong/corrupted guid
SetGuidValue(OBJECT_FIELD_GUID, guid);
SetGuidValue(CORPSE_FIELD_OWNER, playerGuid);
SetObjectScale(DEFAULT_OBJECT_SCALE);
PlayerInfo const* info = sObjectMgr.GetPlayerInfo(race, _class);
if (!info)
{
sLog.outError("Player %u has incorrect race/class pair.", GetGUIDLow());
return false;
}
SetUInt32Value(CORPSE_FIELD_DISPLAY_ID, gender == GENDER_FEMALE ? info->displayId_f : info->displayId_m);
// Load equipment
Tokens data = StrSplit(fields[15].GetCppString(), " ");
for (uint8 slot = 0; slot < EQUIPMENT_SLOT_END; ++slot)
{
uint32 visualbase = slot * 2;
uint32 item_id = GetUInt32ValueFromArray(data, visualbase);
const ItemPrototype* proto = ObjectMgr::GetItemPrototype(item_id);
if (!proto)
{
SetUInt32Value(CORPSE_FIELD_ITEM + slot, 0);
continue;
}
SetUInt32Value(CORPSE_FIELD_ITEM + slot, proto->DisplayInfoID | (proto->InventoryType << 24));
}
uint8 skin = (uint8)(playerBytes);
uint8 face = (uint8)(playerBytes >> 8);
uint8 hairstyle = (uint8)(playerBytes >> 16);
uint8 haircolor = (uint8)(playerBytes >> 24);
uint8 facialhair = (uint8)(playerBytes2);
SetUInt32Value(CORPSE_FIELD_BYTES_1, ((0x00) | (race << 8) | (gender << 16) | (skin << 24)));
SetUInt32Value(CORPSE_FIELD_BYTES_2, ((face) | (hairstyle << 8) | (haircolor << 16) | (facialhair << 24)));
SetUInt32Value(CORPSE_FIELD_GUILD, guildId);
uint32 flags = CORPSE_FLAG_UNK2;
if (playerFlags & PLAYER_FLAGS_HIDE_HELM)
{ flags |= CORPSE_FLAG_HIDE_HELM; }
if (playerFlags & PLAYER_FLAGS_HIDE_CLOAK)
{ flags |= CORPSE_FLAG_HIDE_CLOAK; }
SetUInt32Value(CORPSE_FIELD_FLAGS, flags);
// no need to mark corpse as lootable, because corpses are not saved in battle grounds
// place
SetLocationInstanceId(instanceid);
SetLocationMapId(mapid);
Relocate(positionX, positionY, positionZ, orientation);
if (!IsPositionValid())
{
sLog.outError("%s Owner %s not created. Suggested coordinates isn't valid (X: %f Y: %f)",
GetGuidStr().c_str(), GetOwnerGuid().GetString().c_str(), GetPositionX(), GetPositionY());
return false;
}
m_grid = MaNGOS::ComputeGridPair(GetPositionX(), GetPositionY());
return true;
}
bool Corpse::IsVisibleForInState(Player const* u, WorldObject const* viewPoint, bool inVisibleList) const
{
return IsInWorld() && u->IsInWorld() && IsWithinDistInMap(viewPoint, GetMap()->GetVisibilityDistance() + (inVisibleList ? World::GetVisibleObjectGreyDistance() : 0.0f), false);
}
bool Corpse::IsHostileTo(Unit const* unit) const
{
if (Player* owner = sObjectMgr.GetPlayer(GetOwnerGuid()))
{ return owner->IsHostileTo(unit); }
else
{ return false; }
}
bool Corpse::IsFriendlyTo(Unit const* unit) const
{
if (Player* owner = sObjectMgr.GetPlayer(GetOwnerGuid()))
{ return owner->IsFriendlyTo(unit); }
else
{ return true; }
}
bool Corpse::IsExpired(time_t t) const
{
if (m_type == CORPSE_BONES)
{ return m_time < t - 60 * MINUTE; }
else
{ return m_time < t - 3 * DAY; }
}
| 33.921233 | 180 | 0.649571 | Zilvereyes |
140698983dfcde02a684576c884d1d551c33c6ac | 2,006 | cpp | C++ | samples/snippets/cpp/VS_Snippets_CLR/string.equals/CPP/equals.cpp | hamarb123/dotnet-api-docs | 6aeb55784944a2f1f5e773b657791cbd73a92dd4 | [
"CC-BY-4.0",
"MIT"
] | 421 | 2018-04-01T01:57:50.000Z | 2022-03-28T15:24:42.000Z | samples/snippets/cpp/VS_Snippets_CLR/string.equals/CPP/equals.cpp | hamarb123/dotnet-api-docs | 6aeb55784944a2f1f5e773b657791cbd73a92dd4 | [
"CC-BY-4.0",
"MIT"
] | 5,797 | 2018-04-02T21:12:23.000Z | 2022-03-31T23:54:38.000Z | samples/snippets/cpp/VS_Snippets_CLR/string.equals/CPP/equals.cpp | hamarb123/dotnet-api-docs | 6aeb55784944a2f1f5e773b657791cbd73a92dd4 | [
"CC-BY-4.0",
"MIT"
] | 1,482 | 2018-03-31T11:26:20.000Z | 2022-03-30T22:36:45.000Z |
//<snippet1>
// Sample for String::Equals(Object)
// String::Equals(String)
// String::Equals(String, String)
using namespace System;
using namespace System::Text;
int main()
{
StringBuilder^ sb = gcnew StringBuilder( "abcd" );
String^ str1 = "abcd";
String^ str2 = nullptr;
Object^ o2 = nullptr;
Console::WriteLine();
Console::WriteLine( " * The value of String str1 is '{0}'.", str1 );
Console::WriteLine( " * The value of StringBuilder sb is '{0}'.", sb );
Console::WriteLine();
Console::WriteLine( "1a) String::Equals(Object). Object is a StringBuilder, not a String." );
Console::WriteLine( " Is str1 equal to sb?: {0}", str1->Equals( sb ) );
Console::WriteLine();
Console::WriteLine( "1b) String::Equals(Object). Object is a String." );
str2 = sb->ToString();
o2 = str2;
Console::WriteLine( " * The value of Object o2 is '{0}'.", o2 );
Console::WriteLine( " Is str1 equal to o2?: {0}", str1->Equals( o2 ) );
Console::WriteLine();
Console::WriteLine( " 2) String::Equals(String)" );
Console::WriteLine( " * The value of String str2 is '{0}'.", str2 );
Console::WriteLine( " Is str1 equal to str2?: {0}", str1->Equals( str2 ) );
Console::WriteLine();
Console::WriteLine( " 3) String::Equals(String, String)" );
Console::WriteLine( " Is str1 equal to str2?: {0}", String::Equals( str1, str2 ) );
}
/*
This example produces the following results:
* The value of String str1 is 'abcd'.
* The value of StringBuilder sb is 'abcd'.
1a) String::Equals(Object). Object is a StringBuilder, not a String.
Is str1 equal to sb?: False
1b) String::Equals(Object). Object is a String.
* The value of Object o2 is 'abcd'.
Is str1 equal to o2?: True
2) String::Equals(String)
* The value of String str2 is 'abcd'.
Is str1 equal to str2?: True
3) String::Equals(String, String)
Is str1 equal to str2?: True
*/
//</snippet1>
| 35.821429 | 97 | 0.614158 | hamarb123 |
1406de2798c39a32a6fa42099bba06066254b323 | 4,720 | cpp | C++ | libs/vision/src/pnp/lhm.cpp | zarmomin/mrpt | 1baff7cf8ec9fd23e1a72714553bcbd88c201966 | [
"BSD-3-Clause"
] | 1 | 2021-12-10T06:24:08.000Z | 2021-12-10T06:24:08.000Z | libs/vision/src/pnp/lhm.cpp | gao-ouyang/mrpt | 4af5fdf7e45b00be4a64c3d4f009acb9ef415ec7 | [
"BSD-3-Clause"
] | null | null | null | libs/vision/src/pnp/lhm.cpp | gao-ouyang/mrpt | 4af5fdf7e45b00be4a64c3d4f009acb9ef415ec7 | [
"BSD-3-Clause"
] | 1 | 2019-09-11T02:55:04.000Z | 2019-09-11T02:55:04.000Z | /* +------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| https://www.mrpt.org/ |
| |
| Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
| See: https://www.mrpt.org/Authors - All rights reserved. |
| Released under BSD License. See: https://www.mrpt.org/License |
+------------------------------------------------------------------------+ */
#include <iostream>
#include "vision-precomp.h" // Precompiled headers
//#include <mrpt/math/types_math.h> // Eigen must be included first via MRPT to
// enable the plugin system
#include <Eigen/Dense>
#include <Eigen/SVD>
#include <Eigen/StdVector>
#include "lhm.h"
using namespace mrpt::vision::pnp;
lhm::lhm(
Eigen::MatrixXd obj_pts_, Eigen::MatrixXd img_pts_, Eigen::MatrixXd cam_,
int n0)
: F(n0)
{
obj_pts = obj_pts_;
img_pts = img_pts_;
cam_intrinsic = cam_;
n = n0;
// Store obj_pts as 3XN and img_projections as 2XN matrices
P = obj_pts.transpose();
Q = Eigen::MatrixXd::Ones(3, n);
Q = img_pts.transpose();
t.setZero();
}
void lhm::estimate_t()
{
Eigen::Vector3d sum_;
sum_.setZero();
for (int i = 0; i < n; i++) sum_ += F[i] * R * P.col(i);
t = G * sum_;
}
void lhm::xform()
{
for (int i = 0; i < n; i++) Q.col(i) = R * P.col(i) + t;
}
Eigen::Matrix4d lhm::qMatQ(Eigen::VectorXd q)
{
Eigen::Matrix4d Q_(4, 4);
Q_ << q(0), -q(1), -q(2), -q(3), q(1), q(0), -q(3), q(2), q(2), q(3), q(0),
-q(1), q(3), -q(2), q(1), q(0);
return Q_;
}
Eigen::Matrix4d lhm::qMatW(Eigen::VectorXd q)
{
Eigen::Matrix4d Q_(4, 4);
Q_ << q(0), -q(1), -q(2), -q(3), q(1), q(0), q(3), -q(2), q(2), -q(3), q(0),
q(1), q(3), q(2), -q(1), q(0);
return Q_;
}
void lhm::absKernel()
{
for (int i = 0; i < n; i++) Q.col(i) = F[i] * Q.col(i);
Eigen::Vector3d P_bar, Q_bar;
P_bar = P.rowwise().mean();
Q_bar = Q.rowwise().mean();
for (int i = 0; i < n; i++)
{
P.col(i) = P.col(i) - P_bar;
Q.col(i) = Q.col(i) - Q_bar;
}
//<------------------- Use SVD Solution ------------------->//
/*
Eigen::Matrix3d M;
M.setZero();
for (i = 0; i < n; i++)
M += P.col(i)*Q.col(i).transpose();
Eigen::JacobiSVD<Eigen::MatrixXd> svd(M, Eigen::ComputeThinU |
Eigen::ComputeThinV);
R = svd.matrixV()*svd.matrixU().transpose();
Eigen::Matrix3d dummy;
dummy.col(0) = -svd.matrixV().col(0);
dummy.col(1) = -svd.matrixV().col(1);
dummy.col(2) = svd.matrixV().col(2);
if (R.determinant() == 1)
{
estimate_t();
if (t(2) < 0)
{
R = dummy*svd.matrixU().transpose();
estimate_t();
}
}
else
{
R = -dummy*svd.matrixU().transpose();
estimate_t();
if (t(2) < 0)
{
R = -svd.matrixV()*svd.matrixU().transpose();
estimate_t();
}
}
err2 = 0;
xform();
Eigen::Vector3d vec;
Eigen::Matrix3d I3 = Eigen::MatrixXd::Identity(3, 3);
for (i = 0; i < n; i++)
{
vec = (I3 - F[i])*Q.col(i);
err2 += vec.squaredNorm();
}
*/
//<------------------- Use QTN Solution ------------------->//
Eigen::Matrix4d A;
A.setZero();
for (int i = 0; i < n; i++)
{
Eigen::Vector4d q1, q2;
q1 << 1, Q.col(i);
q2 << 1, P.col(i);
A += qMatQ(q1).transpose() * qMatW(q2);
}
Eigen::EigenSolver<Eigen::Matrix4d> es(A);
const Eigen::Matrix4d Ae = es.pseudoEigenvalueMatrix();
Eigen::Vector4d D; // Ae.diagonal(); for some reason this leads to an
// internal compiler error in MSVC11... (sigh)
for (int i = 0; i < 4; i++) D[i] = Ae(i, i);
Eigen::Matrix4d V_mat = es.pseudoEigenvectors();
Eigen::Vector4d::Index max_index;
D.maxCoeff(&max_index);
Eigen::Vector4d V;
V = V_mat.col(max_index);
Eigen::Quaterniond q(V(0), V(1), V(2), V(3));
R = q.toRotationMatrix();
estimate_t();
err2 = 0;
xform();
Eigen::Vector3d vec;
Eigen::Matrix3d I3 = Eigen::MatrixXd::Identity(3, 3);
for (int i = 0; i < n; i++)
{
vec = (I3 - F[i]) * Q.col(i);
err2 += vec.squaredNorm();
}
}
bool lhm::compute_pose(
Eigen::Ref<Eigen::Matrix3d> R_, Eigen::Ref<Eigen::Vector3d> t_)
{
int i, j = 0;
Eigen::VectorXd p_bar;
Eigen::Matrix3d sum_F, I3;
I3 = Eigen::MatrixXd::Identity(3, 3);
sum_F.setZero();
p_bar = P.rowwise().mean();
for (i = 0; i < n; i++)
{
P.col(i) -= p_bar;
F[i] = Q.col(i) * Q.col(i).transpose() / Q.col(i).squaredNorm();
sum_F = sum_F + F[i];
}
G = (I3 - sum_F / n).inverse() / n;
err = 0;
err2 = 1000;
absKernel();
while (std::abs(err2 - err) > TOL_LHM && err2 > EPSILON_LHM)
{
err = err2;
absKernel();
j += 1;
if (j > 100) break;
}
R_ = R;
t_ = t - R * p_bar;
return true;
}
| 20.792952 | 80 | 0.528178 | zarmomin |
14096755a4b69d0e141e87a956c5147ad7a26c71 | 6,436 | cpp | C++ | friend_functions.cpp | portfoliocourses/cplusplus-example-code | 629a16c52fdee1b59896951235be59be096b0359 | [
"MIT"
] | null | null | null | friend_functions.cpp | portfoliocourses/cplusplus-example-code | 629a16c52fdee1b59896951235be59be096b0359 | [
"MIT"
] | null | null | null | friend_functions.cpp | portfoliocourses/cplusplus-example-code | 629a16c52fdee1b59896951235be59be096b0359 | [
"MIT"
] | null | null | null | /*******************************************************************************
*
* Program: Friend Functions Examples
*
* Description: Examples of how to use friend functions in C++.
*
* YouTube Lesson: https://www.youtube.com/watch?v=lOfI1At3tKM
*
* Author: Kevin Browne @ https://portfoliocourses.com
*
*******************************************************************************/
#include <iostream>
using namespace std;
// A simple class with some private members
class MyClass
{
// We declare a 'friend function' double_x that will be allowed access to any
// protected and private members of MyClass objects. The friend function is
// NOT a member function of MyClass. We could put this declaration beneath
// the public or private access specifiers and it would work the same as it
// does here, because it is NOT a member of MyClass.
friend void double_x(MyClass &object);
private:
// a private member variable x
int x;
// a private member function add that adds an int argument provided to x
void add(int n)
{
x += n;
}
public:
// a constructor that sets the member variable x to the int argument provided
MyClass(int x) : x(x) {};
// A public member function that prints out the value of member variable x...
// MyClass CAN access private members of MyClass, but the "outside world"
// such as the main function cannot... friend functions will *also* be able
// to access private and protected members!
void print()
{
cout << "x: " << x << endl;
}
};
// We define the friend function double_x and because it is declared a friend
// function inside MyClass (notice the friend keyword is absent here) we can
// access the private and protected members of the MyClass object instance.
void double_x(MyClass &object)
{
// access the private member variable x, store it into current_x_value
int current_x_value = object.x;
// use the private member function add to add the current_x_value to itself,
// having the effect of doubling x
object.add(current_x_value);
// Alternatively we could have accessed the private member variable x directly
// in order to double it like this...
//
// object.x *= 2;
}
// A friend function can also be a friend to multiple classes, here we have an
// example of a friend function that is a friend to both a Revenue1 class and a
// Costs1 class.
// forward declaration of Costs1 so we can use it in the Revenue1 class
class Costs1;
// A very simple class for representing revenue
class Revenue1
{
// declare friend function profit1
friend bool profit1(Revenue1 rev, Costs1 cos);
private:
// private member variable revenue for representing revenue
int revenue;
public:
// construct sets the revenue member variable to the int argument provided
Revenue1(int revenue) : revenue(revenue) {}
};
// A very simple class for representing costs
class Costs1
{
// we ALSO declare the profit1 function as a friend of Costs1
friend bool profit1(Revenue1 rev, Costs1 cos);
private:
// private member variable for representing costs
int costs;
public:
// Constructor for setting the costs member variable
Costs1(int costs) : costs(costs) {}
};
// The profit1() function will have access to the protected and private members
// of BOTH Revenue1 AND Costs1 because both classes declare it as a friend
// function! We return true if revenue is greater than costs (as this would
// represent a profit), otherwise we return false.
bool profit1(Revenue1 rev, Costs1 cos)
{
if (rev.revenue > cos.costs) return true;
else return false;
}
// A friend function can also be a member function of another class! Here we
// re-work the above example to make the profit2 function a member of class
// Revenue2 and a friend function of Costs2.
// Again we provide a forward declaration of Costs2
class Costs2;
// A simple class for representing revenues
class Revenue2
{
private:
// a private member variable for representing the revenue
int revenue;
public:
// Construct sets revenue member variable to the int argument provided
Revenue2(int revenue) : revenue(revenue) {}
// profit2 is a member variable of Revenue2 (we will define it later) and it
// will be a friend function of the Costs2 class
bool profit2(Costs2 cos);
};
// A simple class for representing costs
class Costs2
{
// profit2 is a member function of Revenue2 (notice Revenue2::) BUT is also
// declared as a friend function of Class2 below
friend bool Revenue2::profit2(Costs2 cos);
private:
// private member variable for representing costs
int costs;
public:
// Constructor sets costs member variable to the int argument provided
Costs2(int costs) : costs(costs) {}
};
// Define the Revenue2 member function profit2... because it is a friend of
// Costs2 it will have access to the private and protected members of the
// Costs2 object. We return return if revenue is greater than costs, and
// false otherwise.
bool Revenue2::profit2(Costs2 cos)
{
if (revenue > cos.costs) return true;
else return false;
}
// Test out the above classes
int main()
{
// Create an instance of MyClass with x set to 7
MyClass myobject(7);
// Call print to print out the current value of x
myobject.print();
// Use friend function double_x() to double the value of x... notice how we
// do NOT call it like a member function (e.g. my.object.doublex(...)) because
// it is NOT a member function of MyClass objects.
double_x(myobject);
// Print out the current value of x again to verify that it has doubled to 14
myobject.print();
// Create Revenue1 and Costs1 objects, here revenue is greater than costs
Revenue1 revenue1(1000);
Costs1 costs1(500);
// Use the profit1() function which is a friend of both Revenue1 and Costs1
// classes, and we should report that a profit has occurred
if (profit1(revenue1, costs1)) cout << "Profit!" << endl;
else cout << "No profit!" << endl;
// Create Revenue2 and Costs2 objects, here revenue is not greater than costs
Revenue2 revenue2(500);
Costs2 costs2(1000);
// Use the profit2() member function of the Revenue2 object revenue2 which is
// ALSO a friend of the Costs2 class, and we should report no profit this time
if (revenue2.profit2(costs2)) cout << "Profit!" << endl;
else cout << "No profit!" << endl;
return 0;
} | 29.388128 | 80 | 0.699037 | portfoliocourses |
140defc8281e5d5db4e0b27685869396b61c5fed | 84 | cpp | C++ | ARM/NXP/LPC11xx/src/i2c_lpc11uxx.cpp | SoniaZotz/IOsonata | a0eaa1d0bf1d23785af6af037d84d87348dc4597 | [
"MIT"
] | 94 | 2015-03-12T14:49:43.000Z | 2021-08-05T00:43:50.000Z | ARM/NXP/LPC11xx/src/i2c_lpc11uxx.cpp | SoniaZotz/IOsonata | a0eaa1d0bf1d23785af6af037d84d87348dc4597 | [
"MIT"
] | 10 | 2019-10-16T19:02:47.000Z | 2022-02-27T21:35:56.000Z | ARM/NXP/LPC11xx/src/i2c_lpc11uxx.cpp | SoniaZotz/IOsonata | a0eaa1d0bf1d23785af6af037d84d87348dc4597 | [
"MIT"
] | 24 | 2015-04-22T20:35:28.000Z | 2022-01-10T13:08:40.000Z | /*
* i2c_lpc11uxx.cpp
*
* Created on: Mar. 1, 2019
* Author: hoan
*/
| 7.636364 | 28 | 0.5 | SoniaZotz |
140fac534dda0b13fb63ab566e55fc0f47ca6057 | 2,232 | cpp | C++ | OCTLib/code/phase_calibration.cpp | wjh1001/octlab | 77be6161a31d2f40af238f394ee8d486e050cf73 | [
"BSD-3-Clause-Clear"
] | 1 | 2015-05-31T11:03:55.000Z | 2015-05-31T11:03:55.000Z | OCTLib/code/phase_calibration.cpp | caoyuan0923/octlab | 77be6161a31d2f40af238f394ee8d486e050cf73 | [
"BSD-3-Clause-Clear"
] | null | null | null | OCTLib/code/phase_calibration.cpp | caoyuan0923/octlab | 77be6161a31d2f40af238f394ee8d486e050cf73 | [
"BSD-3-Clause-Clear"
] | null | null | null | /*******************************************************************************
* $Id$
* Copyright (C) 2010 Stepan A. Baranov ([email protected])
* All rights reserved.
* web-site: www.OCTLab.org
* ***** ******* *****
* Use of this source code is governed by a Clear BSD-style license that can be
* found on the http://octlab.googlecode.com/svn/trunk/COPYRIGHT.TXT web-page or
* in the COPYRIGHT.TXT file
*******************************************************************************/
// common header
#include "./OCTLib.h"
// for DLL export
extern "C" {
DllExport I8 OL_phase_calibration(U32, U32, U32, DBL *, DBL *);
}
/* phase calibration main function
PURPOSE:
calculate corrected phase based on phase information from calibration mirror
[1].
INPUTS:
X - number of elements in each row (A-scan size)
Y - number of rows (# of A-scans)
level - the depth position of calibration mirror reflector
ref - pointer to buffer with phase B-scan after FFT from calibration mirror
(size: X * Y)
OUTPUTS:
out - pointer to buffer with phase B-scan after FFT from sample
(size: X * Y)
REMARKS:
note that for all depth indexes below level the phase correction is taken
without calibration coefficient.
REFERENCES:
[1] B. J. Vakoc, S. H. Yun, J. F. de Boer, G. J. Tearney, and B. E. Bouma,
"Phase-resolved optical frequency domain imaging", Opt. Express 13,
5483-5493 (2005)
*/
I8 OL_phase_calibration(U32 X, U32 Y, U32 level, DBL *ref, DBL *ptr) {
I32 i, j;
// simple checks
if (level < 1) return EXIT_FAILURE;
#pragma omp parallel for default(shared) private(i, j)
for (i = 0; i < static_cast<I32>(Y); i++)
for (j = 0; j < static_cast<I32>(X); j++)
if (j < static_cast<I32>(level))
ptr[i * X + j] = ptr[i * X + j] - ref[i] * j / level;
else
ptr[i * X + j] = ptr[i * X + j] - ref[i];
return EXIT_SUCCESS;
}
/*******************************************************************************
Checked by http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py
*******************************************************************************/
| 36 | 80 | 0.537634 | wjh1001 |
1411ed3837576e17f0f96af7faa51ba74d33e139 | 4,537 | hpp | C++ | src/rdb_protocol/batching.hpp | sauter-hq/rethinkdb | f34541d501bcf109c2825a7a1b67cf8fd39b9133 | [
"Apache-2.0"
] | null | null | null | src/rdb_protocol/batching.hpp | sauter-hq/rethinkdb | f34541d501bcf109c2825a7a1b67cf8fd39b9133 | [
"Apache-2.0"
] | null | null | null | src/rdb_protocol/batching.hpp | sauter-hq/rethinkdb | f34541d501bcf109c2825a7a1b67cf8fd39b9133 | [
"Apache-2.0"
] | null | null | null | // Copyright 2010-2014 RethinkDB, all rights reserved.
#ifndef RDB_PROTOCOL_BATCHING_HPP_
#define RDB_PROTOCOL_BATCHING_HPP_
#include <utility>
#include "containers/archive/archive.hpp"
#include "containers/archive/versioned.hpp"
#include "rdb_protocol/datum.hpp"
#include "rpc/serialize_macros.hpp"
#include "time.hpp"
template<class T>
class counted_t;
namespace ql {
class datum_t;
class env_t;
enum class batch_type_t {
// A normal batch.
NORMAL = 0,
// The first batch in a series of normal batches. The size limit is reduced
// to help minimizing the latency until a user receives their first response.
NORMAL_FIRST = 1,
// A batch fetched for a terminal or terminal-like term, e.g. a big batched
// insert. Ignores latency caps because the latency the user encounters is
// determined by bandwidth instead.
TERMINAL = 2,
// If we're ordering by an sindex, get a batch with a constant value for
// that sindex. We sometimes need a batch with that invariant for sorting.
// (This replaces that SORTING_HINT_NEXT stuff.)
SINDEX_CONSTANT = 3
};
ARCHIVE_PRIM_MAKE_RANGED_SERIALIZABLE(
batch_type_t, int8_t, batch_type_t::NORMAL, batch_type_t::SINDEX_CONSTANT);
enum ignore_latency_t { NO, YES };
class batcher_t {
public:
bool note_el(const datum_t &t) {
seen_one_el = true;
els_left -= 1;
min_els_left -= 1;
size_left -= serialized_size<cluster_version_t::CLUSTER>(t);
return should_send_batch();
}
bool should_send_batch(
ignore_latency_t ignore_latency = ignore_latency_t::NO) const;
batcher_t(batcher_t &&other) :
batch_type(std::move(other.batch_type)),
seen_one_el(std::move(other.seen_one_el)),
min_els_left(std::move(other.min_els_left)),
els_left(std::move(other.els_left)),
size_left(std::move(other.size_left)),
end_time(std::move(other.end_time)) { }
microtime_t microtime_left() {
microtime_t cur_time = current_microtime();
return end_time > cur_time ? end_time - cur_time : 0;
}
batch_type_t get_batch_type() { return batch_type; }
private:
DISABLE_COPYING(batcher_t);
friend class batchspec_t;
batcher_t(batch_type_t batch_type, int64_t min_els, int64_t max_els,
int64_t max_size, microtime_t end_time);
const batch_type_t batch_type;
bool seen_one_el;
int64_t min_els_left, els_left, size_left;
const microtime_t end_time;
};
class batchspec_t {
public:
static batchspec_t user(batch_type_t batch_type, env_t *env);
static batchspec_t all(); // Gimme everything.
static batchspec_t empty() { return batchspec_t(); }
static batchspec_t default_for(batch_type_t batch_type);
batch_type_t get_batch_type() const { return batch_type; }
batchspec_t with_new_batch_type(batch_type_t new_batch_type) const;
batchspec_t with_min_els(int64_t new_min_els) const;
batchspec_t with_max_dur(int64_t new_max_dur) const;
batchspec_t with_at_most(uint64_t max_els) const;
// These are used to allow batchspecs to override the default ordering on a
// stream. This is only really useful when a stream is being treated as a
// set, as in the case of `include_initial` changefeeds where always using
// `ASCENDING` ordering allows the logic to be simpler.
batchspec_t with_lazy_sorting_override(sorting_t sort) const;
sorting_t lazy_sorting(sorting_t base) const {
return lazy_sorting_override ? *lazy_sorting_override : base;
}
batchspec_t scale_down(int64_t divisor) const;
batcher_t to_batcher() const;
private:
// I made this private and accessible through a static function because it
// was being accidentally default-initialized.
batchspec_t() { } // USE ONLY FOR SERIALIZATION
batchspec_t(batch_type_t batch_type, int64_t min_els, int64_t max_els,
int64_t max_size, int64_t first_scaledown,
int64_t max_dur, microtime_t start_time);
template<cluster_version_t W>
friend void serialize(write_message_t *wm, const batchspec_t &batchspec);
template<cluster_version_t W>
friend archive_result_t deserialize(read_stream_t *s, batchspec_t *batchspec);
batch_type_t batch_type;
int64_t min_els, max_els, max_size, first_scaledown_factor, max_dur;
microtime_t start_time;
boost::optional<sorting_t> lazy_sorting_override;
};
RDB_DECLARE_SERIALIZABLE(batchspec_t);
} // namespace ql
#endif // RDB_PROTOCOL_BATCHING_HPP_
| 36.886179 | 82 | 0.728675 | sauter-hq |
1413dfe7cd85c122d1f627a71f8c04d446f74a28 | 12,668 | cpp | C++ | src/casinocoin/beast/utility/src/beast_PropertyStream.cpp | MassICTBV/casinocoind | 81d6a15a0578c086c1812dd2203c0973099b0061 | [
"BSL-1.0"
] | 1 | 2020-03-17T21:31:14.000Z | 2020-03-17T21:31:14.000Z | src/casinocoin/beast/utility/src/beast_PropertyStream.cpp | MassICTBV/casinocoind | 81d6a15a0578c086c1812dd2203c0973099b0061 | [
"BSL-1.0"
] | 1 | 2018-09-29T17:35:07.000Z | 2018-09-29T17:35:07.000Z | src/casinocoin/beast/utility/src/beast_PropertyStream.cpp | MassICTBV/casinocoind | 81d6a15a0578c086c1812dd2203c0973099b0061 | [
"BSL-1.0"
] | 3 | 2018-07-12T11:34:45.000Z | 2021-09-13T18:08:25.000Z | //------------------------------------------------------------------------------
/*
This file is part of Beast: https://github.com/vinniefalco/Beast
Copyright 2013, Vinnie Falco <[email protected]>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#include <casinocoin/beast/utility/PropertyStream.h>
#include <algorithm>
#include <cassert>
#include <limits>
#include <iostream>
namespace beast {
//------------------------------------------------------------------------------
//
// Item
//
//------------------------------------------------------------------------------
PropertyStream::Item::Item (Source* source)
: m_source (source)
{
}
PropertyStream::Source& PropertyStream::Item::source() const
{
return *m_source;
}
PropertyStream::Source* PropertyStream::Item::operator-> () const
{
return &source();
}
PropertyStream::Source& PropertyStream::Item::operator* () const
{
return source();
}
//------------------------------------------------------------------------------
//
// Proxy
//
//------------------------------------------------------------------------------
PropertyStream::Proxy::Proxy (
Map const& map, std::string const& key)
: m_map (&map)
, m_key (key)
{
}
PropertyStream::Proxy::Proxy (Proxy const& other)
: m_map (other.m_map)
, m_key (other.m_key)
{
}
PropertyStream::Proxy::~Proxy ()
{
std::string const s (m_ostream.str());
if (! s.empty())
m_map->add (m_key, s);
}
std::ostream& PropertyStream::Proxy::operator<< (
std::ostream& manip (std::ostream&)) const
{
return m_ostream << manip;
}
//------------------------------------------------------------------------------
//
// Map
//
//------------------------------------------------------------------------------
PropertyStream::Map::Map (PropertyStream& stream)
: m_stream (stream)
{
}
PropertyStream::Map::Map (Set& parent)
: m_stream (parent.stream())
{
m_stream.map_begin ();
}
PropertyStream::Map::Map (std::string const& key, Map& map)
: m_stream (map.stream())
{
m_stream.map_begin (key);
}
PropertyStream::Map::Map (std::string const& key, PropertyStream& stream)
: m_stream (stream)
{
m_stream.map_begin (key);
}
PropertyStream::Map::~Map ()
{
m_stream.map_end ();
}
PropertyStream& PropertyStream::Map::stream()
{
return m_stream;
}
PropertyStream const& PropertyStream::Map::stream() const
{
return m_stream;
}
PropertyStream::Proxy PropertyStream::Map::operator[] (std::string const& key)
{
return Proxy (*this, key);
}
//------------------------------------------------------------------------------
//
// Set
//
//------------------------------------------------------------------------------
PropertyStream::Set::Set (std::string const& key, Map& map)
: m_stream (map.stream())
{
m_stream.array_begin (key);
}
PropertyStream::Set::Set (std::string const& key, PropertyStream& stream)
: m_stream (stream)
{
m_stream.array_begin (key);
}
PropertyStream::Set::~Set ()
{
m_stream.array_end ();
}
PropertyStream& PropertyStream::Set::stream()
{
return m_stream;
}
PropertyStream const& PropertyStream::Set::stream() const
{
return m_stream;
}
//------------------------------------------------------------------------------
//
// Source
//
//------------------------------------------------------------------------------
PropertyStream::Source::Source (std::string const& name)
: m_name (name)
, item_ (this)
, parent_ (nullptr)
{
}
PropertyStream::Source::~Source ()
{
std::lock_guard<std::recursive_mutex> _(lock_);
if (parent_ != nullptr)
parent_->remove (*this);
removeAll ();
}
std::string const& PropertyStream::Source::name () const
{
return m_name;
}
void PropertyStream::Source::add (Source& source)
{
std::lock(lock_, source.lock_);
std::lock_guard<std::recursive_mutex> lk1(lock_, std::adopt_lock);
std::lock_guard<std::recursive_mutex> lk2(source.lock_, std::adopt_lock);
assert (source.parent_ == nullptr);
children_.push_back (source.item_);
source.parent_ = this;
}
void PropertyStream::Source::remove (Source& child)
{
std::lock(lock_, child.lock_);
std::lock_guard<std::recursive_mutex> lk1(lock_, std::adopt_lock);
std::lock_guard<std::recursive_mutex> lk2(child.lock_, std::adopt_lock);
assert (child.parent_ == this);
children_.erase (
children_.iterator_to (
child.item_));
child.parent_ = nullptr;
}
void PropertyStream::Source::removeAll ()
{
std::lock_guard<std::recursive_mutex> _(lock_);
for (auto iter = children_.begin(); iter != children_.end(); )
{
std::lock_guard<std::recursive_mutex> _cl((*iter)->lock_);
remove (*(*iter));
}
}
//------------------------------------------------------------------------------
void PropertyStream::Source::write_one (PropertyStream& stream)
{
Map map (m_name, stream);
onWrite (map);
}
void PropertyStream::Source::write (PropertyStream& stream)
{
Map map (m_name, stream);
onWrite (map);
std::lock_guard<std::recursive_mutex> _(lock_);
for (auto& child : children_)
child.source().write (stream);
}
void PropertyStream::Source::write (PropertyStream& stream, std::string const& path)
{
std::pair <Source*, bool> result (find (path));
if (result.first == nullptr)
return;
if (result.second)
result.first->write (stream);
else
result.first->write_one (stream);
}
std::pair <PropertyStream::Source*, bool> PropertyStream::Source::find (std::string path)
{
bool const deep (peel_trailing_slashstar (&path));
bool const rooted (peel_leading_slash (&path));
Source* source (this);
if (! path.empty())
{
if (! rooted)
{
std::string const name (peel_name (&path));
source = find_one_deep (name);
if (source == nullptr)
return std::make_pair (nullptr, deep);
}
source = source->find_path (path);
}
return std::make_pair (source, deep);
}
bool PropertyStream::Source::peel_leading_slash (std::string* path)
{
if (! path->empty() && path->front() == '/')
{
*path = std::string (path->begin() + 1, path->end());
return true;
}
return false;
}
bool PropertyStream::Source::peel_trailing_slashstar (std::string* path)
{
bool found(false);
if (path->empty())
return false;
if (path->back() == '*')
{
found = true;
path->pop_back();
}
if(! path->empty() && path->back() == '/')
path->pop_back();
return found;
}
std::string PropertyStream::Source::peel_name (std::string* path)
{
if (path->empty())
return "";
std::string::const_iterator first = (*path).begin();
std::string::const_iterator last = (*path).end();
std::string::const_iterator pos = std::find (first, last, '/');
std::string s (first, pos);
if (pos != last)
*path = std::string (pos+1, last);
else
*path = std::string ();
return s;
}
// Recursive search through the whole tree until name is found
PropertyStream::Source* PropertyStream::Source::find_one_deep (std::string const& name)
{
Source* found = find_one (name);
if (found != nullptr)
return found;
std::lock_guard<std::recursive_mutex> _(lock_);
for (auto& s : children_)
{
found = s.source().find_one_deep (name);
if (found != nullptr)
return found;
}
return nullptr;
}
PropertyStream::Source* PropertyStream::Source::find_path (std::string path)
{
if (path.empty())
return this;
Source* source (this);
do
{
std::string const name (peel_name (&path));
if(name.empty ())
break;
source = source->find_one(name);
}
while (source != nullptr);
return source;
}
// This function only looks at immediate children
// If no immediate children match, then return nullptr
PropertyStream::Source* PropertyStream::Source::find_one (std::string const& name)
{
std::lock_guard<std::recursive_mutex> _(lock_);
for (auto& s : children_)
{
if (s.source().m_name == name)
return &s.source();
}
return nullptr;
}
void PropertyStream::Source::onWrite (Map&)
{
}
//------------------------------------------------------------------------------
//
// PropertyStream
//
//------------------------------------------------------------------------------
PropertyStream::PropertyStream ()
{
}
PropertyStream::~PropertyStream ()
{
}
void PropertyStream::add (std::string const& key, bool value)
{
if (value)
add (key, "true");
else
add (key, "false");
}
void PropertyStream::add (std::string const& key, char value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, signed char value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, unsigned char value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, wchar_t value)
{
lexical_add (key, value);
}
#if 0
void PropertyStream::add (std::string const& key, char16_t value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, char32_t value)
{
lexical_add (key, value);
}
#endif
void PropertyStream::add (std::string const& key, short value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, unsigned short value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, int value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, unsigned int value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, long value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, unsigned long value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, long long value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, unsigned long long value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, float value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, double value)
{
lexical_add (key, value);
}
void PropertyStream::add (std::string const& key, long double value)
{
lexical_add (key, value);
}
void PropertyStream::add (bool value)
{
if (value)
add ("true");
else
add ("false");
}
void PropertyStream::add (char value)
{
lexical_add (value);
}
void PropertyStream::add (signed char value)
{
lexical_add (value);
}
void PropertyStream::add (unsigned char value)
{
lexical_add (value);
}
void PropertyStream::add (wchar_t value)
{
lexical_add (value);
}
#if 0
void PropertyStream::add (char16_t value)
{
lexical_add (value);
}
void PropertyStream::add (char32_t value)
{
lexical_add (value);
}
#endif
void PropertyStream::add (short value)
{
lexical_add (value);
}
void PropertyStream::add (unsigned short value)
{
lexical_add (value);
}
void PropertyStream::add (int value)
{
lexical_add (value);
}
void PropertyStream::add (unsigned int value)
{
lexical_add (value);
}
void PropertyStream::add (long value)
{
lexical_add (value);
}
void PropertyStream::add (unsigned long value)
{
lexical_add (value);
}
void PropertyStream::add (long long value)
{
lexical_add (value);
}
void PropertyStream::add (unsigned long long value)
{
lexical_add (value);
}
void PropertyStream::add (float value)
{
lexical_add (value);
}
void PropertyStream::add (double value)
{
lexical_add (value);
}
void PropertyStream::add (long double value)
{
lexical_add (value);
}
}
| 21.916955 | 89 | 0.586517 | MassICTBV |
141442bb280965fafefcd810c2a762ad51690759 | 54,805 | cpp | C++ | core/fpdfapi/page/cpdf_streamcontentparser.cpp | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | 1 | 2019-01-12T07:08:25.000Z | 2019-01-12T07:08:25.000Z | core/fpdfapi/page/cpdf_streamcontentparser.cpp | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | null | null | null | core/fpdfapi/page/cpdf_streamcontentparser.cpp | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | 1 | 2019-09-20T07:47:55.000Z | 2019-09-20T07:47:55.000Z | // Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/fpdfapi/page/cpdf_streamcontentparser.h"
#include <memory>
#include <utility>
#include <vector>
#include "core/fpdfapi/font/cpdf_font.h"
#include "core/fpdfapi/font/cpdf_type3font.h"
#include "core/fpdfapi/page/cpdf_allstates.h"
#include "core/fpdfapi/page/cpdf_docpagedata.h"
#include "core/fpdfapi/page/cpdf_form.h"
#include "core/fpdfapi/page/cpdf_formobject.h"
#include "core/fpdfapi/page/cpdf_image.h"
#include "core/fpdfapi/page/cpdf_imageobject.h"
#include "core/fpdfapi/page/cpdf_meshstream.h"
#include "core/fpdfapi/page/cpdf_pageobject.h"
#include "core/fpdfapi/page/cpdf_pathobject.h"
#include "core/fpdfapi/page/cpdf_shadingobject.h"
#include "core/fpdfapi/page/cpdf_shadingpattern.h"
#include "core/fpdfapi/page/cpdf_streamparser.h"
#include "core/fpdfapi/page/cpdf_textobject.h"
#include "core/fpdfapi/page/pageint.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_dictionary.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/parser/cpdf_name.h"
#include "core/fpdfapi/parser/cpdf_number.h"
#include "core/fpdfapi/parser/cpdf_reference.h"
#include "core/fpdfapi/parser/cpdf_stream.h"
#include "core/fpdfapi/parser/fpdf_parser_decode.h"
#include "core/fxcrt/fx_safe_types.h"
#include "core/fxge/cfx_graphstatedata.h"
#include "third_party/base/ptr_util.h"
namespace {
const int kMaxFormLevel = 30;
const int kSingleCoordinatePair = 1;
const int kTensorCoordinatePairs = 16;
const int kCoonsCoordinatePairs = 12;
const int kSingleColorPerPatch = 1;
const int kQuadColorsPerPatch = 4;
const char kPathOperatorSubpath = 'm';
const char kPathOperatorLine = 'l';
const char kPathOperatorCubicBezier1 = 'c';
const char kPathOperatorCubicBezier2 = 'v';
const char kPathOperatorCubicBezier3 = 'y';
const char kPathOperatorClosePath = 'h';
const char kPathOperatorRectangle[] = "re";
class CPDF_StreamParserAutoClearer {
public:
CPDF_StreamParserAutoClearer(CPDF_StreamParser** scoped_variable,
CPDF_StreamParser* new_parser)
: scoped_variable_(scoped_variable) {
*scoped_variable_ = new_parser;
}
~CPDF_StreamParserAutoClearer() { *scoped_variable_ = nullptr; }
private:
CPDF_StreamParser** scoped_variable_;
};
CFX_FloatRect GetShadingBBox(CPDF_ShadingPattern* pShading,
const CFX_Matrix& matrix) {
ShadingType type = pShading->GetShadingType();
CPDF_Stream* pStream = ToStream(pShading->GetShadingObject());
CPDF_ColorSpace* pCS = pShading->GetCS();
if (!pStream || !pCS)
return CFX_FloatRect(0, 0, 0, 0);
CPDF_MeshStream stream(type, pShading->GetFuncs(), pStream, pCS);
if (!stream.Load())
return CFX_FloatRect(0, 0, 0, 0);
CFX_FloatRect rect;
bool bStarted = false;
bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
type == kLatticeFormGouraudTriangleMeshShading;
int point_count = kSingleCoordinatePair;
if (type == kTensorProductPatchMeshShading)
point_count = kTensorCoordinatePairs;
else if (type == kCoonsPatchMeshShading)
point_count = kCoonsCoordinatePairs;
int color_count = kSingleColorPerPatch;
if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
color_count = kQuadColorsPerPatch;
while (!stream.BitStream()->IsEOF()) {
uint32_t flag = 0;
if (type != kLatticeFormGouraudTriangleMeshShading)
flag = stream.GetFlag();
if (!bGouraud && flag) {
point_count -= 4;
color_count -= 2;
}
for (int i = 0; i < point_count; i++) {
FX_FLOAT x;
FX_FLOAT y;
stream.GetCoords(x, y);
if (bStarted) {
rect.UpdateRect(x, y);
} else {
rect.InitRect(x, y);
bStarted = true;
}
}
FX_SAFE_UINT32 nBits = stream.Components();
nBits *= stream.ComponentBits();
nBits *= color_count;
if (!nBits.IsValid())
break;
stream.BitStream()->SkipBits(nBits.ValueOrDie());
if (bGouraud)
stream.BitStream()->ByteAlign();
}
rect.Transform(&matrix);
return rect;
}
struct AbbrPair {
const FX_CHAR* abbr;
const FX_CHAR* full_name;
};
const AbbrPair InlineKeyAbbr[] = {
{"BPC", "BitsPerComponent"}, {"CS", "ColorSpace"}, {"D", "Decode"},
{"DP", "DecodeParms"}, {"F", "Filter"}, {"H", "Height"},
{"IM", "ImageMask"}, {"I", "Interpolate"}, {"W", "Width"},
};
const AbbrPair InlineValueAbbr[] = {
{"G", "DeviceGray"}, {"RGB", "DeviceRGB"},
{"CMYK", "DeviceCMYK"}, {"I", "Indexed"},
{"AHx", "ASCIIHexDecode"}, {"A85", "ASCII85Decode"},
{"LZW", "LZWDecode"}, {"Fl", "FlateDecode"},
{"RL", "RunLengthDecode"}, {"CCF", "CCITTFaxDecode"},
{"DCT", "DCTDecode"},
};
struct AbbrReplacementOp {
bool is_replace_key;
CFX_ByteString key;
CFX_ByteStringC replacement;
};
CFX_ByteStringC FindFullName(const AbbrPair* table,
size_t count,
const CFX_ByteStringC& abbr) {
auto it = std::find_if(table, table + count, [abbr](const AbbrPair& pair) {
return pair.abbr == abbr;
});
return it != table + count ? CFX_ByteStringC(it->full_name)
: CFX_ByteStringC();
}
void ReplaceAbbr(CPDF_Object* pObj) {
switch (pObj->GetType()) {
case CPDF_Object::DICTIONARY: {
CPDF_Dictionary* pDict = pObj->AsDictionary();
std::vector<AbbrReplacementOp> replacements;
for (const auto& it : *pDict) {
CFX_ByteString key = it.first;
CPDF_Object* value = it.second.get();
CFX_ByteStringC fullname = FindFullName(
InlineKeyAbbr, FX_ArraySize(InlineKeyAbbr), key.AsStringC());
if (!fullname.IsEmpty()) {
AbbrReplacementOp op;
op.is_replace_key = true;
op.key = key;
op.replacement = fullname;
replacements.push_back(op);
key = fullname;
}
if (value->IsName()) {
CFX_ByteString name = value->GetString();
fullname = FindFullName(
InlineValueAbbr, FX_ArraySize(InlineValueAbbr), name.AsStringC());
if (!fullname.IsEmpty()) {
AbbrReplacementOp op;
op.is_replace_key = false;
op.key = key;
op.replacement = fullname;
replacements.push_back(op);
}
} else {
ReplaceAbbr(value);
}
}
for (const auto& op : replacements) {
if (op.is_replace_key)
pDict->ReplaceKey(op.key, CFX_ByteString(op.replacement));
else
pDict->SetNewFor<CPDF_Name>(op.key, CFX_ByteString(op.replacement));
}
break;
}
case CPDF_Object::ARRAY: {
CPDF_Array* pArray = pObj->AsArray();
for (size_t i = 0; i < pArray->GetCount(); i++) {
CPDF_Object* pElement = pArray->GetObjectAt(i);
if (pElement->IsName()) {
CFX_ByteString name = pElement->GetString();
CFX_ByteStringC fullname = FindFullName(
InlineValueAbbr, FX_ArraySize(InlineValueAbbr), name.AsStringC());
if (!fullname.IsEmpty())
pArray->SetNewAt<CPDF_Name>(i, CFX_ByteString(fullname));
} else {
ReplaceAbbr(pElement);
}
}
break;
}
default:
break;
}
}
} // namespace
CFX_ByteStringC PDF_FindKeyAbbreviationForTesting(const CFX_ByteStringC& abbr) {
return FindFullName(InlineKeyAbbr, FX_ArraySize(InlineKeyAbbr), abbr);
}
CFX_ByteStringC PDF_FindValueAbbreviationForTesting(
const CFX_ByteStringC& abbr) {
return FindFullName(InlineValueAbbr, FX_ArraySize(InlineValueAbbr), abbr);
}
CPDF_StreamContentParser::CPDF_StreamContentParser(
CPDF_Document* pDocument,
CPDF_Dictionary* pPageResources,
CPDF_Dictionary* pParentResources,
const CFX_Matrix* pmtContentToUser,
CPDF_PageObjectHolder* pObjHolder,
CPDF_Dictionary* pResources,
CFX_FloatRect* pBBox,
CPDF_AllStates* pStates,
int level)
: m_pDocument(pDocument),
m_pPageResources(pPageResources),
m_pParentResources(pParentResources),
m_pResources(pResources),
m_pObjectHolder(pObjHolder),
m_Level(level),
m_ParamStartPos(0),
m_ParamCount(0),
m_pCurStates(new CPDF_AllStates),
m_pLastTextObject(nullptr),
m_DefFontSize(0),
m_pPathPoints(nullptr),
m_PathPointCount(0),
m_PathAllocSize(0),
m_PathCurrentX(0.0f),
m_PathCurrentY(0.0f),
m_PathClipType(0),
m_pLastImage(nullptr),
m_bColored(false),
m_bResourceMissing(false) {
if (pmtContentToUser)
m_mtContentToUser = *pmtContentToUser;
if (!m_pResources)
m_pResources = m_pParentResources;
if (!m_pResources)
m_pResources = m_pPageResources;
if (pBBox)
m_BBox = *pBBox;
if (pStates) {
m_pCurStates->Copy(*pStates);
} else {
m_pCurStates->m_GeneralState.Emplace();
m_pCurStates->m_GraphState.Emplace();
m_pCurStates->m_TextState.Emplace();
m_pCurStates->m_ColorState.Emplace();
}
for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
m_Type3Data[i] = 0.0;
}
}
CPDF_StreamContentParser::~CPDF_StreamContentParser() {
ClearAllParams();
FX_Free(m_pPathPoints);
}
int CPDF_StreamContentParser::GetNextParamPos() {
if (m_ParamCount == kParamBufSize) {
m_ParamStartPos++;
if (m_ParamStartPos == kParamBufSize) {
m_ParamStartPos = 0;
}
if (m_ParamBuf[m_ParamStartPos].m_Type == ContentParam::OBJECT)
m_ParamBuf[m_ParamStartPos].m_pObject.reset();
return m_ParamStartPos;
}
int index = m_ParamStartPos + m_ParamCount;
if (index >= kParamBufSize) {
index -= kParamBufSize;
}
m_ParamCount++;
return index;
}
void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
CFX_ByteStringC bsName(name, len);
ContentParam& param = m_ParamBuf[GetNextParamPos()];
if (len > 32) {
param.m_Type = ContentParam::OBJECT;
param.m_pObject = pdfium::MakeUnique<CPDF_Name>(
m_pDocument->GetByteStringPool(), PDF_NameDecode(bsName));
} else {
param.m_Type = ContentParam::NAME;
if (bsName.Find('#') == -1) {
FXSYS_memcpy(param.m_Name.m_Buffer, name, len);
param.m_Name.m_Len = len;
} else {
CFX_ByteString str = PDF_NameDecode(bsName);
FXSYS_memcpy(param.m_Name.m_Buffer, str.c_str(), str.GetLength());
param.m_Name.m_Len = str.GetLength();
}
}
}
void CPDF_StreamContentParser::AddNumberParam(const FX_CHAR* str, int len) {
ContentParam& param = m_ParamBuf[GetNextParamPos()];
param.m_Type = ContentParam::NUMBER;
param.m_Number.m_bInteger =
FX_atonum(CFX_ByteStringC(str, len), ¶m.m_Number.m_Integer);
}
void CPDF_StreamContentParser::AddObjectParam(
std::unique_ptr<CPDF_Object> pObj) {
ContentParam& param = m_ParamBuf[GetNextParamPos()];
param.m_Type = ContentParam::OBJECT;
param.m_pObject = std::move(pObj);
}
void CPDF_StreamContentParser::ClearAllParams() {
uint32_t index = m_ParamStartPos;
for (uint32_t i = 0; i < m_ParamCount; i++) {
if (m_ParamBuf[index].m_Type == ContentParam::OBJECT)
m_ParamBuf[index].m_pObject.reset();
index++;
if (index == kParamBufSize)
index = 0;
}
m_ParamStartPos = 0;
m_ParamCount = 0;
}
CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
if (index >= m_ParamCount) {
return nullptr;
}
int real_index = m_ParamStartPos + m_ParamCount - index - 1;
if (real_index >= kParamBufSize) {
real_index -= kParamBufSize;
}
ContentParam& param = m_ParamBuf[real_index];
if (param.m_Type == ContentParam::NUMBER) {
param.m_Type = ContentParam::OBJECT;
param.m_pObject =
param.m_Number.m_bInteger
? pdfium::MakeUnique<CPDF_Number>(param.m_Number.m_Integer)
: pdfium::MakeUnique<CPDF_Number>(param.m_Number.m_Float);
return param.m_pObject.get();
}
if (param.m_Type == ContentParam::NAME) {
param.m_Type = ContentParam::OBJECT;
param.m_pObject = pdfium::MakeUnique<CPDF_Name>(
m_pDocument->GetByteStringPool(),
CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
return param.m_pObject.get();
}
if (param.m_Type == ContentParam::OBJECT)
return param.m_pObject.get();
ASSERT(false);
return nullptr;
}
CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
if (index >= m_ParamCount) {
return CFX_ByteString();
}
int real_index = m_ParamStartPos + m_ParamCount - index - 1;
if (real_index >= kParamBufSize) {
real_index -= kParamBufSize;
}
ContentParam& param = m_ParamBuf[real_index];
if (param.m_Type == ContentParam::NAME) {
return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
}
if (param.m_Type == 0 && param.m_pObject) {
return param.m_pObject->GetString();
}
return CFX_ByteString();
}
FX_FLOAT CPDF_StreamContentParser::GetNumber(uint32_t index) {
if (index >= m_ParamCount) {
return 0;
}
int real_index = m_ParamStartPos + m_ParamCount - index - 1;
if (real_index >= kParamBufSize) {
real_index -= kParamBufSize;
}
ContentParam& param = m_ParamBuf[real_index];
if (param.m_Type == ContentParam::NUMBER) {
return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
: param.m_Number.m_Float;
}
if (param.m_Type == 0 && param.m_pObject) {
return param.m_pObject->GetNumber();
}
return 0;
}
void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
bool bColor,
bool bText,
bool bGraph) {
pObj->m_GeneralState = m_pCurStates->m_GeneralState;
pObj->m_ClipPath = m_pCurStates->m_ClipPath;
pObj->m_ContentMark = m_CurContentMark;
if (bColor) {
pObj->m_ColorState = m_pCurStates->m_ColorState;
}
if (bGraph) {
pObj->m_GraphState = m_pCurStates->m_GraphState;
}
if (bText) {
pObj->m_TextState = m_pCurStates->m_TextState;
}
}
// static
CPDF_StreamContentParser::OpCodes
CPDF_StreamContentParser::InitializeOpCodes() {
return OpCodes({
{FXBSTR_ID('"', 0, 0, 0),
&CPDF_StreamContentParser::Handle_NextLineShowText_Space},
{FXBSTR_ID('\'', 0, 0, 0),
&CPDF_StreamContentParser::Handle_NextLineShowText},
{FXBSTR_ID('B', 0, 0, 0),
&CPDF_StreamContentParser::Handle_FillStrokePath},
{FXBSTR_ID('B', '*', 0, 0),
&CPDF_StreamContentParser::Handle_EOFillStrokePath},
{FXBSTR_ID('B', 'D', 'C', 0),
&CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
{FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
{FXBSTR_ID('B', 'M', 'C', 0),
&CPDF_StreamContentParser::Handle_BeginMarkedContent},
{FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
{FXBSTR_ID('C', 'S', 0, 0),
&CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
{FXBSTR_ID('D', 'P', 0, 0),
&CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
{FXBSTR_ID('D', 'o', 0, 0),
&CPDF_StreamContentParser::Handle_ExecuteXObject},
{FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
{FXBSTR_ID('E', 'M', 'C', 0),
&CPDF_StreamContentParser::Handle_EndMarkedContent},
{FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
{FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
{FXBSTR_ID('G', 0, 0, 0),
&CPDF_StreamContentParser::Handle_SetGray_Stroke},
{FXBSTR_ID('I', 'D', 0, 0),
&CPDF_StreamContentParser::Handle_BeginImageData},
{FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
{FXBSTR_ID('K', 0, 0, 0),
&CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
{FXBSTR_ID('M', 0, 0, 0),
&CPDF_StreamContentParser::Handle_SetMiterLimit},
{FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
{FXBSTR_ID('Q', 0, 0, 0),
&CPDF_StreamContentParser::Handle_RestoreGraphState},
{FXBSTR_ID('R', 'G', 0, 0),
&CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
{FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
{FXBSTR_ID('S', 'C', 0, 0),
&CPDF_StreamContentParser::Handle_SetColor_Stroke},
{FXBSTR_ID('S', 'C', 'N', 0),
&CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
{FXBSTR_ID('T', '*', 0, 0),
&CPDF_StreamContentParser::Handle_MoveToNextLine},
{FXBSTR_ID('T', 'D', 0, 0),
&CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
{FXBSTR_ID('T', 'J', 0, 0),
&CPDF_StreamContentParser::Handle_ShowText_Positioning},
{FXBSTR_ID('T', 'L', 0, 0),
&CPDF_StreamContentParser::Handle_SetTextLeading},
{FXBSTR_ID('T', 'c', 0, 0),
&CPDF_StreamContentParser::Handle_SetCharSpace},
{FXBSTR_ID('T', 'd', 0, 0),
&CPDF_StreamContentParser::Handle_MoveTextPoint},
{FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
{FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
{FXBSTR_ID('T', 'm', 0, 0),
&CPDF_StreamContentParser::Handle_SetTextMatrix},
{FXBSTR_ID('T', 'r', 0, 0),
&CPDF_StreamContentParser::Handle_SetTextRenderMode},
{FXBSTR_ID('T', 's', 0, 0),
&CPDF_StreamContentParser::Handle_SetTextRise},
{FXBSTR_ID('T', 'w', 0, 0),
&CPDF_StreamContentParser::Handle_SetWordSpace},
{FXBSTR_ID('T', 'z', 0, 0),
&CPDF_StreamContentParser::Handle_SetHorzScale},
{FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
{FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
{FXBSTR_ID('b', 0, 0, 0),
&CPDF_StreamContentParser::Handle_CloseFillStrokePath},
{FXBSTR_ID('b', '*', 0, 0),
&CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
{FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
{FXBSTR_ID('c', 'm', 0, 0),
&CPDF_StreamContentParser::Handle_ConcatMatrix},
{FXBSTR_ID('c', 's', 0, 0),
&CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
{FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
{FXBSTR_ID('d', '0', 0, 0),
&CPDF_StreamContentParser::Handle_SetCharWidth},
{FXBSTR_ID('d', '1', 0, 0),
&CPDF_StreamContentParser::Handle_SetCachedDevice},
{FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
{FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
{FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
{FXBSTR_ID('g', 's', 0, 0),
&CPDF_StreamContentParser::Handle_SetExtendGraphState},
{FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
{FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
{FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
{FXBSTR_ID('k', 0, 0, 0),
&CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
{FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
{FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
{FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
{FXBSTR_ID('q', 0, 0, 0),
&CPDF_StreamContentParser::Handle_SaveGraphState},
{FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
{FXBSTR_ID('r', 'g', 0, 0),
&CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
{FXBSTR_ID('r', 'i', 0, 0),
&CPDF_StreamContentParser::Handle_SetRenderIntent},
{FXBSTR_ID('s', 0, 0, 0),
&CPDF_StreamContentParser::Handle_CloseStrokePath},
{FXBSTR_ID('s', 'c', 0, 0),
&CPDF_StreamContentParser::Handle_SetColor_Fill},
{FXBSTR_ID('s', 'c', 'n', 0),
&CPDF_StreamContentParser::Handle_SetColorPS_Fill},
{FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
{FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
{FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
{FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
});
}
void CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
int i = 0;
uint32_t opid = 0;
while (i < 4 && op[i]) {
opid = (opid << 8) + op[i];
i++;
}
while (i < 4) {
opid <<= 8;
i++;
}
static const OpCodes s_OpCodes = InitializeOpCodes();
auto it = s_OpCodes.find(opid);
if (it != s_OpCodes.end())
(this->*it->second)();
}
void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
Handle_ClosePath();
AddPathObject(FXFILL_WINDING, true);
}
void CPDF_StreamContentParser::Handle_FillStrokePath() {
AddPathObject(FXFILL_WINDING, true);
}
void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
AddPathObject(FXFILL_ALTERNATE, true);
}
void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
AddPathObject(FXFILL_ALTERNATE, true);
}
void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
CFX_ByteString tag = GetString(1);
CPDF_Object* pProperty = GetObject(0);
if (!pProperty) {
return;
}
bool bDirect = true;
if (pProperty->IsName()) {
pProperty = FindResourceObj("Properties", pProperty->GetString());
if (!pProperty)
return;
bDirect = false;
}
if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
m_CurContentMark.AddMark(tag, pDict, bDirect);
}
}
void CPDF_StreamContentParser::Handle_BeginImage() {
FX_FILESIZE savePos = m_pSyntax->GetPos();
auto pDict =
pdfium::MakeUnique<CPDF_Dictionary>(m_pDocument->GetByteStringPool());
while (1) {
CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
if (type == CPDF_StreamParser::Keyword) {
CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(),
m_pSyntax->GetWordSize());
if (bsKeyword != "ID") {
m_pSyntax->SetPos(savePos);
return;
}
}
if (type != CPDF_StreamParser::Name) {
break;
}
CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1,
m_pSyntax->GetWordSize() - 1);
auto pObj = m_pSyntax->ReadNextObject(false, 0);
if (!key.IsEmpty()) {
uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
if (dwObjNum)
pDict->SetNewFor<CPDF_Reference>(key, m_pDocument, dwObjNum);
else
pDict->SetFor(key, std::move(pObj));
}
}
ReplaceAbbr(pDict.get());
CPDF_Object* pCSObj = nullptr;
if (pDict->KeyExist("ColorSpace")) {
pCSObj = pDict->GetDirectObjectFor("ColorSpace");
if (pCSObj->IsName()) {
CFX_ByteString name = pCSObj->GetString();
if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
pCSObj = FindResourceObj("ColorSpace", name);
if (pCSObj && pCSObj->IsInline())
pDict->SetFor("ColorSpace", pCSObj->Clone());
}
}
}
pDict->SetNewFor<CPDF_Name>("Subtype", "Image");
std::unique_ptr<CPDF_Stream> pStream =
m_pSyntax->ReadInlineStream(m_pDocument, std::move(pDict), pCSObj);
while (1) {
CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
if (type == CPDF_StreamParser::EndOfData) {
break;
}
if (type != CPDF_StreamParser::Keyword) {
continue;
}
if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
m_pSyntax->GetWordBuf()[1] == 'I') {
break;
}
}
AddImage(std::move(pStream));
}
void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
m_CurContentMark.AddMark(GetString(0), nullptr, false);
}
void CPDF_StreamContentParser::Handle_BeginText() {
m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
OnChangeTextMatrix();
m_pCurStates->m_TextX = 0;
m_pCurStates->m_TextY = 0;
m_pCurStates->m_TextLineX = 0;
m_pCurStates->m_TextLineY = 0;
}
void CPDF_StreamContentParser::Handle_CurveTo_123() {
AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
}
void CPDF_StreamContentParser::Handle_ConcatMatrix() {
CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
GetNumber(1), GetNumber(0));
new_matrix.Concat(m_pCurStates->m_CTM);
m_pCurStates->m_CTM = new_matrix;
OnChangeTextMatrix();
}
void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
if (!pCS)
return;
m_pCurStates->m_ColorState.GetMutableFillColor()->SetColorSpace(pCS);
}
void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
if (!pCS)
return;
m_pCurStates->m_ColorState.GetMutableStrokeColor()->SetColorSpace(pCS);
}
void CPDF_StreamContentParser::Handle_SetDash() {
CPDF_Array* pArray = ToArray(GetObject(1));
if (!pArray)
return;
m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
}
void CPDF_StreamContentParser::Handle_SetCharWidth() {
m_Type3Data[0] = GetNumber(1);
m_Type3Data[1] = GetNumber(0);
m_bColored = true;
}
void CPDF_StreamContentParser::Handle_SetCachedDevice() {
for (int i = 0; i < 6; i++) {
m_Type3Data[i] = GetNumber(5 - i);
}
m_bColored = false;
}
void CPDF_StreamContentParser::Handle_ExecuteXObject() {
CFX_ByteString name = GetString(0);
if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
m_pLastImage->GetStream()->GetObjNum()) {
AddImage(m_pLastImage);
return;
}
CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
if (!pXObject) {
m_bResourceMissing = true;
return;
}
CFX_ByteString type;
if (pXObject->GetDict())
type = pXObject->GetDict()->GetStringFor("Subtype");
if (type == "Image") {
CPDF_ImageObject* pObj = pXObject->IsInline()
? AddImage(std::unique_ptr<CPDF_Stream>(
ToStream(pXObject->Clone())))
: AddImage(pXObject->GetObjNum());
m_LastImageName = name;
m_pLastImage = pObj->GetImage();
if (!m_pObjectHolder->HasImageMask())
m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
} else if (type == "Form") {
AddForm(pXObject);
}
}
void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
std::unique_ptr<CPDF_FormObject> pFormObj(new CPDF_FormObject);
pFormObj->m_pForm.reset(
new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources));
pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
CPDF_AllStates status;
status.m_GeneralState = m_pCurStates->m_GeneralState;
status.m_GraphState = m_pCurStates->m_GraphState;
status.m_ColorState = m_pCurStates->m_ColorState;
status.m_TextState = m_pCurStates->m_TextState;
pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
pFormObj->m_pForm->BackgroundAlphaNeeded()) {
m_pObjectHolder->SetBackgroundAlphaNeeded(true);
}
pFormObj->CalcBoundingBox();
SetGraphicStates(pFormObj.get(), true, true, true);
m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
}
CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
std::unique_ptr<CPDF_Stream> pStream) {
if (!pStream)
return nullptr;
auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
pImageObj->SetOwnedImage(
pdfium::MakeUnique<CPDF_Image>(m_pDocument, std::move(pStream)));
return AddImageObject(std::move(pImageObj));
}
CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
pImageObj->SetUnownedImage(m_pDocument->LoadImageFromPageData(streamObjNum));
return AddImageObject(std::move(pImageObj));
}
CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Image* pImage) {
if (!pImage)
return nullptr;
auto pImageObj = pdfium::MakeUnique<CPDF_ImageObject>();
pImageObj->SetUnownedImage(
m_pDocument->GetPageData()->GetImage(pImage->GetStream()->GetObjNum()));
return AddImageObject(std::move(pImageObj));
}
CPDF_ImageObject* CPDF_StreamContentParser::AddImageObject(
std::unique_ptr<CPDF_ImageObject> pImageObj) {
SetGraphicStates(pImageObj.get(), pImageObj->GetImage()->IsMask(), false,
false);
CFX_Matrix ImageMatrix = m_pCurStates->m_CTM;
ImageMatrix.Concat(m_mtContentToUser);
pImageObj->set_matrix(ImageMatrix);
pImageObj->CalcBoundingBox();
CPDF_ImageObject* pRet = pImageObj.get();
m_pObjectHolder->GetPageObjectList()->push_back(std::move(pImageObj));
return pRet;
}
void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
void CPDF_StreamContentParser::Handle_EndImage() {}
void CPDF_StreamContentParser::Handle_EndMarkedContent() {
if (m_CurContentMark)
m_CurContentMark.DeleteLastMark();
}
void CPDF_StreamContentParser::Handle_EndText() {
if (m_ClipTextList.empty())
return;
if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState.GetTextMode()))
m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
m_ClipTextList.clear();
}
void CPDF_StreamContentParser::Handle_FillPath() {
AddPathObject(FXFILL_WINDING, false);
}
void CPDF_StreamContentParser::Handle_FillPathOld() {
AddPathObject(FXFILL_WINDING, false);
}
void CPDF_StreamContentParser::Handle_EOFillPath() {
AddPathObject(FXFILL_ALTERNATE, false);
}
void CPDF_StreamContentParser::Handle_SetGray_Fill() {
FX_FLOAT value = GetNumber(0);
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
}
void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
FX_FLOAT value = GetNumber(0);
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
}
void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
CFX_ByteString name = GetString(0);
CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
if (!pGS) {
m_bResourceMissing = true;
return;
}
m_pCurStates->ProcessExtGS(pGS, this);
}
void CPDF_StreamContentParser::Handle_ClosePath() {
if (m_PathPointCount == 0) {
return;
}
if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
} else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
}
}
void CPDF_StreamContentParser::Handle_SetFlat() {
m_pCurStates->m_GeneralState.SetFlatness(GetNumber(0));
}
void CPDF_StreamContentParser::Handle_BeginImageData() {}
void CPDF_StreamContentParser::Handle_SetLineJoin() {
m_pCurStates->m_GraphState.SetLineJoin(
static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0)));
}
void CPDF_StreamContentParser::Handle_SetLineCap() {
m_pCurStates->m_GraphState.SetLineCap(
static_cast<CFX_GraphStateData::LineCap>(GetInteger(0)));
}
void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
if (m_ParamCount != 4)
return;
FX_FLOAT values[4];
for (int i = 0; i < 4; i++) {
values[i] = GetNumber(3 - i);
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
m_pCurStates->m_ColorState.SetFillColor(pCS, values, 4);
}
void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
if (m_ParamCount != 4)
return;
FX_FLOAT values[4];
for (int i = 0; i < 4; i++) {
values[i] = GetNumber(3 - i);
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
}
void CPDF_StreamContentParser::Handle_LineTo() {
if (m_ParamCount != 2)
return;
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
}
void CPDF_StreamContentParser::Handle_MoveTo() {
if (m_ParamCount != 2)
return;
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
ParsePathObject();
}
void CPDF_StreamContentParser::Handle_SetMiterLimit() {
m_pCurStates->m_GraphState.SetMiterLimit(GetNumber(0));
}
void CPDF_StreamContentParser::Handle_MarkPlace() {}
void CPDF_StreamContentParser::Handle_EndPath() {
AddPathObject(0, false);
}
void CPDF_StreamContentParser::Handle_SaveGraphState() {
std::unique_ptr<CPDF_AllStates> pStates(new CPDF_AllStates);
pStates->Copy(*m_pCurStates);
m_StateStack.push_back(std::move(pStates));
}
void CPDF_StreamContentParser::Handle_RestoreGraphState() {
if (m_StateStack.empty())
return;
std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
m_StateStack.pop_back();
m_pCurStates->Copy(*pStates);
}
void CPDF_StreamContentParser::Handle_Rectangle() {
FX_FLOAT x = GetNumber(3), y = GetNumber(2);
FX_FLOAT w = GetNumber(1), h = GetNumber(0);
AddPathRect(x, y, w, h);
}
void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
FX_FLOAT y,
FX_FLOAT w,
FX_FLOAT h) {
AddPathPoint(x, y, FXPT_MOVETO);
AddPathPoint(x + w, y, FXPT_LINETO);
AddPathPoint(x + w, y + h, FXPT_LINETO);
AddPathPoint(x, y + h, FXPT_LINETO);
AddPathPoint(x, y, FXPT_LINETO | FXPT_CLOSEFIGURE);
}
void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
if (m_ParamCount != 3)
return;
FX_FLOAT values[3];
for (int i = 0; i < 3; i++) {
values[i] = GetNumber(2 - i);
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
m_pCurStates->m_ColorState.SetFillColor(pCS, values, 3);
}
void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
if (m_ParamCount != 3)
return;
FX_FLOAT values[3];
for (int i = 0; i < 3; i++) {
values[i] = GetNumber(2 - i);
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
}
void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
void CPDF_StreamContentParser::Handle_CloseStrokePath() {
Handle_ClosePath();
AddPathObject(0, true);
}
void CPDF_StreamContentParser::Handle_StrokePath() {
AddPathObject(0, true);
}
void CPDF_StreamContentParser::Handle_SetColor_Fill() {
FX_FLOAT values[4];
int nargs = m_ParamCount;
if (nargs > 4) {
nargs = 4;
}
for (int i = 0; i < nargs; i++) {
values[i] = GetNumber(nargs - i - 1);
}
m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nargs);
}
void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
FX_FLOAT values[4];
int nargs = m_ParamCount;
if (nargs > 4) {
nargs = 4;
}
for (int i = 0; i < nargs; i++) {
values[i] = GetNumber(nargs - i - 1);
}
m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nargs);
}
void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
CPDF_Object* pLastParam = GetObject(0);
if (!pLastParam) {
return;
}
uint32_t nargs = m_ParamCount;
uint32_t nvalues = nargs;
if (pLastParam->IsName())
nvalues--;
FX_FLOAT* values = nullptr;
if (nvalues) {
values = FX_Alloc(FX_FLOAT, nvalues);
for (uint32_t i = 0; i < nvalues; i++) {
values[i] = GetNumber(nargs - i - 1);
}
}
if (nvalues != nargs) {
CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
if (pPattern) {
m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
}
} else {
m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nvalues);
}
FX_Free(values);
}
void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
CPDF_Object* pLastParam = GetObject(0);
if (!pLastParam) {
return;
}
int nargs = m_ParamCount;
int nvalues = nargs;
if (pLastParam->IsName())
nvalues--;
FX_FLOAT* values = nullptr;
if (nvalues) {
values = FX_Alloc(FX_FLOAT, nvalues);
for (int i = 0; i < nvalues; i++) {
values[i] = GetNumber(nargs - i - 1);
}
}
if (nvalues != nargs) {
CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
if (pPattern) {
m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
}
} else {
m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nvalues);
}
FX_Free(values);
}
void CPDF_StreamContentParser::Handle_ShadeFill() {
CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
if (!pPattern)
return;
CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
if (!pShading)
return;
if (!pShading->IsShadingObject() || !pShading->Load())
return;
std::unique_ptr<CPDF_ShadingObject> pObj(new CPDF_ShadingObject);
pObj->m_pShading = pShading;
SetGraphicStates(pObj.get(), false, false, false);
pObj->m_Matrix = m_pCurStates->m_CTM;
pObj->m_Matrix.Concat(m_mtContentToUser);
CFX_FloatRect bbox =
pObj->m_ClipPath ? pObj->m_ClipPath.GetClipBox() : m_BBox;
if (pShading->IsMeshShading())
bbox.Intersect(GetShadingBBox(pShading, pObj->m_Matrix));
pObj->m_Left = bbox.left;
pObj->m_Right = bbox.right;
pObj->m_Top = bbox.top;
pObj->m_Bottom = bbox.bottom;
m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
}
void CPDF_StreamContentParser::Handle_SetCharSpace() {
m_pCurStates->m_TextState.SetCharSpace(GetNumber(0));
}
void CPDF_StreamContentParser::Handle_MoveTextPoint() {
m_pCurStates->m_TextLineX += GetNumber(1);
m_pCurStates->m_TextLineY += GetNumber(0);
m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
}
void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
Handle_MoveTextPoint();
m_pCurStates->m_TextLeading = -GetNumber(0);
}
void CPDF_StreamContentParser::Handle_SetFont() {
FX_FLOAT fs = GetNumber(0);
if (fs == 0) {
fs = m_DefFontSize;
}
m_pCurStates->m_TextState.SetFontSize(fs);
CPDF_Font* pFont = FindFont(GetString(1));
if (pFont) {
m_pCurStates->m_TextState.SetFont(pFont);
}
}
CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
const CFX_ByteString& type,
const CFX_ByteString& name) {
if (!m_pResources)
return nullptr;
CPDF_Dictionary* pDict = m_pResources->GetDictFor(type);
if (pDict)
return pDict->GetDirectObjectFor(name);
if (m_pResources == m_pPageResources || !m_pPageResources)
return nullptr;
CPDF_Dictionary* pPageDict = m_pPageResources->GetDictFor(type);
return pPageDict ? pPageDict->GetDirectObjectFor(name) : nullptr;
}
CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
if (!pFontDict) {
m_bResourceMissing = true;
return CPDF_Font::GetStockFont(m_pDocument, "Helvetica");
}
CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
if (pFont && pFont->IsType3Font()) {
pFont->AsType3Font()->SetPageResources(m_pResources);
pFont->AsType3Font()->CheckType3FontMetrics();
}
return pFont;
}
CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(
const CFX_ByteString& name) {
if (name == "Pattern") {
return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
}
if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
CFX_ByteString defname = "Default";
defname += name.Mid(7);
CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
if (!pDefObj) {
if (name == "DeviceGray") {
return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
}
if (name == "DeviceRGB") {
return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
}
return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
}
return m_pDocument->LoadColorSpace(pDefObj);
}
CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
if (!pCSObj) {
m_bResourceMissing = true;
return nullptr;
}
return m_pDocument->LoadColorSpace(pCSObj);
}
CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
bool bShading) {
CPDF_Object* pPattern =
FindResourceObj(bShading ? "Shading" : "Pattern", name);
if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
m_bResourceMissing = true;
return nullptr;
}
return m_pDocument->LoadPattern(pPattern, bShading,
m_pCurStates->m_ParentMatrix);
}
void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
ConvertUserSpace(x, y);
}
void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
m_pCurStates->m_CTM.Transform(x, y, x, y);
m_mtContentToUser.Transform(x, y, x, y);
}
void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs,
FX_FLOAT fInitKerning,
FX_FLOAT* pKerning,
int nsegs) {
CPDF_Font* pFont = m_pCurStates->m_TextState.GetFont();
if (!pFont) {
return;
}
if (fInitKerning != 0) {
if (!pFont->IsVertWriting()) {
m_pCurStates->m_TextX -=
(fInitKerning * m_pCurStates->m_TextState.GetFontSize() *
m_pCurStates->m_TextHorzScale) /
1000;
} else {
m_pCurStates->m_TextY -=
(fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
}
}
if (nsegs == 0) {
return;
}
const TextRenderingMode text_mode =
pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
: m_pCurStates->m_TextState.GetTextMode();
{
std::unique_ptr<CPDF_TextObject> pText(new CPDF_TextObject);
m_pLastTextObject = pText.get();
SetGraphicStates(m_pLastTextObject, true, true, true);
if (TextRenderingModeIsStrokeMode(text_mode)) {
FX_FLOAT* pCTM = pText->m_TextState.GetMutableCTM();
pCTM[0] = m_pCurStates->m_CTM.a;
pCTM[1] = m_pCurStates->m_CTM.c;
pCTM[2] = m_pCurStates->m_CTM.b;
pCTM[3] = m_pCurStates->m_CTM.d;
}
pText->SetSegments(pStrs, pKerning, nsegs);
pText->m_PosX = m_pCurStates->m_TextX;
pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
ConvertTextSpace(pText->m_PosX, pText->m_PosY);
FX_FLOAT x_advance;
FX_FLOAT y_advance;
pText->CalcPositionData(&x_advance, &y_advance,
m_pCurStates->m_TextHorzScale);
m_pCurStates->m_TextX += x_advance;
m_pCurStates->m_TextY += y_advance;
if (TextRenderingModeIsClipMode(text_mode)) {
m_ClipTextList.push_back(
std::unique_ptr<CPDF_TextObject>(pText->Clone()));
}
m_pObjectHolder->GetPageObjectList()->push_back(std::move(pText));
}
if (pKerning && pKerning[nsegs - 1] != 0) {
if (!pFont->IsVertWriting()) {
m_pCurStates->m_TextX -=
(pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize() *
m_pCurStates->m_TextHorzScale) /
1000;
} else {
m_pCurStates->m_TextY -=
(pKerning[nsegs - 1] * m_pCurStates->m_TextState.GetFontSize()) /
1000;
}
}
}
void CPDF_StreamContentParser::Handle_ShowText() {
CFX_ByteString str = GetString(0);
if (str.IsEmpty()) {
return;
}
AddTextObject(&str, 0, nullptr, 1);
}
void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
CPDF_Array* pArray = ToArray(GetObject(0));
if (!pArray)
return;
size_t n = pArray->GetCount();
size_t nsegs = 0;
for (size_t i = 0; i < n; i++) {
if (pArray->GetDirectObjectAt(i)->IsString())
nsegs++;
}
if (nsegs == 0) {
for (size_t i = 0; i < n; i++) {
m_pCurStates->m_TextX -=
(pArray->GetNumberAt(i) * m_pCurStates->m_TextState.GetFontSize() *
m_pCurStates->m_TextHorzScale) /
1000;
}
return;
}
CFX_ByteString* pStrs = new CFX_ByteString[nsegs];
FX_FLOAT* pKerning = FX_Alloc(FX_FLOAT, nsegs);
size_t iSegment = 0;
FX_FLOAT fInitKerning = 0;
for (size_t i = 0; i < n; i++) {
CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
if (pObj->IsString()) {
CFX_ByteString str = pObj->GetString();
if (str.IsEmpty()) {
continue;
}
pStrs[iSegment] = str;
pKerning[iSegment++] = 0;
} else {
FX_FLOAT num = pObj ? pObj->GetNumber() : 0;
if (iSegment == 0) {
fInitKerning += num;
} else {
pKerning[iSegment - 1] += num;
}
}
}
AddTextObject(pStrs, fInitKerning, pKerning, iSegment);
delete[] pStrs;
FX_Free(pKerning);
}
void CPDF_StreamContentParser::Handle_SetTextLeading() {
m_pCurStates->m_TextLeading = GetNumber(0);
}
void CPDF_StreamContentParser::Handle_SetTextMatrix() {
m_pCurStates->m_TextMatrix.Set(GetNumber(5), GetNumber(4), GetNumber(3),
GetNumber(2), GetNumber(1), GetNumber(0));
OnChangeTextMatrix();
m_pCurStates->m_TextX = 0;
m_pCurStates->m_TextY = 0;
m_pCurStates->m_TextLineX = 0;
m_pCurStates->m_TextLineY = 0;
}
void CPDF_StreamContentParser::OnChangeTextMatrix() {
CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f);
text_matrix.Concat(m_pCurStates->m_TextMatrix);
text_matrix.Concat(m_pCurStates->m_CTM);
text_matrix.Concat(m_mtContentToUser);
FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetMutableMatrix();
pTextMatrix[0] = text_matrix.a;
pTextMatrix[1] = text_matrix.c;
pTextMatrix[2] = text_matrix.b;
pTextMatrix[3] = text_matrix.d;
}
void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
TextRenderingMode mode;
if (SetTextRenderingModeFromInt(GetInteger(0), &mode))
m_pCurStates->m_TextState.SetTextMode(mode);
}
void CPDF_StreamContentParser::Handle_SetTextRise() {
m_pCurStates->m_TextRise = GetNumber(0);
}
void CPDF_StreamContentParser::Handle_SetWordSpace() {
m_pCurStates->m_TextState.SetWordSpace(GetNumber(0));
}
void CPDF_StreamContentParser::Handle_SetHorzScale() {
if (m_ParamCount != 1) {
return;
}
m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
OnChangeTextMatrix();
}
void CPDF_StreamContentParser::Handle_MoveToNextLine() {
m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
}
void CPDF_StreamContentParser::Handle_CurveTo_23() {
AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
}
void CPDF_StreamContentParser::Handle_SetLineWidth() {
m_pCurStates->m_GraphState.SetLineWidth(GetNumber(0));
}
void CPDF_StreamContentParser::Handle_Clip() {
m_PathClipType = FXFILL_WINDING;
}
void CPDF_StreamContentParser::Handle_EOClip() {
m_PathClipType = FXFILL_ALTERNATE;
}
void CPDF_StreamContentParser::Handle_CurveTo_13() {
AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
}
void CPDF_StreamContentParser::Handle_NextLineShowText() {
Handle_MoveToNextLine();
Handle_ShowText();
}
void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
m_pCurStates->m_TextState.SetWordSpace(GetNumber(2));
m_pCurStates->m_TextState.SetCharSpace(GetNumber(1));
Handle_NextLineShowText();
}
void CPDF_StreamContentParser::Handle_Invalid() {}
void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
m_PathCurrentX = x;
m_PathCurrentY = y;
if (flag == FXPT_MOVETO) {
m_PathStartX = x;
m_PathStartY = y;
if (m_PathPointCount &&
m_pPathPoints[m_PathPointCount - 1].m_Flag == FXPT_MOVETO) {
m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
return;
}
} else if (m_PathPointCount == 0) {
return;
}
m_PathPointCount++;
if (m_PathPointCount > m_PathAllocSize) {
int newsize = m_PathPointCount + 256;
FX_PATHPOINT* pNewPoints = FX_Alloc(FX_PATHPOINT, newsize);
if (m_PathAllocSize) {
FXSYS_memcpy(pNewPoints, m_pPathPoints,
m_PathAllocSize * sizeof(FX_PATHPOINT));
FX_Free(m_pPathPoints);
}
m_pPathPoints = pNewPoints;
m_PathAllocSize = newsize;
}
m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
}
void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke) {
int PathPointCount = m_PathPointCount;
uint8_t PathClipType = m_PathClipType;
m_PathPointCount = 0;
m_PathClipType = 0;
if (PathPointCount <= 1) {
if (PathPointCount && PathClipType) {
CPDF_Path path;
path.AppendRect(0, 0, 0, 0);
m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, true);
}
return;
}
if (PathPointCount &&
m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
PathPointCount--;
}
CPDF_Path Path;
Path.SetPointCount(PathPointCount);
FXSYS_memcpy(Path.GetMutablePoints(), m_pPathPoints,
sizeof(FX_PATHPOINT) * PathPointCount);
CFX_Matrix matrix = m_pCurStates->m_CTM;
matrix.Concat(m_mtContentToUser);
if (bStroke || FillType) {
std::unique_ptr<CPDF_PathObject> pPathObj(new CPDF_PathObject);
pPathObj->m_bStroke = bStroke;
pPathObj->m_FillType = FillType;
pPathObj->m_Path = Path;
pPathObj->m_Matrix = matrix;
SetGraphicStates(pPathObj.get(), true, false, true);
pPathObj->CalcBoundingBox();
m_pObjectHolder->GetPageObjectList()->push_back(std::move(pPathObj));
}
if (PathClipType) {
if (!matrix.IsIdentity()) {
Path.Transform(&matrix);
matrix.SetIdentity();
}
m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, true);
}
}
uint32_t CPDF_StreamContentParser::Parse(const uint8_t* pData,
uint32_t dwSize,
uint32_t max_cost) {
if (m_Level > kMaxFormLevel)
return dwSize;
uint32_t InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
CPDF_StreamParser syntax(pData, dwSize, m_pDocument->GetByteStringPool());
CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
while (1) {
uint32_t cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
if (max_cost && cost >= max_cost) {
break;
}
switch (syntax.ParseNextElement()) {
case CPDF_StreamParser::EndOfData:
return m_pSyntax->GetPos();
case CPDF_StreamParser::Keyword:
OnOperator((char*)syntax.GetWordBuf());
ClearAllParams();
break;
case CPDF_StreamParser::Number:
AddNumberParam((char*)syntax.GetWordBuf(), syntax.GetWordSize());
break;
case CPDF_StreamParser::Name:
AddNameParam((const FX_CHAR*)syntax.GetWordBuf() + 1,
syntax.GetWordSize() - 1);
break;
default:
AddObjectParam(syntax.GetObject());
}
}
return m_pSyntax->GetPos();
}
void CPDF_StreamContentParser::ParsePathObject() {
FX_FLOAT params[6] = {};
int nParams = 0;
int last_pos = m_pSyntax->GetPos();
while (1) {
CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
bool bProcessed = true;
switch (type) {
case CPDF_StreamParser::EndOfData:
return;
case CPDF_StreamParser::Keyword: {
int len = m_pSyntax->GetWordSize();
if (len == 1) {
switch (m_pSyntax->GetWordBuf()[0]) {
case kPathOperatorSubpath:
AddPathPoint(params[0], params[1], FXPT_MOVETO);
nParams = 0;
break;
case kPathOperatorLine:
AddPathPoint(params[0], params[1], FXPT_LINETO);
nParams = 0;
break;
case kPathOperatorCubicBezier1:
AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
AddPathPoint(params[4], params[5], FXPT_BEZIERTO);
nParams = 0;
break;
case kPathOperatorCubicBezier2:
AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
nParams = 0;
break;
case kPathOperatorCubicBezier3:
AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
nParams = 0;
break;
case kPathOperatorClosePath:
Handle_ClosePath();
nParams = 0;
break;
default:
bProcessed = false;
break;
}
} else if (len == 2) {
if (m_pSyntax->GetWordBuf()[0] == kPathOperatorRectangle[0] &&
m_pSyntax->GetWordBuf()[1] == kPathOperatorRectangle[1]) {
AddPathRect(params[0], params[1], params[2], params[3]);
nParams = 0;
} else {
bProcessed = false;
}
} else {
bProcessed = false;
}
if (bProcessed) {
last_pos = m_pSyntax->GetPos();
}
break;
}
case CPDF_StreamParser::Number: {
if (nParams == 6)
break;
int value;
bool bInteger = FX_atonum(
CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()),
&value);
params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
break;
}
default:
bProcessed = false;
}
if (!bProcessed) {
m_pSyntax->SetPos(last_pos);
return;
}
}
}
CPDF_StreamContentParser::ContentParam::ContentParam() {}
CPDF_StreamContentParser::ContentParam::~ContentParam() {}
| 32.837028 | 80 | 0.671417 | guidopola |
14146dfbc9bec580cf9fb46ba61bc929de305f6f | 6,648 | hpp | C++ | unit_test/include/extra_features_test.hpp | wh5a/intel-qs | b625e1fb09c5aa3c146cb7129a2a29cdb6ff186a | [
"Apache-2.0"
] | 1 | 2021-04-15T11:41:57.000Z | 2021-04-15T11:41:57.000Z | unit_test/include/extra_features_test.hpp | wh5a/intel-qs | b625e1fb09c5aa3c146cb7129a2a29cdb6ff186a | [
"Apache-2.0"
] | null | null | null | unit_test/include/extra_features_test.hpp | wh5a/intel-qs | b625e1fb09c5aa3c146cb7129a2a29cdb6ff186a | [
"Apache-2.0"
] | null | null | null | #ifndef EXTRA_FEATURES_TEST_HPP
#define EXTRA_FEATURES_TEST_HPP
#include "../../include/qureg.hpp"
#include "../../include/qaoa_features.hpp"
//////////////////////////////////////////////////////////////////////////////
// Test fixture class.
class ExtraFeaturesTest : public ::testing::Test
{
protected:
ExtraFeaturesTest()
{ }
// just after the 'constructor'
void SetUp() override
{
// All tests are skipped if the rank is dummy.
if (qhipster::mpi::Environment::IsUsefulRank() == false)
GTEST_SKIP();
// All tests are skipped if the 6-qubit state is distributed in more than 2^5 ranks.
// In fact the MPI version needs to allocate half-the-local-storage for communication.
// If the local storage is a single amplitude, this cannot be further divided.
if (qhipster::mpi::Environment::GetStateSize() > 32)
GTEST_SKIP();
}
const std::size_t num_qubits_ = 6;
double accepted_error_ = 1e-15;
};
//////////////////////////////////////////////////////////////////////////////
// Functions developed to facilitate the simulation of QAOA circuits.
//////////////////////////////////////////////////////////////////////////////
TEST_F(ExtraFeaturesTest, qaoa_maxcut)
{
// Instance of the max-cut problem provided as adjacency matrix.
// It is a ring of 6 vertices:
//
// 0--1--2
// | |
// 5--4--3
//
std::vector<int> adjacency = {0, 1, 0, 0, 0, 1,
1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 0, 0,
0, 0, 1, 0, 1, 0,
0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 0};
QubitRegister<ComplexDP> diag (num_qubits_,"base",0);
int max_cut_value;
max_cut_value = qaoa::InitializeVectorAsMaxCutCostFunction(diag,adjacency);
// Among other properties, only two bipartition has cut=0.
ComplexDP amplitude;
amplitude = { 0, 0 };
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(0), amplitude, accepted_error_);
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(diag.GlobalSize()-1), amplitude,
accepted_error_);
// No bipartition can cut a single edge.
for (size_t j=0; j<diag.LocalSize(); ++j)
ASSERT_GT( std::abs(diag[j].real()-1.), accepted_error_);
// Perform QAOA simulation (p=1).
QubitRegister<ComplexDP> psi (num_qubits_,"++++",0);
double gamma = 0.4;
double beta = 0.3;
// Emulation of the layer based on the cost function:
qaoa::ImplementQaoaLayerBasedOnCostFunction(psi, diag, gamma);
// Simulation of the layer based on the local transverse field:
for (int qubit=0; qubit<num_qubits_; ++qubit)
psi.ApplyRotationX(qubit, beta);
// Get average of cut value:
double expectation = qaoa::GetExpectationValueFromCostFunction( psi, diag);
// Get histogram of the cut values:
std::vector<double> histo = qaoa::GetHistogramFromCostFunction(psi, diag, max_cut_value);
ASSERT_EQ(histo.size(), max_cut_value+1);
double average=0;
for (int j=0; j<histo.size(); ++j)
average += double(j)*histo[j];
ASSERT_DOUBLE_EQ(expectation, average);
}
//////////////////////////////////////////////////////////////////////////////
TEST_F(ExtraFeaturesTest, qaoa_weighted_maxcut)
{
// Instance of the max-cut problem provided as adjacency matrix.
// It is a ring of 6 vertices:
//
// 0--1--2
// | |
// 5--4--3
//
// where the verical edges have weight 1.4
std::vector<double> adjacency = {0 , 1 , 0 , 0 , 0 , 1.4,
1 , 0 , 1 , 0 , 0 , 0 ,
0 , 1 , 0 , 1.4, 0 , 0 ,
0 , 0 , 1.4, 0 , 1 , 0 ,
0 , 0 , 0 , 1 , 0 , 1 ,
1.4, 0 , 0 , 0 , 1 , 0 };
QubitRegister<ComplexDP> diag (num_qubits_,"base",0);
double max_cut_value;
max_cut_value = qaoa::InitializeVectorAsWeightedMaxCutCostFunction(diag,adjacency);
// Among other properties, only two bipartition has cut=0.
ComplexDP amplitude;
amplitude = { 0, 0 };
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(0), amplitude, accepted_error_);
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(diag.GlobalSize()-1), amplitude,
accepted_error_);
// Case in which only 2 is dis-aligned:
// 001000 = 1*2^2
amplitude = { 1+1.4, 0 };
size_t index = 2*2;
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(index), amplitude, accepted_error_);
// Case in which only 2 and 5 are dis-aligned:
// 001001 = 1*2^2 + 1*2^5
amplitude = { 1+1.4+1+1.4, 0 };
index = 4+32;
ASSERT_COMPLEX_NEAR(diag.GetGlobalAmplitude(index), amplitude, accepted_error_);
// No bipartition can cut a single edge.
for (size_t j=0; j<diag.LocalSize(); ++j)
ASSERT_GT( std::abs(diag[j].real()-1.), accepted_error_);
// Perform QAOA simulation (p=1).
QubitRegister<ComplexDP> psi (num_qubits_,"++++",0);
double gamma = 0.4;
double beta = 0.3;
// Emulation of the layer based on the cost function:
qaoa::ImplementQaoaLayerBasedOnCostFunction(psi, diag, gamma);
// Simulation of the layer based on the local transverse field:
for (int qubit=0; qubit<num_qubits_; ++qubit)
psi.ApplyRotationX(qubit, beta);
// Get average of cut value:
double expectation = qaoa::GetExpectationValueFromCostFunction(psi, diag);
// Histogram for rounded cutvals and check if it matches expval to the tolerance.
std::vector<double> histo = qaoa::GetHistogramFromCostFunctionWithWeightsRounded(psi, diag, max_cut_value);
ASSERT_EQ(histo.size(), (int)(floor(max_cut_value))+1);
double average=0;
for (int j=0; j<histo.size(); ++j)
average += double(j)*histo[j];
// The expval will be within less than 1.0 of the actual since the cutvals are rounded down to nearest 1.0.
ASSERT_TRUE( (abs(expectation - average) )<=1.0+1e-7);
// Histogram for rounded cutvals and check if it matches expval to the tolerance.
double bin_width = 0.1;
std::vector<double> histo2 = qaoa::GetHistogramFromCostFunctionWithWeightsBinned(psi, diag, max_cut_value, bin_width);
ASSERT_EQ(histo2.size(), (int)(ceil(max_cut_value / bin_width)) + 1);
average = 0.0;
for (int j=0; j<histo2.size(); ++j)
average += double(j)*bin_width*histo2[j];
// The expval will be within less than bin_width of the actual since the cutvals are rounded down to the bin_width.
ASSERT_TRUE( (abs(expectation - average) )<=bin_width+1e-7);
}
//////////////////////////////////////////////////////////////////////////////
#endif // header guard EXTRA_FEATURES_TEST_HPP
| 39.337278 | 120 | 0.602136 | wh5a |
14149a39491f7d7fde5c6c4282ddd14371a352f0 | 8,667 | cpp | C++ | lib/string.cpp | bilyanhadzhi/susi | 92ae0e30fe67b544f75fc3581b292ea87f4f078c | [
"MIT"
] | 1 | 2021-03-01T14:14:56.000Z | 2021-03-01T14:14:56.000Z | lib/string.cpp | bilyanhadzhi/susi | 92ae0e30fe67b544f75fc3581b292ea87f4f078c | [
"MIT"
] | null | null | null | lib/string.cpp | bilyanhadzhi/susi | 92ae0e30fe67b544f75fc3581b292ea87f4f078c | [
"MIT"
] | null | null | null | #include <fstream>
#include <cstring>
#include <cassert>
#include "string.hpp"
#include "../constants.hpp"
void String::copy_from(const String& other)
{
this->capacity = this->get_needed_capacity(other.value);
this->set_value(other.value);
this->len = other.len;
}
void String::free_memory()
{
if (this->value != nullptr)
{
delete[] this->value;
this->value = nullptr;
}
}
String::String()
{
this->capacity = BUFFER_SIZE;
this->value = new char[this->capacity]();
this->len = 0;
}
String::String(const char* str)
{
assert(str != nullptr);
this->capacity = this->get_needed_capacity(str);
this->value = new char[this->capacity]();
strcpy(this->value, str);
this->len = strlen(this->value);
}
String::String(const String& other)
{
this->capacity = other.capacity;
this->value = nullptr;
this->set_value(other.value);
this->len = other.len;
}
String& String::operator=(const String& other)
{
if (this == &other)
{
return *this;
}
this->free_memory();
this->copy_from(other);
return *this;
}
String& String::operator=(const char* str)
{
assert(str != nullptr);
this->set_value(str);
return *this;
}
String::~String()
{
this->free_memory();
}
void String::set_value(const char* value)
{
assert(value != nullptr);
const int value_len = strlen(value);
this->capacity = this->get_needed_capacity(value);
this->len = value_len;
char* new_value = new char[this->capacity]();
strcpy(new_value, value);
if (this->value != nullptr)
{
delete[] this->value;
}
this->value = new_value;
this->len = strlen(this->value);
}
void String::increase_capacity()
{
this->capacity *= 2;
char* value_new_capacity = new char[this->capacity]();
strcpy(value_new_capacity, this->value);
delete[] this->value;
this->value = value_new_capacity;
}
int String::get_needed_capacity(const char* string) const
{
int temp_capacity = BUFFER_SIZE;
int str_len = strlen(string);
if (str_len == 0)
{
return temp_capacity;
}
while (temp_capacity < str_len)
{
temp_capacity *= 2;
}
return temp_capacity;
}
std::ostream& operator<<(std::ostream& o_stream, const String& string)
{
o_stream << string.value;
return o_stream;
}
char String::operator[](int i) const
{
assert(i >= 0);
if (i >= this->len)
{
return '\0';
}
return this->value[i];
}
void String::input(std::istream& i_stream, bool whole_line)
{
char curr_char;
int string_len = 0;
int string_capacity = BUFFER_SIZE;
char* new_string_value = new char[string_capacity]();
if (i_stream.peek() == EOF || i_stream.peek() == '\n')
{
delete[] new_string_value;
this->set_value("");
if (std::cin.peek() == '\n')
{
std::cin.get();
}
return;
}
// skip whitespace
while (i_stream.peek() == ' ')
{
i_stream.get();
}
do
{
curr_char = i_stream.get();
if (!whole_line && curr_char == ' ')
{
break;
}
if (curr_char == '\n' || curr_char == EOF)
{
break;
}
if (string_len + 1 >= string_capacity)
{
char* bigger = new char[string_capacity *= 2]();
strcpy(bigger, new_string_value);
delete[] new_string_value;
new_string_value = bigger;
}
new_string_value[string_len++] = curr_char;
} while (i_stream.peek() != '\n');
new_string_value[string_len] = '\0';
this->set_value(new_string_value);
delete[] new_string_value;
}
std::istream& operator>>(std::istream& i_stream, String& string)
{
string.input(i_stream);
return i_stream;
}
bool operator==(const String& left_string, const String& right_string)
{
return strcmp(left_string.value, right_string.value) == 0;
}
bool operator==(const String& string, const char* c_string)
{
return strcmp(string.value, c_string) == 0;
}
bool operator==(const char* c_string, const String& string)
{
return strcmp(c_string, string.value) == 0;
}
bool operator!=(const String& left_string, const String& right_string)
{
return !(left_string == right_string);
}
bool operator!=(const String& string, const char* c_string)
{
return !(string == c_string);
}
bool operator!=(const char* c_string, const String& string)
{
return !(c_string == string);
}
String& String::operator+=(const char new_char)
{
if (this->len + 1 >= this->capacity)
{
this->increase_capacity();
}
this->value[len] = new_char;
if (new_char != '\0')
{
++len;
}
return *this;
}
String& String::operator+=(const char* to_append)
{
assert(to_append != nullptr);
const int to_append_len = strlen(to_append);
if (to_append_len < 1)
{
return *this;
}
for (int i = 0; i < to_append_len; ++i)
{
*this += to_append[i];
}
return *this;
}
String& String::operator+=(const String to_append)
{
const int to_append_len = to_append.get_len();
if (to_append_len < 1)
{
return *this;
}
for (int i = 0; i < to_append_len; ++i)
{
*this += to_append[i];
}
return *this;
}
int String::get_len() const
{
return this->len;
}
bool String::is_valid_number(bool check_for_int_only) const
{
const int len = this->get_len();
bool found_dot = this->value[0] == '.';
bool is_valid = true;
if (len < 1)
{
is_valid = false;
}
if (this->value[0] != '-' && this->value[0] != '+' && !isdigit(this->value[0]))
{
is_valid = false;
}
int beg_index = this->value[0] == '-' || this->value[0] == '+';
for (int i = beg_index; i < len && is_valid; ++i)
{
if (!isdigit(this->value[i]))
{
if (this->value[i] == '.')
{
// Found 2nd dot -> invalid
if (found_dot)
{
is_valid = false;
}
else
{
found_dot = true;
}
}
else
{
is_valid = false;
}
}
}
if (check_for_int_only && found_dot)
{
is_valid = false;
}
return is_valid;
}
double String::to_double() const
{
if (!this->is_valid_number())
{
return -__DBL_MAX__;
}
double result = 0.0;
int len = this->get_len();
bool has_sign = this->value[0] == '+' || this->value[0] == '-';
bool is_int = true;
int begin_index = has_sign ? 1 : 0;
int i = begin_index;
// skip beginning zeros
while (this->value[i] == '0')
{
++i;
}
// get integer part
while (i < len)
{
if (this->value[i] == '.')
{
is_int = false;
++i;
break;
}
result *= 10;
result += (int)(this->value[i] - '0');
++i;
}
// get fractional part
double divide_by = 10;
// know decimal places so to round number
int dec_places = 0;
if (!is_int)
{
while (i < len && dec_places < 2)
{
result += (double)(this->value[i] - '0') / divide_by;
divide_by *= 10;
++dec_places;
++i;
}
}
if (dec_places >= 2 && (int)(this->value[i] - '0') >= 5)
{
result += 10 / divide_by;
}
bool is_negative = has_sign && this->value[0] == '-';
return is_negative ? -result : result;
}
int String::to_int() const
{
return (int)this->to_double();
}
bool String::read_from_bin(std::ifstream& if_stream)
{
if (if_stream.eof())
{
return false;
}
int value_len;
if (!if_stream.read((char*)&value_len, sizeof(int)))
{
return false;
}
char* new_value = new char[value_len + 1];
if (!if_stream.read(new_value, value_len))
{
delete[] new_value;
return false;
}
new_value[value_len] = '\0';
this->set_value(new_value);
delete[] new_value;
return true;
}
bool String::write_to_bin(std::ofstream& of_stream) const
{
if (this->len < 1)
{
return false;
}
if (!of_stream.write((char*)&this->len, sizeof(int)))
{
return false;
}
if (!of_stream.write(this->value, this->len))
{
return false;
}
return true;
}
const char* String::to_c_string() const
{
return this->value;
}
| 18.440426 | 83 | 0.543671 | bilyanhadzhi |
1416b0991154bafad89626ae8e9641383bab2bd8 | 6,244 | hpp | C++ | include/UnityEngine/TextCore/LowLevel/GlyphPairAdjustmentRecord.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | include/UnityEngine/TextCore/LowLevel/GlyphPairAdjustmentRecord.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | include/UnityEngine/TextCore/LowLevel/GlyphPairAdjustmentRecord.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | // Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "beatsaber-hook/shared/utils/typedefs.h"
#include "beatsaber-hook/shared/utils/byref.hpp"
// Including type: System.ValueType
#include "System/ValueType.hpp"
// Including type: UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord
#include "UnityEngine/TextCore/LowLevel/GlyphAdjustmentRecord.hpp"
// Including type: UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags
#include "UnityEngine/TextCore/LowLevel/FontFeatureLookupFlags.hpp"
// Completed includes
// Type namespace: UnityEngine.TextCore.LowLevel
namespace UnityEngine::TextCore::LowLevel {
// Forward declaring type: GlyphPairAdjustmentRecord
struct GlyphPairAdjustmentRecord;
}
#include "beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
DEFINE_IL2CPP_ARG_TYPE(::UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord, "UnityEngine.TextCore.LowLevel", "GlyphPairAdjustmentRecord");
// Type namespace: UnityEngine.TextCore.LowLevel
namespace UnityEngine::TextCore::LowLevel {
// Size: 0x2C
#pragma pack(push, 1)
// WARNING Layout: Sequential may not be correctly taken into account!
// Autogenerated type: UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord
// [TokenAttribute] Offset: FFFFFFFF
// [UsedByNativeCodeAttribute] Offset: 5BC52C
// [DebuggerDisplayAttribute] Offset: 5BC52C
struct GlyphPairAdjustmentRecord/*, public ::System::ValueType*/ {
public:
public:
// [NativeNameAttribute] Offset: 0x5BD1F8
// private UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord m_FirstAdjustmentRecord
// Size: 0x14
// Offset: 0x0
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord m_FirstAdjustmentRecord;
// Field size check
static_assert(sizeof(::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord) == 0x14);
// [NativeNameAttribute] Offset: 0x5BD244
// private UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord m_SecondAdjustmentRecord
// Size: 0x14
// Offset: 0x14
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord m_SecondAdjustmentRecord;
// Field size check
static_assert(sizeof(::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord) == 0x14);
// private UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags m_FeatureLookupFlags
// Size: 0x4
// Offset: 0x28
::UnityEngine::TextCore::LowLevel::FontFeatureLookupFlags m_FeatureLookupFlags;
// Field size check
static_assert(sizeof(::UnityEngine::TextCore::LowLevel::FontFeatureLookupFlags) == 0x4);
public:
// Creating value type constructor for type: GlyphPairAdjustmentRecord
constexpr GlyphPairAdjustmentRecord(::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord m_FirstAdjustmentRecord_ = {}, ::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord m_SecondAdjustmentRecord_ = {}, ::UnityEngine::TextCore::LowLevel::FontFeatureLookupFlags m_FeatureLookupFlags_ = {}) noexcept : m_FirstAdjustmentRecord{m_FirstAdjustmentRecord_}, m_SecondAdjustmentRecord{m_SecondAdjustmentRecord_}, m_FeatureLookupFlags{m_FeatureLookupFlags_} {}
// Creating interface conversion operator: operator ::System::ValueType
operator ::System::ValueType() noexcept {
return *reinterpret_cast<::System::ValueType*>(this);
}
// Get instance field reference: private UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord m_FirstAdjustmentRecord
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord& dyn_m_FirstAdjustmentRecord();
// Get instance field reference: private UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord m_SecondAdjustmentRecord
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord& dyn_m_SecondAdjustmentRecord();
// Get instance field reference: private UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags m_FeatureLookupFlags
::UnityEngine::TextCore::LowLevel::FontFeatureLookupFlags& dyn_m_FeatureLookupFlags();
// public UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord get_firstAdjustmentRecord()
// Offset: 0x12E96BC
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord get_firstAdjustmentRecord();
// public UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord get_secondAdjustmentRecord()
// Offset: 0x12E96D0
::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord get_secondAdjustmentRecord();
}; // UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord
#pragma pack(pop)
static check_size<sizeof(GlyphPairAdjustmentRecord), 40 + sizeof(::UnityEngine::TextCore::LowLevel::FontFeatureLookupFlags)> __UnityEngine_TextCore_LowLevel_GlyphPairAdjustmentRecordSizeCheck;
static_assert(sizeof(GlyphPairAdjustmentRecord) == 0x2C);
}
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
// Writing MetadataGetter for method: UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::get_firstAdjustmentRecord
// Il2CppName: get_firstAdjustmentRecord
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord (UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::*)()>(&UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::get_firstAdjustmentRecord)> {
static const MethodInfo* get() {
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord), "get_firstAdjustmentRecord", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{});
}
};
// Writing MetadataGetter for method: UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::get_secondAdjustmentRecord
// Il2CppName: get_secondAdjustmentRecord
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<::UnityEngine::TextCore::LowLevel::GlyphAdjustmentRecord (UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::*)()>(&UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord::get_secondAdjustmentRecord)> {
static const MethodInfo* get() {
return ::il2cpp_utils::FindMethod(classof(UnityEngine::TextCore::LowLevel::GlyphPairAdjustmentRecord), "get_secondAdjustmentRecord", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{});
}
};
| 65.726316 | 464 | 0.788597 | RedBrumbler |
1417207abb02a99c22957e6bf67017ba855f6d3e | 2,370 | cc | C++ | shell/browser/ui/win/atom_desktop_native_widget_aura.cc | CezaryKulakowski/electron | eb6660f5341d6d7e2143be31eefec558fd866c84 | [
"MIT"
] | 4 | 2019-07-05T20:42:42.000Z | 2020-01-02T07:26:56.000Z | shell/browser/ui/win/atom_desktop_native_widget_aura.cc | CezaryKulakowski/electron | eb6660f5341d6d7e2143be31eefec558fd866c84 | [
"MIT"
] | 4 | 2021-03-11T05:19:38.000Z | 2022-03-28T01:24:48.000Z | shell/browser/ui/win/atom_desktop_native_widget_aura.cc | CezaryKulakowski/electron | eb6660f5341d6d7e2143be31eefec558fd866c84 | [
"MIT"
] | null | null | null | // Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/browser/ui/win/atom_desktop_native_widget_aura.h"
#include "shell/browser/ui/win/atom_desktop_window_tree_host_win.h"
#include "ui/views/corewm/tooltip_controller.h"
#include "ui/wm/public/tooltip_client.h"
namespace electron {
AtomDesktopNativeWidgetAura::AtomDesktopNativeWidgetAura(
NativeWindowViews* native_window_view)
: views::DesktopNativeWidgetAura(native_window_view->widget()),
native_window_view_(native_window_view) {
GetNativeWindow()->SetName("AtomDesktopNativeWidgetAura");
// This is to enable the override of OnWindowActivated
wm::SetActivationChangeObserver(GetNativeWindow(), this);
}
void AtomDesktopNativeWidgetAura::InitNativeWidget(
const views::Widget::InitParams& params) {
views::Widget::InitParams modified_params = params;
desktop_window_tree_host_ = new AtomDesktopWindowTreeHostWin(
native_window_view_,
static_cast<views::DesktopNativeWidgetAura*>(params.native_widget));
modified_params.desktop_window_tree_host = desktop_window_tree_host_;
views::DesktopNativeWidgetAura::InitNativeWidget(modified_params);
}
void AtomDesktopNativeWidgetAura::Activate() {
// Activate can cause the focused window to be blurred so only
// call when the window being activated is visible. This prevents
// hidden windows from blurring the focused window when created.
if (IsVisible())
views::DesktopNativeWidgetAura::Activate();
}
void AtomDesktopNativeWidgetAura::OnWindowActivated(
wm::ActivationChangeObserver::ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) {
views::DesktopNativeWidgetAura::OnWindowActivated(reason, gained_active,
lost_active);
if (lost_active != nullptr) {
auto* tooltip_controller = static_cast<views::corewm::TooltipController*>(
wm::GetTooltipClient(lost_active->GetRootWindow()));
// This will cause the tooltip to be hidden when a window is deactivated,
// as it should be.
// TODO(brenca): Remove this fix when the chromium issue is fixed.
// crbug.com/724538
if (tooltip_controller != nullptr)
tooltip_controller->OnCancelMode(nullptr);
}
}
} // namespace electron
| 39.5 | 78 | 0.753586 | CezaryKulakowski |
141bb1ef6637cb707642cb2d692ff6b0307652cf | 1,868 | cpp | C++ | main.cpp | chenhongqiao/FCWT | 16034c4422db0119d680ff1af0ad68dc149b0b47 | [
"MIT"
] | null | null | null | main.cpp | chenhongqiao/FCWT | 16034c4422db0119d680ff1af0ad68dc149b0b47 | [
"MIT"
] | null | null | null | main.cpp | chenhongqiao/FCWT | 16034c4422db0119d680ff1af0ad68dc149b0b47 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <map>
#include <fstream>
#include "input.h"
#include <iomanip>
std::map<std::string, short int> vocab_tree(const std::vector<std::string> &v) {
std::map<std::string, short int> m;
for (auto &i : v) {
for (int j = 1; j < i.size(); ++j) {
if (m[i.substr(0, j)] != 2) {
m[i.substr(0, j)] = 1;
}
}
m[i] = 2;
}
return m;
}
int main() {
std::ifstream vs;
std::ifstream ps;
vs.open("vocab.in");
ps.open("para.in");
if (!vs) {
vs.close();
std::string vfn;
std::cout << "Vocabulary file path: ";
std::cin >> vfn;
vs.open(vfn);
}
if (!ps) {
ps.close();
std::string pfn;
std::cout << "Paragraph file path: ";
std::cin >> pfn;
ps.open(pfn);
}
std::vector<std::string> v = read_vocab(vs);
std::map<std::string, short int> vt = vocab_tree(v);
std::string p = read_para(ps);
std::map<std::string, int> cnt;
for (int i = 0; i < p.size(); ++i) {
std::string can;
int j;
for (j = 1; j <= p.size() - i; ++j) {
if (vt[p.substr(i, j)] == 2) {
can = p.substr(i, j);
} else if (vt[p.substr(i, j)] != 1) {
break;
}
}
if (!can.empty()) {
i += j - 3;
cnt[can]++;
}
}
int cvd = 0;
for (auto &i : v) {
if (cnt[i] > 0) {
cvd++;
std::cout << "(" << cnt[i] << ") " << i << std::endl;
} else {
std::cout << "(X)" << " " << i << std::endl;
}
}
std::cout << cvd << "/" << v.size();
std::cout << " " << std::fixed << std::setprecision(1) << 1.0 * cvd / v.size() * 100 + 0.05 << "% " << std::endl;
return 0;
}
| 24.25974 | 117 | 0.41167 | chenhongqiao |
142a715eb42fa83babbd86b50d9936cb60b046da | 70 | cpp | C++ | Autoplay/Source/Autoplay/Private/Autoplay.cpp | realityreflection/Autoplay | e81555444f821d44ce986c4e5e450dabb0930af0 | [
"MIT"
] | 6 | 2017-05-22T02:24:50.000Z | 2021-11-08T07:22:52.000Z | Example/Plugins/Autoplay/Source/Autoplay/Private/Autoplay.cpp | realityreflection/Autoplay | e81555444f821d44ce986c4e5e450dabb0930af0 | [
"MIT"
] | null | null | null | Example/Plugins/Autoplay/Source/Autoplay/Private/Autoplay.cpp | realityreflection/Autoplay | e81555444f821d44ce986c4e5e450dabb0930af0 | [
"MIT"
] | 4 | 2018-04-10T11:06:59.000Z | 2020-07-05T14:21:56.000Z | #include "Autoplay.h"
IMPLEMENT_MODULE(AutoplayModuleImpl, Autoplay); | 23.333333 | 47 | 0.828571 | realityreflection |
28a2f38bd00c1ccd4103718bfd98e16013240a4c | 3,812 | cpp | C++ | src/nnfusion/core/kernels/cuda_gpu/kernels/layer_norm.cpp | nox-410/nnfusion | 0777e297299c4e7a5071dc2ee97b87adcd22840e | [
"MIT"
] | 639 | 2020-09-05T10:00:59.000Z | 2022-03-30T08:42:39.000Z | src/nnfusion/core/kernels/cuda_gpu/kernels/layer_norm.cpp | QPC-database/nnfusion | 99ada47c50f355ca278001f11bc752d1c7abcee2 | [
"MIT"
] | 252 | 2020-09-09T05:35:36.000Z | 2022-03-29T04:58:41.000Z | src/nnfusion/core/kernels/cuda_gpu/kernels/layer_norm.cpp | QPC-database/nnfusion | 99ada47c50f355ca278001f11bc752d1c7abcee2 | [
"MIT"
] | 104 | 2020-09-05T10:01:08.000Z | 2022-03-23T10:59:13.000Z | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
// #include "../cuda_cudnn.hpp"
#include "../cuda_cudnn.hpp"
#include "../cuda_emitter.hpp"
#include "../cuda_langunit.hpp"
#include "nnfusion/core/operators/generic_op/generic_op.hpp"
namespace nnfusion
{
namespace kernels
{
namespace cuda
{
class LayerNorm : public CudaLibEmitter
{
shared_ptr<nnfusion::op::GenericOp> generic_op;
public:
LayerNorm(shared_ptr<KernelContext> ctx)
: CudaLibEmitter(ctx)
, generic_op(
static_pointer_cast<nnfusion::op::GenericOp>(ctx->gnode->get_op_ptr()))
{
GENERIC_OP_LOGGING();
}
LanguageUnit_p emit_function_body() override
{
GENERIC_OP_LOGGING();
const nnfusion::Shape& input_shape = m_context->inputs[0]->get_shape();
auto& cfg = generic_op->localOpConfig.getRoot();
float eps = cfg["epsilon"];
int axis = cfg["axis"];
axis += axis < 0 ? input_shape.size() : 0;
size_t n1 = 1, n2 = 1;
for (auto i = 0; i < axis; i++)
{
n1 *= input_shape[i];
}
for (auto i = axis; i < input_shape.size(); i++)
{
n2 *= input_shape[i];
}
nnfusion::element::Type dtype = m_context->inputs[0]->get_element_type();
LanguageUnit_p _lu(new LanguageUnit(get_function_name()));
auto& lu = *_lu;
// lu << "HostApplyLayerNorm(output0,"
// << " output1,"
// << " output2,"
// << " input0," << n1 << "," << n2 << "," << eps << ","
// << " input1,"
// << " input2);\n";
auto code = nnfusion::op::create_code_from_template(
R"(
HostApplyLayerNorm<@dtype@>(
output0, output1, output2, input0, @n1@, @n2@, @expression1@@eps@@expression2@, input1, input2);
)",
{{"n1", n1},
{"n2", n2},
{"dtype", (dtype == element::f16) ? "half" : "float"},
{"expression1", (dtype == element::f16) ? "__float2half_rn(" : ""},
{"expression2", (dtype == element::f16) ? ")" : ""},
{"eps", eps}});
lu << code << "\n";
return _lu;
}
LanguageUnit_p emit_dependency() override
{
GENERIC_OP_LOGGING();
LanguageUnit_p _lu(new LanguageUnit(get_function_name() + "_dep"));
_lu->require(header::cuda);
_lu->require(declaration::cuda_layer_norm);
declaration::cuda_layer_norm->require(declaration::math_Rsqrt);
declaration::cuda_layer_norm->require(declaration::warp);
return _lu;
}
};
} // namespace cuda
} // namespace kernels
} // namespace nnfusion
// Register kernel emitter
using namespace nnfusion;
using namespace nnfusion::kernels;
REGISTER_KERNEL_EMITTER("LayerNorm", // op_name
Device(CUDA_GPU).TypeConstraint(element::f32).Tag("cudalib"), // attrs
cuda::LayerNorm) // constructor
| 38.12 | 100 | 0.444386 | nox-410 |
28a4931a93ce452e7bccfa0b8200fc8589aae136 | 3,016 | cpp | C++ | src/GTKClient.cpp | Ladislus/svg-project-l3 | e1932dd175b59c81af39b8f49c4fb28f963e9c4f | [
"MIT"
] | null | null | null | src/GTKClient.cpp | Ladislus/svg-project-l3 | e1932dd175b59c81af39b8f49c4fb28f963e9c4f | [
"MIT"
] | null | null | null | src/GTKClient.cpp | Ladislus/svg-project-l3 | e1932dd175b59c81af39b8f49c4fb28f963e9c4f | [
"MIT"
] | null | null | null | //
// Created by o2173194 on 04/03/20.
//
#include <gtk/gtk.h>
#include <cctype>
static void enter_callback( GtkWidget *widget, GtkWidget *entry )
{
const gchar *entry_text;
entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
printf ("Entry contents: %s\n", entry_text);
}
void insert_text_event(GtkEditable *editable, const gchar *text, gint length, gint *position, gpointer data)
{
int i;
for (i = 0; i < length; i++) {
if (!isdigit(text[i])) {
g_signal_stop_emission_by_name(G_OBJECT(editable), "insert-text");
return;
}
}
}
/*
* Initialize GTK Window and all widgets
* */
int main(int argc, char *argv[])
{
/*Initialization of widgets*/
GtkWidget *window, *button, *input1, *input2, *vbox, *hbox;
/*Init*/
gtk_init(&argc, &argv);
/* Creation of a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
input1 = gtk_entry_new();
gtk_entry_set_max_length (GTK_ENTRY (input1), 3);
g_signal_connect (input1, "activate",
G_CALLBACK (enter_callback),
input1);
g_signal_connect(G_OBJECT(input1), "insert_text",
G_CALLBACK(insert_text_event),
NULL);
gtk_box_pack_start (GTK_BOX (vbox), input1, TRUE, TRUE, 0);
gtk_widget_show (input1);
input2 = gtk_entry_new();
gtk_entry_set_max_length (GTK_ENTRY (input2), 3);
g_signal_connect (input2, "activate",
G_CALLBACK (enter_callback),
input2);
g_signal_connect(G_OBJECT(input2), "insert_text",
G_CALLBACK(insert_text_event),
NULL);
gtk_box_pack_start (GTK_BOX (vbox), input2, TRUE, TRUE, 0);
gtk_widget_show (input2);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_widget_show (hbox);
button = gtk_button_new_with_label ("Submit to server");
g_signal_connect(button, "clicked",
G_CALLBACK (enter_callback),
window);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
// /* This function will WRITE all the modifications of the SVG in the XMLFile*/
// svg_data.SaveFile("../Resources/Image Samples/atom.svg");
/*
* Connecting all the events to the GTK window
* */
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
/* Configuration of the window */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 275, 275);
gtk_window_set_title(GTK_WINDOW(window), "Client SVG");
/*
* This will show all the widgets in the window
* */
gtk_widget_show_all(window);
gtk_main();
return 0;
}
| 30.464646 | 108 | 0.634947 | Ladislus |
28a73e8d0c6a8676d78e0aff4af2e7f5a6281d84 | 53,394 | cpp | C++ | wxWidgets-2.9.1/src/richtext/richtextliststylepage.cpp | gamekit-developers/gamekit | 74c896af5826ebe8fb72f2911015738f38ab7bb2 | [
"Zlib",
"MIT"
] | 241 | 2015-01-04T00:36:58.000Z | 2022-01-06T19:19:23.000Z | wxWidgets-2.9.1/src/richtext/richtextliststylepage.cpp | gamekit-developers/gamekit | 74c896af5826ebe8fb72f2911015738f38ab7bb2 | [
"Zlib",
"MIT"
] | 10 | 2015-07-10T18:27:17.000Z | 2019-06-26T20:59:59.000Z | wxWidgets-2.9.1/src/richtext/richtextliststylepage.cpp | gamekit-developers/gamekit | 74c896af5826ebe8fb72f2911015738f38ab7bb2 | [
"Zlib",
"MIT"
] | 82 | 2015-01-25T18:02:35.000Z | 2022-03-05T12:28:17.000Z | /////////////////////////////////////////////////////////////////////////////
// Name: src/richtext/richtextliststylepage.cpp
// Purpose:
// Author: Julian Smart
// Modified by:
// Created: 10/18/2006 11:36:37 AM
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/richtext/richtextliststylepage.h"
////@begin XPM images
////@end XPM images
/*!
* wxRichTextListStylePage type definition
*/
IMPLEMENT_DYNAMIC_CLASS( wxRichTextListStylePage, wxPanel )
/*!
* wxRichTextListStylePage event table definition
*/
BEGIN_EVENT_TABLE( wxRichTextListStylePage, wxPanel )
////@begin wxRichTextListStylePage event table entries
EVT_SPINCTRL( ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxRichTextListStylePage::OnLevelUpdated )
EVT_SPIN_UP( ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxRichTextListStylePage::OnLevelUp )
EVT_SPIN_DOWN( ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxRichTextListStylePage::OnLevelDown )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxRichTextListStylePage::OnLevelTextUpdated )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxRichTextListStylePage::OnLevelUIUpdate )
EVT_BUTTON( ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_FONT, wxRichTextListStylePage::OnChooseFontClick )
EVT_LISTBOX( ID_RICHTEXTLISTSTYLEPAGE_STYLELISTBOX, wxRichTextListStylePage::OnStylelistboxSelected )
EVT_CHECKBOX( ID_RICHTEXTLISTSTYLEPAGE_PERIODCTRL, wxRichTextListStylePage::OnPeriodctrlClick )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_PERIODCTRL, wxRichTextListStylePage::OnPeriodctrlUpdate )
EVT_CHECKBOX( ID_RICHTEXTLISTSTYLEPAGE_PARENTHESESCTRL, wxRichTextListStylePage::OnParenthesesctrlClick )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_PARENTHESESCTRL, wxRichTextListStylePage::OnParenthesesctrlUpdate )
EVT_CHECKBOX( ID_RICHTEXTLISTSTYLEPAGE_RIGHTPARENTHESISCTRL, wxRichTextListStylePage::OnRightParenthesisCtrlClick )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_RIGHTPARENTHESISCTRL, wxRichTextListStylePage::OnRightParenthesisCtrlUpdate )
EVT_COMBOBOX( ID_RICHTEXTLISTSTYLEPAGE_BULLETALIGNMENTCTRL, wxRichTextListStylePage::OnBulletAlignmentCtrlSelected )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLSTATIC, wxRichTextListStylePage::OnSymbolstaticUpdate )
EVT_COMBOBOX( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLCTRL, wxRichTextListStylePage::OnSymbolctrlSelected )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLCTRL, wxRichTextListStylePage::OnSymbolctrlUpdated )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLCTRL, wxRichTextListStylePage::OnSymbolctrlUIUpdate )
EVT_BUTTON( ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_SYMBOL, wxRichTextListStylePage::OnChooseSymbolClick )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_SYMBOL, wxRichTextListStylePage::OnChooseSymbolUpdate )
EVT_COMBOBOX( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL, wxRichTextListStylePage::OnSymbolfontctrlSelected )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL, wxRichTextListStylePage::OnSymbolfontctrlUpdated )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL, wxRichTextListStylePage::OnSymbolfontctrlUIUpdate )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_NAMESTATIC, wxRichTextListStylePage::OnNamestaticUpdate )
EVT_COMBOBOX( ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL, wxRichTextListStylePage::OnNamectrlSelected )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL, wxRichTextListStylePage::OnNamectrlUpdated )
EVT_UPDATE_UI( ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL, wxRichTextListStylePage::OnNamectrlUIUpdate )
EVT_RADIOBUTTON( ID_RICHTEXTLISTSTYLEPAGE_ALIGNLEFT, wxRichTextListStylePage::OnRichtextliststylepageAlignleftSelected )
EVT_RADIOBUTTON( ID_RICHTEXTLISTSTYLEPAGE_ALIGNRIGHT, wxRichTextListStylePage::OnRichtextliststylepageAlignrightSelected )
EVT_RADIOBUTTON( ID_RICHTEXTLISTSTYLEPAGE_JUSTIFIED, wxRichTextListStylePage::OnRichtextliststylepageJustifiedSelected )
EVT_RADIOBUTTON( ID_RICHTEXTLISTSTYLEPAGE_CENTERED, wxRichTextListStylePage::OnRichtextliststylepageCenteredSelected )
EVT_RADIOBUTTON( ID_RICHTEXTLISTSTYLEPAGE_ALIGNINDETERMINATE, wxRichTextListStylePage::OnRichtextliststylepageAlignindeterminateSelected )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_INDENTLEFT, wxRichTextListStylePage::OnIndentLeftUpdated )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_INDENTFIRSTLINE, wxRichTextListStylePage::OnIndentFirstLineUpdated )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_INDENTRIGHT, wxRichTextListStylePage::OnIndentRightUpdated )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_SPACINGBEFORE, wxRichTextListStylePage::OnSpacingBeforeUpdated )
EVT_TEXT( ID_RICHTEXTLISTSTYLEPAGE_SPACINGAFTER, wxRichTextListStylePage::OnSpacingAfterUpdated )
EVT_COMBOBOX( ID_RICHTEXTLISTSTYLEPAGE_LINESPACING, wxRichTextListStylePage::OnLineSpacingSelected )
////@end wxRichTextListStylePage event table entries
END_EVENT_TABLE()
/*!
* wxRichTextListStylePage constructors
*/
wxRichTextListStylePage::wxRichTextListStylePage( )
{
Init();
}
wxRichTextListStylePage::wxRichTextListStylePage( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style )
{
Init();
Create(parent, id, pos, size, style);
}
/*!
* wxRichTextListStylePage creator
*/
bool wxRichTextListStylePage::Create( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style )
{
////@begin wxRichTextListStylePage creation
wxPanel::Create( parent, id, pos, size, style );
CreateControls();
if (GetSizer())
{
GetSizer()->SetSizeHints(this);
}
Centre();
////@end wxRichTextListStylePage creation
return true;
}
/*!
* Member initialisation
*/
void wxRichTextListStylePage::Init()
{
m_dontUpdate = false;
m_currentLevel = 1;
////@begin wxRichTextListStylePage member initialisation
m_levelCtrl = NULL;
m_styleListBox = NULL;
m_periodCtrl = NULL;
m_parenthesesCtrl = NULL;
m_rightParenthesisCtrl = NULL;
m_bulletAlignmentCtrl = NULL;
m_symbolCtrl = NULL;
m_symbolFontCtrl = NULL;
m_bulletNameCtrl = NULL;
m_alignmentLeft = NULL;
m_alignmentRight = NULL;
m_alignmentJustified = NULL;
m_alignmentCentred = NULL;
m_alignmentIndeterminate = NULL;
m_indentLeft = NULL;
m_indentLeftFirst = NULL;
m_indentRight = NULL;
m_spacingBefore = NULL;
m_spacingAfter = NULL;
m_spacingLine = NULL;
m_previewCtrl = NULL;
////@end wxRichTextListStylePage member initialisation
}
/*!
* Control creation for wxRichTextListStylePage
*/
void wxRichTextListStylePage::CreateControls()
{
////@begin wxRichTextListStylePage content construction
wxRichTextListStylePage* itemPanel1 = this;
wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
itemPanel1->SetSizer(itemBoxSizer2);
wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer2->Add(itemBoxSizer3, 1, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer3->Add(itemBoxSizer4, 0, wxALIGN_CENTER_HORIZONTAL, 5);
wxStaticText* itemStaticText5 = new wxStaticText( itemPanel1, wxID_STATIC, _("&List level:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer4->Add(itemStaticText5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_levelCtrl = new wxSpinCtrl( itemPanel1, ID_RICHTEXTLISTSTYLEPAGE_LEVEL, wxT("1"), wxDefaultPosition, wxSize(60, -1), wxSP_ARROW_KEYS, 1, 10, 1 );
m_levelCtrl->SetHelpText(_("Selects the list level to edit."));
if (wxRichTextListStylePage::ShowToolTips())
m_levelCtrl->SetToolTip(_("Selects the list level to edit."));
itemBoxSizer4->Add(m_levelCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
itemBoxSizer4->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxButton* itemButton8 = new wxButton( itemPanel1, ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_FONT, _("&Font for Level..."), wxDefaultPosition, wxDefaultSize, 0 );
itemButton8->SetHelpText(_("Click to choose the font for this level."));
if (wxRichTextListStylePage::ShowToolTips())
itemButton8->SetToolTip(_("Click to choose the font for this level."));
itemBoxSizer4->Add(itemButton8, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxNotebook* itemNotebook9 = new wxNotebook( itemPanel1, ID_RICHTEXTLISTSTYLEPAGE_NOTEBOOK, wxDefaultPosition, wxDefaultSize, wxNB_DEFAULT|wxNB_TOP );
wxPanel* itemPanel10 = new wxPanel( itemNotebook9, ID_RICHTEXTLISTSTYLEPAGE_BULLETS, wxDefaultPosition, wxDefaultSize, wxNO_BORDER|wxTAB_TRAVERSAL );
wxBoxSizer* itemBoxSizer11 = new wxBoxSizer(wxVERTICAL);
itemPanel10->SetSizer(itemBoxSizer11);
wxBoxSizer* itemBoxSizer12 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer11->Add(itemBoxSizer12, 1, wxGROW, 5);
wxBoxSizer* itemBoxSizer13 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer12->Add(itemBoxSizer13, 0, wxGROW, 5);
wxStaticText* itemStaticText14 = new wxStaticText( itemPanel10, wxID_STATIC, _("&Bullet style:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer13->Add(itemStaticText14, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxArrayString m_styleListBoxStrings;
m_styleListBox = new wxListBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_STYLELISTBOX, wxDefaultPosition, wxSize(-1, 140), m_styleListBoxStrings, wxLB_SINGLE );
m_styleListBox->SetHelpText(_("The available bullet styles."));
if (wxRichTextListStylePage::ShowToolTips())
m_styleListBox->SetToolTip(_("The available bullet styles."));
itemBoxSizer13->Add(m_styleListBox, 1, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer16 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer13->Add(itemBoxSizer16, 0, wxGROW, 5);
m_periodCtrl = new wxCheckBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_PERIODCTRL, _("Peri&od"), wxDefaultPosition, wxDefaultSize, 0 );
m_periodCtrl->SetValue(false);
m_periodCtrl->SetHelpText(_("Check to add a period after the bullet."));
if (wxRichTextListStylePage::ShowToolTips())
m_periodCtrl->SetToolTip(_("Check to add a period after the bullet."));
itemBoxSizer16->Add(m_periodCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_parenthesesCtrl = new wxCheckBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_PARENTHESESCTRL, _("(*)"), wxDefaultPosition, wxDefaultSize, 0 );
m_parenthesesCtrl->SetValue(false);
m_parenthesesCtrl->SetHelpText(_("Check to enclose the bullet in parentheses."));
if (wxRichTextListStylePage::ShowToolTips())
m_parenthesesCtrl->SetToolTip(_("Check to enclose the bullet in parentheses."));
itemBoxSizer16->Add(m_parenthesesCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_rightParenthesisCtrl = new wxCheckBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_RIGHTPARENTHESISCTRL, _("*)"), wxDefaultPosition, wxDefaultSize, 0 );
m_rightParenthesisCtrl->SetValue(false);
m_rightParenthesisCtrl->SetHelpText(_("Check to add a right parenthesis."));
if (wxRichTextListStylePage::ShowToolTips())
m_rightParenthesisCtrl->SetToolTip(_("Check to add a right parenthesis."));
itemBoxSizer16->Add(m_rightParenthesisCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
itemBoxSizer13->Add(2, 1, 0, wxALIGN_CENTER_HORIZONTAL, 5);
wxStaticText* itemStaticText21 = new wxStaticText( itemPanel10, wxID_STATIC, _("Bullet &Alignment:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer13->Add(itemStaticText21, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxArrayString m_bulletAlignmentCtrlStrings;
m_bulletAlignmentCtrlStrings.Add(_("Left"));
m_bulletAlignmentCtrlStrings.Add(_("Centre"));
m_bulletAlignmentCtrlStrings.Add(_("Right"));
m_bulletAlignmentCtrl = new wxComboBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_BULLETALIGNMENTCTRL, _("Left"), wxDefaultPosition, wxSize(60, -1), m_bulletAlignmentCtrlStrings, wxCB_READONLY );
m_bulletAlignmentCtrl->SetStringSelection(_("Left"));
m_bulletAlignmentCtrl->SetHelpText(_("The bullet character."));
if (wxRichTextListStylePage::ShowToolTips())
m_bulletAlignmentCtrl->SetToolTip(_("The bullet character."));
itemBoxSizer13->Add(m_bulletAlignmentCtrl, 0, wxGROW|wxALL|wxFIXED_MINSIZE, 5);
itemBoxSizer12->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxStaticLine* itemStaticLine24 = new wxStaticLine( itemPanel10, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer12->Add(itemStaticLine24, 0, wxGROW|wxALL, 5);
itemBoxSizer12->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxBoxSizer* itemBoxSizer26 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer12->Add(itemBoxSizer26, 0, wxGROW, 5);
wxStaticText* itemStaticText27 = new wxStaticText( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_SYMBOLSTATIC, _("&Symbol:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(itemStaticText27, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxBoxSizer* itemBoxSizer28 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer26->Add(itemBoxSizer28, 0, wxGROW, 5);
wxArrayString m_symbolCtrlStrings;
m_symbolCtrl = new wxComboBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_SYMBOLCTRL, wxT(""), wxDefaultPosition, wxSize(60, -1), m_symbolCtrlStrings, wxCB_DROPDOWN );
m_symbolCtrl->SetHelpText(_("The bullet character."));
if (wxRichTextListStylePage::ShowToolTips())
m_symbolCtrl->SetToolTip(_("The bullet character."));
itemBoxSizer28->Add(m_symbolCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxFIXED_MINSIZE, 5);
wxButton* itemButton30 = new wxButton( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_SYMBOL, _("Ch&oose..."), wxDefaultPosition, wxDefaultSize, 0 );
itemButton30->SetHelpText(_("Click to browse for a symbol."));
if (wxRichTextListStylePage::ShowToolTips())
itemButton30->SetToolTip(_("Click to browse for a symbol."));
itemBoxSizer28->Add(itemButton30, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
itemBoxSizer26->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL, 5);
wxStaticText* itemStaticText32 = new wxStaticText( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_SYMBOLSTATIC, _("Symbol &font:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(itemStaticText32, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxArrayString m_symbolFontCtrlStrings;
m_symbolFontCtrl = new wxComboBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL, wxT(""), wxDefaultPosition, wxDefaultSize, m_symbolFontCtrlStrings, wxCB_DROPDOWN );
if (wxRichTextListStylePage::ShowToolTips())
m_symbolFontCtrl->SetToolTip(_("Available fonts."));
itemBoxSizer26->Add(m_symbolFontCtrl, 0, wxGROW|wxALL, 5);
itemBoxSizer26->Add(5, 5, 1, wxALIGN_CENTER_HORIZONTAL, 5);
wxStaticText* itemStaticText35 = new wxStaticText( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_NAMESTATIC, _("S&tandard bullet name:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(itemStaticText35, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxArrayString m_bulletNameCtrlStrings;
m_bulletNameCtrl = new wxComboBox( itemPanel10, ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL, wxT(""), wxDefaultPosition, wxDefaultSize, m_bulletNameCtrlStrings, wxCB_DROPDOWN );
m_bulletNameCtrl->SetHelpText(_("A standard bullet name."));
if (wxRichTextListStylePage::ShowToolTips())
m_bulletNameCtrl->SetToolTip(_("A standard bullet name."));
itemBoxSizer26->Add(m_bulletNameCtrl, 0, wxGROW|wxALL, 5);
itemNotebook9->AddPage(itemPanel10, _("Bullet style"));
wxPanel* itemPanel37 = new wxPanel( itemNotebook9, ID_RICHTEXTLISTSTYLEPAGE_SPACING, wxDefaultPosition, wxDefaultSize, wxNO_BORDER|wxTAB_TRAVERSAL );
wxBoxSizer* itemBoxSizer38 = new wxBoxSizer(wxVERTICAL);
itemPanel37->SetSizer(itemBoxSizer38);
wxBoxSizer* itemBoxSizer39 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer38->Add(itemBoxSizer39, 0, wxGROW, 5);
wxBoxSizer* itemBoxSizer40 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer39->Add(itemBoxSizer40, 0, wxGROW, 5);
wxStaticText* itemStaticText41 = new wxStaticText( itemPanel37, wxID_STATIC, _("&Alignment"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer40->Add(itemStaticText41, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxBoxSizer* itemBoxSizer42 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer40->Add(itemBoxSizer42, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
itemBoxSizer42->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL, 5);
wxBoxSizer* itemBoxSizer44 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer42->Add(itemBoxSizer44, 0, wxALIGN_CENTER_VERTICAL|wxTOP, 5);
m_alignmentLeft = new wxRadioButton( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_ALIGNLEFT, _("&Left"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
m_alignmentLeft->SetValue(false);
m_alignmentLeft->SetHelpText(_("Left-align text."));
if (wxRichTextListStylePage::ShowToolTips())
m_alignmentLeft->SetToolTip(_("Left-align text."));
itemBoxSizer44->Add(m_alignmentLeft, 0, wxALIGN_LEFT|wxALL, 5);
m_alignmentRight = new wxRadioButton( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_ALIGNRIGHT, _("&Right"), wxDefaultPosition, wxDefaultSize, 0 );
m_alignmentRight->SetValue(false);
m_alignmentRight->SetHelpText(_("Right-align text."));
if (wxRichTextListStylePage::ShowToolTips())
m_alignmentRight->SetToolTip(_("Right-align text."));
itemBoxSizer44->Add(m_alignmentRight, 0, wxALIGN_LEFT|wxALL, 5);
m_alignmentJustified = new wxRadioButton( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_JUSTIFIED, _("&Justified"), wxDefaultPosition, wxDefaultSize, 0 );
m_alignmentJustified->SetValue(false);
m_alignmentJustified->SetHelpText(_("Justify text left and right."));
if (wxRichTextListStylePage::ShowToolTips())
m_alignmentJustified->SetToolTip(_("Justify text left and right."));
itemBoxSizer44->Add(m_alignmentJustified, 0, wxALIGN_LEFT|wxALL, 5);
m_alignmentCentred = new wxRadioButton( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_CENTERED, _("Cen&tred"), wxDefaultPosition, wxDefaultSize, 0 );
m_alignmentCentred->SetValue(false);
m_alignmentCentred->SetHelpText(_("Centre text."));
if (wxRichTextListStylePage::ShowToolTips())
m_alignmentCentred->SetToolTip(_("Centre text."));
itemBoxSizer44->Add(m_alignmentCentred, 0, wxALIGN_LEFT|wxALL, 5);
m_alignmentIndeterminate = new wxRadioButton( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_ALIGNINDETERMINATE, _("&Indeterminate"), wxDefaultPosition, wxDefaultSize, 0 );
m_alignmentIndeterminate->SetValue(false);
m_alignmentIndeterminate->SetHelpText(_("Use the current alignment setting."));
if (wxRichTextListStylePage::ShowToolTips())
m_alignmentIndeterminate->SetToolTip(_("Use the current alignment setting."));
itemBoxSizer44->Add(m_alignmentIndeterminate, 0, wxALIGN_LEFT|wxALL, 5);
itemBoxSizer39->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxStaticLine* itemStaticLine51 = new wxStaticLine( itemPanel37, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer39->Add(itemStaticLine51, 0, wxGROW|wxLEFT|wxBOTTOM, 5);
itemBoxSizer39->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxBoxSizer* itemBoxSizer53 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer39->Add(itemBoxSizer53, 0, wxGROW, 5);
wxStaticText* itemStaticText54 = new wxStaticText( itemPanel37, wxID_STATIC, _("&Indentation (tenths of a mm)"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer53->Add(itemStaticText54, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxBoxSizer* itemBoxSizer55 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer53->Add(itemBoxSizer55, 0, wxALIGN_LEFT|wxALL, 5);
itemBoxSizer55->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL, 5);
wxFlexGridSizer* itemFlexGridSizer57 = new wxFlexGridSizer(2, 2, 0, 0);
itemBoxSizer55->Add(itemFlexGridSizer57, 0, wxALIGN_CENTER_VERTICAL, 5);
wxStaticText* itemStaticText58 = new wxStaticText( itemPanel37, wxID_STATIC, _("&Left:"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer57->Add(itemStaticText58, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer59 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer57->Add(itemBoxSizer59, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_indentLeft = new wxTextCtrl( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_INDENTLEFT, wxT(""), wxDefaultPosition, wxSize(50, -1), 0 );
m_indentLeft->SetHelpText(_("The left indent."));
if (wxRichTextListStylePage::ShowToolTips())
m_indentLeft->SetToolTip(_("The left indent."));
itemBoxSizer59->Add(m_indentLeft, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticText* itemStaticText61 = new wxStaticText( itemPanel37, wxID_STATIC, _("Left (&first line):"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer57->Add(itemStaticText61, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer62 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer57->Add(itemBoxSizer62, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_indentLeftFirst = new wxTextCtrl( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_INDENTFIRSTLINE, wxT(""), wxDefaultPosition, wxSize(50, -1), 0 );
m_indentLeftFirst->SetHelpText(_("The first line indent."));
if (wxRichTextListStylePage::ShowToolTips())
m_indentLeftFirst->SetToolTip(_("The first line indent."));
itemBoxSizer62->Add(m_indentLeftFirst, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticText* itemStaticText64 = new wxStaticText( itemPanel37, wxID_STATIC, _("&Right:"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer57->Add(itemStaticText64, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer65 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer57->Add(itemBoxSizer65, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_indentRight = new wxTextCtrl( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_INDENTRIGHT, wxT(""), wxDefaultPosition, wxSize(50, -1), 0 );
m_indentRight->SetHelpText(_("The right indent."));
if (wxRichTextListStylePage::ShowToolTips())
m_indentRight->SetToolTip(_("The right indent."));
itemBoxSizer65->Add(m_indentRight, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
itemBoxSizer39->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxStaticLine* itemStaticLine68 = new wxStaticLine( itemPanel37, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer39->Add(itemStaticLine68, 0, wxGROW|wxTOP|wxBOTTOM, 5);
itemBoxSizer39->Add(2, 1, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
wxBoxSizer* itemBoxSizer70 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer39->Add(itemBoxSizer70, 0, wxGROW, 5);
wxStaticText* itemStaticText71 = new wxStaticText( itemPanel37, wxID_STATIC, _("&Spacing (tenths of a mm)"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer70->Add(itemStaticText71, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
wxBoxSizer* itemBoxSizer72 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer70->Add(itemBoxSizer72, 0, wxALIGN_LEFT|wxALL, 5);
itemBoxSizer72->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL, 5);
wxFlexGridSizer* itemFlexGridSizer74 = new wxFlexGridSizer(2, 2, 0, 0);
itemBoxSizer72->Add(itemFlexGridSizer74, 0, wxALIGN_CENTER_VERTICAL, 5);
wxStaticText* itemStaticText75 = new wxStaticText( itemPanel37, wxID_STATIC, _("Before a paragraph:"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer74->Add(itemStaticText75, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer76 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer74->Add(itemBoxSizer76, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_spacingBefore = new wxTextCtrl( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_SPACINGBEFORE, wxT(""), wxDefaultPosition, wxSize(50, -1), 0 );
m_spacingBefore->SetHelpText(_("The spacing before the paragraph."));
if (wxRichTextListStylePage::ShowToolTips())
m_spacingBefore->SetToolTip(_("The spacing before the paragraph."));
itemBoxSizer76->Add(m_spacingBefore, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticText* itemStaticText78 = new wxStaticText( itemPanel37, wxID_STATIC, _("After a paragraph:"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer74->Add(itemStaticText78, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer79 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer74->Add(itemBoxSizer79, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
m_spacingAfter = new wxTextCtrl( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_SPACINGAFTER, wxT(""), wxDefaultPosition, wxSize(50, -1), 0 );
m_spacingAfter->SetHelpText(_("The spacing after the paragraph."));
if (wxRichTextListStylePage::ShowToolTips())
m_spacingAfter->SetToolTip(_("The spacing after the paragraph."));
itemBoxSizer79->Add(m_spacingAfter, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticText* itemStaticText81 = new wxStaticText( itemPanel37, wxID_STATIC, _("Line spacing:"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer74->Add(itemStaticText81, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer82 = new wxBoxSizer(wxHORIZONTAL);
itemFlexGridSizer74->Add(itemBoxSizer82, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
wxArrayString m_spacingLineStrings;
m_spacingLineStrings.Add(_("Single"));
m_spacingLineStrings.Add(_("1.5"));
m_spacingLineStrings.Add(_("2"));
m_spacingLine = new wxComboBox( itemPanel37, ID_RICHTEXTLISTSTYLEPAGE_LINESPACING, _("Single"), wxDefaultPosition, wxDefaultSize, m_spacingLineStrings, wxCB_READONLY );
m_spacingLine->SetStringSelection(_("Single"));
m_spacingLine->SetHelpText(_("The line spacing."));
if (wxRichTextListStylePage::ShowToolTips())
m_spacingLine->SetToolTip(_("The line spacing."));
itemBoxSizer82->Add(m_spacingLine, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
itemNotebook9->AddPage(itemPanel37, _("Spacing"));
itemBoxSizer3->Add(itemNotebook9, 0, wxGROW|wxALL, 5);
m_previewCtrl = new wxRichTextCtrl( itemPanel1, ID_RICHTEXTLISTSTYLEPAGE_RICHTEXTCTRL, wxEmptyString, wxDefaultPosition, wxSize(350, 180), wxSUNKEN_BORDER|wxVSCROLL|wxTE_READONLY );
m_previewCtrl->SetHelpText(_("Shows a preview of the bullet settings."));
if (wxRichTextListStylePage::ShowToolTips())
m_previewCtrl->SetToolTip(_("Shows a preview of the bullet settings."));
itemBoxSizer3->Add(m_previewCtrl, 0, wxGROW|wxALL, 5);
////@end wxRichTextListStylePage content construction
m_dontUpdate = true;
m_styleListBox->Append(_("(None)"));
m_styleListBox->Append(_("Arabic"));
m_styleListBox->Append(_("Upper case letters"));
m_styleListBox->Append(_("Lower case letters"));
m_styleListBox->Append(_("Upper case roman numerals"));
m_styleListBox->Append(_("Lower case roman numerals"));
m_styleListBox->Append(_("Numbered outline"));
m_styleListBox->Append(_("Symbol"));
m_styleListBox->Append(_("Bitmap"));
m_styleListBox->Append(_("Standard"));
m_symbolCtrl->Append(_("*"));
m_symbolCtrl->Append(_("-"));
m_symbolCtrl->Append(_(">"));
m_symbolCtrl->Append(_("+"));
m_symbolCtrl->Append(_("~"));
wxArrayString standardBulletNames;
if (wxRichTextBuffer::GetRenderer())
wxRichTextBuffer::GetRenderer()->EnumerateStandardBulletNames(standardBulletNames);
m_bulletNameCtrl->Append(standardBulletNames);
wxArrayString facenames = wxRichTextCtrl::GetAvailableFontNames();
facenames.Sort();
m_symbolFontCtrl->Append(facenames);
m_levelCtrl->SetValue(m_currentLevel);
m_dontUpdate = false;
}
/// Updates the font preview
void wxRichTextListStylePage::UpdatePreview()
{
static const wxChar* s_para1 = wxT("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. \
Nullam ante sapien, vestibulum nonummy, pulvinar sed, luctus ut, lacus.\n");
static const wxChar* s_para2 = wxT("Duis pharetra consequat dui. Nullam vitae justo id mauris lobortis interdum.\n");
static const wxChar* s_para3 = wxT("Integer convallis dolor at augue \
iaculis malesuada. Donec bibendum ipsum ut ante porta fringilla.\n");
wxRichTextListStyleDefinition* def = wxDynamicCast(wxRichTextFormattingDialog::GetDialogStyleDefinition(this),
wxRichTextListStyleDefinition);
wxRichTextStyleSheet* styleSheet = wxRichTextFormattingDialog::GetDialog(this)->GetStyleSheet();
wxTextAttr attr((const wxTextAttr &)(styleSheet ? def->GetStyle() : def->GetStyleMergedWithBase(styleSheet)));
attr.SetFlags(attr.GetFlags() &
(wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|
wxTEXT_ATTR_LINE_SPACING|
wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_TEXT));
wxFont font(m_previewCtrl->GetFont());
font.SetPointSize(9);
m_previewCtrl->SetFont(font);
wxTextAttr normalParaAttr;
normalParaAttr.SetFont(font);
normalParaAttr.SetTextColour(wxColour(wxT("LIGHT GREY")));
m_previewCtrl->Freeze();
m_previewCtrl->Clear();
m_previewCtrl->BeginStyle(normalParaAttr);
m_previewCtrl->WriteText(s_para1);
m_previewCtrl->EndStyle();
m_previewCtrl->BeginStyle(attr);
long listStart = m_previewCtrl->GetInsertionPoint() + 1;
int i;
for (i = 0; i < 10; i++)
{
wxTextAttr levelAttr = * def->GetLevelAttributes(i);
levelAttr.SetBulletNumber(1);
m_previewCtrl->BeginStyle(levelAttr);
m_previewCtrl->WriteText(wxString::Format(wxT("List level %d. "), i+1) + s_para2);
m_previewCtrl->EndStyle();
}
m_previewCtrl->EndStyle();
long listEnd = m_previewCtrl->GetInsertionPoint();
m_previewCtrl->BeginStyle(normalParaAttr);
m_previewCtrl->WriteText(s_para3);
m_previewCtrl->EndStyle();
m_previewCtrl->NumberList(wxRichTextRange(listStart, listEnd), def);
m_previewCtrl->Thaw();
}
/// Transfer data from/to window
bool wxRichTextListStylePage::TransferDataFromWindow()
{
wxPanel::TransferDataFromWindow();
m_currentLevel = m_levelCtrl->GetValue();
wxTextAttr* attr = GetAttributesForSelection();
if (m_alignmentLeft->GetValue())
attr->SetAlignment(wxTEXT_ALIGNMENT_LEFT);
else if (m_alignmentCentred->GetValue())
attr->SetAlignment(wxTEXT_ALIGNMENT_CENTRE);
else if (m_alignmentRight->GetValue())
attr->SetAlignment(wxTEXT_ALIGNMENT_RIGHT);
else if (m_alignmentJustified->GetValue())
attr->SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED);
else
{
attr->SetAlignment(wxTEXT_ALIGNMENT_DEFAULT);
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_ALIGNMENT));
}
wxString leftIndent(m_indentLeft->GetValue());
wxString leftFirstIndent(m_indentLeftFirst->GetValue());
if (!leftIndent.empty())
{
int visualLeftIndent = wxAtoi(leftIndent);
int visualLeftFirstIndent = wxAtoi(leftFirstIndent);
int actualLeftIndent = visualLeftFirstIndent;
int actualLeftSubIndent = visualLeftIndent - visualLeftFirstIndent;
attr->SetLeftIndent(actualLeftIndent, actualLeftSubIndent);
}
else
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_LEFT_INDENT));
wxString rightIndent(m_indentRight->GetValue());
if (!rightIndent.empty())
attr->SetRightIndent(wxAtoi(rightIndent));
else
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_RIGHT_INDENT));
wxString spacingAfter(m_spacingAfter->GetValue());
if (!spacingAfter.empty())
attr->SetParagraphSpacingAfter(wxAtoi(spacingAfter));
else
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_PARA_SPACING_AFTER));
wxString spacingBefore(m_spacingBefore->GetValue());
if (!spacingBefore.empty())
attr->SetParagraphSpacingBefore(wxAtoi(spacingBefore));
else
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_PARA_SPACING_BEFORE));
int spacingIndex = m_spacingLine->GetSelection();
int lineSpacing = 0;
if (spacingIndex == 0)
lineSpacing = 10;
else if (spacingIndex == 1)
lineSpacing = 15;
else if (spacingIndex == 2)
lineSpacing = 20;
if (lineSpacing == 0)
attr->SetFlags(attr->GetFlags() & (~wxTEXT_ATTR_LINE_SPACING));
else
attr->SetLineSpacing(lineSpacing);
/// BULLETS
// if (m_hasBulletStyle)
{
long bulletStyle = 0;
int index = m_styleListBox->GetSelection();
if (index == wxRICHTEXT_BULLETINDEX_ARABIC)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_ARABIC;
else if (index == wxRICHTEXT_BULLETINDEX_UPPER_CASE)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER;
else if (index == wxRICHTEXT_BULLETINDEX_LOWER_CASE)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER;
else if (index == wxRICHTEXT_BULLETINDEX_UPPER_CASE_ROMAN)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER;
else if (index == wxRICHTEXT_BULLETINDEX_LOWER_CASE_ROMAN)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER;
else if (index == wxRICHTEXT_BULLETINDEX_OUTLINE)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_OUTLINE;
else if (index == wxRICHTEXT_BULLETINDEX_SYMBOL)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_SYMBOL;
else if (index == wxRICHTEXT_BULLETINDEX_BITMAP)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_BITMAP;
else if (index == wxRICHTEXT_BULLETINDEX_STANDARD)
{
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_STANDARD;
attr->SetBulletName(m_bulletNameCtrl->GetValue());
}
if (m_parenthesesCtrl->GetValue())
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_PARENTHESES;
if (m_rightParenthesisCtrl->GetValue())
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS;
if (m_periodCtrl->GetValue())
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_PERIOD;
if (m_bulletAlignmentCtrl->GetSelection() == 1)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE;
else if (m_bulletAlignmentCtrl->GetSelection() == 2)
bulletStyle |= wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT;
// Left is implied
attr->SetBulletStyle(bulletStyle);
}
// if (m_hasBulletSymbol)
{
attr->SetBulletText(m_symbolCtrl->GetValue());
attr->SetBulletFont(m_symbolFontCtrl->GetValue());
}
return true;
}
bool wxRichTextListStylePage::TransferDataToWindow()
{
DoTransferDataToWindow();
UpdatePreview();
return true;
}
/// Just transfer to the window
void wxRichTextListStylePage::DoTransferDataToWindow()
{
m_dontUpdate = true;
wxPanel::TransferDataToWindow();
wxTextAttr* attr = GetAttributesForSelection();
if (attr->HasAlignment())
{
if (attr->GetAlignment() == wxTEXT_ALIGNMENT_LEFT)
m_alignmentLeft->SetValue(true);
else if (attr->GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
m_alignmentRight->SetValue(true);
else if (attr->GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
m_alignmentCentred->SetValue(true);
else if (attr->GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED)
m_alignmentJustified->SetValue(true);
else
m_alignmentIndeterminate->SetValue(true);
}
else
m_alignmentIndeterminate->SetValue(true);
if (attr->HasLeftIndent())
{
wxString leftIndent(wxString::Format(wxT("%ld"), attr->GetLeftIndent() + attr->GetLeftSubIndent()));
wxString leftFirstIndent(wxString::Format(wxT("%ld"), attr->GetLeftIndent()));
m_indentLeft->SetValue(leftIndent);
m_indentLeftFirst->SetValue(leftFirstIndent);
}
else
{
m_indentLeft->SetValue(wxEmptyString);
m_indentLeftFirst->SetValue(wxEmptyString);
}
if (attr->HasRightIndent())
{
wxString rightIndent(wxString::Format(wxT("%ld"), attr->GetRightIndent()));
m_indentRight->SetValue(rightIndent);
}
else
m_indentRight->SetValue(wxEmptyString);
if (attr->HasParagraphSpacingAfter())
{
wxString spacingAfter(wxString::Format(wxT("%d"), attr->GetParagraphSpacingAfter()));
m_spacingAfter->SetValue(spacingAfter);
}
else
m_spacingAfter->SetValue(wxEmptyString);
if (attr->HasParagraphSpacingBefore())
{
wxString spacingBefore(wxString::Format(wxT("%d"), attr->GetParagraphSpacingBefore()));
m_spacingBefore->SetValue(spacingBefore);
}
else
m_spacingBefore->SetValue(wxEmptyString);
if (attr->HasLineSpacing())
{
int index = 0;
int lineSpacing = attr->GetLineSpacing();
if (lineSpacing == 10)
index = 0;
else if (lineSpacing == 15)
index = 1;
else if (lineSpacing == 20)
index = 2;
else
index = -1;
m_spacingLine->SetSelection(index);
}
else
m_spacingLine->SetSelection(-1);
/// BULLETS
if (attr->HasBulletStyle())
{
int index = 0;
if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ARABIC)
index = wxRICHTEXT_BULLETINDEX_ARABIC;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)
index = wxRICHTEXT_BULLETINDEX_UPPER_CASE;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)
index = wxRICHTEXT_BULLETINDEX_LOWER_CASE;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)
index = wxRICHTEXT_BULLETINDEX_UPPER_CASE_ROMAN;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)
index = wxRICHTEXT_BULLETINDEX_LOWER_CASE_ROMAN;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
index = wxRICHTEXT_BULLETINDEX_OUTLINE;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
index = wxRICHTEXT_BULLETINDEX_SYMBOL;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP)
index = wxRICHTEXT_BULLETINDEX_BITMAP;
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_STANDARD)
index = wxRICHTEXT_BULLETINDEX_STANDARD;
m_styleListBox->SetSelection(index);
if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)
m_parenthesesCtrl->SetValue(true);
else
m_parenthesesCtrl->SetValue(false);
if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)
m_rightParenthesisCtrl->SetValue(true);
else
m_rightParenthesisCtrl->SetValue(false);
if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PERIOD)
m_periodCtrl->SetValue(true);
else
m_periodCtrl->SetValue(false);
if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)
m_bulletAlignmentCtrl->SetSelection(1);
else if (attr->GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)
m_bulletAlignmentCtrl->SetSelection(2);
else
m_bulletAlignmentCtrl->SetSelection(0);
}
else
{
m_styleListBox->SetSelection(-1);
m_bulletAlignmentCtrl->SetSelection(-1);
}
if (attr->HasBulletText())
{
m_symbolCtrl->SetValue(attr->GetBulletText());
m_symbolFontCtrl->SetValue(attr->GetBulletFont());
}
else
m_symbolCtrl->SetValue(wxEmptyString);
if (attr->HasBulletName())
m_bulletNameCtrl->SetValue(attr->GetBulletName());
else
m_bulletNameCtrl->SetValue(wxEmptyString);
m_dontUpdate = false;
}
/// Get attributes for selected level
wxTextAttr* wxRichTextListStylePage::GetAttributesForSelection()
{
wxRichTextListStyleDefinition* def = wxDynamicCast(wxRichTextFormattingDialog::GetDialogStyleDefinition(this),
wxRichTextListStyleDefinition);
int value = m_levelCtrl->GetValue();
if (def)
return def->GetLevelAttributes(value-1);
else
return NULL;
}
/// Just transfer from the window and update the preview
void wxRichTextListStylePage::TransferAndPreview()
{
if (!m_dontUpdate)
{
TransferDataFromWindow();
UpdatePreview();
}
}
/*!
* wxEVT_COMMAND_SPINCTRL_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL
*/
void wxRichTextListStylePage::OnLevelUpdated( wxSpinEvent& WXUNUSED(event) )
{
if (!m_dontUpdate)
{
m_currentLevel = m_levelCtrl->GetValue();
TransferDataToWindow();
}
}
/*!
* wxEVT_SCROLL_LINEUP event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL
*/
void wxRichTextListStylePage::OnLevelUp( wxSpinEvent& event )
{
if (!m_dontUpdate)
{
m_currentLevel = event.GetPosition();
TransferDataToWindow();
}
}
/*!
* wxEVT_SCROLL_LINEDOWN event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL
*/
void wxRichTextListStylePage::OnLevelDown( wxSpinEvent& event )
{
if (!m_dontUpdate)
{
m_currentLevel = event.GetPosition();
TransferDataToWindow();
}
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL
*/
void wxRichTextListStylePage::OnLevelTextUpdated( wxCommandEvent& WXUNUSED(event) )
{
// Can cause problems
#if 0
if (!m_dontUpdate)
{
m_currentLevel = event.GetInt();
TransferDataToWindow();
}
#endif
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL
*/
void wxRichTextListStylePage::OnLevelUIUpdate( wxUpdateUIEvent& event )
{
////@begin wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL in wxRichTextListStylePage.
// Before editing this code, remove the block markers.
event.Skip();
////@end wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_LEVEL in wxRichTextListStylePage.
}
/*!
* wxEVT_COMMAND_LISTBOX_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_STYLELISTBOX
*/
void wxRichTextListStylePage::OnStylelistboxSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_SYMBOLSTATIC
*/
void wxRichTextListStylePage::OnSymbolstaticUpdate( wxUpdateUIEvent& event )
{
OnSymbolUpdate(event);
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_RICHTEXTBULLETSPAGE_SYMBOLCTRL
*/
void wxRichTextListStylePage::OnSymbolctrlSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTBULLETSPAGE_SYMBOLCTRL
*/
void wxRichTextListStylePage::OnSymbolctrlUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTBULLETSPAGE_SYMBOLCTRL
*/
void wxRichTextListStylePage::OnSymbolctrlUIUpdate( wxUpdateUIEvent& event )
{
OnSymbolUpdate(event);
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_RICHTEXTBULLETSPAGE_CHOOSE_SYMBOL
*/
void wxRichTextListStylePage::OnChooseSymbolClick( wxCommandEvent& WXUNUSED(event) )
{
int sel = m_styleListBox->GetSelection();
if (sel == wxRICHTEXT_BULLETINDEX_SYMBOL)
{
wxString symbol = m_symbolCtrl->GetValue();
wxString fontName = m_symbolFontCtrl->GetValue();
wxSymbolPickerDialog dlg(symbol, fontName, fontName, this);
if (dlg.ShowModal() == wxID_OK)
{
m_dontUpdate = true;
m_symbolCtrl->SetValue(dlg.GetSymbol());
m_symbolFontCtrl->SetValue(dlg.GetFontName());
TransferAndPreview();
m_dontUpdate = false;
}
}
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTBULLETSPAGE_CHOOSE_SYMBOL
*/
void wxRichTextListStylePage::OnChooseSymbolUpdate( wxUpdateUIEvent& event )
{
OnSymbolUpdate(event);
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL
*/
void wxRichTextListStylePage::OnSymbolfontctrlSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL
*/
void wxRichTextListStylePage::OnSymbolfontctrlUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_SYMBOLFONTCTRL
*/
void wxRichTextListStylePage::OnSymbolfontctrlUIUpdate( wxUpdateUIEvent& event )
{
OnSymbolUpdate(event);
}
/*!
* wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_RICHTEXTLISTSTYLEPAGE__PARENTHESESCTRL
*/
void wxRichTextListStylePage::OnParenthesesctrlClick( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE__PARENTHESESCTRL
*/
void wxRichTextListStylePage::OnParenthesesctrlUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable((sel != wxRICHTEXT_BULLETINDEX_SYMBOL &&
sel != wxRICHTEXT_BULLETINDEX_BITMAP &&
sel != wxRICHTEXT_BULLETINDEX_NONE));
}
/*!
* wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_RICHTEXTLISTSTYLEPAGE_PERIODCTRL
*/
void wxRichTextListStylePage::OnPeriodctrlClick( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_PERIODCTRL
*/
void wxRichTextListStylePage::OnPeriodctrlUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable((sel != wxRICHTEXT_BULLETINDEX_SYMBOL &&
sel != wxRICHTEXT_BULLETINDEX_BITMAP &&
sel != wxRICHTEXT_BULLETINDEX_NONE));
}
/*!
* wxEVT_COMMAND_RADIOBUTTON_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_ALIGNLEFT
*/
void wxRichTextListStylePage::OnRichtextliststylepageAlignleftSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_RADIOBUTTON_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_ALIGNRIGHT
*/
void wxRichTextListStylePage::OnRichtextliststylepageAlignrightSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_RADIOBUTTON_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_JUSTIFIED
*/
void wxRichTextListStylePage::OnRichtextliststylepageJustifiedSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_RADIOBUTTON_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_CENTERED
*/
void wxRichTextListStylePage::OnRichtextliststylepageCenteredSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_RADIOBUTTON_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_ALIGNINDETERMINATE
*/
void wxRichTextListStylePage::OnRichtextliststylepageAlignindeterminateSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_INDENTLEFT
*/
void wxRichTextListStylePage::OnIndentLeftUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_INDENTFIRSTLINE
*/
void wxRichTextListStylePage::OnIndentFirstLineUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_INDENTRIGHT
*/
void wxRichTextListStylePage::OnIndentRightUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_SPACINGBEFORE
*/
void wxRichTextListStylePage::OnSpacingBeforeUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_SPACINGAFTER
*/
void wxRichTextListStylePage::OnSpacingAfterUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_LINESPACING
*/
void wxRichTextListStylePage::OnLineSpacingSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* Should we show tooltips?
*/
bool wxRichTextListStylePage::ShowToolTips()
{
return wxRichTextFormattingDialog::ShowToolTips();
}
/*!
* Get bitmap resources
*/
wxBitmap wxRichTextListStylePage::GetBitmapResource( const wxString& name )
{
// Bitmap retrieval
////@begin wxRichTextListStylePage bitmap retrieval
wxUnusedVar(name);
return wxNullBitmap;
////@end wxRichTextListStylePage bitmap retrieval
}
/*!
* Get icon resources
*/
wxIcon wxRichTextListStylePage::GetIconResource( const wxString& name )
{
// Icon retrieval
////@begin wxRichTextListStylePage icon retrieval
wxUnusedVar(name);
return wxNullIcon;
////@end wxRichTextListStylePage icon retrieval
}
/// Update for symbol-related controls
void wxRichTextListStylePage::OnSymbolUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable(sel == wxRICHTEXT_BULLETINDEX_SYMBOL);
}
/// Update for number-related controls
void wxRichTextListStylePage::OnNumberUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable((sel != wxRICHTEXT_BULLETINDEX_SYMBOL &&
sel != wxRICHTEXT_BULLETINDEX_BITMAP &&
sel != wxRICHTEXT_BULLETINDEX_STANDARD &&
sel != wxRICHTEXT_BULLETINDEX_NONE));
}
/// Update for standard bullet-related controls
void wxRichTextListStylePage::OnStandardBulletUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable( sel == wxRICHTEXT_BULLETINDEX_STANDARD );
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_RICHTEXTLISTSTYLEPAGE_CHOOSE_FONT
*/
void wxRichTextListStylePage::OnChooseFontClick( wxCommandEvent& WXUNUSED(event) )
{
wxTextAttr* attr = GetAttributesForSelection();
int pages = wxRICHTEXT_FORMAT_FONT;
wxRichTextFormattingDialog formatDlg;
formatDlg.SetStyle(*attr, false);
formatDlg.Create(pages, this);
if (formatDlg.ShowModal() == wxID_OK)
{
(*attr) = formatDlg.GetAttributes();
TransferAndPreview();
}
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_NAMESTATIC
*/
void wxRichTextListStylePage::OnNamestaticUpdate( wxUpdateUIEvent& event )
{
OnStandardBulletUpdate(event);
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL
*/
void wxRichTextListStylePage::OnNamectrlSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL
*/
void wxRichTextListStylePage::OnNamectrlUpdated( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_NAMECTRL
*/
void wxRichTextListStylePage::OnNamectrlUIUpdate( wxUpdateUIEvent& event )
{
OnStandardBulletUpdate(event);
}
/*!
* wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_RICHTEXTLISTSTYLEPAGE_RIGHTPARENTHESISCTRL
*/
void wxRichTextListStylePage::OnRightParenthesisCtrlClick( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
/*!
* wxEVT_UPDATE_UI event handler for ID_RICHTEXTLISTSTYLEPAGE_RIGHTPARENTHESISCTRL
*/
void wxRichTextListStylePage::OnRightParenthesisCtrlUpdate( wxUpdateUIEvent& event )
{
int sel = m_styleListBox->GetSelection();
event.Enable((sel != wxRICHTEXT_BULLETINDEX_SYMBOL &&
sel != wxRICHTEXT_BULLETINDEX_BITMAP &&
sel != wxRICHTEXT_BULLETINDEX_NONE));
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_RICHTEXTLISTSTYLEPAGE_BULLETALIGNMENTCTRL
*/
void wxRichTextListStylePage::OnBulletAlignmentCtrlSelected( wxCommandEvent& WXUNUSED(event) )
{
TransferAndPreview();
}
| 39.202643 | 196 | 0.725625 | gamekit-developers |
28abb27fd199f22440597d85f90b972ddd7ad853 | 2,852 | cpp | C++ | vulkanon/generator/data/code/vulkanon/l0_enemy23.cpp | pqrs-org/Vulkanon | 3c161b83e64f18be2ba916055e5761fbc0b61028 | [
"Unlicense"
] | 5 | 2020-04-20T02:28:15.000Z | 2021-12-05T22:04:06.000Z | vulkanon/generator/data/code/vulkanon/l0_enemy23.cpp | pqrs-org/Vulkanon | 3c161b83e64f18be2ba916055e5761fbc0b61028 | [
"Unlicense"
] | null | null | null | vulkanon/generator/data/code/vulkanon/l0_enemy23.cpp | pqrs-org/Vulkanon | 3c161b83e64f18be2ba916055e5761fbc0b61028 | [
"Unlicense"
] | null | null | null | // XXX uniqID XXX 318a5e347d432a1a29542cd45457692a XXX
#include <gba_types.h>
#include "bullet.hpp"
#include "fixed.hpp"
#include "vulkanon/l0_enemy23.hpp"
extern const BulletStepFunc bullet_72977f5a201704a116fed2c268b98db5_318a5e347d432a1a29542cd45457692a[] = {
stepfunc_b9f3746024faf71a948d02a3f58cba12_318a5e347d432a1a29542cd45457692a,
stepfunc_874e5b4a542f0f7f52ac24d8da866549_318a5e347d432a1a29542cd45457692a,
NULL};
extern const BulletStepFunc bullet_da391036f4887058d231358ef78fb2f0_318a5e347d432a1a29542cd45457692a[] = {
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a,
stepfunc_dae2cf81747ffb5070f05c8837b1d568_318a5e347d432a1a29542cd45457692a,
NULL};
void stepfunc_b9f3746024faf71a948d02a3f58cba12_318a5e347d432a1a29542cd45457692a(BulletInfo *p) {
p->wait = static_cast<u16>(10);
}
void stepfunc_874e5b4a542f0f7f52ac24d8da866549_318a5e347d432a1a29542cd45457692a(BulletInfo *p) {
{
u16 life = static_cast<u16>(1); FixedPointNum speed = (256 * -90 / 360) + ((180 * 1.0 * 256 / 360)) - p->getAngle();p->setRound(speed, life);}
}
void stepfunc_f8e5484dd9ba577849087e287b940bef_318a5e347d432a1a29542cd45457692a(BulletInfo *p) {
{
BulletInfo *bi; p->lastBulletAngle = p->lastBulletAngle + ((30 * 1.0 * 256 / 360)); p->lastBulletSpeed = (1); bi = ListBullets::makeNewBullet(); if (bi != NULL) { bi->initialize(BULLET_TYPE_NORMAL, p->getPosX(), p->getPosY(), p->lastBulletAngle, p->lastBulletSpeed, bullet_72977f5a201704a116fed2c268b98db5_318a5e347d432a1a29542cd45457692a);
}
}
}
void stepfunc_dae2cf81747ffb5070f05c8837b1d568_318a5e347d432a1a29542cd45457692a(BulletInfo *p) {
ListBullets::stepFuncDrop(p);}
BulletInfo *genBulletFunc_318a5e347d432a1a29542cd45457692a(FixedPointNum posx, FixedPointNum posy) { BulletInfo * bi; bi = ListBullets::makeNewBullet(); if (bi != NULL) { bi->initialize(BULLET_TYPE_ROOT, posx, posy, BulletInfo::DEFAULT_ANGLE, 0, bullet_da391036f4887058d231358ef78fb2f0_318a5e347d432a1a29542cd45457692a);
}
return bi;}
| 55.921569 | 350 | 0.860098 | pqrs-org |
28b08ebb4e2e8a1448c6ecb8dded527de3550256 | 963 | cpp | C++ | vnoj/nkpath.cpp | tiozo/Training | 02cc8c4fcf68e07c16520fd05fcbfa524c171b6b | [
"MIT"
] | 1 | 2021-08-28T04:16:34.000Z | 2021-08-28T04:16:34.000Z | vnoj/nkpath.cpp | tiozo/Training | 02cc8c4fcf68e07c16520fd05fcbfa524c171b6b | [
"MIT"
] | null | null | null | vnoj/nkpath.cpp | tiozo/Training | 02cc8c4fcf68e07c16520fd05fcbfa524c171b6b | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
long long gcd(long long int a, long long int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
long long lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
const int MOD=1e9;
int main() {
int M,N;
cin >> M >> N;
vector<vi > a(M+1,vi (N+1,0));
for (int i=1;i<=M;++i) {
for (int j=1;j<=N;++j) {
cin >> a[i][j];
}
}
vector<vi > F(M+1,vi (N+1,0));
for (int i=1;i<=M;++i) {
F[i][1]=1;
}
for (int i=1;i<=M;++i) {
for (int j=1;j<=N;++j) {
for (int x=1;x<=i;++x) {
for (int y=1;y<=j;++y) {
if (y < N && x+y<i+j && gcd(a[x][y],a[i][j])!=1)
F[i][j]=(F[i][j]+F[x][y])%MOD;
}
}
}
}
int sum=0;
for (int i=1;i<=M;++i) {
sum=(sum+F[i][N])%MOD;
}
cout << sum;
return 0;
}
| 19.26 | 69 | 0.379024 | tiozo |
28b5525bc8a63b03219b8d88bf631993ca818f4f | 28,439 | hpp | C++ | include/netp/constants.hpp | cainiaoDJ/netplus | 03350d507830b3a39620374225d16c0b57623ef1 | [
"MIT"
] | null | null | null | include/netp/constants.hpp | cainiaoDJ/netplus | 03350d507830b3a39620374225d16c0b57623ef1 | [
"MIT"
] | null | null | null | include/netp/constants.hpp | cainiaoDJ/netplus | 03350d507830b3a39620374225d16c0b57623ef1 | [
"MIT"
] | null | null | null | #ifndef _NETP_CONSTANTS_H_
#define _NETP_CONSTANTS_H_
#include <climits>
#include <netp/core/platform.hpp>
#define NETP_SOCKET_ERROR (-1)
#define NETP_INVALID_SOCKET netp::SOCKET(~0)
namespace netp {
namespace u8 {
const u32_t MAX = 0xffU;
}
namespace i8 {
const u32_t MAX = 0x7f;
}
namespace u16 {
const u32_t MAX = 0xffffU;
}
namespace i16 {
const u32_t MAX = 0x7fffU;
}
namespace u32 {
const u32_t MAX = 0xffffffffUL;
}
namespace i32 {
const u32_t MAX = 0x7fffffffUL;
}
namespace u64 {
const u64_t MAX = 0xffffffffffffffffULL;
}
namespace i64 {
const u64_t MAX = 0x7fffffffffffffffULL;
}
//WSAEWOULDBLOCK
const int OK = 0;
#if defined(_NETP_APPLE)
const int E_EPERM = -1; /* Operation not permitted */
const int E_ENOENT = -2; /* No such file or directory */
const int E_ESRCH = -3; /* No such process */
const int E_EINTR =-4; /* Interrupted system call */
const int E_EIO = -5; /* Input/output error */
const int E_ENXIO = -6; /* Device not configured */
const int E_E2BIG = -7; /* Argument list too long */
const int E_ENOEXEC = -8; /* Exec format error */
const int E_EBADF = -9; /* Bad file descriptor */
const int E_ECHILD = -10; /* No child processes */
const int E_EDEADLK = -11; /* Resource deadlock avoided */
/* 11 was EAGAIN */
const int E_ENOMEM = -12; /* Cannot allocate memory */
const int E_EACCES = -13; /* Permission denied */
const int E_EFAULT = -14; /* Bad address */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_ENOTBLK = -15; ; /* Block device required */
#endif
const int E_EBUSY = -16; /* Device / Resource busy */
const int E_EEXIST =-17; /* File exists */
const int E_EXDEV = -18; /* Cross-device link */
const int E_ENODEV = -19; /* Operation not supported by device */
const int E_ENOTDIR = -20; /* Not a directory */
const int E_EISDIR = -21; /* Is a directory */
const int E_EINVAL = -22; /* Invalid argument */
const int E_ENFILE = -23; /* Too many open files in system */
const int E_EMFILE = -24; /* Too many open files */
const int E_ENOTTY = -25; /* Inappropriate ioctl for device */
const int E_ETXTBSY = 26; /* Text file busy */
const int E_EFBIG = -27; /* File too large */
const int E_ENOSPC = -28; /* No space left on device */
const int E_ESPIPE = -29; /* Illegal seek */
const int E_EROFS = -30; /* Read-only file system */
const int E_EMLINK = -31; /* Too many links */
const int E_EPIPE = -32; /* Broken pipe */
/* math software */
const int E_EDOM = -33; /* Numerical argument out of domain */
const int E_ERANGE = -34; /* Result too large */
/* non-blocking and interrupt i/o */
const int E_EAGAIN = -35; /* Resource temporarily unavailable */
const int E_EWOULDBLOCK = E_EAGAIN; /* Operation would block */
const int E_EINPROGRESS = -36; /* Operation now in progress */
const int E_EALREADY = -37; /* Operation already in progress */
/* ipc/network software -- argument errors */
const int E_ENOTSOCK = -38; /* Socket operation on non-socket */
const int E_EDESTADDRREQ = -39; /* Destination address required */
const int E_EMSGSIZE = -40; /* Message too long */
const int E_EPROTOTYPE = -41; /* Protocol wrong type for socket */
const int E_ENOPROTOOPT = -42; /* Protocol not available */
const int E_EPROTONOSUPPORT = -43; /* Protocol not supported */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_ESOCKTNOSUPPORT = -44; /* Socket type not supported */
#endif
const int E_ENOTSUP = -45; /* Operation not supported */
#if !__DARWIN_UNIX03 && !defined(KERNEL)
/*
* This is the same for binary and source copmpatability, unless compiling
* the kernel itself, or compiling __DARWIN_UNIX03; if compiling for the
* kernel, the correct value will be returned. If compiling non-POSIX
* source, the kernel return value will be converted by a stub in libc, and
* if compiling source with __DARWIN_UNIX03, the conversion in libc is not
* done, and the caller gets the expected (discrete) value.
*/
const int E_EOPNOTSUPP = E_ENOTSUP; /* Operation not supported on socket */
#endif /* !__DARWIN_UNIX03 && !KERNEL */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EPFNOSUPPORT = -46; /* Protocol family not supported */
#endif
const int E_EAFNOSUPPORT = -47; /* Address family not supported by protocol family */
const int E_EADDRINUSE = -48; /* Address already in use */
const int E_EADDRNOTAVAIL = -49; /* Can't assign requested address */
/* ipc/network software -- operational errors */
const int E_ENETDOWN = -50; /* Network is down */
const int E_ENETUNREACH = -51; /* Network is unreachable */
const int E_ENETRESET = -52;/* Network dropped connection on reset */
const int E_ECONNABORTED = -53; /* Software caused connection abort */
const int E_ECONNRESET = -54; /* Connection reset by peer */
const int E_ENOBUFS = -55; /* No buffer space available */
const int E_EISCONN = -56; /* Socket is already connected */
const int E_ENOTCONN = -57; /* Socket is not connected */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_ESHUTDOWN = -58; /* Can't send after socket shutdown */
const int E_ETOOMANYREFS = -59; /* Too many references: can't splice */
#endif
const int E_ETIMEDOUT = -60; /* Operation timed out */
const int E_ECONNREFUSED = -61; /* Connection refused */
const int E_ELOOP = -62; /* Too many levels of symbolic links */
const int E_ENAMETOOLONG = -63; /* File name too long */
/* should be rearranged */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EHOSTDOWN = -64; /* Host is down */
#endif
const int E_EHOSTUNREACH = -65; /* No route to host */
const int E_ENOTEMPTY = -66; /* Directory not empty */
/* quotas & mush */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EPROCLIM = -67; /* Too many processes */
const int E_EUSERS = -68; /* Too many users */
#endif
const int E_EDQUOT = -69; /* Disc quota exceeded */
/* Network File System */
const int E_ESTALE = -70; /* Stale NFS file handle */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EREMOTE = -71; /* Too many levels of remote in path */
const int E_EBADRPC = -72; /* RPC struct is bad */
const int E_ERPCMISMATCH = -73; /* RPC version wrong */
const int E_EPROGUNAVAIL = -74; /* RPC prog. not avail */
const int E_EPROGMISMATCH = -75; /* Program version wrong */
const int E_EPROCUNAVAIL = -76; /* Bad procedure for program */
#endif
const int E_ENOLCK = -77; /* No locks available */
const int E_ENOSYS = -78; /* Function not implemented */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EFTYPE = -79; /* Inappropriate file type or format */
const int E_EAUTH = -80; /* Authentication error */
const int E_ENEEDAUTH = -81; /* Need authenticator */
/* Intelligent device errors */
const int E_EPWROFF = -82; /* Device power is off */
const int E_EDEVERR = -83; /* Device error, e.g. paper out */
#endif
const int E_EOVERFLOW = -84; /* Value too large to be stored in data type */
/* Program loading errors */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EBADEXEC = -85; /* Bad executable */
const int E_EBADARCH = -86; /* Bad CPU type in executable */
const int E_ESHLIBVERS = -87; /* Shared library version mismatch */
const int E_EBADMACHO = -88; /* Malformed Macho file */
#endif
const int E_ECANCELED = -89; /* Operation canceled */
const int E_EIDRM = -90; /* Identifier removed */
const int E_ENOMSG = -91; /* No message of desired type */
const int E_EILSEQ = -92; /* Illegal byte sequence */
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_ENOATTR = -93; /* Attribute not found */
#endif
const int E_EBADMSG = -94; /* Bad message */
const int E_EMULTIHOP = -95; /* Reserved */
const int E_ENODATA = -96; /* No message available on STREAM */
const int E_ENOLINK = -97; /* Reserved */
const int E_ENOSR = -98; /* No STREAM resources */
const int E_ENOSTR = -99; /* Not a STREAM */
const int E_EPROTO = -100; /* Protocol error */
const int E_ETIME = -101; /* STREAM ioctl timeout */
#if __DARWIN_UNIX03 || defined(KERNEL)
/* This value is only discrete when compiling __DARWIN_UNIX03, or KERNEL */
const int E_EOPNOTSUPP = -102; /* Operation not supported on socket */
#endif /* __DARWIN_UNIX03 || KERNEL */
const int E_ENOPOLICY = -103; /* No such policy registered */
#if __DARWIN_C_LEVEL >= 200809L
const int E_ENOTRECOVERABLE = -104; /* State not recoverable */
const int E_EOWNERDEAD = -105; /* Previous owner died */
#endif
#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
const int E_EQFULL = -106; /* Interface output queue is full */
const int E_ELAST = -106; /* Must be equal largest errno */
#endif
#elif defined(_NETP_GNU_LINUX) || defined(_NETP_ANDROID)
const int E_EPERM = -1; //operation not permitted
const int E_ENOENT = -2; //no such file or directory
const int E_ESRCH = -3; //no such process
const int E_EINTR = -4; //interrupted system call
const int E_EIO = -5; //I/O error
const int E_ENXIO = -6; //no such device or address
const int E_E2BIG = -7; //Arg list too long
const int E_ENOEXEC = -8; //Exec format error
const int E_EBADF = -9; //Bad file number
const int E_ECHILD = -10; //No child processes
const int E_EAGAIN = -11; //Try again
const int E_ENOMEM = -12; //Out of memory
const int E_EACCESS = -13; //Permission denied
const int E_EFAULT = -14; //Bad address
const int E_ENOTBLK = -15; //Block device required
const int E_EBUSY = -16; //Device or resource busy
const int E_EEXIST = -17; //File exists
const int E_EEXDEV = -18; //Cross-device link
const int E_ENODEV = -19; //No such device
const int E_ENOTDIR = -20; //Not a directory
const int E_EISDIR = -21; //Is a directory
const int E_EINVAL = -22; //Invalid argument
const int E_ENFILE = -23; //File table overflow
const int E_EMFILE = -24; //Too many open files
const int E_ENOTTY = -25; //Not a tty device
const int E_ETXTBSY = -26; //Text file busy
const int E_EFBIG = -27; //File too large
const int E_ENOSPC = -28; //No space left on device
const int E_ESPIPE = -29; //Illegal seek
const int E_EROFS = -30; //read-only file system
const int E_EMLINK = -31; //Too many links
const int E_EPIPE = -32; //broken pipe
const int E_EDOM = -33; //Math argument out of domain
const int E_ERANGE = -34; //Math result not representable
const int E_EDEADLK = -35; //dead lock wolld occur
const int E_ENAMETOOLONG = -36; //file too long
const int E_ENOLCK = -37; //No record locks available
const int E_ENOSYS = -38; //Function not implemented
const int E_ENOTEMPTY = -39; //dierctory not empty
const int E_ELOOP = -40; //too many symbolic links encountered
const int E_EWOULDBLOCK = -41; //same as EAGAIN
const int E_ENOMSG = -42; //No message of desired type
const int E_EIDRM = -43; //identifier removed
const int E_ECHRNG = -44; //channel number out of range
const int E_EL2NSYNC = -45; //level 2 not synchronized
const int E_EL3HLT = -46; //level 3 halted
const int E_EL3RST = -47; //level3 reset
const int E_ELNRNG = -48; //Link number out of range
const int E_EUNATCH = -49; //protocol driver not attached
const int E_ENOCSI = -50; //No CSI structure available
const int E_EL2HLT = -51; //Level 2 halted
const int E_EBADE = -52; //Invalid exchange
const int E_EBADR = -53; //Invalid request descriptor
const int E_EXFULL = -54; //Exchange full
const int E_ENOANO = -55; //No anode
const int E_EBADRQC = -56; //Invalid request code
const int E_EBADSLT = -57; //Invalid slot
const int E_EDEADLOCK = -58; //Same as EDEADLK
const int E_EBFONT = -59; //Bad font file format
const int E_ENOSTR = -60; //No data available
const int E_ENODATA = -61; //No data available
const int E_ETIME = -62; //Timer expired
const int E_ENOSR = -63; //Out of streams resources
const int E_ERROR_NETNAME_DELETED = -64; //WINDOWS IOCP: The specified network name is no longer available
const int E_ENONET = -64; //machine is not on network
const int E_ENOPKG = -65; //Package not installed
const int E_EREMOTE = -66; //Object is remote
const int E_ENOLINK = -67; //Link has been severed
const int E_EADV = -68; //Advertise error
const int E_ESRMNT = -69; //Srmount error
const int E_ECOMM = -70; //Communication error on send
const int E_EPROTO = -71; //protocol error
const int E_EMULTIHOP = -72; //Multihop attempted
const int E_EDOTDOT = -73; //RFS specific error
const int E_EBADMSG = -74; //Not a data message
const int E_EOVERFLOW = -75; //Value too large for defined data type
const int E_ENOTUNIQ = -76; //Name not unique on network
const int E_EBADFD = -77; //File descriptor in bad state
const int E_REMCHG = -78; //Remote address changed
const int E_ELIBACC = -79; //Cannot access a needed shared library
const int E_ELIBBAD = -80; //Accessing a corrupted shared library
const int E_ELIBSCN = -81; //A .lib section in an .out is corrupted
const int E_ELIMAX = -82; //Linking in too many shared libraries
const int E_ELIEXEC = -83; //Cannot exec a shared library directly
const int E_ELIILSEQ = -84; //Illegal byte sequence
const int E_ERESTART = -85; //Interrupted system call should be restarted
const int E_ESTRPIPE = -86; //Streams pipe error
const int E_EUSERS = -87; //Too many users
const int E_ENOTSOCK = -88; //socket operation on non-socket
const int E_EDESTADDRREQ = -89; //Destination address required
const int E_EMSGSIZE = -90; //Message too long
const int E_EPROTOTYPE = -91; //protocol wrong type for socket
const int E_ENOPROTOOPT = -92; //protocol not available
const int E_EPROTONOSUPPORT = -93; //protocol not supported
const int E_ESOCKTNOSUPPORT = -94; //socket type not supported
const int E_EOPNOTSUPP = -95; //Operation not supported on transport
const int E_EPFNOSUPPORT = -96; //protocol family not supported
const int E_EAFNOSUPPORT = -97; //address family not supported by protocol
const int E_EADDRINUSE = -98; //address already in use
const int E_EADDRNOTAVAIL = -99; //Cannot assign requested address
const int E_ENETDOWN = -100; //Network is down
const int E_ENETUNREACH = -101; //Network is unreachable
const int E_ENETRESET = -102; //Network dropped
const int E_ECONNABORTED = -103; //Software caused connection
const int E_ECONNRESET = -104; //Connection reset by
const int E_ENOBUFS = -105; //No buffer space available
const int E_EISCONN = -106; //Transport endpoint
const int E_ENOTCONN = -107; //Transport endpoint
const int E_ESHUTDOWN = -108; //Cannot send after transport
const int E_ETOOMANYREFS = -109; //Too many references
const int E_ETIMEOUT = -110; //Connection timed
const int E_ECONNREFUSED = -111; //Connection refused
const int E_EHOSTDOWN = -112; //Host is down
const int E_EHOSTUNREACH = -113; //No route to host
const int E_EALREADY = -114; //Operation already
const int E_EINPROGRESS = -115; //Operation now in
const int E_ESTALE = -116; //Stale NFS file handle
const int E_EUCLEAN = -117; //Structure needs cleaning
const int E_ENOTNAM = -118; //Not a XENIX-named
const int E_ENAVAIL = -119; //No XENIX semaphores
const int E_EISNAM = -120; //Is a named type file
const int E_EREMOTEIO = -121; //Remote I/O error
const int E_EDQUOT = -122; //Quota exceeded
const int E_ENOMEDIUM = -123; //No medium found
const int E_EMEDIUMTYPE = -124; //Wrong medium type
const int E_ECANCELED = -125;
const int E_ENOKEY = -126;
const int E_EKEYEXPIRED = -127;
const int E_EKEYREVOKED = -128;
const int E_EKEYREJECTED = -129;
const int E_EOWNERDEAD = -130;
const int E_ENOTRECOVERABLE = -131;
const int E_ERFKILL = -132;
const int E_EHWPOISON = -133;
#elif defined(_NETP_WIN)
const int E_ERROR_ACCESS_DENIED = -5;
const int E_WSA_INVALID_HANDLE = -6;
const int E_ERROR_HANDLE_EOF = -38;
const int E_WSA_INVALID_PARAMETER = -87;
const int E_ERROR_MORE_DATA = -234;
const int E_WAIT_TIMEOUT = -258;
const int E_ERROR_ABANDONED_WAIT_0 = -735;
const int E_WSA_OPERATION_ABORTED = -995;
const int E_WSA_IO_INCOMPLETE = -996;
const int E_WSA_IO_PENDING = -997;
const int E_ERROR_PRIVILEGE_NOT_HELD = -1314;
const int E_ERROR_CONNECTION_ABORTED = -1236;
// 1---19999; reserved for system call error code (windows)
const int E_WSAEINTR = -10004; // A blocking operation was interrupted by a call to WSACancelBlockingCall.
const int E_WSAEBADF = -10009; // The file handle supplied is not valid.
const int E_WSAEACCES = -10013; //An attempt was made to access a socket in a way forbidden by its access permissions.
const int E_WSAEFAULT = -10014; // The system detected an invalid pointer address in attempting to use a pointer argument in a call.
const int E_WSAEINVAL = -10022; // An invalid argument was supplied
const int E_WSAEMFILE = -10024; // Too many open sockets.
const int E_WSAEWOULDBLOCK = -10035; // A non-blocking socket operation could not be completed immediately.
const int E_WSAEINPROGRESS = -10036; // A blocking operation is currently executing.
const int E_WSAEALREADY = -10037; // An operation was attempted on a non-blocking socket that already had an operation in progress.
const int E_WSAENOTSOCK = -10038; // An operation was attempted on something that is not a socket.
const int E_WSAEMSGSIZE = -10040; // A message sent on a datagram socket was larger than the internal message buffer or some other network limit; or the buffer used to receive a datagram into was smaller than the datagram itself.
const int E_WSAEPROTOTYPE = -10041; //A protocol was specified in the socket function call that does not support the semantics of the socket type requested.
const int E_WSAENOPROTOOPT = -10042; //An unknown; invalid; or unsupported option or level was specified in a getsockopt or setsockopt call
const int E_WSAEPROTONOSUPPORT = -10043; //The requested protocol has not been configured into the system; or no implementation for it exists.
const int E_WSAESOCKTNOSUPPORT = -10044; //The support for the specified socket type does not exist in this address family
const int E_WSAEOPNOTSUPP = -10045; //The attempted operation is not supported for the type of object referenced.
const int E_WSAEPFNOSUPPORT = -10046; //The protocol family has not been configured into the system or no implementation for it exists
const int E_WSAEAFNOSUPPORT = -10047; //An address incompatible with the requested protocol was used
const int E_WSAEADDRINUSE = -10048; // Only one usage of each socket address (protocol/network address/port) is normally permitted.
const int E_WSAEADDRNOTAVAIL = -10049; // The requested address is not valid in its context.
const int E_WSAENETDOWN = -10050; //A socket operation encountered a dead network.
const int E_WSAENETUNREACH = -10051; // A socket operation was attempted to an unreachable network.
const int E_WSAENETRESET = -10052; // The connection has been broken due to keep-alive activity detecting a failure while the operation was in progress.
const int E_WSAECONNABORTED = -10053; // An established connection was aborted by the software in your host machine.
const int E_WSAECONNRESET = -10054; // An existing connection was forcibly closed by the remote host.
const int E_WSAENOBUFS = -10055; // An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full.
const int E_WSAEISCONN = -10056; // A request to send or receive data was disallowed because the socket is not connected and (when sending on a datagram socket using a sendto call) no address was supplied.
const int E_WSAENOTCONN = -10057; // A request to send or receive data was disallowed because the socket is not connected and (when sending on a datagram socket using a sendto call) no address was supplied.
const int E_WSAESHUTDOWN = -10058; //A request to send or receive data was disallowed because the socket had already been shut down in that direction with a previous shutdown call
const int E_WSAETOOMANYREFS = -10059; //Too many references to some kernel object.
const int E_WSAETIMEDOUT = -10060; //A connection attempt failed because the connected party did not properly respond after a period of time; or established connection failed because connected host has failed to respond.
const int E_WSAECONNREFUSED = -10061; //No connection could be made because the target machine actively refused it.
const int E_WSAELOOP = -10062; //Cannot translate name
const int E_WSAEHOSTDOWN = -10064; // A socket operation failed because the destination host was down
const int E_WSAEHOSTUNREACH = -10065; // A socket operation was attempted to an unreachable host.
const int E_WSAEPROCLIM = -10067; // A Windows Sockets implementation may have a limit on the number of applications that may use it simultaneously.
const int E_WSAEUSERS = -10068;
const int E_WSAEDQUOT = -10069;
const int E_WSASYSNOTREADY = -10091;
const int E_WSANOTINITIALISED = -10093;
const int E_WSAEPROVIDERFAILEDINIT = -10106;
const int E_WSASYSCALLFAILURE = -10107;
const int E_WSASERVICE_NOT_FOUND = -10108;
const int E_WSATYPE_NOT_FOUND = -10109;
const int E_WSA_E_NO_MORE = -10110;
const int E_WSA_E_CANCELLED = -10111;
const int E_WSAEREFUSED = -10112;
const int E_WSAHOST_NOT_FOUND = -11001;
const int E_WSATRY_AGAIN = -11002;
const int E_WSANO_RECOVERY = -11003;
const int E_WSANO_DATA = -11004;
const int E_WSA_QOS_RECEIVERS = -11005;
const int E_WSA_QOS_SENDERS = -11006;
const int E_ECONNABORTED = E_WSAECONNABORTED;
const int E_EINTR = E_WSAEINTR;
const int E_EWOULDBLOCK = E_WSAEWOULDBLOCK;
const int E_EAGAIN = E_EWOULDBLOCK;
const int E_EINPROGRESS = E_WSAEWOULDBLOCK; //pls refer tohttps://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect
const int E_EMFILE = E_WSAEMFILE;
const int E_EACCESS = E_WSAEACCES;
const int E_EBADF = E_WSAEBADF;
const int E_EALREADY = E_WSAEALREADY;
const int E_ECONNRESET = E_WSAECONNRESET;
const int E_ETIMEOUT = E_WSAETIMEDOUT;
const int E_EADDRINUSE = E_WSAEADDRINUSE;
const int E_EINVAL = E_WSAEINVAL;
const int E_ENOTCONN = E_WSAENOTCONN;
#endif
//internal error
const int E_NETP_APP_EXIT = -20000;
const int E_NO_NET_DEV = -20001;
const int E_INVALID_OPERATION = -20002;
const int E_INVALID_STATE = -20003;
const int E_MEMORY_MALLOC_FAILED = -20004;
const int E_MEMORY_ACCESS_ERROR = -20005;
const int E_MEMORY_ALLOC_FAILED = -20006;
const int E_MEMORY_NEW_FAILED = -20007;
const int E_TRY_AGAIN = -20008;
const int E_INVAL = -20009;
const int E_ASSERT_FAILED = -20010;
const int E_NETP_THROW = -20011;
const int E_UNKNOWN = -20012;
const int E_THREAD_INTERRUPT = -20013;
const int E_TODO = -20014;
const int E_BAD_CAST = -20015;
const int E_OP_INPROCESS = -20016;
const int E_OP_ABORT = -20017;
const int E_OP_TIMEOUT = -20018;
const int E_OP_ALREADY = -20019;
const int E_EVENT_BROKER_BINDED_ALREADY = -21001;
const int E_EVENT_BROKER_NO_LISTENER = -21002;
const int E_XXTEA_INVALID_DATA = -22001;
const int E_XXTEA_DECRYPT_FAILED = -22002;
const int E_XXTEA_ENCRYPT_FAILED = -22003;
const int E_DH_HANDSHAKE_MESSAGE_CHECK_FAILED = -22011;
const int E_DH_HANDSHAKE_FAILED = -22012;
const int E_IO_EVENT_LOOP_NOTIFY_TERMINATING = -25001;
const int E_IO_EVENT_LOOP_TERMINATED = -25002;
const int E_IO_EVENT_LOOP_BYE_DO_NOTHING = -25003;
const int E_IO_BEGIN_FAILED = -25004;
//30000 - 30999 //system level socket error
const int E_SOCKET_EPOLLHUP = -30001;
const int E_SOCKET_GRACE_CLOSE = -30002;
//31000 - 31999 //user custom socket error
const int E_SOCKET_INVALID_FAMILY = -31001;
const int E_SOCKET_INVALID_TYPE = -31002;
const int E_SOCKET_INVALID_ADDRESS = -31003;
const int E_SOCKET_INVALID_PROTOCOL = -31004;
const int E_SOCKET_INVALID_STATE = -31005;
const int E_SOCKET_SELF_CONNCTED = -31006;
const int E_SOCKET_READ_CLOSED_ALREADY = -31007;
const int E_SOCKET_WRITE_CLOSED_ALREADY = -31008;
const int E_SOCKET_NO_AVAILABLE_ADDR = -31009;
const int E_SOCKET_OP_ALREADY = -31010;
const int E_CHANNEL_BDLIMIT = -34001;
const int E_CHANNEL_READ_BLOCK = -34002;
const int E_CHANNEL_WRITE_BLOCK = -34003;
const int E_CHANNEL_READ_CLOSED = -34004;
const int E_CHANNEL_WRITE_CLOSED = -34005;
const int E_CHANNEL_INVALID_STATE = -34006;
const int E_CHANNEL_NOT_EXISTS = -34007;
const int E_CHANNEL_EXISTS = -34008;
const int E_CHANNEL_CLOSED = -34009;
const int E_CHANNEL_CLOSING = -34010;
const int E_CHANNEL_WRITE_SHUTDOWNING = -34011;
const int E_CHANNEL_WRITING = -34012;
const int E_CHANNEL_OUTGO_LIST_EMPTY = -34013; //FOR IOCP
const int E_CHANNEL_READ_WRITE_ERROR = -34014;
const int E_CHANNEL_ABORT = -34015;
const int E_CHANNEL_CONTEXT_REMOVED = -34016;
const int E_CHANNEL_OVERLAPPED_OP_TRY = -34017;
const int E_CHANNEL_MISSING_MAKER = -34018;//custom socket channel must have its own maker
const int E_FORWARDER_DOMAIN_LEN_EXCEED = -35001;
const int E_FORWARDER_INVALID_IPV4 = -35002;
const int E_FORWARDER_DIAL_DST_FAILED = -35003;
const int E_DNS_LOOKUP_RETURN_NO_IP = -36001;
const int E_DNS_TEMPORARY_ERROR = -36002;
const int E_DNS_PROTOCOL_ERROR = -36003;
const int E_DNS_DOMAIN_NAME_NOT_EXISTS = -36004;
const int E_DNS_DOMAIN_NO_DATA = -36005;
const int E_DNS_NOMEM = -36006;
const int E_DNS_BADQUERY = -36007;
const int E_DNS_SERVER_SHUTDOWN = -36008;
const int E_MUX_STREAM_TRANSPORT_CLOSED = -37001;
const int E_MUX_STREAM_RST = -37002;
const int E_RPC_NO_WRITE_CHANNEL = -40001;
const int E_RPC_CALL_UNKNOWN_API = -40002;
const int E_RPC_CALL_INVALID_PARAM = -40003;
const int E_RPC_CALL_ERROR_UNKNOWN = -40004;
const int E_RPC_CALL_CANCEL = -40005;
const int E_RPC_CALL_TIMEOUT = -40006;
const int E_RPC_WRITE_TIMEOUT = -40007;
const int E_RPC_CONNECT_ABORT = -40008;
const int E_RPC_MESSAGE_DECODE_FAILED = -40009;
const int E_HTTP_CLIENT_REQ_IN_OP = -41001;
const int E_HTTP_MESSAGE_INVALID_TYPE = -41002;
const int E_HTTP_REQUEST_NOT_DONE = -41003;
const int E_HTTP_INVALID_HOST = -41004;
const int E_HTTP_INVALID_OP = -41005;
const int E_HTTP_REQ_TIMEOUT = -41006;
const int E_HTTP_CLIENT_DIAL_CANCEL = -41007;
const int E_HTTP_CLIENT_CLOSING = -41008;
const int E_HTTP_EMPTY_FILED_NAME = -41009;
} //endif netp ns
#endif //END OF NETP_ERROR_HEADER
| 50.513321 | 236 | 0.674215 | cainiaoDJ |
28b5ef0e98123bbcae16199980e1ed619eb5e3f4 | 103,207 | inl | C++ | Src/FEMTree.IsoSurface.specialized.inl | DamonsJ/PoissonRecon | fec7801bd10a02bbb9036b52de5f7c3955f399dc | [
"MIT"
] | 15 | 2021-05-26T11:47:59.000Z | 2022-01-20T12:34:15.000Z | Src/FEMTree.IsoSurface.specialized.inl | DamonsJ/PoissonRecon | fec7801bd10a02bbb9036b52de5f7c3955f399dc | [
"MIT"
] | 7 | 2021-06-08T08:35:00.000Z | 2021-11-07T10:27:30.000Z | Src/FEMTree.IsoSurface.specialized.inl | DamonsJ/PoissonRecon | fec7801bd10a02bbb9036b52de5f7c3955f399dc | [
"MIT"
] | 14 | 2017-03-16T10:09:22.000Z | 2021-12-28T03:53:18.000Z | /*
Copyright (c) 2006, Michael Kazhdan and Matthew Bolitho
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the distribution.
Neither the name of the Johns Hopkins University nor the names of its contributors
may be used to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/
#include <sstream>
#include <sstream>
#include <iomanip>
#include <unordered_map>
#include "MyMiscellany.h"
#include "MarchingCubes.h"
#include "MAT.h"
// Specialized iso-surface extraction
template< class Real , class Vertex >
struct IsoSurfaceExtractor< 3 , Real , Vertex >
{
static const unsigned int Dim = 3;
typedef typename FEMTree< Dim , Real >::LocalDepth LocalDepth;
typedef typename FEMTree< Dim , Real >::LocalOffset LocalOffset;
typedef typename FEMTree< Dim , Real >::ConstOneRingNeighborKey ConstOneRingNeighborKey;
typedef typename FEMTree< Dim , Real >::ConstOneRingNeighbors ConstOneRingNeighbors;
typedef RegularTreeNode< Dim , FEMTreeNodeData , depth_and_offset_type > TreeNode;
template< unsigned int WeightDegree > using DensityEstimator = typename FEMTree< Dim , Real >::template DensityEstimator< WeightDegree >;
template< typename FEMSigPack , unsigned int PointD > using _Evaluator = typename FEMTree< Dim , Real >::template _Evaluator< FEMSigPack , PointD >;
protected:
static std::mutex _pointInsertionMutex;
static std::atomic< size_t > _BadRootCount;
//////////
// _Key //
//////////
struct _Key
{
int idx[Dim];
_Key( void ){ for( unsigned int d=0 ; d<Dim ; d++ ) idx[d] = 0; }
int &operator[]( int i ){ return idx[i]; }
const int &operator[]( int i ) const { return idx[i]; }
bool operator == ( const _Key &key ) const
{
for( unsigned int d=0 ; d<Dim ; d++ ) if( idx[d]!=key[d] ) return false;
return true;
}
bool operator != ( const _Key &key ) const { return !operator==( key ); }
std::string to_string( void ) const
{
std::stringstream stream;
stream << "(";
for( unsigned int d=0 ; d<Dim ; d++ )
{
if( d ) stream << ",";
stream << idx[d];
}
stream << ")";
return stream.str();
}
struct Hasher
{
size_t operator()( const _Key &i ) const
{
size_t hash = 0;
for( unsigned int d=0 ; d<Dim ; d++ ) hash ^= i.idx[d];
return hash;
}
};
};
//////////////
// _IsoEdge //
//////////////
struct _IsoEdge
{
_Key vertices[2];
_IsoEdge( void ) {}
_IsoEdge( _Key v1 , _Key v2 ){ vertices[0] = v1 , vertices[1] = v2; }
_Key &operator[]( int idx ){ return vertices[idx]; }
const _Key &operator[]( int idx ) const { return vertices[idx]; }
};
////////////////
// _FaceEdges //
////////////////
struct _FaceEdges{ _IsoEdge edges[2] ; int count; };
///////////////
// SliceData //
///////////////
class SliceData
{
typedef RegularTreeNode< Dim , FEMTreeNodeData , depth_and_offset_type > TreeOctNode;
public:
template< unsigned int Indices >
struct _Indices
{
node_index_type idx[Indices];
_Indices( void ){ for( unsigned int i=0 ; i<Indices ; i++ ) idx[i] = -1; }
node_index_type& operator[] ( int i ) { return idx[i]; }
const node_index_type& operator[] ( int i ) const { return idx[i]; }
};
typedef _Indices< HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() > SquareCornerIndices;
typedef _Indices< HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() > SquareEdgeIndices;
typedef _Indices< HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() > SquareFaceIndices;
struct SliceTableData
{
Pointer( SquareCornerIndices ) cTable;
Pointer( SquareEdgeIndices ) eTable;
Pointer( SquareFaceIndices ) fTable;
node_index_type nodeOffset;
node_index_type cCount , eCount , fCount;
node_index_type nodeCount;
SliceTableData( void ){ fCount = eCount = cCount = 0 , _oldNodeCount = 0 , cTable = NullPointer( SquareCornerIndices ) , eTable = NullPointer( SquareEdgeIndices ) , fTable = NullPointer( SquareFaceIndices ) , _cMap = _eMap = _fMap = NullPointer( node_index_type ) , _processed = NullPointer( char ); }
void clear( void ){ DeletePointer( cTable ) ; DeletePointer( eTable ) ; DeletePointer( fTable ) ; DeletePointer( _cMap ) ; DeletePointer( _eMap ) ; DeletePointer( _fMap ) ; DeletePointer( _processed ) ; fCount = eCount = cCount = 0; }
~SliceTableData( void ){ clear(); }
SquareCornerIndices& cornerIndices( const TreeOctNode* node ) { return cTable[ node->nodeData.nodeIndex - nodeOffset ]; }
SquareCornerIndices& cornerIndices( node_index_type idx ) { return cTable[ idx - nodeOffset ]; }
const SquareCornerIndices& cornerIndices( const TreeOctNode* node ) const { return cTable[ node->nodeData.nodeIndex - nodeOffset ]; }
const SquareCornerIndices& cornerIndices( node_index_type idx ) const { return cTable[ idx - nodeOffset ]; }
SquareEdgeIndices& edgeIndices( const TreeOctNode* node ) { return eTable[ node->nodeData.nodeIndex - nodeOffset ]; }
SquareEdgeIndices& edgeIndices( node_index_type idx ) { return eTable[ idx - nodeOffset ]; }
const SquareEdgeIndices& edgeIndices( const TreeOctNode* node ) const { return eTable[ node->nodeData.nodeIndex - nodeOffset ]; }
const SquareEdgeIndices& edgeIndices( node_index_type idx ) const { return eTable[ idx - nodeOffset ]; }
SquareFaceIndices& faceIndices( const TreeOctNode* node ) { return fTable[ node->nodeData.nodeIndex - nodeOffset ]; }
SquareFaceIndices& faceIndices( node_index_type idx ) { return fTable[ idx - nodeOffset ]; }
const SquareFaceIndices& faceIndices( const TreeOctNode* node ) const { return fTable[ node->nodeData.nodeIndex - nodeOffset ]; }
const SquareFaceIndices& faceIndices( node_index_type idx ) const { return fTable[ idx - nodeOffset ]; }
protected:
Pointer( node_index_type ) _cMap;
Pointer( node_index_type ) _eMap;
Pointer( node_index_type ) _fMap;
Pointer( char ) _processed;
node_index_type _oldNodeCount;
friend SliceData;
};
struct XSliceTableData
{
Pointer( SquareCornerIndices ) eTable;
Pointer( SquareEdgeIndices ) fTable;
node_index_type nodeOffset;
node_index_type fCount , eCount;
node_index_type nodeCount;
XSliceTableData( void ){ fCount = eCount = 0 , _oldNodeCount = 0 , eTable = NullPointer( SquareCornerIndices ) , fTable = NullPointer( SquareEdgeIndices ) , _eMap = _fMap = NullPointer( node_index_type ); }
~XSliceTableData( void ){ clear(); }
void clear( void ) { DeletePointer( fTable ) ; DeletePointer( eTable ) ; DeletePointer( _eMap ) ; DeletePointer( _fMap ) ; fCount = eCount = 0; }
SquareCornerIndices& edgeIndices( const TreeOctNode* node ) { return eTable[ node->nodeData.nodeIndex - nodeOffset ]; }
SquareCornerIndices& edgeIndices( node_index_type idx ) { return eTable[ idx - nodeOffset ]; }
const SquareCornerIndices& edgeIndices( const TreeOctNode* node ) const { return eTable[ node->nodeData.nodeIndex - nodeOffset ]; }
const SquareCornerIndices& edgeIndices( node_index_type idx ) const { return eTable[ idx - nodeOffset ]; }
SquareEdgeIndices& faceIndices( const TreeOctNode* node ) { return fTable[ node->nodeData.nodeIndex - nodeOffset ]; }
SquareEdgeIndices& faceIndices( node_index_type idx ) { return fTable[ idx - nodeOffset ]; }
const SquareEdgeIndices& faceIndices( const TreeOctNode* node ) const { return fTable[ node->nodeData.nodeIndex - nodeOffset ]; }
const SquareEdgeIndices& faceIndices( node_index_type idx ) const { return fTable[ idx - nodeOffset ]; }
protected:
Pointer( node_index_type ) _eMap;
Pointer( node_index_type ) _fMap;
node_index_type _oldNodeCount;
friend SliceData;
};
template< unsigned int D , unsigned int ... Ks > struct HyperCubeTables{};
template< unsigned int D , unsigned int K >
struct HyperCubeTables< D , K >
{
static unsigned int CellOffset[ HyperCube::Cube< D >::template ElementNum< K >() ][ HyperCube::Cube< D >::template IncidentCubeNum< K >() ];
static unsigned int IncidentElementCoIndex[ HyperCube::Cube< D >::template ElementNum< K >() ][ HyperCube::Cube< D >::template IncidentCubeNum< K >() ];
static unsigned int CellOffsetAntipodal[ HyperCube::Cube< D >::template ElementNum< K >() ];
static typename HyperCube::Cube< D >::template IncidentCubeIndex< K > IncidentCube[ HyperCube::Cube< D >::template ElementNum< K >() ];
static typename HyperCube::Direction Directions[ HyperCube::Cube< D >::template ElementNum< K >() ][ D ];
static void SetTables( void )
{
for( typename HyperCube::Cube< D >::template Element< K > e ; e<HyperCube::Cube< D >::template ElementNum< K >() ; e++ )
{
for( typename HyperCube::Cube< D >::template IncidentCubeIndex< K > i ; i<HyperCube::Cube< D >::template IncidentCubeNum< K >() ; i++ )
{
CellOffset[e.index][i.index] = HyperCube::Cube< D >::CellOffset( e , i );
IncidentElementCoIndex[e.index][i.index] = HyperCube::Cube< D >::IncidentElement( e , i ).coIndex();
}
CellOffsetAntipodal[e.index] = HyperCube::Cube< D >::CellOffset( e , HyperCube::Cube< D >::IncidentCube( e ).antipodal() );
IncidentCube[ e.index ] = HyperCube::Cube< D >::IncidentCube( e );
e.directions( Directions[e.index] );
}
}
};
template< unsigned int D , unsigned int K1 , unsigned int K2 >
struct HyperCubeTables< D , K1 , K2 >
{
static typename HyperCube::Cube< D >::template Element< K2 > OverlapElements[ HyperCube::Cube< D >::template ElementNum< K1 >() ][ HyperCube::Cube< D >::template OverlapElementNum< K1 , K2 >() ];
static bool Overlap[ HyperCube::Cube< D >::template ElementNum< K1 >() ][ HyperCube::Cube< D >::template ElementNum< K2 >() ];
static void SetTables( void )
{
for( typename HyperCube::Cube< D >::template Element< K1 > e ; e<HyperCube::Cube< D >::template ElementNum< K1 >() ; e++ )
{
for( typename HyperCube::Cube< D >::template Element< K2 > _e ; _e<HyperCube::Cube< D >::template ElementNum< K2 >() ; _e++ )
Overlap[e.index][_e.index] = HyperCube::Cube< D >::Overlap( e , _e );
HyperCube::Cube< D >::OverlapElements( e , OverlapElements[e.index] );
}
if( !K2 ) HyperCubeTables< D , K1 >::SetTables();
}
};
template< unsigned int D=Dim , unsigned int K1=Dim , unsigned int K2=Dim > static typename std::enable_if< K2!=0 >::type SetHyperCubeTables( void )
{
HyperCubeTables< D , K1 , K2 >::SetTables() ; SetHyperCubeTables< D , K1 , K2-1 >();
}
template< unsigned int D=Dim , unsigned int K1=Dim , unsigned int K2=Dim > static typename std::enable_if< K1!=0 && K2==0 >::type SetHyperCubeTables( void )
{
HyperCubeTables< D , K1 , K2 >::SetTables(); SetHyperCubeTables< D , K1-1 , D >();
}
template< unsigned int D=Dim , unsigned int K1=Dim , unsigned int K2=Dim > static typename std::enable_if< D!=1 && K1==0 && K2==0 >::type SetHyperCubeTables( void )
{
HyperCubeTables< D , K1 , K2 >::SetTables() ; SetHyperCubeTables< D-1 , D-1 , D-1 >();
}
template< unsigned int D=Dim , unsigned int K1=Dim , unsigned int K2=Dim > static typename std::enable_if< D==1 && K1==0 && K2==0 >::type SetHyperCubeTables( void )
{
HyperCubeTables< D , K1 , K2 >::SetTables();
}
static void SetSliceTableData( const SortedTreeNodes< Dim >& sNodes , SliceTableData* sData0 , XSliceTableData* xData , SliceTableData* sData1 , int depth , int offset )
{
// [NOTE] This is structure is purely for determining adjacency and is independent of the FEM degree
typedef typename FEMTree< Dim , Real >::ConstOneRingNeighborKey ConstOneRingNeighborKey;
if( offset<0 || offset>((size_t)1<<depth) ) return;
if( sData0 )
{
std::pair< node_index_type , node_index_type > span( sNodes.begin( depth , offset-1 ) , sNodes.end( depth , offset ) );
sData0->nodeOffset = span.first , sData0->nodeCount = span.second - span.first;
}
if( sData1 )
{
std::pair< node_index_type , node_index_type > span( sNodes.begin( depth , offset ) , sNodes.end( depth , offset+1 ) );
sData1->nodeOffset = span.first , sData1->nodeCount = span.second - span.first;
}
if( xData )
{
std::pair< node_index_type , node_index_type > span( sNodes.begin( depth , offset ) , sNodes.end( depth , offset ) );
xData->nodeOffset = span.first , xData->nodeCount = span.second - span.first;
}
SliceTableData* sData[] = { sData0 , sData1 };
for( int i=0 ; i<2 ; i++ ) if( sData[i] )
{
if( sData[i]->nodeCount>sData[i]->_oldNodeCount )
{
DeletePointer( sData[i]->_cMap ) ; DeletePointer( sData[i]->_eMap ) ; DeletePointer( sData[i]->_fMap );
DeletePointer( sData[i]->cTable ) ; DeletePointer( sData[i]->eTable ) ; DeletePointer( sData[i]->fTable );
DeletePointer( sData[i]->_processed );
sData[i]->_cMap = NewPointer< node_index_type >( sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() );
sData[i]->_eMap = NewPointer< node_index_type >( sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() );
sData[i]->_fMap = NewPointer< node_index_type >( sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() );
sData[i]->_processed = NewPointer< char >( sData[i]->nodeCount );
sData[i]->cTable = NewPointer< typename SliceData::SquareCornerIndices >( sData[i]->nodeCount );
sData[i]->eTable = NewPointer< typename SliceData::SquareEdgeIndices >( sData[i]->nodeCount );
sData[i]->fTable = NewPointer< typename SliceData::SquareFaceIndices >( sData[i]->nodeCount );
sData[i]->_oldNodeCount = sData[i]->nodeCount;
}
memset( sData[i]->_cMap , 0 , sizeof(node_index_type) * sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() );
memset( sData[i]->_eMap , 0 , sizeof(node_index_type) * sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() );
memset( sData[i]->_fMap , 0 , sizeof(node_index_type) * sData[i]->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() );
memset( sData[i]->_processed , 0 , sizeof(char) * sData[i]->nodeCount );
}
if( xData )
{
if( xData->nodeCount>xData->_oldNodeCount )
{
DeletePointer( xData->_eMap ) ; DeletePointer( xData->_fMap );
DeletePointer( xData->eTable ) ; DeletePointer( xData->fTable );
xData->_eMap = NewPointer< node_index_type >( xData->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() );
xData->_fMap = NewPointer< node_index_type >( xData->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() );
xData->eTable = NewPointer< typename SliceData::SquareCornerIndices >( xData->nodeCount );
xData->fTable = NewPointer< typename SliceData::SquareEdgeIndices >( xData->nodeCount );
xData->_oldNodeCount = xData->nodeCount;
}
memset( xData->_eMap , 0 , sizeof(node_index_type) * xData->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() );
memset( xData->_fMap , 0 , sizeof(node_index_type) * xData->nodeCount * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() );
}
std::vector< ConstOneRingNeighborKey > neighborKeys( ThreadPool::NumThreads() );
for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( depth );
typedef typename FEMTree< Dim , Real >::ConstOneRingNeighbors ConstNeighbors;
// Process the corners
// z: which side of the cell \in {0,1}
// zOff: which neighbor \in {-1,0,1}
auto ProcessCorners = []( SliceTableData& sData , const ConstNeighbors& neighbors , HyperCube::Direction zDir , int zOff )
{
const TreeOctNode* node = neighbors.neighbors[1][1][1+zOff];
node_index_type i = node->nodeData.nodeIndex;
// Iterate over the corners in the face
for( typename HyperCube::Cube< Dim-1 >::template Element< 0 > _c ; _c<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; _c++ )
{
bool owner = true;
typename HyperCube::Cube< Dim >::template Element< 0 > c( zDir , _c.index ); // Corner-in-cube index
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 0 > my_ic = HyperCubeTables< Dim , 0 >::IncidentCube[c.index]; // The index of the node relative to the corner
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 0 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 0 >() ; ic++ ) // Iterate over the nodes adjacent to the corner
{
// Get the index of cube relative to the corner neighbors
unsigned int xx = HyperCubeTables< Dim , 0 >::CellOffset[c.index][ic.index] + zOff;
// If the neighbor exists and comes before, they own the corner
if( neighbors.neighbors.data[xx] && ic<my_ic ){ owner = false ; break; }
}
if( owner )
{
node_index_type myCount = ( i-sData.nodeOffset ) * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() + _c.index;
sData._cMap[ myCount ] = 1;
// Set the corner pointer for all cubes incident on the corner
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 0 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 0 >() ; ic++ ) // Iterate over the nodes adjacent to the corner
{
unsigned int xx = HyperCubeTables< Dim , 0 >::CellOffset[c.index][ic.index] + zOff;
// If the neighbor exits, sets its corner
if( neighbors.neighbors.data[xx] ) sData.cornerIndices( neighbors.neighbors.data[xx] )[ HyperCubeTables< Dim , 0 >::IncidentElementCoIndex[c.index][ic.index] ] = myCount;
}
}
}
};
// Process the in-plane edges
auto ProcessIEdges = []( SliceTableData& sData , const ConstNeighbors& neighbors , HyperCube::Direction zDir , int zOff )
{
const TreeOctNode* node = neighbors.neighbors[1][1][1+zOff];
node_index_type i = node->nodeData.nodeIndex;
// Iterate over the edges in the face
for( typename HyperCube::Cube< Dim-1 >::template Element< 1 > _e ; _e<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; _e++ )
{
bool owner = true;
// The edge in the cube
typename HyperCube::Cube< Dim >::template Element< 1 > e( zDir , _e.index );
// The index of the cube relative to the edge
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > my_ic = HyperCubeTables< Dim , 1 >::IncidentCube[e.index];
// Iterate over the cubes incident on the edge
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ )
{
// Get the indices of the cube relative to the center
unsigned int xx = HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index] + zOff;
// If the neighbor exists and comes before, they own the corner
if( neighbors.neighbors.data[xx] && ic<my_ic ){ owner = false ; break; }
}
if( owner )
{
node_index_type myCount = ( i - sData.nodeOffset ) * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() + _e.index;
sData._eMap[ myCount ] = 1;
// Set all edge indices
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index] + zOff;
// If the neighbor exists, set the index
if( neighbors.neighbors.data[xx] ) sData.edgeIndices( neighbors.neighbors.data[xx] )[ HyperCubeTables< Dim , 1 >::IncidentElementCoIndex[e.index][ic.index] ] = myCount;
}
}
}
};
// Process the cross-plane edges
auto ProcessXEdges = []( XSliceTableData& xData , const ConstNeighbors& neighbors )
{
const TreeOctNode* node = neighbors.neighbors[1][1][1];
node_index_type i = node->nodeData.nodeIndex;
for( typename HyperCube::Cube< Dim-1 >::template Element< 0 > _c ; _c<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; _c++ )
{
bool owner = true;
typename HyperCube::Cube< Dim >::template Element< 1 > e( HyperCube::CROSS , _c.index );
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > my_ic = HyperCubeTables< Dim , 1 >::IncidentCube[e.index];
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index];
if( neighbors.neighbors.data[xx] && ic<my_ic ){ owner = false ; break; }
}
if( owner )
{
node_index_type myCount = ( i - xData.nodeOffset ) * HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() + _c.index;
xData._eMap[ myCount ] = 1;
// Set all edge indices
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index];
if( neighbors.neighbors.data[xx] ) xData.edgeIndices( neighbors.neighbors.data[xx] )[ HyperCubeTables< Dim , 1 >::IncidentElementCoIndex[e.index][ic.index] ] = myCount;
}
}
}
};
// Process the in-plane faces
auto ProcessIFaces = []( SliceTableData& sData , const ConstNeighbors& neighbors , HyperCube::Direction zDir , int zOff )
{
const TreeOctNode* node = neighbors.neighbors[1][1][1+zOff];
node_index_type i = node->nodeData.nodeIndex;
for( typename HyperCube::Cube< Dim-1 >::template Element< 2 > _f ; _f<HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() ; _f++ )
{
bool owner = true;
typename HyperCube::Cube< Dim >::template Element< 2 > f( zDir , _f.index );
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > my_ic = HyperCubeTables< Dim , 2 >::IncidentCube[f.index];
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 2 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 2 >::CellOffset[f.index][ic.index] + zOff;
if( neighbors.neighbors.data[xx] && ic<my_ic ){ owner = false ; break; }
}
if( owner )
{
node_index_type myCount = ( i - sData.nodeOffset ) * HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() + _f.index;
sData._fMap[ myCount ] = 1;
// Set all the face indices
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 2 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 2 >::CellOffset[f.index][ic.index] + zOff;
if( neighbors.neighbors.data[xx] ) sData.faceIndices( neighbors.neighbors.data[xx] )[ HyperCubeTables< Dim , 2 >::IncidentElementCoIndex[f.index][ic.index] ] = myCount;
}
}
}
};
// Process the cross-plane faces
auto ProcessXFaces = []( XSliceTableData& xData , const ConstNeighbors& neighbors )
{
const TreeOctNode* node = neighbors.neighbors[1][1][1];
node_index_type i = node->nodeData.nodeIndex;
for( typename HyperCube::Cube< Dim-1 >::template Element< 1 > _e ; _e<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; _e++ )
{
bool owner = true;
typename HyperCube::Cube< Dim >::template Element< 2 > f( HyperCube::CROSS , _e.index );
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > my_ic = HyperCubeTables< Dim , 2 >::IncidentCube[f.index];
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 2 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 2 >::CellOffset[f.index][ic.index];
if( neighbors.neighbors.data[xx] && ic<my_ic ){ owner = false ; break; }
}
if( owner )
{
node_index_type myCount = ( i - xData.nodeOffset ) * HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() + _e.index;
xData._fMap[ myCount ] = 1;
// Set all the face indices
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 2 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 2 >() ; ic++ )
{
unsigned int xx = HyperCubeTables< Dim , 2 >::CellOffset[f.index][ic.index];
if( neighbors.neighbors.data[xx] ) xData.faceIndices( neighbors.neighbors.data[xx] )[ HyperCubeTables< Dim , 2 >::IncidentElementCoIndex[f.index][ic.index] ] = myCount;
}
}
}
};
// Try and get at the nodes outside of the slab through the neighbor key
ThreadPool::Parallel_for( sNodes.begin(depth,offset) , sNodes.end(depth,offset) , [&]( unsigned int thread , size_t i )
{
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
const TreeOctNode* node = sNodes.treeNodes[i];
ConstNeighbors& neighbors = neighborKey.getNeighbors( node );
for( int i=0 ; i<3 ; i++ ) for( int j=0 ; j<3 ; j++ ) for( int k=0 ; k<3 ; k++ ) if( !IsActiveNode< Dim >( neighbors.neighbors[i][j][k] ) ) neighbors.neighbors[i][j][k] = NULL;
if( sData0 )
{
ProcessCorners( *sData0 , neighbors , HyperCube::BACK , 0 ) , ProcessIEdges( *sData0 , neighbors , HyperCube::BACK , 0 ) , ProcessIFaces( *sData0 , neighbors , HyperCube::BACK , 0 );
const TreeOctNode* _node = neighbors.neighbors[1][1][0];
if( _node )
{
ProcessCorners( *sData0 , neighbors , HyperCube::FRONT , -1 ) , ProcessIEdges( *sData0 , neighbors , HyperCube::FRONT , -1 ) , ProcessIFaces( *sData0 , neighbors , HyperCube::FRONT , -1 );
sData0->_processed[ _node->nodeData.nodeIndex - sNodes.begin(depth,offset-1) ] = 1;
}
}
if( sData1 )
{
ProcessCorners( *sData1 , neighbors , HyperCube::FRONT , 0 ) , ProcessIEdges( *sData1 , neighbors , HyperCube::FRONT , 0 ) , ProcessIFaces( *sData1 , neighbors , HyperCube::FRONT , 0 );
const TreeOctNode* _node = neighbors.neighbors[1][1][2];
if( _node )
{
ProcessCorners( *sData1 , neighbors , HyperCube::BACK , 1 ) , ProcessIEdges( *sData1 , neighbors , HyperCube::BACK , 1 ) , ProcessIFaces( *sData1, neighbors , HyperCube::BACK , 1 );
sData1->_processed[ _node->nodeData.nodeIndex - sNodes.begin(depth,offset+1) ] = true;
}
}
if( xData ) ProcessXEdges( *xData , neighbors ) , ProcessXFaces( *xData , neighbors );
}
);
if( sData0 )
{
node_index_type off = sNodes.begin(depth,offset-1);
node_index_type size = sNodes.end(depth,offset-1) - sNodes.begin(depth,offset-1);
ThreadPool::Parallel_for( 0 , size , [&]( unsigned int thread , size_t i )
{
if( !sData0->_processed[i] )
{
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
const TreeOctNode* node = sNodes.treeNodes[i+off];
ConstNeighbors& neighbors = neighborKey.getNeighbors( node );
for( int i=0 ; i<3 ; i++ ) for( int j=0 ; j<3 ; j++ ) for( int k=0 ; k<3 ; k++ ) if( !IsActiveNode< Dim >( neighbors.neighbors[i][j][k] ) ) neighbors.neighbors[i][j][k] = NULL;
ProcessCorners( *sData0 , neighbors , HyperCube::FRONT , 0 ) , ProcessIEdges( *sData0 , neighbors , HyperCube::FRONT , 0 ) , ProcessIFaces( *sData0 , neighbors , HyperCube::FRONT , 0 );
}
}
);
}
if( sData1 )
{
node_index_type off = sNodes.begin(depth,offset+1);
node_index_type size = sNodes.end(depth,offset+1) - sNodes.begin(depth,offset+1);
ThreadPool::Parallel_for( 0 , size , [&]( unsigned int thread , size_t i )
{
if( !sData1->_processed[i] )
{
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
const TreeOctNode* node = sNodes.treeNodes[i+off];
ConstNeighbors& neighbors = neighborKey.getNeighbors( node );
for( int i=0 ; i<3 ; i++ ) for( int j=0 ; j<3 ; j++ ) for( int k=0 ; k<3 ; k++ ) if( !IsActiveNode< Dim >( neighbors.neighbors[i][j][k] ) ) neighbors.neighbors[i][j][k] = NULL;
ProcessCorners( *sData1 , neighbors , HyperCube::BACK , 0 ) , ProcessIEdges( *sData1 , neighbors , HyperCube::BACK , 0 ) , ProcessIFaces( *sData1 , neighbors , HyperCube::BACK , 0 );
}
}
);
}
auto SetICounts = [&]( SliceTableData& sData )
{
node_index_type cCount = 0 , eCount = 0 , fCount = 0;
for( node_index_type i=0 ; i<sData.nodeCount * (node_index_type)HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; i++ ) if( sData._cMap[i] ) sData._cMap[i] = cCount++;
for( node_index_type i=0 ; i<sData.nodeCount * (node_index_type)HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; i++ ) if( sData._eMap[i] ) sData._eMap[i] = eCount++;
for( node_index_type i=0 ; i<sData.nodeCount * (node_index_type)HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() ; i++ ) if( sData._fMap[i] ) sData._fMap[i] = fCount++;
ThreadPool::Parallel_for( 0 , sData.nodeCount , [&]( unsigned int , size_t i )
{
for( unsigned int j=0 ; j<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; j++ ) sData.cTable[i][j] = sData._cMap[ sData.cTable[i][j] ];
for( unsigned int j=0 ; j<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; j++ ) sData.eTable[i][j] = sData._eMap[ sData.eTable[i][j] ];
for( unsigned int j=0 ; j<HyperCube::Cube< Dim-1 >::template ElementNum< 2 >() ; j++ ) sData.fTable[i][j] = sData._fMap[ sData.fTable[i][j] ];
}
);
sData.cCount = cCount , sData.eCount = eCount , sData.fCount = fCount;
};
auto SetXCounts = [&]( XSliceTableData& xData )
{
node_index_type eCount = 0 , fCount = 0;
for( node_index_type i=0 ; i<xData.nodeCount * (node_index_type)HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; i++ ) if( xData._eMap[i] ) xData._eMap[i] = eCount++;
for( node_index_type i=0 ; i<xData.nodeCount * (node_index_type)HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; i++ ) if( xData._fMap[i] ) xData._fMap[i] = fCount++;
ThreadPool::Parallel_for( 0 , xData.nodeCount , [&]( unsigned int , size_t i )
{
for( unsigned int j=0 ; j<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; j++ ) xData.eTable[i][j] = xData._eMap[ xData.eTable[i][j] ];
for( unsigned int j=0 ; j<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; j++ ) xData.fTable[i][j] = xData._fMap[ xData.fTable[i][j] ];
}
);
xData.eCount = eCount , xData.fCount = fCount;
};
if( sData0 ) SetICounts( *sData0 );
if( sData1 ) SetICounts( *sData1 );
if( xData ) SetXCounts( *xData );
}
};
//////////////////
// _SliceValues //
//////////////////
struct _SliceValues
{
typename SliceData::SliceTableData sliceData;
Pointer( Real ) cornerValues ; Pointer( Point< Real , Dim > ) cornerGradients ; Pointer( char ) cornerSet;
Pointer( _Key ) edgeKeys ; Pointer( char ) edgeSet;
Pointer( _FaceEdges ) faceEdges ; Pointer( char ) faceSet;
Pointer( char ) mcIndices;
std::unordered_map< _Key , std::vector< _IsoEdge > , typename _Key::Hasher > faceEdgeMap;
std::unordered_map< _Key , std::pair< node_index_type, Vertex > , typename _Key::Hasher > edgeVertexMap;
std::unordered_map< _Key , _Key , typename _Key::Hasher > vertexPairMap;
std::vector< std::vector< std::pair< _Key , std::vector< _IsoEdge > > > > faceEdgeKeyValues;
std::vector< std::vector< std::pair< _Key , std::pair< node_index_type , Vertex > > > > edgeVertexKeyValues;
std::vector< std::vector< std::pair< _Key , _Key > > > vertexPairKeyValues;
_SliceValues( void )
{
_oldCCount = _oldECount = _oldFCount = 0;
_oldNCount = 0;
cornerValues = NullPointer( Real ) ; cornerGradients = NullPointer( Point< Real , Dim > ) ; cornerSet = NullPointer( char );
edgeKeys = NullPointer( _Key ) ; edgeSet = NullPointer( char );
faceEdges = NullPointer( _FaceEdges ) ; faceSet = NullPointer( char );
mcIndices = NullPointer( char );
edgeVertexKeyValues.resize( ThreadPool::NumThreads() );
vertexPairKeyValues.resize( ThreadPool::NumThreads() );
faceEdgeKeyValues.resize( ThreadPool::NumThreads() );
}
~_SliceValues( void )
{
_oldCCount = _oldECount = _oldFCount = 0;
_oldNCount = 0;
FreePointer( cornerValues ) ; FreePointer( cornerGradients ) ; FreePointer( cornerSet );
FreePointer( edgeKeys ) ; FreePointer( edgeSet );
FreePointer( faceEdges ) ; FreePointer( faceSet );
FreePointer( mcIndices );
}
void setEdgeVertexMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)edgeVertexKeyValues.size() ; i++ )
{
for( int j=0 ; j<edgeVertexKeyValues[i].size() ; j++ ) edgeVertexMap[ edgeVertexKeyValues[i][j].first ] = edgeVertexKeyValues[i][j].second;
edgeVertexKeyValues[i].clear();
}
}
void setVertexPairMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)vertexPairKeyValues.size() ; i++ )
{
for( int j=0 ; j<vertexPairKeyValues[i].size() ; j++ )
{
vertexPairMap[ vertexPairKeyValues[i][j].first ] = vertexPairKeyValues[i][j].second;
vertexPairMap[ vertexPairKeyValues[i][j].second ] = vertexPairKeyValues[i][j].first;
}
vertexPairKeyValues[i].clear();
}
}
void setFaceEdgeMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)faceEdgeKeyValues.size() ; i++ )
{
for( int j=0 ; j<faceEdgeKeyValues[i].size() ; j++ )
{
auto iter = faceEdgeMap.find( faceEdgeKeyValues[i][j].first );
if( iter==faceEdgeMap.end() ) faceEdgeMap[ faceEdgeKeyValues[i][j].first ] = faceEdgeKeyValues[i][j].second;
else for( int k=0 ; k<faceEdgeKeyValues[i][j].second.size() ; k++ ) iter->second.push_back( faceEdgeKeyValues[i][j].second[k] );
}
faceEdgeKeyValues[i].clear();
}
}
void reset( bool nonLinearFit )
{
faceEdgeMap.clear() , edgeVertexMap.clear() , vertexPairMap.clear();
for( node_index_type i=0 ; i<(node_index_type)edgeVertexKeyValues.size() ; i++ ) edgeVertexKeyValues[i].clear();
for( node_index_type i=0 ; i<(node_index_type)vertexPairKeyValues.size() ; i++ ) vertexPairKeyValues[i].clear();
for( node_index_type i=0 ; i<(node_index_type)faceEdgeKeyValues.size() ; i++ ) faceEdgeKeyValues[i].clear();
if( _oldNCount<sliceData.nodeCount )
{
_oldNCount = sliceData.nodeCount;
FreePointer( mcIndices );
if( sliceData.nodeCount>0 ) mcIndices = AllocPointer< char >( _oldNCount );
}
if( _oldCCount<sliceData.cCount )
{
_oldCCount = sliceData.cCount;
FreePointer( cornerValues ) ; FreePointer( cornerGradients ) ; FreePointer( cornerSet );
if( sliceData.cCount>0 )
{
cornerValues = AllocPointer< Real >( _oldCCount );
if( nonLinearFit ) cornerGradients = AllocPointer< Point< Real , Dim > >( _oldCCount );
cornerSet = AllocPointer< char >( _oldCCount );
}
}
if( _oldECount<sliceData.eCount )
{
_oldECount = sliceData.eCount;
FreePointer( edgeKeys ) ; FreePointer( edgeSet );
edgeKeys = AllocPointer< _Key >( _oldECount );
edgeSet = AllocPointer< char >( _oldECount );
}
if( _oldFCount<sliceData.fCount )
{
_oldFCount = sliceData.fCount;
FreePointer( faceEdges ) ; FreePointer( faceSet );
faceEdges = AllocPointer< _FaceEdges >( _oldFCount );
faceSet = AllocPointer< char >( _oldFCount );
}
if( sliceData.cCount>0 ) memset( cornerSet , 0 , sizeof( char ) * sliceData.cCount );
if( sliceData.eCount>0 ) memset( edgeSet , 0 , sizeof( char ) * sliceData.eCount );
if( sliceData.fCount>0 ) memset( faceSet , 0 , sizeof( char ) * sliceData.fCount );
}
protected:
node_index_type _oldCCount , _oldECount , _oldFCount;
node_index_type _oldNCount;
};
///////////////////
// _XSliceValues //
///////////////////
struct _XSliceValues
{
typename SliceData::XSliceTableData xSliceData;
Pointer( _Key ) edgeKeys ; Pointer( char ) edgeSet;
Pointer( _FaceEdges ) faceEdges ; Pointer( char ) faceSet;
std::unordered_map< _Key , std::vector< _IsoEdge > , typename _Key::Hasher > faceEdgeMap;
std::unordered_map< _Key , std::pair< node_index_type , Vertex > , typename _Key::Hasher > edgeVertexMap;
std::unordered_map< _Key , _Key , typename _Key::Hasher > vertexPairMap;
std::vector< std::vector< std::pair< _Key , std::pair< node_index_type , Vertex > > > > edgeVertexKeyValues;
std::vector< std::vector< std::pair< _Key , _Key > > > vertexPairKeyValues;
std::vector< std::vector< std::pair< _Key , std::vector< _IsoEdge > > > > faceEdgeKeyValues;
_XSliceValues( void )
{
_oldECount = _oldFCount = 0;
edgeKeys = NullPointer( _Key ) ; edgeSet = NullPointer( char );
faceEdges = NullPointer( _FaceEdges ) ; faceSet = NullPointer( char );
edgeVertexKeyValues.resize( ThreadPool::NumThreads() );
vertexPairKeyValues.resize( ThreadPool::NumThreads() );
faceEdgeKeyValues.resize( ThreadPool::NumThreads() );
}
~_XSliceValues( void )
{
_oldECount = _oldFCount = 0;
FreePointer( edgeKeys ) ; FreePointer( edgeSet );
FreePointer( faceEdges ) ; FreePointer( faceSet );
}
void setEdgeVertexMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)edgeVertexKeyValues.size() ; i++ )
{
for( int j=0 ; j<edgeVertexKeyValues[i].size() ; j++ ) edgeVertexMap[ edgeVertexKeyValues[i][j].first ] = edgeVertexKeyValues[i][j].second;
edgeVertexKeyValues[i].clear();
}
}
void setVertexPairMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)vertexPairKeyValues.size() ; i++ )
{
for( int j=0 ; j<vertexPairKeyValues[i].size() ; j++ )
{
vertexPairMap[ vertexPairKeyValues[i][j].first ] = vertexPairKeyValues[i][j].second;
vertexPairMap[ vertexPairKeyValues[i][j].second ] = vertexPairKeyValues[i][j].first;
}
vertexPairKeyValues[i].clear();
}
}
void setFaceEdgeMap( void )
{
for( node_index_type i=0 ; i<(node_index_type)faceEdgeKeyValues.size() ; i++ )
{
for( int j=0 ; j<faceEdgeKeyValues[i].size() ; j++ )
{
auto iter = faceEdgeMap.find( faceEdgeKeyValues[i][j].first );
if( iter==faceEdgeMap.end() ) faceEdgeMap[ faceEdgeKeyValues[i][j].first ] = faceEdgeKeyValues[i][j].second;
else for( int k=0 ; k<faceEdgeKeyValues[i][j].second.size() ; k++ ) iter->second.push_back( faceEdgeKeyValues[i][j].second[k] );
}
faceEdgeKeyValues[i].clear();
}
}
void reset( void )
{
faceEdgeMap.clear() , edgeVertexMap.clear() , vertexPairMap.clear();
for( node_index_type i=0 ; i<(node_index_type)edgeVertexKeyValues.size() ; i++ ) edgeVertexKeyValues[i].clear();
for( node_index_type i=0 ; i<(node_index_type)vertexPairKeyValues.size() ; i++ ) vertexPairKeyValues[i].clear();
for( node_index_type i=0 ; i<(node_index_type)faceEdgeKeyValues.size() ; i++ ) faceEdgeKeyValues[i].clear();
if( _oldECount<xSliceData.eCount )
{
_oldECount = xSliceData.eCount;
FreePointer( edgeKeys ) ; FreePointer( edgeSet );
edgeKeys = AllocPointer< _Key >( _oldECount );
edgeSet = AllocPointer< char >( _oldECount );
}
if( _oldFCount<xSliceData.fCount )
{
_oldFCount = xSliceData.fCount;
FreePointer( faceEdges ) ; FreePointer( faceSet );
faceEdges = AllocPointer< _FaceEdges >( _oldFCount );
faceSet = AllocPointer< char >( _oldFCount );
}
if( xSliceData.eCount>0 ) memset( edgeSet , 0 , sizeof( char ) * xSliceData.eCount );
if( xSliceData.fCount>0 ) memset( faceSet , 0 , sizeof( char ) * xSliceData.fCount );
}
protected:
node_index_type _oldECount , _oldFCount;
};
/////////////////
// _SlabValues //
/////////////////
struct _SlabValues
{
protected:
_XSliceValues _xSliceValues[2];
_SliceValues _sliceValues[2];
public:
_SliceValues& sliceValues( int idx ){ return _sliceValues[idx&1]; }
const _SliceValues& sliceValues( int idx ) const { return _sliceValues[idx&1]; }
_XSliceValues& xSliceValues( int idx ){ return _xSliceValues[idx&1]; }
const _XSliceValues& xSliceValues( int idx ) const { return _xSliceValues[idx&1]; }
};
template< unsigned int ... FEMSigs >
static void _SetSliceIsoCorners( const FEMTree< Dim , Real >& tree , ConstPointer( Real ) coefficients , ConstPointer( Real ) coarseCoefficients , Real isoValue , LocalDepth depth , int slice , std::vector< _SlabValues >& slabValues , const _Evaluator< UIntPack< FEMSigs ... > , 1 >& evaluator )
{
if( slice>0 ) _SetSliceIsoCorners< FEMSigs ... >( tree , coefficients , coarseCoefficients , isoValue , depth , slice , HyperCube::FRONT , slabValues , evaluator );
if( slice<(1<<depth) ) _SetSliceIsoCorners< FEMSigs ... >( tree , coefficients , coarseCoefficients , isoValue , depth , slice , HyperCube::BACK , slabValues , evaluator );
}
template< unsigned int ... FEMSigs >
static void _SetSliceIsoCorners( const FEMTree< Dim , Real >& tree , ConstPointer( Real ) coefficients , ConstPointer( Real ) coarseCoefficients , Real isoValue , LocalDepth depth , int slice , HyperCube::Direction zDir , std::vector< _SlabValues >& slabValues , const _Evaluator< UIntPack< FEMSigs ... > , 1 >& evaluator )
{
static const unsigned int FEMDegrees[] = { FEMSignature< FEMSigs >::Degree ... };
_SliceValues& sValues = slabValues[depth].sliceValues( slice );
bool useBoundaryEvaluation = false;
for( int d=0 ; d<Dim ; d++ ) if( FEMDegrees[d]==0 || ( FEMDegrees[d]==1 && sValues.cornerGradients ) ) useBoundaryEvaluation = true;
std::vector< ConstPointSupportKey< UIntPack< FEMSignature< FEMSigs >::Degree ... > > > neighborKeys( ThreadPool::NumThreads() );
std::vector< ConstCornerSupportKey< UIntPack< FEMSignature< FEMSigs >::Degree ... > > > bNeighborKeys( ThreadPool::NumThreads() );
if( useBoundaryEvaluation ) for( size_t i=0 ; i<neighborKeys.size() ; i++ ) bNeighborKeys[i].set( tree._localToGlobal( depth ) );
else for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( tree._localToGlobal( depth ) );
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , tree._sNodesEnd(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
Real squareValues[ HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ];
ConstPointSupportKey< UIntPack< FEMSignature< FEMSigs >::Degree ... > >& neighborKey = neighborKeys[ thread ];
ConstCornerSupportKey< UIntPack< FEMSignature< FEMSigs >::Degree ... > >& bNeighborKey = bNeighborKeys[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
if( !IsActiveNode< Dim >( leaf->children ) )
{
const typename SliceData::SquareCornerIndices& cIndices = sValues.sliceData.cornerIndices( leaf );
bool isInterior = tree._isInteriorlySupported( UIntPack< FEMSignature< FEMSigs >::Degree ... >() , leaf->parent );
if( useBoundaryEvaluation ) bNeighborKey.getNeighbors( leaf );
else neighborKey.getNeighbors( leaf );
for( typename HyperCube::Cube< Dim-1 >::template Element< 0 > _c ; _c<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; _c++ )
{
typename HyperCube::Cube< Dim >::template Element< 0 > c( zDir , _c.index );
node_index_type vIndex = cIndices[_c.index];
if( !sValues.cornerSet[vIndex] )
{
if( sValues.cornerGradients )
{
CumulativeDerivativeValues< Real , Dim , 1 > p;
if( useBoundaryEvaluation ) p = tree.template _getCornerValues< Real , 1 >( bNeighborKey , leaf , c.index , coefficients , coarseCoefficients , evaluator , tree._maxDepth , isInterior );
else p = tree.template _getCornerValues< Real , 1 >( neighborKey , leaf , c.index , coefficients , coarseCoefficients , evaluator , tree._maxDepth , isInterior );
sValues.cornerValues[vIndex] = p[0] , sValues.cornerGradients[vIndex] = Point< Real , Dim >( p[1] , p[2] , p[3] );
}
else
{
if( useBoundaryEvaluation ) sValues.cornerValues[vIndex] = tree.template _getCornerValues< Real , 0 >( bNeighborKey , leaf , c.index , coefficients , coarseCoefficients , evaluator , tree._maxDepth , isInterior )[0];
else sValues.cornerValues[vIndex] = tree.template _getCornerValues< Real , 0 >( neighborKey , leaf , c.index , coefficients , coarseCoefficients , evaluator , tree._maxDepth , isInterior )[0];
}
sValues.cornerSet[vIndex] = 1;
}
squareValues[_c.index] = sValues.cornerValues[ vIndex ];
TreeNode* node = leaf;
LocalDepth _depth = depth;
int _slice = slice;
while( tree._isValidSpaceNode( node->parent ) && (node-node->parent->children)==c.index )
{
node = node->parent , _depth-- , _slice >>= 1;
_SliceValues& _sValues = slabValues[_depth].sliceValues( _slice );
const typename SliceData::SquareCornerIndices& _cIndices = _sValues.sliceData.cornerIndices( node );
node_index_type _vIndex = _cIndices[_c.index];
_sValues.cornerValues[_vIndex] = sValues.cornerValues[vIndex];
if( _sValues.cornerGradients ) _sValues.cornerGradients[_vIndex] = sValues.cornerGradients[vIndex];
_sValues.cornerSet[_vIndex] = 1;
}
}
sValues.mcIndices[ i - sValues.sliceData.nodeOffset ] = HyperCube::Cube< Dim-1 >::MCIndex( squareValues , isoValue );
}
}
}
);
}
/////////////////
// _VertexData //
/////////////////
class _VertexData
{
public:
static _Key EdgeIndex( const TreeNode* node , typename HyperCube::Cube< Dim >::template Element< 1 > e , int maxDepth )
{
_Key key;
const HyperCube::Direction* x = SliceData::template HyperCubeTables< Dim , 1 >::Directions[ e.index ];
int d , off[Dim];
node->depthAndOffset( d , off );
for( int dd=0 ; dd<Dim ; dd++ )
{
if( x[dd]==HyperCube::CROSS )
{
key[(dd+0)%3] = (int)BinaryNode::CornerIndex( maxDepth+1 , d+1 , off[(dd+0)%3]<<1 , 1 );
key[(dd+1)%3] = (int)BinaryNode::CornerIndex( maxDepth+1 , d , off[(dd+1)%3] , x[(dd+1)%3]==HyperCube::BACK ? 0 : 1 );
key[(dd+2)%3] = (int)BinaryNode::CornerIndex( maxDepth+1 , d , off[(dd+2)%3] , x[(dd+2)%3]==HyperCube::BACK ? 0 : 1 );
}
}
return key;
}
static _Key FaceIndex( const TreeNode* node , typename HyperCube::Cube< Dim >::template Element< Dim-1 > f , int maxDepth )
{
_Key key;
const HyperCube::Direction* x = SliceData::template HyperCubeTables< Dim , 2 >::Directions[ f.index ];
int d , o[Dim];
node->depthAndOffset( d , o );
for( int dd=0 ; dd<Dim ; dd++ )
if( x[dd]==HyperCube::CROSS ) key[dd] = (int)BinaryNode::CornerIndex( maxDepth+1 , d+1 , o[dd]<<1 , 1 );
else key[dd] = (int)BinaryNode::CornerIndex( maxDepth+1 , d , o[dd] , x[dd]==HyperCube::BACK ? 0 : 1 );
return key;
}
};
template< unsigned int WeightDegree , typename Data , unsigned int DataSig >
static void _SetSliceIsoVertices( const FEMTree< Dim , Real >& tree , typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , Real isoValue , LocalDepth depth , int slice , node_index_type& vOffset , CoredMeshData< Vertex , node_index_type >& mesh , std::vector< _SlabValues >& slabValues , std::function< void ( Vertex& , Point< Real , Dim > , Real , Data ) > SetVertex )
{
if( slice>0 ) _SetSliceIsoVertices< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , depth , slice , HyperCube::FRONT , vOffset , mesh , slabValues , SetVertex );
if( slice<(1<<depth) ) _SetSliceIsoVertices< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , depth , slice , HyperCube::BACK , vOffset , mesh , slabValues , SetVertex );
}
template< unsigned int WeightDegree , typename Data , unsigned int DataSig >
static void _SetSliceIsoVertices( const FEMTree< Dim , Real >& tree , typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , Real isoValue , LocalDepth depth , int slice , HyperCube::Direction zDir , node_index_type& vOffset , CoredMeshData< Vertex , node_index_type >& mesh , std::vector< _SlabValues >& slabValues , std::function< void ( Vertex& , Point< Real , Dim > , Real , Data ) > SetVertex )
{
static const unsigned int DataDegree = FEMSignature< DataSig >::Degree;
_SliceValues& sValues = slabValues[depth].sliceValues( slice );
// [WARNING] In the case Degree=2, these two keys are the same, so we don't have to maintain them separately.
std::vector< ConstOneRingNeighborKey > neighborKeys( ThreadPool::NumThreads() );
std::vector< ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > > > weightKeys( ThreadPool::NumThreads() );
std::vector< ConstPointSupportKey< IsotropicUIntPack< Dim , DataDegree > > > dataKeys( ThreadPool::NumThreads() );
for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( tree._localToGlobal( depth ) ) , weightKeys[i].set( tree._localToGlobal( depth ) ) , dataKeys[i].set( tree._localToGlobal( depth ) );
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , tree._sNodesEnd(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > >& weightKey = weightKeys[ thread ];
ConstPointSupportKey< IsotropicUIntPack< Dim , DataDegree > >& dataKey = dataKeys[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
if( !IsActiveNode< Dim >( leaf->children ) )
{
node_index_type idx = (node_index_type)i - sValues.sliceData.nodeOffset;
const typename SliceData::SquareEdgeIndices& eIndices = sValues.sliceData.edgeIndices( leaf );
if( HyperCube::Cube< Dim-1 >::HasMCRoots( sValues.mcIndices[idx] ) )
{
neighborKey.getNeighbors( leaf );
if( densityWeights ) weightKey.getNeighbors( leaf );
if( data ) dataKey.getNeighbors( leaf );
for( typename HyperCube::Cube< Dim-1 >::template Element< 1 > _e ; _e<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; _e++ )
if( HyperCube::Cube< 1 >::HasMCRoots( HyperCube::Cube< Dim-1 >::ElementMCIndex( _e , sValues.mcIndices[idx] ) ) )
{
typename HyperCube::Cube< Dim >::template Element< 1 > e( zDir , _e.index );
node_index_type vIndex = eIndices[_e.index];
volatile char &edgeSet = sValues.edgeSet[vIndex];
if( !edgeSet )
{
Vertex vertex;
_Key key = _VertexData::EdgeIndex( leaf , e , tree._localToGlobal( tree._maxDepth ) );
_GetIsoVertex< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , weightKey , dataKey , leaf , _e , zDir , sValues , vertex , SetVertex );
bool stillOwner = false;
std::pair< node_index_type , Vertex > hashed_vertex;
{
std::lock_guard< std::mutex > lock( _pointInsertionMutex );
if( !edgeSet )
{
mesh.addOutOfCorePoint( vertex );
edgeSet = 1;
hashed_vertex = std::pair< node_index_type , Vertex >( vOffset , vertex );
sValues.edgeKeys[ vIndex ] = key;
vOffset++;
stillOwner = true;
}
}
if( stillOwner ) sValues.edgeVertexKeyValues[ thread ].push_back( std::pair< _Key , std::pair< node_index_type , Vertex > >( key , hashed_vertex ) );
if( stillOwner )
{
// We only need to pass the iso-vertex down if the edge it lies on is adjacent to a coarser leaf
auto IsNeeded = [&]( unsigned int depth )
{
bool isNeeded = false;
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > my_ic = SliceData::template HyperCubeTables< Dim , 1 >::IncidentCube[e.index];
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ ) if( ic!=my_ic )
{
unsigned int xx = SliceData::template HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index];
isNeeded |= !tree._isValidSpaceNode( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx] );
}
return isNeeded;
};
if( IsNeeded( depth ) )
{
const typename HyperCube::Cube< Dim >::template Element< Dim-1 > *f = SliceData::template HyperCubeTables< Dim , 1 , Dim-1 >::OverlapElements[e.index];
for( int k=0 ; k<2 ; k++ )
{
TreeNode* node = leaf;
LocalDepth _depth = depth;
int _slice = slice;
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 2 , 0 >::Overlap[f[k].index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slice >>= 1;
_SliceValues& _sValues = slabValues[_depth].sliceValues( _slice );
_sValues.edgeVertexKeyValues[ thread ].push_back( std::pair< _Key , std::pair< node_index_type , Vertex > >( key , hashed_vertex ) );
if( !IsNeeded( _depth ) ) break;
}
}
}
}
}
}
}
}
}
}
);
}
////////////////////
// Iso-Extraction //
////////////////////
template< unsigned int WeightDegree , typename Data , unsigned int DataSig >
static void _SetXSliceIsoVertices( const FEMTree< Dim , Real >& tree , typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , Real isoValue , LocalDepth depth , int slab , node_index_type &vOffset , CoredMeshData< Vertex , node_index_type >& mesh , std::vector< _SlabValues >& slabValues , std::function< void ( Vertex& , Point< Real , Dim > , Real , Data ) > SetVertex )
{
static const unsigned int DataDegree = FEMSignature< DataSig >::Degree;
_SliceValues& bValues = slabValues[depth].sliceValues ( slab );
_SliceValues& fValues = slabValues[depth].sliceValues ( slab+1 );
_XSliceValues& xValues = slabValues[depth].xSliceValues( slab );
// [WARNING] In the case Degree=2, these two keys are the same, so we don't have to maintain them separately.
std::vector< ConstOneRingNeighborKey > neighborKeys( ThreadPool::NumThreads() );
std::vector< ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > > > weightKeys( ThreadPool::NumThreads() );
std::vector< ConstPointSupportKey< IsotropicUIntPack< Dim , DataDegree > > > dataKeys( ThreadPool::NumThreads() );
for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( tree._localToGlobal( depth ) ) , weightKeys[i].set( tree._localToGlobal( depth ) ) , dataKeys[i].set( tree._localToGlobal( depth ) );
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slab) , tree._sNodesEnd(depth,slab) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > >& weightKey = weightKeys[ thread ];
ConstPointSupportKey< IsotropicUIntPack< Dim , DataDegree > >& dataKey = dataKeys[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
if( !IsActiveNode< Dim >( leaf->children ) )
{
unsigned char mcIndex = ( bValues.mcIndices[ i - bValues.sliceData.nodeOffset ] ) | ( fValues.mcIndices[ i - fValues.sliceData.nodeOffset ] )<<4;
const typename SliceData::SquareCornerIndices& eIndices = xValues.xSliceData.edgeIndices( leaf );
if( HyperCube::Cube< Dim >::HasMCRoots( mcIndex ) )
{
neighborKey.getNeighbors( leaf );
if( densityWeights ) weightKey.getNeighbors( leaf );
if( data ) dataKey.getNeighbors( leaf );
for( typename HyperCube::Cube< Dim-1 >::template Element< 0 > _c ; _c<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; _c++ )
{
typename HyperCube::Cube< Dim >::template Element< 1 > e( HyperCube::CROSS , _c.index );
unsigned int _mcIndex = HyperCube::Cube< Dim >::ElementMCIndex( e , mcIndex );
if( HyperCube::Cube< 1 >::HasMCRoots( _mcIndex ) )
{
node_index_type vIndex = eIndices[_c.index];
volatile char &edgeSet = xValues.edgeSet[vIndex];
if( !edgeSet )
{
Vertex vertex;
_Key key = _VertexData::EdgeIndex( leaf , e.index , tree._localToGlobal( tree._maxDepth ) );
_GetIsoVertex< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , weightKey , dataKey , leaf , _c , bValues , fValues , vertex , SetVertex );
bool stillOwner = false;
std::pair< node_index_type , Vertex > hashed_vertex;
{
std::lock_guard< std::mutex > lock( _pointInsertionMutex );
if( !edgeSet )
{
mesh.addOutOfCorePoint( vertex );
edgeSet = 1;
hashed_vertex = std::pair< node_index_type , Vertex >( vOffset , vertex );
xValues.edgeKeys[ vIndex ] = key;
vOffset++;
stillOwner = true;
}
}
if( stillOwner ) xValues.edgeVertexKeyValues[ thread ].push_back( std::pair< _Key , std::pair< node_index_type , Vertex > >( key , hashed_vertex ) );
if( stillOwner )
{
// We only need to pass the iso-vertex down if the edge it lies on is adjacent to a coarser leaf
auto IsNeeded = [&]( unsigned int depth )
{
bool isNeeded = false;
typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > my_ic = SliceData::template HyperCubeTables< Dim , 1 >::IncidentCube[e.index];
for( typename HyperCube::Cube< Dim >::template IncidentCubeIndex< 1 > ic ; ic<HyperCube::Cube< Dim >::template IncidentCubeNum< 1 >() ; ic++ ) if( ic!=my_ic )
{
unsigned int xx = SliceData::template HyperCubeTables< Dim , 1 >::CellOffset[e.index][ic.index];
isNeeded |= !tree._isValidSpaceNode( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx] );
}
return isNeeded;
};
if( IsNeeded( depth ) )
{
const typename HyperCube::Cube< Dim >::template Element< Dim-1 > *f = SliceData::template HyperCubeTables< Dim , 1 , Dim-1 >::OverlapElements[e.index];
for( int k=0 ; k<2 ; k++ )
{
TreeNode* node = leaf;
LocalDepth _depth = depth;
int _slab = slab;
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 2 , 0 >::Overlap[f[k].index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slab >>= 1;
_XSliceValues& _xValues = slabValues[_depth].xSliceValues( _slab );
_xValues.edgeVertexKeyValues[ thread ].push_back( std::pair< _Key , std::pair< node_index_type , Vertex > >( key , hashed_vertex ) );
if( !IsNeeded( _depth ) ) break;
}
}
}
}
}
}
}
}
}
}
}
);
}
static void _CopyFinerSliceIsoEdgeKeys( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slice , std::vector< _SlabValues >& slabValues )
{
if( slice>0 ) _CopyFinerSliceIsoEdgeKeys( tree , depth , slice , HyperCube::FRONT , slabValues );
if( slice<(1<<depth) ) _CopyFinerSliceIsoEdgeKeys( tree , depth , slice , HyperCube::BACK , slabValues );
}
static void _CopyFinerSliceIsoEdgeKeys( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slice , HyperCube::Direction zDir , std::vector< _SlabValues >& slabValues )
{
_SliceValues& pSliceValues = slabValues[depth ].sliceValues(slice );
_SliceValues& cSliceValues = slabValues[depth+1].sliceValues(slice<<1);
typename SliceData::SliceTableData& pSliceData = pSliceValues.sliceData;
typename SliceData::SliceTableData& cSliceData = cSliceValues.sliceData;
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , tree._sNodesEnd(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) ) if( IsActiveNode< Dim >( tree._sNodes.treeNodes[i]->children ) )
{
typename SliceData::SquareEdgeIndices& pIndices = pSliceData.edgeIndices( (node_index_type)i );
// Copy the edges that overlap the coarser edges
for( typename HyperCube::Cube< Dim-1 >::template Element< 1 > _e ; _e<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; _e++ )
{
node_index_type pIndex = pIndices[_e.index];
if( !pSliceValues.edgeSet[ pIndex ] )
{
typename HyperCube::Cube< Dim >::template Element< 1 > e( zDir , _e.index );
const typename HyperCube::Cube< Dim >::template Element< 0 > *c = SliceData::template HyperCubeTables< Dim , 1 , 0 >::OverlapElements[e.index];
// [SANITY CHECK]
// if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c[0].index )!=tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c[1].index ) ) ERROR_OUT( "Finer edges should both be valid or invalid" );
if( !tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c[0].index ) || !tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c[1].index ) ) continue;
node_index_type cIndex1 = cSliceData.edgeIndices( tree._sNodes.treeNodes[i]->children + c[0].index )[_e.index];
node_index_type cIndex2 = cSliceData.edgeIndices( tree._sNodes.treeNodes[i]->children + c[1].index )[_e.index];
if( cSliceValues.edgeSet[cIndex1] != cSliceValues.edgeSet[cIndex2] )
{
_Key key;
if( cSliceValues.edgeSet[cIndex1] ) key = cSliceValues.edgeKeys[cIndex1];
else key = cSliceValues.edgeKeys[cIndex2];
pSliceValues.edgeKeys[pIndex] = key;
pSliceValues.edgeSet[pIndex] = 1;
}
else if( cSliceValues.edgeSet[cIndex1] && cSliceValues.edgeSet[cIndex2] )
{
_Key key1 = cSliceValues.edgeKeys[cIndex1] , key2 = cSliceValues.edgeKeys[cIndex2];
pSliceValues.vertexPairKeyValues[ thread ].push_back( std::pair< _Key , _Key >( key1 , key2 ) );
const TreeNode* node = tree._sNodes.treeNodes[i];
LocalDepth _depth = depth;
int _slice = slice;
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 1 , 0 >::Overlap[e.index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slice >>= 1;
_SliceValues& _pSliceValues = slabValues[_depth].sliceValues(_slice);
_pSliceValues.vertexPairKeyValues[ thread ].push_back( std::pair< _Key , _Key >( key1 , key2 ) );
}
}
}
}
}
}
);
}
static void _CopyFinerXSliceIsoEdgeKeys( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slab , std::vector< _SlabValues>& slabValues )
{
_XSliceValues& pSliceValues = slabValues[depth ].xSliceValues(slab);
_XSliceValues& cSliceValues0 = slabValues[depth+1].xSliceValues( (slab<<1)|0 );
_XSliceValues& cSliceValues1 = slabValues[depth+1].xSliceValues( (slab<<1)|1 );
typename SliceData::XSliceTableData& pSliceData = pSliceValues.xSliceData;
typename SliceData::XSliceTableData& cSliceData0 = cSliceValues0.xSliceData;
typename SliceData::XSliceTableData& cSliceData1 = cSliceValues1.xSliceData;
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slab) , tree._sNodesEnd(depth,slab) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) ) if( IsActiveNode< Dim >( tree._sNodes.treeNodes[i]->children ) )
{
typename SliceData::SquareCornerIndices& pIndices = pSliceData.edgeIndices( (node_index_type)i );
for( typename HyperCube::Cube< Dim-1 >::template Element< 0 > _c ; _c<HyperCube::Cube< Dim-1 >::template ElementNum< 0 >() ; _c++ )
{
typename HyperCube::Cube< Dim >::template Element< 1 > e( HyperCube::CROSS , _c.index );
node_index_type pIndex = pIndices[ _c.index ];
if( !pSliceValues.edgeSet[pIndex] )
{
typename HyperCube::Cube< Dim >::template Element< 0 > c0( HyperCube::BACK , _c.index ) , c1( HyperCube::FRONT , _c.index );
// [SANITY CHECK]
// if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c0 )!=tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c1 ) ) ERROR_OUT( "Finer edges should both be valid or invalid" );
if( !tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c0.index ) || !tree._isValidSpaceNode( tree._sNodes.treeNodes[i]->children + c1.index ) ) continue;
node_index_type cIndex0 = cSliceData0.edgeIndices( tree._sNodes.treeNodes[i]->children + c0.index )[_c.index];
node_index_type cIndex1 = cSliceData1.edgeIndices( tree._sNodes.treeNodes[i]->children + c1.index )[_c.index];
// If there's one zero-crossing along the edge
if( cSliceValues0.edgeSet[cIndex0] != cSliceValues1.edgeSet[cIndex1] )
{
_Key key;
if( cSliceValues0.edgeSet[cIndex0] ) key = cSliceValues0.edgeKeys[cIndex0]; //, vPair = cSliceValues0.edgeVertexMap.find( key )->second;
else key = cSliceValues1.edgeKeys[cIndex1]; //, vPair = cSliceValues1.edgeVertexMap.find( key )->second;
pSliceValues.edgeKeys[ pIndex ] = key;
pSliceValues.edgeSet[ pIndex ] = 1;
}
// If there's are two zero-crossings along the edge
else if( cSliceValues0.edgeSet[cIndex0] && cSliceValues1.edgeSet[cIndex1] )
{
_Key key0 = cSliceValues0.edgeKeys[cIndex0] , key1 = cSliceValues1.edgeKeys[cIndex1];
pSliceValues.vertexPairKeyValues[ thread ].push_back( std::pair< _Key , _Key >( key0 , key1 ) );
const TreeNode* node = tree._sNodes.treeNodes[i];
LocalDepth _depth = depth;
int _slab = slab;
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 1 , 0 >::Overlap[e.index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slab>>= 1;
_SliceValues& _pSliceValues = slabValues[_depth].sliceValues(_slab);
_pSliceValues.vertexPairKeyValues[ thread ].push_back( std::pair< _Key , _Key >( key0 , key1 ) );
}
}
}
}
}
}
);
}
static void _SetSliceIsoEdges( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slice , std::vector< _SlabValues >& slabValues )
{
if( slice>0 ) _SetSliceIsoEdges( tree , depth , slice , HyperCube::FRONT , slabValues );
if( slice<(1<<depth) ) _SetSliceIsoEdges( tree , depth , slice , HyperCube::BACK , slabValues );
}
static void _SetSliceIsoEdges( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slice , HyperCube::Direction zDir , std::vector< _SlabValues >& slabValues )
{
_SliceValues& sValues = slabValues[depth].sliceValues( slice );
std::vector< ConstOneRingNeighborKey > neighborKeys( ThreadPool::NumThreads() );
for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( tree._localToGlobal( depth ) );
ThreadPool::Parallel_for( tree._sNodesBegin(depth, slice-(zDir==HyperCube::BACK ? 0 : 1)) , tree._sNodesEnd(depth,slice-(zDir==HyperCube::BACK ? 0 : 1)) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
int isoEdges[ 2 * HyperCube::MarchingSquares::MAX_EDGES ];
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
if( !IsActiveNode< Dim >( leaf->children ) )
{
node_index_type idx = (node_index_type)i - sValues.sliceData.nodeOffset;
const typename SliceData::SquareEdgeIndices& eIndices = sValues.sliceData.edgeIndices( leaf );
const typename SliceData::SquareFaceIndices& fIndices = sValues.sliceData.faceIndices( leaf );
unsigned char mcIndex = sValues.mcIndices[idx];
if( !sValues.faceSet[ fIndices[0] ] )
{
neighborKey.getNeighbors( leaf );
unsigned int xx = WindowIndex< IsotropicUIntPack< Dim , 3 > , IsotropicUIntPack< Dim , 1 > >::Index + (zDir==HyperCube::BACK ? -1 : 1);
if( !IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx] ) || !IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx]->children ) )
{
_FaceEdges fe;
fe.count = HyperCube::MarchingSquares::AddEdgeIndices( mcIndex , isoEdges );
for( int j=0 ; j<fe.count ; j++ ) for( int k=0 ; k<2 ; k++ )
{
if( !sValues.edgeSet[ eIndices[ isoEdges[2*j+k] ] ] ) ERROR_OUT( "Edge not set: " , slice , " / " , 1<<depth );
fe.edges[j][k] = sValues.edgeKeys[ eIndices[ isoEdges[2*j+k] ] ];
}
sValues.faceSet[ fIndices[0] ] = 1;
sValues.faceEdges[ fIndices[0] ] = fe;
TreeNode* node = leaf;
LocalDepth _depth = depth;
int _slice = slice;
typename HyperCube::Cube< Dim >::template Element< Dim-1 > f( zDir , 0 );
std::vector< _IsoEdge > edges;
edges.resize( fe.count );
for( int j=0 ; j<fe.count ; j++ ) edges[j] = fe.edges[j];
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 2 , 0 >::Overlap[f.index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slice >>= 1;
if( IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( _depth ) ].neighbors.data[xx] ) && IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( _depth ) ].neighbors.data[xx]->children ) ) break;
_Key key = _VertexData::FaceIndex( node , f , tree._localToGlobal( tree._maxDepth ) );
_SliceValues& _sValues = slabValues[_depth].sliceValues( _slice );
_sValues.faceEdgeKeyValues[ thread ].push_back( std::pair< _Key , std::vector< _IsoEdge > >( key , edges ) );
}
}
}
}
}
}
);
}
static void _SetXSliceIsoEdges( const FEMTree< Dim , Real >& tree , LocalDepth depth , int slab , std::vector< _SlabValues >& slabValues )
{
_SliceValues& bValues = slabValues[depth].sliceValues ( slab );
_SliceValues& fValues = slabValues[depth].sliceValues ( slab+1 );
_XSliceValues& xValues = slabValues[depth].xSliceValues( slab );
std::vector< ConstOneRingNeighborKey > neighborKeys( ThreadPool::NumThreads() );
for( size_t i=0 ; i<neighborKeys.size() ; i++ ) neighborKeys[i].set( tree._localToGlobal( depth ) );
ThreadPool::Parallel_for( tree._sNodesBegin(depth,slab) , tree._sNodesEnd(depth,slab) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
int isoEdges[ 2 * HyperCube::MarchingSquares::MAX_EDGES ];
ConstOneRingNeighborKey& neighborKey = neighborKeys[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
if( !IsActiveNode< Dim >( leaf->children ) )
{
const typename SliceData::SquareCornerIndices& cIndices = xValues.xSliceData.edgeIndices( leaf );
const typename SliceData::SquareEdgeIndices& eIndices = xValues.xSliceData.faceIndices( leaf );
unsigned char mcIndex = ( bValues.mcIndices[ i - bValues.sliceData.nodeOffset ] ) | ( fValues.mcIndices[ i - fValues.sliceData.nodeOffset ]<<4 );
{
neighborKey.getNeighbors( leaf );
// Iterate over the edges on the back
for( typename HyperCube::Cube< Dim-1 >::template Element< 1 > _e ; _e<HyperCube::Cube< Dim-1 >::template ElementNum< 1 >() ; _e++ )
{
typename HyperCube::Cube< Dim >::template Element< 2 > f( HyperCube::CROSS , _e.index );
unsigned char _mcIndex = HyperCube::Cube< Dim >::template ElementMCIndex< 2 >( f , mcIndex );
unsigned int xx = SliceData::template HyperCubeTables< Dim , 2 >::CellOffsetAntipodal[f.index];
if( !xValues.faceSet[ eIndices[_e.index] ] && ( !IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx] ) || !IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( depth ) ].neighbors.data[xx]->children ) ) )
{
_FaceEdges fe;
fe.count = HyperCube::MarchingSquares::AddEdgeIndices( _mcIndex , isoEdges );
for( int j=0 ; j<fe.count ; j++ ) for( int k=0 ; k<2 ; k++ )
{
typename HyperCube::Cube< Dim >::template Element< 1 > e( f , typename HyperCube::Cube< Dim-1 >::template Element< 1 >( isoEdges[2*j+k] ) );
HyperCube::Direction dir ; unsigned int coIndex;
e.factor( dir , coIndex );
if( dir==HyperCube::CROSS ) // Cross-edge
{
node_index_type idx = cIndices[ coIndex ];
if( !xValues.edgeSet[ idx ] ) ERROR_OUT( "Edge not set: " , slab , " / " , 1<<depth );
fe.edges[j][k] = xValues.edgeKeys[ idx ];
}
else
{
const _SliceValues& sValues = dir==HyperCube::BACK ? bValues : fValues;
node_index_type idx = sValues.sliceData.edgeIndices((node_index_type)i)[ coIndex ];
if( !sValues.edgeSet[ idx ] ) ERROR_OUT( "Edge not set: " , slab , " / " , 1<<depth );
fe.edges[j][k] = sValues.edgeKeys[ idx ];
}
}
xValues.faceSet[ eIndices[_e.index] ] = 1;
xValues.faceEdges[ eIndices[_e.index] ] = fe;
TreeNode* node = leaf;
LocalDepth _depth = depth;
int _slab = slab;
std::vector< _IsoEdge > edges;
edges.resize( fe.count );
for( int j=0 ; j<fe.count ; j++ ) edges[j] = fe.edges[j];
while( tree._isValidSpaceNode( node->parent ) && SliceData::template HyperCubeTables< Dim , 2 , 0 >::Overlap[f.index][(unsigned int)(node-node->parent->children) ] )
{
node = node->parent , _depth-- , _slab >>= 1;
if( IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( _depth ) ].neighbors.data[xx] ) && IsActiveNode< Dim >( neighborKey.neighbors[ tree._localToGlobal( _depth ) ].neighbors.data[xx]->children ) ) break;
_Key key = _VertexData::FaceIndex( node , f , tree._localToGlobal( tree._maxDepth ) );
_XSliceValues& _xValues = slabValues[_depth].xSliceValues( _slab );
_xValues.faceEdgeKeyValues[ thread ].push_back( std::pair< _Key , std::vector< _IsoEdge > >( key , edges ) );
}
}
}
}
}
}
}
);
}
static void _SetIsoSurface( const FEMTree< Dim , Real >& tree , LocalDepth depth , int offset , const _SliceValues& bValues , const _SliceValues& fValues , const _XSliceValues& xValues , CoredMeshData< Vertex , node_index_type >& mesh , bool polygonMesh , bool addBarycenter , node_index_type& vOffset , bool flipOrientation )
{
std::vector< std::pair< node_index_type , Vertex > > polygon;
std::vector< std::vector< _IsoEdge > > edgess( ThreadPool::NumThreads() );
ThreadPool::Parallel_for( tree._sNodesBegin(depth,offset) , tree._sNodesEnd(depth,offset) , [&]( unsigned int thread , size_t i )
{
if( tree._isValidSpaceNode( tree._sNodes.treeNodes[i] ) )
{
std::vector< _IsoEdge >& edges = edgess[ thread ];
TreeNode* leaf = tree._sNodes.treeNodes[i];
int res = 1<<depth;
LocalDepth d ; LocalOffset off;
tree._localDepthAndOffset( leaf , d , off );
bool inBounds = off[0]>=0 && off[0]<res && off[1]>=0 && off[1]<res && off[2]>=0 && off[2]<res;
if( inBounds && !IsActiveNode< Dim >( leaf->children ) )
{
edges.clear();
unsigned char mcIndex = ( bValues.mcIndices[ i - bValues.sliceData.nodeOffset ] ) | ( fValues.mcIndices[ i - fValues.sliceData.nodeOffset ]<<4 );
// [WARNING] Just because the node looks empty doesn't mean it doesn't get eges from finer neighbors
{
// Gather the edges from the faces (with the correct orientation)
for( typename HyperCube::Cube< Dim >::template Element< Dim-1 > f ; f<HyperCube::Cube< Dim >::template ElementNum< Dim-1 >() ; f++ )
{
int flip = HyperCube::Cube< Dim >::IsOriented( f ) ? 0 : 1;
HyperCube::Direction fDir = f.direction();
if( fDir==HyperCube::BACK || fDir==HyperCube::FRONT )
{
const _SliceValues& sValues = (fDir==HyperCube::BACK) ? bValues : fValues;
node_index_type fIdx = sValues.sliceData.faceIndices((node_index_type)i)[0];
if( sValues.faceSet[fIdx] )
{
const _FaceEdges& fe = sValues.faceEdges[ fIdx ];
for( int j=0 ; j<fe.count ; j++ ) edges.push_back( _IsoEdge( fe.edges[j][flip] , fe.edges[j][1-flip] ) );
}
else
{
_Key key = _VertexData::FaceIndex( leaf , f , tree._localToGlobal( tree._maxDepth ) );
typename std::unordered_map< _Key , std::vector< _IsoEdge > , typename _Key::Hasher >::const_iterator iter = sValues.faceEdgeMap.find(key);
if( iter!=sValues.faceEdgeMap.end() )
{
const std::vector< _IsoEdge >& _edges = iter->second;
for( size_t j=0 ; j<_edges.size() ; j++ ) edges.push_back( _IsoEdge( _edges[j][flip] , _edges[j][1-flip] ) );
}
else ERROR_OUT( "Invalid faces: " , i , " " , fDir==HyperCube::BACK ? "back" : ( fDir==HyperCube::FRONT ? "front" : ( fDir==HyperCube::CROSS ? "cross" : "unknown" ) ) );
}
}
else
{
node_index_type fIdx = xValues.xSliceData.faceIndices((node_index_type)i)[ f.coIndex() ];
if( xValues.faceSet[fIdx] )
{
const _FaceEdges& fe = xValues.faceEdges[ fIdx ];
for( int j=0 ; j<fe.count ; j++ ) edges.push_back( _IsoEdge( fe.edges[j][flip] , fe.edges[j][1-flip] ) );
}
else
{
_Key key = _VertexData::FaceIndex( leaf , f , tree._localToGlobal( tree._maxDepth ) );
typename std::unordered_map< _Key , std::vector< _IsoEdge > , typename _Key::Hasher >::const_iterator iter = xValues.faceEdgeMap.find(key);
if( iter!=xValues.faceEdgeMap.end() )
{
const std::vector< _IsoEdge >& _edges = iter->second;
for( size_t j=0 ; j<_edges.size() ; j++ ) edges.push_back( _IsoEdge( _edges[j][flip] , _edges[j][1-flip] ) );
}
else ERROR_OUT( "Invalid faces: " , i , " " , fDir==HyperCube::BACK ? "back" : ( fDir==HyperCube::FRONT ? "front" : ( fDir==HyperCube::CROSS ? "cross" : "unknown" ) ) );
}
}
}
// Get the edge loops
std::vector< std::vector< _Key > > loops;
while( edges.size() )
{
loops.resize( loops.size()+1 );
_IsoEdge edge = edges.back();
edges.pop_back();
_Key start = edge[0] , current = edge[1];
while( current!=start )
{
int idx;
for( idx=0 ; idx<(int)edges.size() ; idx++ ) if( edges[idx][0]==current ) break;
if( idx==edges.size() )
{
typename std::unordered_map< _Key , _Key , typename _Key::Hasher >::const_iterator iter;
if ( (iter=bValues.vertexPairMap.find(current))!=bValues.vertexPairMap.end() ) loops.back().push_back( current ) , current = iter->second;
else if( (iter=fValues.vertexPairMap.find(current))!=fValues.vertexPairMap.end() ) loops.back().push_back( current ) , current = iter->second;
else if( (iter=xValues.vertexPairMap.find(current))!=xValues.vertexPairMap.end() ) loops.back().push_back( current ) , current = iter->second;
else
{
LocalDepth d ; LocalOffset off;
tree._localDepthAndOffset( leaf , d , off );
ERROR_OUT( "Failed to close loop [" , d-1 , ": " , off[0] , " " , off[1] , " " , off[2] , "] | (" , i , "): " , current.to_string() );
}
}
else
{
loops.back().push_back( current );
current = edges[idx][1];
edges[idx] = edges.back() , edges.pop_back();
}
}
loops.back().push_back( start );
}
// Add the loops to the mesh
for( size_t j=0 ; j<loops.size() ; j++ )
{
std::vector< std::pair< node_index_type , Vertex > > polygon( loops[j].size() );
for( size_t k=0 ; k<loops[j].size() ; k++ )
{
_Key key = loops[j][k];
typename std::unordered_map< _Key , std::pair< node_index_type , Vertex > , typename _Key::Hasher >::const_iterator iter;
size_t kk = flipOrientation ? loops[j].size()-1-k : k;
if ( ( iter=bValues.edgeVertexMap.find( key ) )!=bValues.edgeVertexMap.end() ) polygon[kk] = iter->second;
else if( ( iter=fValues.edgeVertexMap.find( key ) )!=fValues.edgeVertexMap.end() ) polygon[kk] = iter->second;
else if( ( iter=xValues.edgeVertexMap.find( key ) )!=xValues.edgeVertexMap.end() ) polygon[kk] = iter->second;
else ERROR_OUT( "Couldn't find vertex in edge map" );
}
_AddIsoPolygons( thread , mesh , polygon , polygonMesh , addBarycenter , vOffset );
}
}
}
}
}
);
}
template< unsigned int WeightDegree , typename Data , unsigned int DataSig >
static bool _GetIsoVertex( const FEMTree< Dim , Real >& tree , typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , Real isoValue , ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > >& weightKey , ConstPointSupportKey< IsotropicUIntPack< Dim , FEMSignature< DataSig >::Degree > >& dataKey , const TreeNode* node , typename HyperCube::template Cube< Dim-1 >::template Element< 1 > _e , HyperCube::Direction zDir , const _SliceValues& sValues , Vertex& vertex , std::function< void ( Vertex& , Point< Real , Dim > , Real , Data ) > SetVertex )
{
static const unsigned int DataDegree = FEMSignature< DataSig >::Degree;
Point< Real , Dim > position;
int c0 , c1;
const typename HyperCube::Cube< Dim-1 >::template Element< 0 > *_c = SliceData::template HyperCubeTables< Dim-1 , 1 , 0 >::OverlapElements[_e.index];
c0 = _c[0].index , c1 = _c[1].index;
bool nonLinearFit = sValues.cornerGradients!=NullPointer( Point< Real , Dim > );
const typename SliceData::SquareCornerIndices& idx = sValues.sliceData.cornerIndices( node );
Real x0 = sValues.cornerValues[idx[c0]] , x1 = sValues.cornerValues[idx[c1]];
Point< Real , Dim > s;
Real start , width;
tree._startAndWidth( node , s , width );
int o;
{
const HyperCube::Direction* dirs = SliceData::template HyperCubeTables< Dim-1 , 1 >::Directions[ _e.index ];
for( int d=0 ; d<Dim-1 ; d++ ) if( dirs[d]==HyperCube::CROSS )
{
o = d;
start = s[d];
for( int dd=1 ; dd<Dim-1 ; dd++ ) position[(d+dd)%(Dim-1)] = s[(d+dd)%(Dim-1)] + width * ( dirs[(d+dd)%(Dim-1)]==HyperCube::BACK ? 0 : 1 );
}
}
position[ Dim-1 ] = s[Dim-1] + width * ( zDir==HyperCube::BACK ? 0 : 1 );
double averageRoot;
bool rootFound = false;
if( nonLinearFit )
{
double dx0 = sValues.cornerGradients[idx[c0]][o] * width , dx1 = sValues.cornerGradients[idx[c1]][o] * width;
// The scaling will turn the Hermite Spline into a quadratic
double scl = (x1-x0) / ( (dx1+dx0 ) / 2 );
dx0 *= scl , dx1 *= scl;
// Hermite Spline
Polynomial< 2 > P;
P.coefficients[0] = x0;
P.coefficients[1] = dx0;
P.coefficients[2] = 3*(x1-x0)-dx1-2*dx0;
double roots[2];
int rCount = 0 , rootCount = P.getSolutions( isoValue , roots , 0 );
averageRoot = 0;
for( int i=0 ; i<rootCount ; i++ ) if( roots[i]>=0 && roots[i]<=1 ) averageRoot += roots[i] , rCount++;
if( rCount ) rootFound = true;
averageRoot /= rCount;
}
if( !rootFound )
{
// We have a linear function L, with L(0) = x0 and L(1) = x1
// => L(t) = x0 + t * (x1-x0)
// => L(t) = isoValue <=> t = ( isoValue - x0 ) / ( x1 - x0 )
if( x0==x1 ) ERROR_OUT( "Not a zero-crossing root: " , x0 , " " , x1 );
averageRoot = ( isoValue - x0 ) / ( x1 - x0 );
}
if( averageRoot<=0 || averageRoot>=1 )
{
_BadRootCount++;
if( averageRoot<0 ) averageRoot = 0;
if( averageRoot>1 ) averageRoot = 1;
}
position[o] = Real( start + width*averageRoot );
Real depth = (Real)1.;
Data dataValue;
if( densityWeights )
{
Real weight;
tree._getSampleDepthAndWeight( *densityWeights , node , position , weightKey , depth , weight );
}
if( data )
{
if( DataDegree==0 )
{
Point< Real , 3 > center( s[0] + width/2 , s[1] + width/2 , s[2] + width/2 );
dataValue = tree.template _evaluate< ProjectiveData< Data , Real > , SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > > , 0 >( *data , center , *pointEvaluator , dataKey ).value();
}
else dataValue = tree.template _evaluate< ProjectiveData< Data , Real > , SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > > , 0 >( *data , position , *pointEvaluator , dataKey ).value();
}
SetVertex( vertex , position , depth , dataValue );
return true;
}
template< unsigned int WeightDegree , typename Data , unsigned int DataSig >
static bool _GetIsoVertex( const FEMTree< Dim , Real >& tree , typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , Real isoValue , ConstPointSupportKey< IsotropicUIntPack< Dim , WeightDegree > >& weightKey , ConstPointSupportKey< IsotropicUIntPack< Dim , FEMSignature< DataSig >::Degree > >& dataKey , const TreeNode* node , typename HyperCube::template Cube< Dim-1 >::template Element< 0 > _c , const _SliceValues& bValues , const _SliceValues& fValues , Vertex& vertex , std::function< void ( Vertex& , Point< Real , Dim > , Real , Data ) > SetVertex )
{
static const unsigned int DataDegree = FEMSignature< DataSig >::Degree;
Point< Real , Dim > position;
bool nonLinearFit = bValues.cornerGradients!=NullPointer( Point< Real , Dim > ) && fValues.cornerGradients!=NullPointer( Point< Real , Dim > );
const typename SliceData::SquareCornerIndices& idx0 = bValues.sliceData.cornerIndices( node );
const typename SliceData::SquareCornerIndices& idx1 = fValues.sliceData.cornerIndices( node );
Real x0 = bValues.cornerValues[ idx0[_c.index] ] , x1 = fValues.cornerValues[ idx1[_c.index] ];
Point< Real , Dim > s;
Real start , width;
tree._startAndWidth( node , s , width );
start = s[2];
int x , y;
{
const HyperCube::Direction* xx = SliceData::template HyperCubeTables< Dim-1 , 0 >::Directions[ _c.index ];
x = xx[0]==HyperCube::BACK ? 0 : 1 , y = xx[1]==HyperCube::BACK ? 0 : 1;
}
position[0] = s[0] + width*x;
position[1] = s[1] + width*y;
double averageRoot;
bool rootFound = false;
if( nonLinearFit )
{
double dx0 = bValues.cornerGradients[ idx0[_c.index] ][2] * width , dx1 = fValues.cornerGradients[ idx1[_c.index] ][2] * width;
// The scaling will turn the Hermite Spline into a quadratic
double scl = (x1-x0) / ( (dx1+dx0 ) / 2 );
dx0 *= scl , dx1 *= scl;
// Hermite Spline
Polynomial< 2 > P;
P.coefficients[0] = x0;
P.coefficients[1] = dx0;
P.coefficients[2] = 3*(x1-x0)-dx1-2*dx0;
double roots[2];
int rCount = 0 , rootCount = P.getSolutions( isoValue , roots , 0 );
averageRoot = 0;
for( int i=0 ; i<rootCount ; i++ ) if( roots[i]>=0 && roots[i]<=1 ) averageRoot += roots[i] , rCount++;
if( rCount ) rootFound = true;
averageRoot /= rCount;
}
if( !rootFound )
{
// We have a linear function L, with L(0) = x0 and L(1) = x1
// => L(t) = x0 + t * (x1-x0)
// => L(t) = isoValue <=> t = ( isoValue - x0 ) / ( x1 - x0 )
if( x0==x1 ) ERROR_OUT( "Not a zero-crossing root: " , x0 , " " , x1 );
averageRoot = ( isoValue - x0 ) / ( x1 - x0 );
}
if( averageRoot<=0 || averageRoot>=1 )
{
_BadRootCount++;
}
position[2] = Real( start + width*averageRoot );
Real depth = (Real)1.;
Data dataValue;
if( densityWeights )
{
Real weight;
tree._getSampleDepthAndWeight( *densityWeights , node , position , weightKey , depth , weight );
}
if( data )
{
if( DataDegree==0 )
{
Point< Real , 3 > center( s[0] + width/2 , s[1] + width/2 , s[2] + width/2 );
dataValue = tree.template _evaluate< ProjectiveData< Data , Real > , SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > > , 0 >( *data , center , *pointEvaluator , dataKey ).value();
}
else dataValue = tree.template _evaluate< ProjectiveData< Data , Real > , SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > > , 0 >( *data , position , *pointEvaluator , dataKey ).value();
}
SetVertex( vertex , position , depth , dataValue );
return true;
}
static unsigned int _AddIsoPolygons( unsigned int thread , CoredMeshData< Vertex , node_index_type >& mesh , std::vector< std::pair< node_index_type , Vertex > >& polygon , bool polygonMesh , bool addBarycenter , node_index_type &vOffset )
{
if( polygonMesh )
{
std::vector< node_index_type > vertices( polygon.size() );
for( unsigned int i=0 ; i<polygon.size() ; i++ ) vertices[i] = polygon[polygon.size()-1-i].first;
mesh.addPolygon_s( thread , vertices );
return 1;
}
if( polygon.size()>3 )
{
bool isCoplanar = false;
std::vector< node_index_type > triangle( 3 );
if( addBarycenter )
for( unsigned int i=0 ; i<polygon.size() ; i++ ) for( unsigned int j=0 ; j<i ; j++ )
if( (i+1)%polygon.size()!=j && (j+1)%polygon.size()!=i )
{
Vertex v1 = polygon[i].second , v2 = polygon[j].second;
for( int k=0 ; k<3 ; k++ ) if( v1.point[k]==v2.point[k] ) isCoplanar = true;
}
if( isCoplanar )
{
Vertex c;
c *= 0;
for( unsigned int i=0 ; i<polygon.size() ; i++ ) c += polygon[i].second;
c /= ( typename Vertex::Real )polygon.size();
node_index_type cIdx;
{
std::lock_guard< std::mutex > lock( _pointInsertionMutex );
cIdx = mesh.addOutOfCorePoint( c );
vOffset++;
}
for( unsigned i=0 ; i<polygon.size() ; i++ )
{
triangle[0] = polygon[ i ].first;
triangle[1] = cIdx;
triangle[2] = polygon[(i+1)%polygon.size()].first;
mesh.addPolygon_s( thread , triangle );
}
return (unsigned int)polygon.size();
}
else
{
std::vector< Point< Real , Dim > > vertices( polygon.size() );
for( unsigned int i=0 ; i<polygon.size() ; i++ ) vertices[i] = polygon[i].second.point;
std::vector< TriangleIndex< node_index_type > > triangles = MinimalAreaTriangulation< node_index_type , Real , Dim >( ( ConstPointer( Point< Real , Dim > ) )GetPointer( vertices ) , (node_index_type)vertices.size() );
if( triangles.size()!=polygon.size()-2 ) ERROR_OUT( "Minimal area triangulation failed:" , triangles.size() , " != " , polygon.size()-2 );
for( unsigned int i=0 ; i<triangles.size() ; i++ )
{
for( int j=0 ; j<3 ; j++ ) triangle[2-j] = polygon[ triangles[i].idx[j] ].first;
mesh.addPolygon_s( thread , triangle );
}
}
}
else if( polygon.size()==3 )
{
std::vector< node_index_type > vertices( 3 );
for( int i=0 ; i<3 ; i++ ) vertices[2-i] = polygon[i].first;
mesh.addPolygon_s( thread , vertices );
}
return (unsigned int)polygon.size()-2;
}
public:
struct IsoStats
{
double cornersTime , verticesTime , edgesTime , surfaceTime;
double copyFinerTime , setTableTime;
IsoStats( void ) : cornersTime(0) , verticesTime(0) , edgesTime(0) , surfaceTime(0) , copyFinerTime(0) , setTableTime(0) {;}
std::string toString( void ) const
{
std::stringstream stream;
stream << "Corners / Vertices / Edges / Surface / Set Table / Copy Finer: ";
stream << std::fixed << std::setprecision(1) << cornersTime << " / " << verticesTime << " / " << edgesTime << " / " << surfaceTime << " / " << setTableTime << " / " << copyFinerTime;
stream << " (s)";
return stream.str();
}
};
template< typename Data , typename SetVertexFunction , unsigned int ... FEMSigs , unsigned int WeightDegree , unsigned int DataSig >
static IsoStats Extract( UIntPack< FEMSigs ... > , UIntPack< WeightDegree > , UIntPack< DataSig > , const FEMTree< Dim , Real >& tree , const DensityEstimator< WeightDegree >* densityWeights , const SparseNodeData< ProjectiveData< Data , Real > , IsotropicUIntPack< Dim , DataSig > >* data , const DenseNodeData< Real , UIntPack< FEMSigs ... > >& coefficients , Real isoValue , CoredMeshData< Vertex , node_index_type >& mesh , const SetVertexFunction &SetVertex , bool nonLinearFit , bool addBarycenter , bool polygonMesh , bool flipOrientation )
{
_BadRootCount = 0u;
IsoStats isoStats;
static_assert( sizeof...(FEMSigs)==Dim , "[ERROR] Number of signatures should match dimension" );
tree._setFEM1ValidityFlags( UIntPack< FEMSigs ... >() );
static const unsigned int DataDegree = FEMSignature< DataSig >::Degree;
static const int FEMDegrees[] = { FEMSignature< FEMSigs >::Degree ... };
for( int d=0 ; d<Dim ; d++ ) if( FEMDegrees[d]==0 && nonLinearFit ) WARN( "Constant B-Splines do not support non-linear interpolation" ) , nonLinearFit = false;
SliceData::SetHyperCubeTables();
typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >* pointEvaluator = NULL;
if( data ) pointEvaluator = new typename FEMIntegrator::template PointEvaluator< IsotropicUIntPack< Dim , DataSig > , ZeroUIntPack< Dim > >( tree._maxDepth );
DenseNodeData< Real , UIntPack< FEMSigs ... > > coarseCoefficients( tree._sNodesEnd( tree._maxDepth-1 ) );
memset( coarseCoefficients() , 0 , sizeof(Real)*tree._sNodesEnd( tree._maxDepth-1 ) );
ThreadPool::Parallel_for( tree._sNodesBegin(0) , tree._sNodesEnd( tree._maxDepth-1 ) , [&]( unsigned int, size_t i ){ coarseCoefficients[i] = coefficients[i]; } );
typename FEMIntegrator::template RestrictionProlongation< UIntPack< FEMSigs ... > > rp;
for( LocalDepth d=1 ; d<tree._maxDepth ; d++ ) tree._upSample( UIntPack< FEMSigs ... >() , rp , d , coarseCoefficients() );
FEMTree< Dim , Real >::MemoryUsage();
std::vector< _Evaluator< UIntPack< FEMSigs ... > , 1 > > evaluators( tree._maxDepth+1 );
for( LocalDepth d=0 ; d<=tree._maxDepth ; d++ ) evaluators[d].set( tree._maxDepth );
node_index_type vertexOffset = 0;
std::vector< _SlabValues > slabValues( tree._maxDepth+1 );
// Initialize the back slice
for( LocalDepth d=tree._maxDepth ; d>=0 ; d-- )
{
double t = Time();
SliceData::SetSliceTableData( tree._sNodes , &slabValues[d].sliceValues(0).sliceData , &slabValues[d].xSliceValues(0).xSliceData , &slabValues[d].sliceValues(1).sliceData , tree._localToGlobal( d ) , tree._localInset( d ) );
isoStats.setTableTime += Time()-t;
slabValues[d].sliceValues (0).reset( nonLinearFit );
slabValues[d].sliceValues (1).reset( nonLinearFit );
slabValues[d].xSliceValues(0).reset( );
}
for( LocalDepth d=tree._maxDepth ; d>=0 ; d-- )
{
// Copy edges from finer
double t = Time();
if( d<tree._maxDepth ) _CopyFinerSliceIsoEdgeKeys( tree , d , 0 , slabValues );
isoStats.copyFinerTime += Time()-t , t = Time();
_SetSliceIsoCorners< FEMSigs ... >( tree , coefficients() , coarseCoefficients() , isoValue , d , 0 , slabValues , evaluators[d] );
isoStats.cornersTime += Time()-t , t = Time();
_SetSliceIsoVertices< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , d , 0 , vertexOffset , mesh , slabValues , SetVertex );
isoStats.verticesTime += Time()-t , t = Time();
_SetSliceIsoEdges( tree , d , 0 , slabValues );
isoStats.edgesTime += Time()-t , t = Time();
}
// Iterate over the slices at the finest level
for( int slice=0 ; slice<( 1<<tree._maxDepth ) ; slice++ )
{
// Process at all depths that contain this slice
LocalDepth d ; int o;
for( d=tree._maxDepth , o=slice+1 ; d>=0 ; d-- , o>>=1 )
{
// Copy edges from finer (required to ensure we correctly track edge cancellations)
double t = Time();
if( d<tree._maxDepth )
{
_CopyFinerSliceIsoEdgeKeys( tree , d , o , slabValues );
_CopyFinerXSliceIsoEdgeKeys( tree , d , o-1 , slabValues );
}
isoStats.copyFinerTime += Time()-t , t = Time();
// Set the slice values/vertices
_SetSliceIsoCorners< FEMSigs ... >( tree , coefficients() , coarseCoefficients() , isoValue , d , o , slabValues , evaluators[d] );
isoStats.cornersTime += Time()-t , t = Time();
_SetSliceIsoVertices< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , d , o , vertexOffset , mesh , slabValues , SetVertex );
isoStats.verticesTime += Time()-t , t = Time();
_SetSliceIsoEdges( tree , d , o , slabValues );
isoStats.edgesTime += Time()-t , t = Time();
// Set the cross-slice edges
_SetXSliceIsoVertices< WeightDegree , Data , DataSig >( tree , pointEvaluator , densityWeights , data , isoValue , d , o-1 , vertexOffset , mesh , slabValues , SetVertex );
isoStats.verticesTime += Time()-t , t = Time();
_SetXSliceIsoEdges( tree , d , o-1 , slabValues );
isoStats.edgesTime += Time()-t , t = Time();
ThreadPool::ParallelSections
(
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o-1).setEdgeVertexMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o ).setEdgeVertexMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d].xSliceValues(o-1).setEdgeVertexMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o-1).setVertexPairMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o ).setVertexPairMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d].xSliceValues(o-1).setVertexPairMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o-1).setFaceEdgeMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d]. sliceValues(o ).setFaceEdgeMap(); } ,
[ &slabValues , d , o ]( void ){ slabValues[d].xSliceValues(o-1).setFaceEdgeMap(); }
);
// Add the triangles
t = Time();
_SetIsoSurface( tree , d , o-1 , slabValues[d].sliceValues(o-1) , slabValues[d].sliceValues(o) , slabValues[d].xSliceValues(o-1) , mesh , polygonMesh , addBarycenter , vertexOffset , flipOrientation );
isoStats.surfaceTime += Time()-t;
if( o&1 ) break;
}
for( d=tree._maxDepth , o=slice+1 ; d>=0 ; d-- , o>>=1 )
{
// Initialize for the next pass
if( o<(1<<(d+1)) )
{
double t = Time();
SliceData::SetSliceTableData( tree._sNodes , NULL , &slabValues[d].xSliceValues(o).xSliceData , &slabValues[d].sliceValues(o+1).sliceData , tree._localToGlobal( d ) , o + tree._localInset( d ) );
isoStats.setTableTime += Time()-t;
slabValues[d].sliceValues(o+1).reset( nonLinearFit );
slabValues[d].xSliceValues(o).reset();
}
if( o&1 ) break;
}
}
FEMTree< Dim , Real >::MemoryUsage();
if( pointEvaluator ) delete pointEvaluator;
size_t badRootCount = _BadRootCount;
if( badRootCount!=0 ) WARN( "bad average roots: " , badRootCount );
return isoStats;
}
};
template< class Real , class Vertex > std::mutex IsoSurfaceExtractor< 3 , Real , Vertex >::_pointInsertionMutex;
template< class Real , class Vertex > std::atomic< size_t > IsoSurfaceExtractor< 3 , Real , Vertex >::_BadRootCount;
template< class Real , class Vertex > template< unsigned int D , unsigned int K >
unsigned int IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K >::CellOffset[ HyperCube::Cube< D >::template ElementNum< K >() ][ HyperCube::Cube< D >::template IncidentCubeNum< K >() ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K >
unsigned int IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K >::IncidentElementCoIndex[ HyperCube::Cube< D >::template ElementNum< K >() ][ HyperCube::Cube< D >::template IncidentCubeNum< K >() ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K >
unsigned int IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K >::CellOffsetAntipodal[ HyperCube::Cube< D >::template ElementNum< K >() ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K >
typename HyperCube::Cube< D >::template IncidentCubeIndex < K > IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K >::IncidentCube[ HyperCube::Cube< D >::template ElementNum< K >() ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K >
typename HyperCube::Direction IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K >::Directions[ HyperCube::Cube< D >::template ElementNum< K >() ][ D ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K1 , unsigned int K2 >
typename HyperCube::Cube< D >::template Element< K2 > IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K1 , K2 >::OverlapElements[ HyperCube::Cube< D >::template ElementNum< K1 >() ][ HyperCube::Cube< D >::template OverlapElementNum< K1 , K2 >() ];
template< class Real , class Vertex > template< unsigned int D , unsigned int K1 , unsigned int K2 >
bool IsoSurfaceExtractor< 3 , Real , Vertex >::SliceData::HyperCubeTables< D , K1 , K2 >::Overlap[ HyperCube::Cube< D >::template ElementNum< K1 >() ][ HyperCube::Cube< D >::template ElementNum< K2 >() ];
| 54.89734 | 785 | 0.65075 | DamonsJ |
28bc3aa89f9c3c29f8a3e2e9536533af149ceb1f | 774 | cpp | C++ | test/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp | caiohamamura/libcxx | 27c836ff3a9c505deb9fd1616012924de8ff9279 | [
"MIT"
] | 1,244 | 2015-01-02T21:08:56.000Z | 2022-03-22T21:34:16.000Z | test/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp | caiohamamura/libcxx | 27c836ff3a9c505deb9fd1616012924de8ff9279 | [
"MIT"
] | 125 | 2015-01-22T01:08:00.000Z | 2020-05-25T08:28:17.000Z | test/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp | caiohamamura/libcxx | 27c836ff3a9c505deb9fd1616012924de8ff9279 | [
"MIT"
] | 124 | 2015-01-12T15:06:17.000Z | 2022-03-26T07:48:53.000Z | //===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <locale>
// class time_base
// {
// public:
// enum dateorder {no_order, dmy, mdy, ymd, ydm};
// };
#include <locale>
#include <cassert>
int main()
{
std::time_base::dateorder d = std::time_base::no_order;
assert(std::time_base::no_order == 0);
assert(std::time_base::dmy == 1);
assert(std::time_base::mdy == 2);
assert(std::time_base::ymd == 3);
assert(std::time_base::ydm == 4);
}
| 25.8 | 80 | 0.489664 | caiohamamura |
28bd1df68cd3643736999d01cb1bdc1184d60d1c | 7,492 | hpp | C++ | server/api_grammar.hpp | aaronbenz/osrm-backend | 758d4023050d1f49971f919cea872a2276dafe14 | [
"BSD-2-Clause"
] | 1 | 2021-03-06T05:07:44.000Z | 2021-03-06T05:07:44.000Z | server/api_grammar.hpp | aaronbenz/osrm-backend | 758d4023050d1f49971f919cea872a2276dafe14 | [
"BSD-2-Clause"
] | null | null | null | server/api_grammar.hpp | aaronbenz/osrm-backend | 758d4023050d1f49971f919cea872a2276dafe14 | [
"BSD-2-Clause"
] | null | null | null | /*
Copyright (c) 2013, Project OSRM contributors
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef API_GRAMMAR_HPP
#define API_GRAMMAR_HPP
#include <boost/bind.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_action.hpp>
namespace qi = boost::spirit::qi;
template <typename Iterator, class HandlerT> struct APIGrammar : qi::grammar<Iterator>
{
explicit APIGrammar(HandlerT *h) : APIGrammar::base_type(api_call), handler(h)
{
api_call = qi::lit('/') >> string[boost::bind(&HandlerT::setService, handler, ::_1)] >>
-query;
query = ('?') >> +(zoom | output | jsonp | checksum | uturns | location_with_options | destination_with_options | source_with_options | cmp |
language | instruction | geometry | alt_route | old_API | num_results |
matching_beta | gps_precision | classify | locs);
// all combinations of timestamp, uturn, hint and bearing without duplicates
t_u = (u >> -timestamp) | (timestamp >> -u);
t_h = (hint >> -timestamp) | (timestamp >> -hint);
u_h = (u >> -hint) | (hint >> -u);
t_u_h = (hint >> -t_u) | (u >> -t_h) | (timestamp >> -u_h);
location_options = (bearing >> -t_u_h) | (t_u_h >> -bearing) | //
(u >> bearing >> -t_h) | (timestamp >> bearing >> -u_h) | (hint >> bearing >> t_u) | //
(t_h >> bearing >> -u) | (u_h >> bearing >> -timestamp) | (t_u >> bearing >> -hint);
location_with_options = location >> -location_options;
source_with_options = source >> -location_options;
destination_with_options = destination >> -location_options;
zoom = (-qi::lit('&')) >> qi::lit('z') >> '=' >>
qi::short_[boost::bind(&HandlerT::setZoomLevel, handler, ::_1)];
output = (-qi::lit('&')) >> qi::lit("output") >> '=' >>
string[boost::bind(&HandlerT::setOutputFormat, handler, ::_1)];
jsonp = (-qi::lit('&')) >> qi::lit("jsonp") >> '=' >>
stringwithPercent[boost::bind(&HandlerT::setJSONpParameter, handler, ::_1)];
checksum = (-qi::lit('&')) >> qi::lit("checksum") >> '=' >>
qi::uint_[boost::bind(&HandlerT::setChecksum, handler, ::_1)];
instruction = (-qi::lit('&')) >> qi::lit("instructions") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setInstructionFlag, handler, ::_1)];
geometry = (-qi::lit('&')) >> qi::lit("geometry") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setGeometryFlag, handler, ::_1)];
cmp = (-qi::lit('&')) >> qi::lit("compression") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setCompressionFlag, handler, ::_1)];
location = (-qi::lit('&')) >> qi::lit("loc") >> '=' >>
(qi::double_ >> qi::lit(',') >>
qi::double_)[boost::bind(&HandlerT::addCoordinate, handler, ::_1)];
destination = (-qi::lit('&')) >> qi::lit("dst") >> '=' >>
(qi::double_ >> qi::lit(',') >>
qi::double_)[boost::bind(&HandlerT::addDestination, handler, ::_1)];
source = (-qi::lit('&')) >> qi::lit("src") >> '=' >>
(qi::double_ >> qi::lit(',') >>
qi::double_)[boost::bind(&HandlerT::addSource, handler, ::_1)];
hint = (-qi::lit('&')) >> qi::lit("hint") >> '=' >>
stringwithDot[boost::bind(&HandlerT::addHint, handler, ::_1)];
timestamp = (-qi::lit('&')) >> qi::lit("t") >> '=' >>
qi::uint_[boost::bind(&HandlerT::addTimestamp, handler, ::_1)];
bearing = (-qi::lit('&')) >> qi::lit("b") >> '=' >>
(qi::int_ >> -(qi::lit(',') >> qi::int_ | qi::attr(10)))[boost::bind(&HandlerT::addBearing, handler, ::_1, ::_2, ::_3)];
u = (-qi::lit('&')) >> qi::lit("u") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setUTurn, handler, ::_1)];
uturns = (-qi::lit('&')) >> qi::lit("uturns") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setAllUTurns, handler, ::_1)];
language = (-qi::lit('&')) >> qi::lit("hl") >> '=' >>
string[boost::bind(&HandlerT::setLanguage, handler, ::_1)];
alt_route = (-qi::lit('&')) >> qi::lit("alt") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setAlternateRouteFlag, handler, ::_1)];
old_API = (-qi::lit('&')) >> qi::lit("geomformat") >> '=' >>
string[boost::bind(&HandlerT::setDeprecatedAPIFlag, handler, ::_1)];
num_results = (-qi::lit('&')) >> qi::lit("num_results") >> '=' >>
qi::short_[boost::bind(&HandlerT::setNumberOfResults, handler, ::_1)];
matching_beta = (-qi::lit('&')) >> qi::lit("matching_beta") >> '=' >>
qi::float_[boost::bind(&HandlerT::setMatchingBeta, handler, ::_1)];
gps_precision = (-qi::lit('&')) >> qi::lit("gps_precision") >> '=' >>
qi::float_[boost::bind(&HandlerT::setGPSPrecision, handler, ::_1)];
classify = (-qi::lit('&')) >> qi::lit("classify") >> '=' >>
qi::bool_[boost::bind(&HandlerT::setClassify, handler, ::_1)];
locs = (-qi::lit('&')) >> qi::lit("locs") >> '=' >>
stringforPolyline[boost::bind(&HandlerT::getCoordinatesFromGeometry, handler, ::_1)];
string = +(qi::char_("a-zA-Z"));
stringwithDot = +(qi::char_("a-zA-Z0-9_.-"));
stringwithPercent = +(qi::char_("a-zA-Z0-9_.-") | qi::char_('[') | qi::char_(']') |
(qi::char_('%') >> qi::char_("0-9A-Z") >> qi::char_("0-9A-Z")));
stringforPolyline = +(qi::char_("a-zA-Z0-9_.-[]{}@?|\\%~`^"));
}
qi::rule<Iterator> api_call, query, location_options, location_with_options, destination_with_options, source_with_options, t_u, t_h, u_h, t_u_h;
qi::rule<Iterator, std::string()> service, zoom, output, string, jsonp, checksum, location, destination, source,
hint, timestamp, bearing, stringwithDot, stringwithPercent, language, geometry, cmp, alt_route, u,
uturns, old_API, num_results, matching_beta, gps_precision, classify, locs, instruction, stringforPolyline;
HandlerT *handler;
};
#endif /* API_GRAMMAR_HPP */
| 60.910569 | 150 | 0.573946 | aaronbenz |
28bd5aed619a987f6f1a13ee398a199eec1d31bb | 2,377 | cpp | C++ | rs/test/if_empty_test.cpp | dymk/rs | b75ab0df5f235ac12ec4da825e6bd6e1fa9e7493 | [
"Apache-2.0"
] | 19 | 2017-05-15T08:20:00.000Z | 2021-12-03T05:58:32.000Z | rs/test/if_empty_test.cpp | dymk/rs | b75ab0df5f235ac12ec4da825e6bd6e1fa9e7493 | [
"Apache-2.0"
] | null | null | null | rs/test/if_empty_test.cpp | dymk/rs | b75ab0df5f235ac12ec4da825e6bd6e1fa9e7493 | [
"Apache-2.0"
] | 3 | 2018-01-16T18:07:30.000Z | 2021-06-30T07:33:44.000Z | // Copyright 2017 Per Grön. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <catch.hpp>
#include <string>
#include <vector>
#include <rs/if_empty.h>
#include <rs/just.h>
#include "infinite_range.h"
#include "test_util.h"
namespace shk {
TEST_CASE("IfEmpty") {
SECTION("type") {
auto stream = IfEmpty(Just())(Just());
static_assert(
IsPublisher<decltype(stream)>,
"IfEmpty stream should be a publisher");
}
SECTION("non-empty stream") {
auto null_publisher = MakePublisher([](auto &&subscriber) {
CHECK(!"should not be subscribed to");
return MakeSubscription();
});
SECTION("one value") {
auto stream = IfEmpty(null_publisher)(Just(2));
CHECK(GetAll<int>(stream) == (std::vector<int>{ 2 }));
}
SECTION("several values") {
auto stream = IfEmpty(null_publisher)(Just(2, 4, 6, 8));
CHECK(GetAll<int>(stream) == (std::vector<int>{ 2, 4, 6, 8 }));
}
SECTION("noncopyable value") {
auto if_empty = IfEmpty(Start([] { return std::make_unique<int>(1); }));
auto stream = if_empty(Start([] { return std::make_unique<int>(2); }));
auto result = GetAll<std::unique_ptr<int>>(stream);
REQUIRE(result.size() == 1);
REQUIRE(result[0]);
CHECK(*result[0] == 2);
}
SECTION("don't leak the subscriber") {
CheckLeak(IfEmpty(Just(1))(Just(2)));
}
}
SECTION("empty stream") {
SECTION("one value") {
auto stream = IfEmpty(Just(1))(Just());
CHECK(GetAll<int>(stream) == (std::vector<int>{ 1 }));
}
SECTION("several values") {
auto stream = IfEmpty(Just(1, 2, 3))(Just());
CHECK(GetAll<int>(stream) == (std::vector<int>{ 1, 2, 3 }));
}
SECTION("don't leak the subscriber") {
CheckLeak(IfEmpty(Just(1))(Just()));
}
}
}
} // namespace shk
| 28.297619 | 78 | 0.625999 | dymk |
28c44172bf3c7d44323a7f7fde8bda2fbb4e42c5 | 6,213 | cpp | C++ | src/pmp/gl/MeshViewer.cpp | choyfung/pmp-library | 4a72c918494dac92f5e77545b71c7a327dafe71e | [
"BSD-3-Clause"
] | 1 | 2020-05-21T04:15:44.000Z | 2020-05-21T04:15:44.000Z | src/pmp/gl/MeshViewer.cpp | choyfung/pmp-library | 4a72c918494dac92f5e77545b71c7a327dafe71e | [
"BSD-3-Clause"
] | null | null | null | src/pmp/gl/MeshViewer.cpp | choyfung/pmp-library | 4a72c918494dac92f5e77545b71c7a327dafe71e | [
"BSD-3-Clause"
] | 1 | 2020-05-21T04:15:52.000Z | 2020-05-21T04:15:52.000Z | //=============================================================================
// Copyright (C) 2011-2018 The pmp-library developers
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//=============================================================================
#include "MeshViewer.h"
#include <imgui.h>
#include <cfloat>
#include <iostream>
#include <sstream>
//=============================================================================
namespace pmp {
//=============================================================================
MeshViewer::MeshViewer(const char* title, int width, int height, bool showgui)
: TrackballViewer(title, width, height, showgui)
{
// setup draw modes
clearDrawModes();
addDrawMode("Points");
addDrawMode("Hidden Line");
addDrawMode("Smooth Shading");
addDrawMode("Texture");
setDrawMode("Smooth Shading");
m_creaseAngle = 90.0;
}
//-----------------------------------------------------------------------------
MeshViewer::~MeshViewer() = default;
//-----------------------------------------------------------------------------
bool MeshViewer::loadMesh(const char* filename)
{
// load mesh
if (m_mesh.read(filename))
{
// update scene center and bounds
BoundingBox bb = m_mesh.bounds();
setScene(bb.center(), 0.5 * bb.size());
// compute face & vertex normals, update face indices
updateMesh();
std::cout << "Load " << filename << ": " << m_mesh.nVertices()
<< " vertices, " << m_mesh.nFaces() << " faces\n";
m_filename = filename;
m_creaseAngle = m_mesh.creaseAngle();
return true;
}
std::cerr << "Failed to read mesh from " << filename << " !" << std::endl;
return false;
}
//-----------------------------------------------------------------------------
bool MeshViewer::loadTexture(const char* filename, GLint format,
GLint minFilter, GLint magFilter, GLint wrap)
{
// load texture from file
if (!m_mesh.loadTexture(filename, format, minFilter, magFilter, wrap))
return false;
setDrawMode("Texture");
// set material
m_mesh.setAmbient(1.0);
m_mesh.setDiffuse(0.9);
m_mesh.setSpecular(0.0);
m_mesh.setShininess(1.0);
return true;
}
//-----------------------------------------------------------------------------
void MeshViewer::updateMesh()
{
// re-compute face and vertex normals
m_mesh.updateOpenGLBuffers();
}
//-----------------------------------------------------------------------------
void MeshViewer::processImGUI()
{
if (ImGui::CollapsingHeader("Mesh Info", ImGuiTreeNodeFlags_DefaultOpen))
{
// output mesh statistics
ImGui::BulletText("%d vertices", (int)m_mesh.nVertices());
ImGui::BulletText("%d edges", (int)m_mesh.nEdges());
ImGui::BulletText("%d faces", (int)m_mesh.nFaces());
// control crease angle
ImGui::PushItemWidth(100);
ImGui::SliderFloat("Crease Angle", &m_creaseAngle, 0.0f, 180.0f,
"%.0f");
ImGui::PopItemWidth();
if (m_creaseAngle != m_mesh.creaseAngle())
{
m_mesh.setCreaseAngle(m_creaseAngle);
std::cerr << "change crease angle\n";
}
}
}
//-----------------------------------------------------------------------------
void MeshViewer::draw(const std::string& drawMode)
{
// draw mesh
m_mesh.draw(m_projectionMatrix, m_modelviewMatrix, drawMode);
}
//-----------------------------------------------------------------------------
//
void MeshViewer::keyboard(int key, int scancode, int action, int mods)
{
if (action != GLFW_PRESS && action != GLFW_REPEAT)
return;
switch (key)
{
case GLFW_KEY_BACKSPACE: // reload model
{
loadMesh(m_filename.c_str());
break;
}
case GLFW_KEY_C: // adjust crease angle
{
if (mods & GLFW_MOD_SHIFT)
m_mesh.setCreaseAngle(m_mesh.creaseAngle() + 10);
else
m_mesh.setCreaseAngle(m_mesh.creaseAngle() - 10);
m_creaseAngle = m_mesh.creaseAngle();
std::cout << "crease angle: " << m_mesh.creaseAngle() << std::endl;
break;
}
case GLFW_KEY_O: // write mesh
{
m_mesh.write("output.off");
break;
}
default:
{
TrackballViewer::keyboard(key, scancode, action, mods);
break;
}
}
}
//=============================================================================
} // namespace pmp
//=============================================================================
| 32.528796 | 80 | 0.532593 | choyfung |
28c58478d55622296b9540fb61d83e076cbf5c9e | 5,087 | cpp | C++ | src/cpp/server/scene/SceneView.cpp | ey6es/witgap | 8f4af7adbde6bb172b4c66c0969e6f5d8736e7cb | [
"BSD-2-Clause"
] | 2 | 2017-06-24T03:47:12.000Z | 2017-08-11T00:04:46.000Z | src/cpp/server/scene/SceneView.cpp | ey6es/witgap | 8f4af7adbde6bb172b4c66c0969e6f5d8736e7cb | [
"BSD-2-Clause"
] | null | null | null | src/cpp/server/scene/SceneView.cpp | ey6es/witgap | 8f4af7adbde6bb172b4c66c0969e6f5d8736e7cb | [
"BSD-2-Clause"
] | null | null | null | //
// $Id$
#include <QtDebug>
#include "actor/Pawn.h"
#include "net/Session.h"
#include "scene/Scene.h"
#include "scene/SceneView.h"
SceneView::SceneView (Session* session) :
Component(0)
{
connect(session, SIGNAL(didEnterScene(Scene*)), SLOT(handleDidEnterScene(Scene*)));
connect(session, SIGNAL(willLeaveScene(Scene*)), SLOT(handleWillLeaveScene(Scene*)));
}
SceneView::~SceneView ()
{
Session* session = this->session();
if (session != 0) {
Scene* scene = session->scene();
if (scene != 0) {
scene->removeSpatial(this);
}
}
}
void SceneView::setWorldBounds (const QRect& bounds)
{
if (_worldBounds != bounds) {
QRect oldBounds = _worldBounds;
Scene* scene = session()->scene();
if (scene == 0) {
_worldBounds = bounds;
_scrollAmount = QPoint(0, 0);
} else {
// detect scrolling
if (_worldBounds.size() == bounds.size() && _worldBounds.intersects(bounds)) {
QPoint delta = _worldBounds.topLeft() - bounds.topLeft();
_scrollAmount += delta;
scrollDirty(delta);
} else {
_scrollAmount = QPoint(0, 0);
dirty();
}
scene->removeSpatial(this);
_worldBounds = bounds;
scene->addSpatial(this);
}
emit worldBoundsChanged(oldBounds);
}
}
void SceneView::handleDidEnterScene (Scene* scene)
{
scene->addSpatial(this);
connect(scene, SIGNAL(recordChanged(SceneRecord)), SLOT(maybeScroll()));
Pawn* pawn = session()->pawn();
if (pawn != 0) {
// center around the pawn and adjust when it moves
connect(pawn, SIGNAL(positionChanged(QPoint)), SLOT(maybeScroll()));
QSize size = _bounds.size();
setWorldBounds(QRect(pawn->position() - QPoint(size.width()/2, size.height()/2), size));
}
_scrollAmount = QPoint(0, 0);
dirty();
}
void SceneView::handleWillLeaveScene (Scene* scene)
{
Pawn* pawn = session()->pawn();
if (pawn != 0) {
disconnect(pawn);
}
disconnect(scene);
scene->removeSpatial(this);
}
/**
* Helper function for maybeScroll: returns the signed distance between the specified value and the
* given range.
*/
static int getDelta (int value, int start, int end)
{
return (value < start) ? (value - start) : (value > end ? (value - end) : 0);
}
void SceneView::maybeScroll ()
{
Session* session = this->session();
const SceneRecord& record = session->scene()->record();
QRect scrollBounds(
_worldBounds.left() + _worldBounds.width()/2 - record.scrollWidth/2,
_worldBounds.top() + _worldBounds.height()/2 - record.scrollHeight/2,
record.scrollWidth, record.scrollHeight);
// scroll to fit the pawn position within the scroll bounds
const QPoint& pos = session->pawn()->position();
setWorldBounds(_worldBounds.translated(
getDelta(pos.x(), scrollBounds.left(), scrollBounds.right()),
getDelta(pos.y(), scrollBounds.top(), scrollBounds.bottom())));
}
void SceneView::invalidate ()
{
Component::invalidate();
// resize world bounds if necessary
setWorldBounds(QRect(_worldBounds.topLeft(), _bounds.size()));
}
void SceneView::draw (DrawContext* ctx)
{
Component::draw(ctx);
// apply scroll, if any
if (_scrollAmount != QPoint(0, 0)) {
ctx->scrollContents(localBounds(), _scrollAmount);
_scrollAmount = QPoint(0, 0);
}
Scene* scene = session()->scene();
if (scene == 0) {
return;
}
const QHash<QPoint, Scene::Block>& blocks = scene->blocks();
// find the intersection of the dirty bounds in world space and the world bounds
QRect dirty = ctx->dirty().boundingRect();
dirty.translate(-ctx->pos());
dirty.translate(_worldBounds.topLeft());
dirty &= _worldBounds;
// draw all blocks that intersect
int bx1 = dirty.left() >> Scene::Block::LgSize;
int bx2 = dirty.right() >> Scene::Block::LgSize;
int by1 = dirty.top() >> Scene::Block::LgSize;
int by2 = dirty.bottom() >> Scene::Block::LgSize;
QRect bbounds(0, 0, Scene::Block::Size, Scene::Block::Size);
for (int by = by1; by <= by2; by++) {
for (int bx = bx1; bx <= bx2; bx++) {
QHash<QPoint, Scene::Block>::const_iterator it = blocks.constFind(QPoint(bx, by));
if (it != blocks.constEnd()) {
const Scene::Block& block = *it;
bbounds.moveTo(bx << Scene::Block::LgSize, by << Scene::Block::LgSize);
QRect ibounds = bbounds.intersected(_worldBounds);
ctx->drawContents(
ibounds.left() - _worldBounds.left(), ibounds.top() - _worldBounds.top(),
ibounds.width(), ibounds.height(), block.constData() +
(ibounds.top() - bbounds.top() << Scene::Block::LgSize) +
(ibounds.left() - bbounds.left()),
true, Scene::Block::Size);
}
}
}
}
| 31.79375 | 99 | 0.591115 | ey6es |
28c6123cc903f54864a936a4a4afcda8618cec8a | 543 | hpp | C++ | part-27-vulkan-load-textures/main/src/core/mesh.hpp | tanzle-aames/a-simple-triangle | 3cf7d76e8e8a3b5d42c6db35d3cbfef91b139ab0 | [
"MIT"
] | 52 | 2019-11-30T04:45:02.000Z | 2022-03-10T17:17:57.000Z | part-30-basic-user-input/main/src/core/mesh.hpp | eugenebokhan/a-simple-triangle | 3cf7d76e8e8a3b5d42c6db35d3cbfef91b139ab0 | [
"MIT"
] | null | null | null | part-30-basic-user-input/main/src/core/mesh.hpp | eugenebokhan/a-simple-triangle | 3cf7d76e8e8a3b5d42c6db35d3cbfef91b139ab0 | [
"MIT"
] | 10 | 2020-03-30T16:18:30.000Z | 2022-01-30T14:53:45.000Z | #pragma once
#include "internal-ptr.hpp"
#include "vertex.hpp"
#include <vector>
namespace ast
{
struct Mesh
{
Mesh(const std::vector<ast::Vertex>& vertices, const std::vector<uint32_t>& indices);
const std::vector<ast::Vertex>& getVertices() const;
const std::vector<uint32_t>& getIndices() const;
const uint32_t& getNumVertices() const;
const uint32_t& getNumIndices() const;
private:
struct Internal;
ast::internal_ptr<Internal> internal;
};
} // namespace ast
| 20.884615 | 93 | 0.642726 | tanzle-aames |
28ca111689a28c63c69729f5ca3405bfd07cb618 | 129 | cpp | C++ | src/modules/replay/replay_main.cpp | Diksha-agg/Firmware_val | 1efc1ba06997d19df3ed9bd927cfb24401b0fe03 | [
"BSD-3-Clause"
] | null | null | null | src/modules/replay/replay_main.cpp | Diksha-agg/Firmware_val | 1efc1ba06997d19df3ed9bd927cfb24401b0fe03 | [
"BSD-3-Clause"
] | null | null | null | src/modules/replay/replay_main.cpp | Diksha-agg/Firmware_val | 1efc1ba06997d19df3ed9bd927cfb24401b0fe03 | [
"BSD-3-Clause"
] | null | null | null | version https://git-lfs.github.com/spec/v1
oid sha256:a88a7b61d2bf7615571ada8de82e2cf5034f40407f98a48fadeaad6849143d52
size 2097
| 32.25 | 75 | 0.883721 | Diksha-agg |
28ca4208c578f7cdcc4db8288ec2fa9313bab65e | 3,672 | cpp | C++ | test/atomic/tst_atomic.cpp | ombre5733/weos | 2c3edef042fa80baa7c8fb968ba3104b7119cf2d | [
"BSD-2-Clause"
] | 11 | 2015-10-06T21:00:30.000Z | 2021-07-27T05:54:44.000Z | test/atomic/tst_atomic.cpp | ombre5733/weos | 2c3edef042fa80baa7c8fb968ba3104b7119cf2d | [
"BSD-2-Clause"
] | null | null | null | test/atomic/tst_atomic.cpp | ombre5733/weos | 2c3edef042fa80baa7c8fb968ba3104b7119cf2d | [
"BSD-2-Clause"
] | 1 | 2015-10-03T03:51:28.000Z | 2015-10-03T03:51:28.000Z | /*******************************************************************************
WEOS - Wrapper for embedded operating systems
Copyright (c) 2013-2016, Manuel Freiberger
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
#include <atomic.hpp>
#include "../common/testutils.hpp"
#include "gtest/gtest.h"
TEST(atomic_flag, default_construction)
{
weos::atomic_flag flag;
(void)flag;
}
TEST(atomic_flag, initialization)
{
weos::atomic_flag flag = ATOMIC_FLAG_INIT;
(void)flag;
}
TEST(atomic_flag, test_and_set)
{
weos::atomic_flag flag = ATOMIC_FLAG_INIT;
ASSERT_FALSE(flag.test_and_set());
ASSERT_TRUE(flag.test_and_set());
flag.clear();
ASSERT_FALSE(flag.test_and_set());
ASSERT_TRUE(flag.test_and_set());
}
TEST(atomic_int, default_construction)
{
weos::atomic_int x;
(void)x;
}
TEST(atomic_int, construct_with_value)
{
int value;
weos::atomic_int x(68);
value = x;
ASSERT_EQ(68, value);
}
TEST(atomic_int, load_and_store)
{
int value;
weos::atomic_int x(68);
value = x.load();
ASSERT_EQ(68, value);
x.store(21);
value = x.load();
ASSERT_EQ(21, value);
value = x;
ASSERT_EQ(21, value);
}
TEST(atomic_int, exchange)
{
int value;
weos::atomic_int x(68);
value = x.load();
ASSERT_EQ(68, value);
value = x.exchange(21);
ASSERT_EQ(68, value);
value = x;
ASSERT_EQ(21, value);
}
TEST(atomic_int, fetch_X)
{
int value;
weos::atomic_int x(68);
value = x.fetch_add(3);
ASSERT_EQ(68, value);
value = x.fetch_sub(5);
ASSERT_EQ(71, value);
value = x.fetch_and(64);
ASSERT_EQ(66, value);
value = x.fetch_or(17);
ASSERT_EQ(64, value);
value = x.fetch_xor(66);
ASSERT_EQ(81, value);
value = x;
ASSERT_EQ(19, value);
}
TEST(atomic_int, compare_exchange_strong)
{
int expected = 66;
bool exchanged;
weos::atomic_int x(68);
exchanged = x.compare_exchange_strong(expected, 77);
ASSERT_FALSE(exchanged);
ASSERT_EQ(68, expected);
ASSERT_EQ(68, int(x));
exchanged = x.compare_exchange_strong(expected, 77);
ASSERT_TRUE(exchanged);
ASSERT_EQ(68, expected);
ASSERT_EQ(77, int(x));
}
TEST(atomic_int, operators)
{
weos::atomic_int x(68);
ASSERT_EQ(68, int(x));
x = 77;
ASSERT_EQ(77, int(x));
}
| 25.5 | 80 | 0.666667 | ombre5733 |
28d2d288b28a076d0f22683a831e1365877a90dc | 6,867 | cpp | C++ | vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_005.cpp | neuroradiology/Proton | 5aed286761234b1b362471ca5cf80d25f64cb719 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 17,337 | 2018-08-21T21:43:27.000Z | 2022-03-31T18:06:05.000Z | vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_005.cpp | neuroradiology/Proton | 5aed286761234b1b362471ca5cf80d25f64cb719 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 5,641 | 2018-08-21T22:40:50.000Z | 2022-03-31T23:58:40.000Z | vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_005.cpp | neuroradiology/Proton | 5aed286761234b1b362471ca5cf80d25f64cb719 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 910 | 2018-08-21T22:54:53.000Z | 2022-03-29T17:35:31.000Z | #include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.1/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRApplications_IVRApplications_005.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_AddApplicationManifest(void *linux_side, const char * pchApplicationManifestFullPath, bool bTemporary)
{
return ((IVRApplications*)linux_side)->AddApplicationManifest((const char *)pchApplicationManifestFullPath, (bool)bTemporary);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_RemoveApplicationManifest(void *linux_side, const char * pchApplicationManifestFullPath)
{
return ((IVRApplications*)linux_side)->RemoveApplicationManifest((const char *)pchApplicationManifestFullPath);
}
bool cppIVRApplications_IVRApplications_005_IsApplicationInstalled(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->IsApplicationInstalled((const char *)pchAppKey);
}
uint32_t cppIVRApplications_IVRApplications_005_GetApplicationCount(void *linux_side)
{
return ((IVRApplications*)linux_side)->GetApplicationCount();
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_GetApplicationKeyByIndex(void *linux_side, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
{
return ((IVRApplications*)linux_side)->GetApplicationKeyByIndex((uint32_t)unApplicationIndex, (char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_GetApplicationKeyByProcessId(void *linux_side, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
{
return ((IVRApplications*)linux_side)->GetApplicationKeyByProcessId((uint32_t)unProcessId, (char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_LaunchApplication(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->LaunchApplication((const char *)pchAppKey);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_LaunchTemplateApplication(void *linux_side, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
{
return ((IVRApplications*)linux_side)->LaunchTemplateApplication((const char *)pchTemplateAppKey, (const char *)pchNewAppKey, (const vr::AppOverrideKeys_t *)pKeys, (uint32_t)unKeys);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_LaunchDashboardOverlay(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->LaunchDashboardOverlay((const char *)pchAppKey);
}
bool cppIVRApplications_IVRApplications_005_CancelApplicationLaunch(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->CancelApplicationLaunch((const char *)pchAppKey);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_IdentifyApplication(void *linux_side, uint32_t unProcessId, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->IdentifyApplication((uint32_t)unProcessId, (const char *)pchAppKey);
}
uint32_t cppIVRApplications_IVRApplications_005_GetApplicationProcessId(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->GetApplicationProcessId((const char *)pchAppKey);
}
const char * cppIVRApplications_IVRApplications_005_GetApplicationsErrorNameFromEnum(void *linux_side, EVRApplicationError error)
{
return ((IVRApplications*)linux_side)->GetApplicationsErrorNameFromEnum((vr::EVRApplicationError)error);
}
uint32_t cppIVRApplications_IVRApplications_005_GetApplicationPropertyString(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
{
return ((IVRApplications*)linux_side)->GetApplicationPropertyString((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (char *)pchPropertyValueBuffer, (uint32_t)unPropertyValueBufferLen, (vr::EVRApplicationError *)peError);
}
bool cppIVRApplications_IVRApplications_005_GetApplicationPropertyBool(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
{
return ((IVRApplications*)linux_side)->GetApplicationPropertyBool((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (vr::EVRApplicationError *)peError);
}
uint64_t cppIVRApplications_IVRApplications_005_GetApplicationPropertyUint64(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
{
return ((IVRApplications*)linux_side)->GetApplicationPropertyUint64((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (vr::EVRApplicationError *)peError);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_SetApplicationAutoLaunch(void *linux_side, const char * pchAppKey, bool bAutoLaunch)
{
return ((IVRApplications*)linux_side)->SetApplicationAutoLaunch((const char *)pchAppKey, (bool)bAutoLaunch);
}
bool cppIVRApplications_IVRApplications_005_GetApplicationAutoLaunch(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->GetApplicationAutoLaunch((const char *)pchAppKey);
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_GetStartingApplication(void *linux_side, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
{
return ((IVRApplications*)linux_side)->GetStartingApplication((char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
}
vr::EVRApplicationTransitionState cppIVRApplications_IVRApplications_005_GetTransitionState(void *linux_side)
{
return ((IVRApplications*)linux_side)->GetTransitionState();
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_PerformApplicationPrelaunchCheck(void *linux_side, const char * pchAppKey)
{
return ((IVRApplications*)linux_side)->PerformApplicationPrelaunchCheck((const char *)pchAppKey);
}
const char * cppIVRApplications_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum(void *linux_side, EVRApplicationTransitionState state)
{
return ((IVRApplications*)linux_side)->GetApplicationsTransitionStateNameFromEnum((vr::EVRApplicationTransitionState)state);
}
bool cppIVRApplications_IVRApplications_005_IsQuitUserPromptRequested(void *linux_side)
{
return ((IVRApplications*)linux_side)->IsQuitUserPromptRequested();
}
vr::EVRApplicationError cppIVRApplications_IVRApplications_005_LaunchInternalProcess(void *linux_side, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
{
return ((IVRApplications*)linux_side)->LaunchInternalProcess((const char *)pchBinaryPath, (const char *)pchArguments, (const char *)pchWorkingDirectory);
}
#ifdef __cplusplus
}
#endif
| 50.866667 | 249 | 0.831076 | neuroradiology |
28d4eec23864a024c50381dbe5e0a85707441286 | 5,886 | cpp | C++ | Source/Ilum/Editor/Panels/Hierarchy.cpp | Chaf-Libraries/Ilum | 83d0b7d4f2ba6cc3ba586f5442a09d55b69aedf8 | [
"MIT"
] | 11 | 2022-01-09T05:32:56.000Z | 2022-03-28T06:35:16.000Z | Source/Ilum/Editor/Panels/Hierarchy.cpp | Chaf-Libraries/Ilum | 83d0b7d4f2ba6cc3ba586f5442a09d55b69aedf8 | [
"MIT"
] | null | null | null | Source/Ilum/Editor/Panels/Hierarchy.cpp | Chaf-Libraries/Ilum | 83d0b7d4f2ba6cc3ba586f5442a09d55b69aedf8 | [
"MIT"
] | 1 | 2021-11-20T15:39:03.000Z | 2021-11-20T15:39:03.000Z | #include "Hierarchy.hpp"
#include "Scene/Component/Hierarchy.hpp"
#include "Scene/Component/Tag.hpp"
#include "Scene/Component/Transform.hpp"
#include "Scene/Entity.hpp"
#include "Editor/Editor.hpp"
#include <imgui.h>
namespace Ilum::panel
{
inline void delete_node(Entity entity)
{
if (!entity)
{
return;
}
auto child = Entity(entity.getComponent<cmpt::Hierarchy>().first);
auto sibling = child ? Entity(child.getComponent<cmpt::Hierarchy>().next) : Entity();
while (sibling)
{
auto tmp = Entity(sibling.getComponent<cmpt::Hierarchy>().next);
delete_node(sibling);
sibling = tmp;
}
delete_node(child);
entity.destroy();
}
inline bool is_parent_of(Entity lhs, Entity rhs)
{
auto parent = Entity(rhs.getComponent<cmpt::Hierarchy>().parent);
while (parent)
{
if (parent == lhs)
{
return true;
}
parent = Entity(parent.getComponent<cmpt::Hierarchy>().parent);
}
return false;
}
inline void set_as_son(Entity new_parent, Entity new_son)
{
if (new_parent && is_parent_of(new_son, new_parent))
{
return;
}
auto &h2 = new_son.getComponent<cmpt::Hierarchy>();
if (h2.next != entt::null)
{
Entity(h2.next).getComponent<cmpt::Hierarchy>().prev = h2.prev;
}
if (h2.prev != entt::null)
{
Entity(h2.prev).getComponent<cmpt::Hierarchy>().next = h2.next;
}
if (h2.parent != entt::null && new_son == Entity(h2.parent).getComponent<cmpt::Hierarchy>().first)
{
Entity(h2.parent).getComponent<cmpt::Hierarchy>().first = h2.next;
}
h2.next = new_parent ? new_parent.getComponent<cmpt::Hierarchy>().first : entt::null;
h2.prev = entt::null;
h2.parent = new_parent ? new_parent.getHandle() : entt::null;
if (new_parent && new_parent.getComponent<cmpt::Hierarchy>().first != entt::null)
{
Entity(new_parent.getComponent<cmpt::Hierarchy>().first).getComponent<cmpt::Hierarchy>().prev = new_son;
}
if (new_parent)
{
new_parent.getComponent<cmpt::Hierarchy>().first = new_son;
}
}
inline void draw_node(Entity entity)
{
if (!entity)
{
return;
}
auto &tag = entity.getComponent<cmpt::Tag>().name;
bool has_child = entity.hasComponent<cmpt::Hierarchy>() && entity.getComponent<cmpt::Hierarchy>().first != entt::null;
// Setting up
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(5, 5));
ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_FramePadding | ImGuiTreeNodeFlags_DefaultOpen | (Editor::instance()->getSelect() == entity ? ImGuiTreeNodeFlags_Selected : 0) | (has_child ? 0 : ImGuiTreeNodeFlags_Leaf);
bool open = ImGui::TreeNodeEx(std::to_string(entity).c_str(), flags, "%s", tag.c_str());
ImGui::PopStyleVar();
// Delete entity
ImGui::PushID(std::to_string(entity).c_str());
bool entity_deleted = false;
if (ImGui::BeginPopupContextItem(std::to_string(entity).c_str()))
{
if (ImGui::MenuItem("Delete Entity"))
{
entity_deleted = true;
}
ImGui::EndPopup();
}
ImGui::PopID();
// Select entity
if (ImGui::IsItemClicked())
{
Editor::instance()->select(entity);
}
// Drag and drop
if (ImGui::BeginDragDropSource())
{
if (entity.hasComponent<cmpt::Hierarchy>())
{
ImGui::SetDragDropPayload("Entity", &entity, sizeof(Entity));
}
ImGui::EndDragDropSource();
}
if (ImGui::BeginDragDropTarget())
{
if (const auto *pay_load = ImGui::AcceptDragDropPayload("Entity"))
{
ASSERT(pay_load->DataSize == sizeof(Entity));
set_as_son(entity, *static_cast<Entity *>(pay_load->Data));
entity.getComponent<cmpt::Transform>().update = true;
static_cast<Entity *>(pay_load->Data)->getComponent<cmpt::Transform>().update = true;
}
ImGui::EndDragDropTarget();
}
// Recursively open children entities
if (open)
{
if (has_child)
{
auto child = Entity(entity.getComponent<cmpt::Hierarchy>().first);
while (child)
{
draw_node(child);
if (child)
{
child = Entity(child.getComponent<cmpt::Hierarchy>().next);
}
}
}
ImGui::TreePop();
}
// Delete callback
if (entity_deleted)
{
if (Entity(entity.getComponent<cmpt::Hierarchy>().prev))
{
Entity(entity.getComponent<cmpt::Hierarchy>().prev).getComponent<cmpt::Hierarchy>().next = entity.getComponent<cmpt::Hierarchy>().next;
}
if (Entity(entity.getComponent<cmpt::Hierarchy>().next))
{
Entity(entity.getComponent<cmpt::Hierarchy>().next).getComponent<cmpt::Hierarchy>().prev = entity.getComponent<cmpt::Hierarchy>().prev;
}
if (Entity(entity.getComponent<cmpt::Hierarchy>().parent) && entity == Entity(entity.getComponent<cmpt::Hierarchy>().parent).getComponent<cmpt::Hierarchy>().first)
{
Entity(entity.getComponent<cmpt::Hierarchy>().parent).getComponent<cmpt::Hierarchy>().first = entity.getComponent<cmpt::Hierarchy>().next;
}
delete_node(entity);
if (Editor::instance()->getSelect() == entity)
{
Editor::instance()->select(Entity());
}
}
}
Hierarchy::Hierarchy()
{
m_name = "Hierarchy";
}
void Hierarchy::draw(float delta_time)
{
ImGui::Begin("Scene Hierarchy", &active);
if (ImGui::BeginDragDropTarget())
{
if (const auto *pay_load = ImGui::AcceptDragDropPayload("Entity"))
{
ASSERT(pay_load->DataSize == sizeof(Entity));
set_as_son(Entity(), *static_cast<Entity *>(pay_load->Data));
static_cast<Entity *>(pay_load->Data)->getComponent<cmpt::Transform>().update = true;
}
}
Scene::instance()->getRegistry().each([&](auto entity_id) {
if (Entity(entity_id) && Entity(entity_id).getComponent<cmpt::Hierarchy>().parent == entt::null)
{
draw_node(Entity(entity_id));
}
});
if (ImGui::IsMouseDown(ImGuiMouseButton_Left) && ImGui::IsWindowHovered())
{
Editor::instance()->select(Entity());
}
// Right-click on blank space
if (ImGui::BeginPopupContextWindow(0, 1, false))
{
if (ImGui::MenuItem("New Entity"))
{
Scene::instance()->createEntity("Untitled Entity");
}
ImGui::EndPopup();
}
ImGui::End();
}
} // namespace Ilum::panel | 25.153846 | 217 | 0.681617 | Chaf-Libraries |
28d69e42f3993b3aef47de906eaa6b8a5745446d | 153 | cpp | C++ | lib/source/mylib.cpp | Honeybunch/cpplibtemplate | 23ea15343bb469198420f54eb3d87c4055468084 | [
"MIT"
] | null | null | null | lib/source/mylib.cpp | Honeybunch/cpplibtemplate | 23ea15343bb469198420f54eb3d87c4055468084 | [
"MIT"
] | null | null | null | lib/source/mylib.cpp | Honeybunch/cpplibtemplate | 23ea15343bb469198420f54eb3d87c4055468084 | [
"MIT"
] | null | null | null | #include "mylib.h"
int my_val = 0;
void init_my_lib() { my_val = 10; }
int get_my_lib_val() { return my_val; }
void shutdown_my_lib() { my_val = 0; } | 17 | 39 | 0.660131 | Honeybunch |
28df54ef5b9d2ce9d90f25518306dd1d85e428b0 | 3,337 | cpp | C++ | modules/core/utils.cpp | yjmm10/ModernOCR | a7070c9801ecccbbc5ad66618ca86c830480c573 | [
"MIT"
] | null | null | null | modules/core/utils.cpp | yjmm10/ModernOCR | a7070c9801ecccbbc5ad66618ca86c830480c573 | [
"MIT"
] | null | null | null | modules/core/utils.cpp | yjmm10/ModernOCR | a7070c9801ecccbbc5ad66618ca86c830480c573 | [
"MIT"
] | null | null | null | /*
* @Author: Petrichor
* @Date: 2022-03-11 11:40:37
* @LastEditTime: 2022-03-11 17:21:28
* @LastEditors: Petrichor
* @Description:
* @FilePath: \ModernOCR\modules\core\utils.cpp
* 版权声明
*/
#include "utils.h"
namespace ModernOCR {
namespace utils{
};
namespace image{
cv::Mat getRotateCropImage(const cv::Mat &src, std::vector<cv::Point> box) {
cv::Mat image;
src.copyTo(image);
std::vector<cv::Point> points = box;
int collectX[4] = {box[0].x, box[1].x, box[2].x, box[3].x};
int collectY[4] = {box[0].y, box[1].y, box[2].y, box[3].y};
int left = int(*std::min_element(collectX, collectX + 4));
int right = int(*std::max_element(collectX, collectX + 4));
int top = int(*std::min_element(collectY, collectY + 4));
int bottom = int(*std::max_element(collectY, collectY + 4));
cv::Mat imgCrop;
image(cv::Rect(left, top, right - left, bottom - top)).copyTo(imgCrop);
for (int i = 0; i < points.size(); i++) {
points[i].x -= left;
points[i].y -= top;
}
int imgCropWidth = int(sqrt(pow(points[0].x - points[1].x, 2) +
pow(points[0].y - points[1].y, 2)));
int imgCropHeight = int(sqrt(pow(points[0].x - points[3].x, 2) +
pow(points[0].y - points[3].y, 2)));
cv::Point2f ptsDst[4];
ptsDst[0] = cv::Point2f(0., 0.);
ptsDst[1] = cv::Point2f(imgCropWidth, 0.);
ptsDst[2] = cv::Point2f(imgCropWidth, imgCropHeight);
ptsDst[3] = cv::Point2f(0.f, imgCropHeight);
cv::Point2f ptsSrc[4];
ptsSrc[0] = cv::Point2f(points[0].x, points[0].y);
ptsSrc[1] = cv::Point2f(points[1].x, points[1].y);
ptsSrc[2] = cv::Point2f(points[2].x, points[2].y);
ptsSrc[3] = cv::Point2f(points[3].x, points[3].y);
cv::Mat M = cv::getPerspectiveTransform(ptsSrc, ptsDst);
cv::Mat partImg;
cv::warpPerspective(imgCrop, partImg, M,
cv::Size(imgCropWidth, imgCropHeight),
cv::BORDER_REPLICATE);
if (float(partImg.rows) >= float(partImg.cols) * 1.5) {
cv::Mat srcCopy = cv::Mat(partImg.rows, partImg.cols, partImg.depth());
cv::transpose(partImg, srcCopy);
cv::flip(srcCopy, srcCopy, 0);
return srcCopy;
} else {
return partImg;
}
}
std::vector<cv::Mat> getPartImages(cv::Mat &src, std::vector<types::BoxInfo> &textBoxes) {
std::vector<cv::Mat> partImages;
for (int i = 0; i < textBoxes.size(); ++i) {
cv::Mat partImg = getRotateCropImage(src, textBoxes[i].boxPoint);
partImages.emplace_back(partImg);
// //OutPut DebugImg
if (true) {
std::string debugImgFile = getDebugImgFilePath("", "hh", i, "-part-");
saveImg(partImg, debugImgFile.c_str());
}
}
return partImages;
}
};
namespace str{
};
};
| 34.760417 | 98 | 0.493857 | yjmm10 |
28e42f59d897527a305c2e3a439854cb855e8a89 | 30,158 | cpp | C++ | other/bb_sudoku/bb_sudoku_solver.cpp | dobrichev/tdoku | cda2e52229656bd03db141e6405d50a2a80e2338 | [
"BSD-2-Clause"
] | 100 | 2019-07-01T20:16:33.000Z | 2022-03-27T10:36:48.000Z | other/bb_sudoku/bb_sudoku_solver.cpp | doc22940/tdoku | 63d190a9090d9dc8e613e48e4770c635a5b7e3c3 | [
"BSD-2-Clause"
] | 7 | 2019-12-18T09:07:58.000Z | 2022-03-13T19:39:46.000Z | other/bb_sudoku/bb_sudoku_solver.cpp | doc22940/tdoku | 63d190a9090d9dc8e613e48e4770c635a5b7e3c3 | [
"BSD-2-Clause"
] | 14 | 2019-06-18T05:47:28.000Z | 2022-03-05T08:58:05.000Z | /****************************************************************\
** BB_Sudoku Bit Based Sudoku Solver **
\****************************************************************/
/****************************************************************\
** (c) Copyright Brian Turner, 2008-2009. This file may be **
** freely used, modified, and copied for personal, **
** educational, or non-commercial purposes provided this **
** notice remains attached. **
\****************************************************************/
#include <cstdio>
#include <cstring>
#include "random.h"
#include "bb_sudoku_tables.h"
// moved here from driver program bb_sudoku.cpp
bool InitTables()
{ int i, v;
RND_Init();
for (i = 0; i < 512; i++)
{ B2V[i] = NSet[i] = 0;
for (v = i; v; NSet[i]++)
{ NSetX[i][NSet[i]] = v & -v;
v = v ^ NSetX[i][NSet[i]];
}
}
for (i = 1; i <= 9; i++)
B2V[1 << (i-1)] = i;
return true;
}
// G - Grid data structure
// This contains everything needed for backtracking.
// The larger this gets, the slower backtracking will be
// since the entire structure is copied.
struct Grid_Type
{ int CellsLeft; // Cells left to solve
unsigned int Grid[81]; // Possibilities left for each cell
unsigned int Grp[27]; // Values found in each group
} G[64];
// Solution Grid, which will contain the answer after the puzzle is solved
unsigned int SolGrid[81];
// Naked Singles FIFO stack - new singles found are stored here before
char SingleCnt = 0;
char SinglePos[128];
unsigned int SingleVal[128];
#define PushSingle(p, b) { SinglePos[SingleCnt] = p; SingleVal[SingleCnt] = b; SingleCnt++; Changed = 1; }
// Changed Flags
int Changed; // Flag to indicate Grid has changed
char ChangedGroup[27]; // Marks which groups have changed
char ChangedLC[27];
int SingleGroup[27];
#define MarkChanged(x) { ChangedGroup[C2Grp[x][0]] = ChangedGroup[C2Grp[x][1]] = ChangedGroup[C2Grp[x][2]] = Changed = 1; }
// Guess structure
char GuessPos[128];
int GuessVal[128];
int OneStepP[81], OneStepI;
// Key global variables used throughout the solving
long PuzzleCnt = 0; // Total puzzles tested
long SolvedCnt = 0; // Total puzzles solved
int PuzSolCnt; // Solutions for a single puzzle
int No_Sol; // Flag to indicate there is no solution possible
int PIdx; // Position Index, used for guessing and backtracking
// Debug stats
int SCnt = 0, HCnt = 0, GCnt = 0, LCCnt = 0, SSCnt = 0, FCnt = 0, OneCnt = 0, TwoCnt = 0;
long TSCnt = 0, THCnt = 0, TGCnt = 0, TLCCnt = 0, TSSCnt = 0, TFCnt = 0, TOneCnt = 0, TTwoCnt = 0;
int MaxDepth = 0, Givens = 0;
// forward procedure declarations
int DecodePuzzleString (int ret_puz, char* buffer);
inline void InitGrid ();
inline void ProcessInitSingles (void);
inline void ProcessSingles (void);
inline void FindHiddenSingles (void);
inline void FindLockedCandidates (void);
inline void FindSubsets (void);
inline void FindFishies (void);
void DoStep (int doing_2_step, int use_methods);
inline void MakeGuess (void);
/************\
** Solver *****************************************************\
** **
** Solver runs the sudoku solver. Input puzzle is in the **
** buffer array, and somewhat controlled by a number of **
** globals (see the globals at the top of the main program **
** for globals and meanings). **
** **
\****************************************************************/
int Solver (char num_search, unsigned int use_methods, char ret_puzzle, int initp, char* buffer)
{ int i, PuzSolCnt = 0;
if (!initp)
use_methods |= DecodePuzzleString(ret_puzzle, buffer); // Load the Grid from the buffer
// Loop through the puzzle solving routines until finished
while (Changed)
{ // If No Solution possible, jump straight to the backtrack routine
if (!No_Sol)
{ // Check if any Singles to be propogated
if (SingleCnt)
{ SCnt++;
if (SingleCnt > 2) // If multiple singles
ProcessInitSingles(); // process them all at once
if (SingleCnt) // otherwise
ProcessSingles(); // process them one at a time
if (!G[PIdx].CellsLeft)
{ if (!No_Sol)
{ if (!PuzSolCnt && ret_puzzle)
for (i = 0; i < 81; i++) buffer[i] = '0' + B2V[SolGrid[i]];
if (PuzSolCnt && (ret_puzzle == 2))
for (i = 0; i < 81; i++)
if (buffer[i] != ('0' + B2V[SolGrid[i]])) buffer[i] = '.';
PuzSolCnt++;
if ((PuzSolCnt > 1) && (num_search == 2)) break;
if (num_search == 1) break;
}
No_Sol = Changed = 1;
continue;
}
}
// If nothing has changed, apply the next solver
if (Changed)
{ HCnt++; FindHiddenSingles(); if (SingleCnt) continue;
if (use_methods & USE_LOCK_CAND)
{ LCCnt++; FindLockedCandidates(); if (Changed) continue; }
if (use_methods & USE_SUBSETS)
{ SSCnt++; FindSubsets(); if (Changed) continue; }
if (use_methods & USE_FISHIES)
{ FCnt++; FindFishies(); if (Changed) continue; }
if (use_methods & USE_1_STEP)
{ OneCnt++; DoStep(0, use_methods); if (Changed) continue; }
if (use_methods & USE_2_STEP)
{ TwoCnt++; DoStep(1, use_methods); if (Changed) continue; }
}
}
//If nothing new found, just make a guess
if (use_methods & USE_GUESSES)
{ GCnt++; MakeGuess(); }
if (No_Sol) break;
if (!initp && (MaxDepth < PIdx)) MaxDepth = PIdx;
if (PIdx > 62) { printf ("Max Depth exceeded, recompile for more depth.\n\n"); exit(0); }
}
if (No_Sol && !initp && (ret_puzzle == 2) && !(use_methods & USE_GUESSES))
for (i = 0; i < 81; i++)
buffer[i] = (G[0].Grid[i]) ? '.' : '0' + B2V[SolGrid[i]];
TSCnt += SCnt; // Update Stats
THCnt += HCnt;
TGCnt += GCnt;
TLCCnt += LCCnt;
TSSCnt += SSCnt;
TFCnt += FCnt;
TOneCnt += OneCnt;
TTwoCnt += TwoCnt;
return PuzSolCnt;
}
/************************\
** DecodePuzzleString *****************************************\
** **
** DecodePuzzleString sets up the initial grid (along with **
** InitGrid), and determine what variations are being used. **
** **
\****************************************************************/
int DecodePuzzleString (int ret_puz, char* buffer)
{ int p=0, i=0, KillIdx = 0, CompIdx = 0, g, ret_methods = 0, cpos = 0;
char b[500];
InitGrid();
p = 0; i = 2; b[0] = 'g'; b[1] = '=';
while (buffer[p] > 0) // remove spaces and commas
{ if (buffer[p] == '#') { cpos = p; break; }
if ((buffer[p] != ' ') && (buffer[p] != 9))
{ b[i] = buffer[p]; i++;} p++;
}
if (ret_puz)
{ if (cpos) memmove(&buffer[81], &buffer[p], strlen(buffer)-p+1);
else buffer[81] = 0; // end the buffer
}
b[i] = b[i+1] = b[i+2] = 0; p = 0;
if (b[3] == '=') p = 2;
while (b[p] > 0)
{ if (b[p+1] == '=')
switch (b[p])
{ case 'p' : // Puzzle size (needs to be defined first in used)
case 'P' :
printf ("Size variation are not supported in this version\n");
exit (0);
break;
case 'c' : // Comparison puzzle (Greater Than / Less Than)
case 'C' : //p = Decode_GT_LT(p, b);
//if (GT_LT[0][0] != GT_LT[0][1]) ret_methods |= GT_LT_PUZZLE;
//break;
case 'k' : // Killer Sudoku (Additive or Multiplicitive, and disjoint)
case 'K' :
//break;
case 'j' : // Jigsaw Sudoku (plus additional groupings and disjoint)
case 'J' :
//break;
case 'e' : // Even / Odd Sudoku
case 'E' :
//break;
case 's' : // Subset puzzles
case 'S' :
//break;
case 'a' : // Additional constraints (diagonals, etc)
case 'A' :
printf ("Variations are not supported in this version\n");
exit (0);
break;
case 'g' : // Givens (default puzzle)
case 'G' :
default : p += 2; g = i = 0;
while (g < 81)
{ if ((b[i+p] == ':') || (b[i+p] == ';') || (b[i+p] == '#') || (b[i+p] == 0)) break;
if ((b[i+p] == '/') || (b[i+p] == '\\'))
g = g + 9 - (g % 9) - 1;
if ((b[i+p] > '0') && (b[i+p] <= '9'))
PushSingle((char)(g), V2B[b[i+p] - '0']);
i++; g++;
}
Givens += SingleCnt;
break;
}
p += i;
}
buffer[81] = 10; buffer[82] = 0; // end the buffer
return ret_methods;
}
/**************\
** InitGrid ***************************************************\
** **
** InitGrid takes the text string stored in the buffer and **
** populates the solution grid. It assumes the text is **
** properly formatted. **
** **
\****************************************************************/
inline void InitGrid (void)
{ char i;
// Initialize some key variables
G[0].CellsLeft = 81;
PIdx = 0;
SingleCnt = 0;
Changed = 1;
No_Sol = 0;
OneStepI = 0;
Givens = 0;
SCnt = HCnt = GCnt = LCCnt = SSCnt = FCnt = OneCnt = TwoCnt = 0;
// Loop through the buffer and set the singles to be set
for (i = 0; i < 81; i++)
{ G[0].Grid[i] = 0x1FF;
SolGrid[i] = OneStepP[i] = 0;
}
// Clear the Groups Found values
for (i = 0; i < 27; i++)
G[0].Grp[i] = ChangedGroup[i] = ChangedLC[i] = SingleGroup[i] = 0;
}
/************************\
** ProcessInitSingles *****************************************\
** **
** ProcessInitSingles takes a naked single and marks each **
** cell in the 3 associated groups as not allowing that **
** number. It also marks the groups as changed so we know **
** to check for hidden singles in that group. **
** **
** This routines marks all the groups first, then marks the **
** cells for each changed groups. **
** **
\****************************************************************/
inline void ProcessInitSingles (void)
{ int i, t, g, t2, j;
unsigned int b;
while (SingleCnt > 2)
{ for (i = 0; i < SingleCnt; i++)
{ t = SinglePos[i]; // Get local copy of position
b = SingleVal[i]; // Get local copy of the value
if (G[PIdx].Grid[t] == 0) continue; // Check if we already processed this position
if (!(G[PIdx].Grid[t] & b)) // Check for error conditions
{ No_Sol = 1; SingleCnt = Changed = 0; return; }
SolGrid[SinglePos[i]] = SingleVal[i]; // Store the single in the solution grid
G[PIdx].CellsLeft--; // mark one less empty space
G[PIdx].Grid[t] = 0; // mark this position processed
for (g = 0; g < 3; g++) // loop through all 3 groups
{ if (G[PIdx].Grp[C2Grp[t][g]] & b)
{ No_Sol = 1; SingleCnt = Changed = 0; return; }
G[PIdx].Grp[C2Grp[t][g]] |= b; // mark the value as found in the group
SingleGroup[C2Grp[t][g]] = 1;
}
}
SingleCnt = 0;
for (i = 0; i < 27; i++)
if (SingleGroup[i])
{ SingleGroup[i] = 0;
for (j = 0; j < 9; j++)
{ t2 = Group[i][j]; // get temp copy of position
b = G[PIdx].Grp[i];
if (G[PIdx].Grid[t2] & b) // check if removing a possibility
{ G[PIdx].Grid[t2] = G[PIdx].Grid[t2] & ~b; // remove possibility
if (G[PIdx].Grid[t2] == 0) // check for error (no possibility)
{ No_Sol = 1; SingleCnt = 0; Changed = 0; return; }
if (B2V[G[PIdx].Grid[t2]]) // Check if a naked single is found
PushSingle(t2, G[PIdx].Grid[t2]);
MarkChanged(t2); // Mark groups as changed
}
}
}
}
}
/********************\
** ProcessSingles *********************************************\
** **
** ProcessSingles takes a naked single and marks each cell **
** in the 3 associated groups as not allowing that number. **
** It also marks the groups as changed so we know to check **
** for hidden singles in that group. **
** **
** This routines marks cells changed as each single is **
** processed. **
** **
\****************************************************************/
inline void ProcessSingles (void)
{ int i, t, g, t2;
unsigned int b;
for (i = 0; i < SingleCnt; i++)
{ t = SinglePos[i]; // Get local copy of position
b = SingleVal[i]; // Get local copy of the value
if (G[PIdx].Grid[t] == 0) continue; // Check if we already processed this position
if (!(G[PIdx].Grid[t] & b)) // Check for error conditions
{ No_Sol = 1; SingleCnt = Changed = 0; return; }
SolGrid[SinglePos[i]] = SingleVal[i]; // Store the single in the solution grid
G[PIdx].CellsLeft--; // mark one less empty space
G[PIdx].Grid[t] = 0; // mark this position processed
for (g = 0; g < 3; g++) // loop through all 3 groups
G[PIdx].Grp[C2Grp[t][g]] |= b; // mark the value as found in the group
for (g = 0; g < 20; g++) // loop through each cell in the groups
{ t2 = (int)In_Groups[t][g]; // get temp copy of position
if (G[PIdx].Grid[t2] & b) // check if removing a possibility
{ G[PIdx].Grid[t2] = G[PIdx].Grid[t2] ^ b; // remove possibility
if (G[PIdx].Grid[t2] == 0) // check for error (no possibility)
{ No_Sol = 1; SingleCnt = 0; Changed = 0; return; }
if (B2V[G[PIdx].Grid[t2]]) // Check if a naked single is found
PushSingle(t2, G[PIdx].Grid[t2]);
MarkChanged(t2); // Mark groups as changed
}
}
}
SingleCnt = 0; // Clear the single count
}
/***********************\
** FindHiddenSingles ******************************************\
** **
** FindHiddenSingles checks each grouping that has changed **
** to see if they contain any hidden singles. If one is **
** found, the routine adds it to the queue and exits. **
** **
\****************************************************************/
inline void FindHiddenSingles (void)
{ unsigned int t1, t2, t3, b, t;
int i, j;
for (i = 0; i < 27; i++)
if (ChangedGroup[i])
{ ChangedLC[i] = 1;
t1 = t2 = t3 = 0;
for (j = 0; j < 9; j++)
{ b = G[PIdx].Grid[Group[i][j]];
t2 = t2 | (t1 & b);
t1 = t1 | b;
}
if ((t1 | G[PIdx].Grp[i]) != 0x01FF)
{ No_Sol = 1; SingleCnt = 0; Changed = 0; return; }
t3 = t2 ^ t1;
if (t3)
{ for (j = 0; j < 9; j++)
if (t3 & G[PIdx].Grid[Group[i][j]])
{ t = t3 & G[PIdx].Grid[Group[i][j]];
if (!B2V[t]) { No_Sol = 1; SingleCnt = 0; Changed = 0; return; }
PushSingle((char)Group[i][j], t);
if (t3 == t) return;
t3 = t3 ^ t;
}
}
ChangedGroup[i] = 0;
}
Changed = 0;
}
/**************************\
** FindLockedCandidates ***************************************\
** **
** FindLockedCandidates will scan through the grid to find **
** any locked candidates. **
** **
\****************************************************************/
inline void FindLockedCandidates (void)
{ unsigned int Seg[9], b;
int i, j, k, x;
int s, s1, s2, gp;
for (i = 0; i < 18; i += 3)
if (ChangedLC[i] || ChangedLC[i+1] || ChangedLC[i+2])
{ ChangedLC[i] = ChangedLC[i+1] = ChangedLC[i+2] = 0;
Seg[0] = G[PIdx].Grid[Group[i ][0]] | G[PIdx].Grid[Group[i ][1]] | G[PIdx].Grid[Group[i ][2]];
Seg[1] = G[PIdx].Grid[Group[i ][3]] | G[PIdx].Grid[Group[i ][4]] | G[PIdx].Grid[Group[i ][5]];
Seg[2] = G[PIdx].Grid[Group[i ][6]] | G[PIdx].Grid[Group[i ][7]] | G[PIdx].Grid[Group[i ][8]];
Seg[3] = G[PIdx].Grid[Group[i+1][0]] | G[PIdx].Grid[Group[i+1][1]] | G[PIdx].Grid[Group[i+1][2]];
Seg[4] = G[PIdx].Grid[Group[i+1][3]] | G[PIdx].Grid[Group[i+1][4]] | G[PIdx].Grid[Group[i+1][5]];
Seg[5] = G[PIdx].Grid[Group[i+1][6]] | G[PIdx].Grid[Group[i+1][7]] | G[PIdx].Grid[Group[i+1][8]];
Seg[6] = G[PIdx].Grid[Group[i+2][0]] | G[PIdx].Grid[Group[i+2][1]] | G[PIdx].Grid[Group[i+2][2]];
Seg[7] = G[PIdx].Grid[Group[i+2][3]] | G[PIdx].Grid[Group[i+2][4]] | G[PIdx].Grid[Group[i+2][5]];
Seg[8] = G[PIdx].Grid[Group[i+2][6]] | G[PIdx].Grid[Group[i+2][7]] | G[PIdx].Grid[Group[i+2][8]];
for (j = 0; j < 9; j++)
{ b = Seg[j] & ((Seg[LC_Segment[j][0]] | Seg[LC_Segment[j][1]]) ^ (Seg[LC_Segment[j][2]] | Seg[LC_Segment[j][3]]));
if (b)
{
for (k = 0; k < 4; k++)
{ s = LC_Segment[j][k];
s1 = i+s/3; s2 = (s%3)*3;
for (x = 0; x < 3; x++)
{ gp = Group[s1][s2+x];
if (G[PIdx].Grid[gp] & b)
{ G[PIdx].Grid[gp] = G[PIdx].Grid[gp] & ~b;
MarkChanged(gp);
if (!(G[PIdx].Grid[gp]))
{ No_Sol = 1; SingleCnt = 0; Changed = 0; return; }
if (B2V[G[PIdx].Grid[gp]])
PushSingle(gp, G[PIdx].Grid[gp]);
}
}
}
return;
}
}
}
}
/*****************\
** FindSubsets ************************************************\
** **
** FindSubsets will find all disjoint subsets (Naked/Hidden **
** Pairs/Triples/Quads). While this reduces the solving **
** time on some puzzles, and reduces the numbers of guesses **
** by around 18%, the overhead increases solving time for **
** general puzzles by 100% (doubling the time). **
** **
\****************************************************************/
inline void FindSubsets (void)
{
int i, g, p, m, t[8], v[8];
for (g = 0; g < 27; g++)
{ if (Changed) break;
m = 7 - NSet[G[PIdx].Grp[g]];
if (m < 2) continue;
p = 1; t[1] = -1;
while(p > 0)
{ t[p]++;
if (t[p] == 9) { p--; continue; }
if (p == 1)
{ v[1] = G[PIdx].Grid[Group[g][t[p]]];
if ((!v[1]) || (NSet[v[1]] > m)) continue;
p++; t[2] = t[1]; continue;
}
if (!G[PIdx].Grid[Group[g][t[p]]]) continue;
v[p] = v[p-1] | G[PIdx].Grid[Group[g][t[p]]];
if (NSet[v[p]] > m) continue;
if (NSet[v[p]] == p)
{ for (i = 0; i < 9; i++)
if ((G[PIdx].Grid[Group[g][i]] & ~v[p]) && (G[PIdx].Grid[Group[g][i]] & v[p]))
{ G[PIdx].Grid[Group[g][i]] &= ~v[p];
if (B2V[G[PIdx].Grid[Group[g][i]]])
PushSingle(Group[g][i], G[PIdx].Grid[Group[g][i]]);
MarkChanged(Group[g][i]);
}
p = 1;
continue;
}
if (p < m) { p++; t[p] = t[p-1]; }
}
}
}
/*****************\
** FindFishies ************************************************\
** **
** FindFishies finds the row / column subsets, such as **
** X-Wing, Swordfish, and Jellyfish. **
** **
\****************************************************************/
inline void FindFishies (void)
{ int b, i, g, p, m, t[10], v[10], grid[10], x, y;
for (b = 1; b <= 9; b++)
{ if (Changed) break;
for (g = 0; g < 9; g++) grid[g] = 0;
for (g = 0; g < 9; g ++)
for (i = 0; i < 9; i++)
if (G[PIdx].Grid[(g*9)+i] & V2B[b]) grid[g] |= V2B[i+1];
for (g = m = 0; g < 9; g++)
if (grid[g]) m++;
if (m < 2) continue;
m--;
p = 1; t[1] = -1; t[0] = 0;
while(p > 0)
{ t[p]++;
if (t[p] == 9) { p--; continue; }
if (p == 1)
{ v[1] = grid[t[p]];
if ((!v[1]) || (NSet[v[1]] > m)) continue;
p++; t[2] = t[1]; continue;
}
if (!grid[t[p]]) continue;
v[p] = v[p-1] | grid[t[p]];
if (NSet[v[p]] > m) continue;
if (NSet[v[p]] == p)
{ for (i = 0; i < 9; i++)
if (grid[i] & ~v[p])
{ x = grid[i] & v[p];
while (x)
{ y = (i*9) + B2V[x & -x] - 1;
if (G[PIdx].Grid[y] & V2B[b])
{ G[PIdx].Grid[y] ^= V2B[b];
if (B2V[G[PIdx].Grid[y]])
PushSingle(y, G[PIdx].Grid[y]);
MarkChanged(y);
}
x ^= (x & -x);
}
}
p = 1;
continue;
}
if (p < m) { p++; t[p] = t[p-1]; }
}
}
}
/************\
** DoStep *****************************************************\
** **
** FindFishies finds the row / column subsets, such as **
** X-Wing, Swordfish, and Jellyfish. **
** **
\****************************************************************/
void DoStep (int doing_2_step, int use_methods)
{ static int LastPos = 0;
int i, j, x1, x2, x3, mt, testcell, tested[81], testpidx, new_method;
for (i = 0; i < 81; i++) tested[i] = 0;
testpidx = PIdx;
while (!Changed)
{ // Find next spot to check
testcell = mt = x3 = 99;
for (i = 0; i < 81; i++)
if ((NSet[G[PIdx].Grid[i]] <= mt) && (NSet[G[PIdx].Grid[i]] > 1) && !tested[i])
{ x1 = NSet[G[PIdx].Grp[C2Grp[i][0]]] + NSet[G[PIdx].Grp[C2Grp[i][1]]] + NSet[G[PIdx].Grp[C2Grp[i][2]]];
if ((NSet[G[PIdx].Grid[i]] < mt) ||
((NSet[G[PIdx].Grid[i]] == mt) && (x1 <= x2) && (OneStepP[i] <= x3)))
{ x2 = x1;
testcell = i;
mt = NSet[G[PIdx].Grid[i]];
x3 = OneStepP[i];
}
}
if (testcell == 99) return;
tested[testcell] = 1;
OneStepI++; OneStepP[testcell] = OneStepI;
for (j = 0; j < NSet[G[PIdx].Grid[testcell]]; j++)
{
G[PIdx+1+j] = G[PIdx];
PushSingle(testcell, NSetX[G[PIdx].Grid[testcell]][j]);
PIdx = testpidx + 1 + j;
if ((use_methods & USE_2_STEP) && doing_2_step)
new_method = (use_methods | USE_1_STEP) & ~(USE_GUESSES | USE_2_STEP);
else
new_method = use_methods & ~(USE_GUESSES | USE_1_STEP | USE_2_STEP);
Solver(1, new_method, 0, PIdx, NULL);
PIdx = testpidx;
if (No_Sol)
for (i = 0; i < 81; i++) G[PIdx+1+j].Grid[i] = 0;
else
for (i = 0; i < 81; i++)
if (!G[PIdx+1+j].Grid[i]) G[PIdx+1+j].Grid[i] = SolGrid[i];
No_Sol = 0; SingleCnt = 0;
}
for (j = 1; j < NSet[G[PIdx].Grid[testcell]]; j++)
for (i = 0; i < 81; i++) G[PIdx+1].Grid[i] |= G[PIdx+1+j].Grid[i];
for (i = 0; i < 27; i++) ChangedGroup[i] = 0; Changed = 0;
for (i = 0; i < 81; i++)
if (G[PIdx].Grid[i] && (G[PIdx].Grid[i] != G[PIdx+1].Grid[i]))
{ G[PIdx].Grid[i] = G[PIdx+1].Grid[i];
if (B2V[G[PIdx].Grid[i]]) PushSingle(i, G[PIdx].Grid[i]);
MarkChanged(i);
}
}
}
/***************\
** MakeGuess **************************************************\
** **
** MakeGuess handles the guessing and backtracking used **
** when solving puzzles. **
** **
\****************************************************************/
inline void MakeGuess (void)
{
static int LastPos = 0;
int i;
int x1, x2;
unsigned int v;
int Found = 0;
char mt;
Changed = 1;
SingleCnt = 0;
// Check to see where the next guess should be
if (No_Sol)
while (No_Sol)
{ if (PIdx == 0) return;
G[PIdx-1].Grid[GuessPos[PIdx]] ^= GuessVal[PIdx];
if (G[PIdx-1].Grid[GuessPos[PIdx]])
{ if (B2V[G[PIdx-1].Grid[GuessPos[PIdx]]])
PushSingle(GuessPos[PIdx], G[PIdx-1].Grid[GuessPos[PIdx]]);
No_Sol = 0;
MarkChanged(GuessPos[PIdx]);
PIdx--;
return;
}
}
// Populate the grid for the next guess
G[PIdx+1] = G[PIdx];
PIdx++;
// Find next spot to check
if (!Found)
{ mt = 99;
i = LastPos;
do
{ if ((NSet[G[PIdx].Grid[i]] < mt) && (NSet[G[PIdx].Grid[i]] > 1))
{ GuessPos[PIdx] = i;
mt = NSet[G[PIdx].Grid[i]];
if (mt == 2) break; // if 2, then its the best it can get
}
if (++i >= 81) i = 0;
} while (i != LastPos);
LastPos = i;
}
// Mark the next guess in the position
No_Sol = 1;
v = G[PIdx].Grid[GuessPos[PIdx]];
if (v)
{ v = v & -v;
GuessVal[PIdx] = v;
PushSingle(GuessPos[PIdx], v);
Changed = 1;
No_Sol = 0;
}
}
/****************\
** RatePuzzle *************************************************\
** **
** RatePuzzle converts the status counts into a rating for a **
** given puzzle. This should be called after the solver has **
** been called. **
** **
** ok, I never got a formula I liked. So, if someone wants **
** to play around with this and suggest something, please **
** go ahead. **
** **
** One of the problems is that the soling routines are so **
** generic. I treat X-Wings and Jellyfishes the sames way, **
** same for naked pairs and hidden quads. Makes coming up **
** with a rating difficult. **
** **
\****************************************************************/
int RatePuzzle (void)
{
// Values available to manipulate into a puzzle are
// SCnt, HCnt, GCnt, LCCnt, SSCnt, FCnt, OneCnt, TwoCnt, GCnt
return 0;
}
/***************\
** CatPuzzle **************************************************\
** **
** CatPuzzle returns a difficulty category, rather than a **
** complete ratings. This is based entirely on the most **
** difficult solving technique used. **
** **
** Categories are: **
** - Invalid : No Solution, or Multiple Solutions **
** - Easy : Naked / Hidden Single, Locked Candidate **
** - Medium : Disjoint Subsets / Fishies **
** - Hard : 1 Step Commonality **
** - Expert : 2 Step Commonality **
** - Insane : so far, none exist **
** **
\****************************************************************/
int CatPuzzle (char *buf)
{
if (Solver(2, 0x01, 0, 0, buf) != 1) return 0; // Invalid (No Solution, or mulitples)
if (Solver(1, 0x3E, 0, 0, buf) == 0) return 5; // Insane (none exist, that I know of)
if (TwoCnt) return 4; // Expert (2 Step Commonality)
if (OneCnt) return 3; // Hard (1 Step Commonality)
if (FCnt || SCnt) return 2; // Medium (Disjoint Subsets / Fishies)
return 1; // Easy (Naked/Hidden Single / Locked Candidate)
}
| 38.320203 | 124 | 0.418463 | dobrichev |
28e45dbdbc5bf09ce27c548339c59ceff1d433bc | 1,138 | hpp | C++ | core/src/jni/jni/Error.hpp | RomanWlm/lib-ledger-core | 8c068fccb074c516096abb818a4e20786e02318b | [
"MIT"
] | 92 | 2016-11-13T01:28:34.000Z | 2022-03-25T01:11:37.000Z | core/src/jni/jni/Error.hpp | RomanWlm/lib-ledger-core | 8c068fccb074c516096abb818a4e20786e02318b | [
"MIT"
] | 242 | 2016-11-28T11:13:09.000Z | 2022-03-04T13:02:53.000Z | core/src/jni/jni/Error.hpp | RomanWlm/lib-ledger-core | 8c068fccb074c516096abb818a4e20786e02318b | [
"MIT"
] | 91 | 2017-06-20T10:35:28.000Z | 2022-03-09T14:15:40.000Z | // AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from errors.djinni
#ifndef DJINNI_GENERATED_ERROR_HPP_JNI_
#define DJINNI_GENERATED_ERROR_HPP_JNI_
#include "../../api/Error.hpp"
#include "djinni_support.hpp"
namespace djinni_generated {
class Error final {
public:
using CppType = ::ledger::core::api::Error;
using JniType = jobject;
using Boxed = Error;
~Error();
static CppType toCpp(JNIEnv* jniEnv, JniType j);
static ::djinni::LocalRef<JniType> fromCpp(JNIEnv* jniEnv, const CppType& c);
private:
Error();
friend ::djinni::JniClass<Error>;
const ::djinni::GlobalRef<jclass> clazz { ::djinni::jniFindClass("co/ledger/core/Error") };
const jmethodID jconstructor { ::djinni::jniGetMethodID(clazz.get(), "<init>", "(Lco/ledger/core/ErrorCode;Ljava/lang/String;)V") };
const jfieldID field_code { ::djinni::jniGetFieldID(clazz.get(), "code", "Lco/ledger/core/ErrorCode;") };
const jfieldID field_message { ::djinni::jniGetFieldID(clazz.get(), "message", "Ljava/lang/String;") };
};
} // namespace djinni_generated
#endif //DJINNI_GENERATED_ERROR_HPP_JNI_
| 31.611111 | 136 | 0.710018 | RomanWlm |
28e4c2089b979618e7976220fff29caa27869d48 | 104,500 | cpp | C++ | source/sfsbp/FDP.cpp | kali-allison/SCycle | 0a81edfae8730acb44531e2c2b3f51f25ea193d2 | [
"MIT"
] | 14 | 2019-04-12T16:36:36.000Z | 2022-03-16T00:35:03.000Z | source/sfsbp/FDP.cpp | kali-allison/SCycle | 0a81edfae8730acb44531e2c2b3f51f25ea193d2 | [
"MIT"
] | null | null | null | source/sfsbp/FDP.cpp | kali-allison/SCycle | 0a81edfae8730acb44531e2c2b3f51f25ea193d2 | [
"MIT"
] | 6 | 2019-07-22T23:53:15.000Z | 2022-03-10T03:30:50.000Z | /* FDP.cpp
* -------
* -----------------------------
* Finite-Difference in Parallel
* -----------------------------
*
* Adding Linear Solve Functionality in the Solve_Linear_Equation function.
* - It currently needs to be able to wrap MatMult in MyMatMult, using my Finite-Difference
* Stencils to calculate the matrix-vector product between the vector and the 2nd derivative
* matrix.
*
* The other main part of this program is the MMS Test.
* - The first section of Globals allows the user to change the parameters of the MMS test.
* - There are two sections of Globals for the MMS Test.
* - The first section allows the user to define parameters for the 1-D MMS Test.
* - The second allows the user to define parameters for the 2-D MMS Test.
* - These parameters include a beginning point, and an end point (in each direction for 2-D)
* - There is also another parameter for the number of grid points in each direction.
* - Lastly, there is a parameter that dictates how many times the user wants the program to solve
* each derivative. For example, changing the NUM_GRID_SPACE_CALCULATIONS will change the number of times
* the program will solve the 1st derivative using finite-difference stencils in 1-D.
*/
#include <petscvec.h>
#include <petscdmda.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
// 1-D MMS Test Globals
#define MIN_GRID_POINT 0
#define MAX_GRID_POINT 3
#define STARTING_GRID_SPACING 1//201
#define NUM_GRID_SPACE_CALCULATIONS 0 // 14 FIXME what's the limit here?
#define NUM_2ND_GRID_SPACE_CALCULATIONS 0
// 2-D MMS Test Globals
#define NUM_2D_GRID_SPACE_CALCULATIONS 0 //12 // FIXME is there a limit here? SLOWS DOWN A LOT ON 20k+ values in each direction?
#define NUM_2D_2ND_GRID_SPACE_CALCULATIONS 0
#define COEFFICIENT_SOLVE 1 // IMPORTANT: 0 for NO coefficient solve (w mu), 1 (or any other numeric value) to solve WITH coefficient
#define NUM_X_PTS 5 //201
#define NUM_Y_PTS 6 //201
#define X_MIN 0
#define Y_MIN 0
#define X_MAX 5
#define Y_MAX 10
//--------------------------------------------------------------------------------------------------------------------------------
//Globals for the Linear Solve Program
#define PTS_IN_X 6
#define PTS_IN_Y 5
#define X_MINIMUM 0.0
#define Y_MINIMUM 0.0
#define X_MAXIMUM 5.0
#define Y_MAXIMUM 10.0
typedef struct {
/* problem parameters */
PetscInt order;
PetscInt n_x, n_y;
Vec Bottom, Top, Left, Right; /* boundary values */
PetscScalar alphaDx, alphaDy, alphaT, beta;
Vec mu;
PetscScalar dx_spacing, dy_spacing;
/* Working space */
Vec localX, localV; /* ghosted local vector */
DM da; /* distributed array data structure */
DM cda;
Mat H;
} AppCtx;
PetscScalar MMS_uA(PetscScalar x, PetscScalar y) {
return cos(x) * sin(y) + 2;
}
PetscScalar MMS_uA_dx(PetscScalar x, PetscScalar y) {
return -sin(x) * sin(y);
}
PetscScalar MMS_uA_dxx(PetscScalar x, PetscScalar y) {
return -cos(x) * sin(y);
}
PetscScalar MMS_uA_dy(PetscScalar x, PetscScalar y) {
return cos(x) * cos(y);
}
PetscScalar MMS_uA_dyy(PetscScalar x, PetscScalar y) {
return -cos(x) * sin(y);
}
PetscScalar MMS_mu(PetscScalar x, PetscScalar y) {
return sin(x) * sin(y) + 2;
}
PetscScalar MMS_mu_dx(PetscScalar x, PetscScalar y) {
return cos(x) * sin(y);
}
PetscScalar MMS_mu_dy(PetscScalar x, PetscScalar y) {
return sin(x) * cos(y);
}
PetscScalar MMS_uA_dmuxx(PetscScalar x, PetscScalar y) {
return MMS_mu(x,y) * MMS_uA_dxx(x,y) + MMS_mu_dx(x,y) * MMS_uA_dx(x,y);
}
PetscScalar MMS_uA_dmuyy(PetscScalar x, PetscScalar y) {
return MMS_mu(x,y) * MMS_uA_dyy(x,y) + MMS_mu_dy(x,y) * MMS_uA_dx(x,y);
}
PetscScalar MMS_uS(PetscScalar x, PetscScalar y) {
return MMS_mu(x,y) * (MMS_uA_dxx(x,y) + MMS_uA_dyy(x,y))
+ MMS_mu_dx(x,y) * MMS_uA_dx(x,y) + MMS_mu_dy(x,y) * MMS_uA_dy(x,y);
}
/* Function: writeVec
* ------------------
* This function allows users to pass in a vector and
* a file location (including name) for a PETSc vector.
* If the current directory is the desired location,
* a string containing the name of the file
* will suffice. The vector can then be imported to
* MATLAB for error checking or other usage.
*/
PetscErrorCode writeVec(Vec vec,const char * loc)
{
PetscErrorCode ierr = 0;
PetscViewer viewer;
PetscViewerBinaryOpen(PETSC_COMM_WORLD,loc,FILE_MODE_WRITE,&viewer);
ierr = VecView(vec,viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
return ierr;
}
/* Function: calculate_two_norm
* ----------------------------
* This function calculates the two-norm
* of the difference of two vectors, multiplies
* the calculated norm by 1/sqrt(length of vector)
* and outputs this error value as well as the log (base 2)
* of the error value. The Vec that will contain the difference is
* the first argument (diff). The second and third arguments
* are the two Vecs that we are taking the difference of. The last
* argument is the length of the vectors, the number of entries
* in the given Vecs.
*/
PetscErrorCode calculate_two_norm(Vec &diff, const Vec &x, const Vec &y, int size) {
PetscErrorCode ierr = 0;
PetscScalar a = -1; // set the multiple in the WAXPY operation to negative so it just subtracts
VecWAXPY(diff,a,x,y); // diff = x - y
PetscReal norm = 0; // zeroes out the norm value
VecNorm(diff,NORM_2,&norm); // norm = NORM_2(diff)
PetscReal answer = norm * (1/(sqrt(size))); // error equals norm times 1 over the sqrt of the Vec length
PetscPrintf(PETSC_COMM_WORLD, "Error: % .5e ", answer);
answer = log2(answer); // take the log (base 2) for easier readability
PetscPrintf(PETSC_COMM_WORLD, "Log of Error: % .5e\n", answer); // I USED TO HAVE %.15e
return ierr;
}
/* Function: Dx_1d
* ------------------------------------
* This function takes in a derivative matrix (in the form of a vector)
* that it will fill. It also takes in a grid spacing interval (PetscScalar)
* and the values at each interval (which is a matrix placed in the form
* of a vector). The vectors are passed in by reference. One
* also needs to pass in the DMDA associated with the given Vecs.
*
* Vecs:
* - u is the vector that one passes in to hold the calculated derivative.
* - z is the vector that holds the sampled values of the function
*/
PetscErrorCode Dx_1d(Vec &u, Vec &z, PetscScalar spacing, DM &da) {
PetscErrorCode ierr = 0;
// Creating local Vecs y (function values) and calc_diff (derivative)
Vec y, calc_diff;
// Values that hold specific indices for iteration
PetscInt yistart, yiend, fistart, fiend, yi_extra;
// Creates local vectors using the DMDA to ensure correct partitioning
DMCreateLocalVector(da,&y);
DMCreateLocalVector(da,&calc_diff);
// Make it such that the DMDA splits the global Vecs into local Vecs
ierr = DMGlobalToLocalBegin(da,z,INSERT_VALUES,y);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da,z,INSERT_VALUES,y);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da,u,INSERT_VALUES,calc_diff);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da,u,INSERT_VALUES,calc_diff);CHKERRQ(ierr);
// Obtains the ownership range of both the function-value Vec and the derivative Vec
ierr = VecGetOwnershipRange(y,&yistart,&yiend);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(calc_diff,&fistart,&fiend);CHKERRQ(ierr);
// Here we set the current to the beginning and the previous to the beginning
// We set the next to the one directly after the start.
PetscInt yi_current = yistart;
PetscInt yi_prev = yistart;
PetscInt yi_next = yistart + 1;
PetscScalar slope = 0; // This will contain the derivative on each calculation
PetscScalar y_1, y_2, y_3; // These are used to keep the derivative values we pull from the function Vec
PetscInt fi = fistart; // We start the current iteration on the first value in the function Vec
while(yi_current < yiend) {
yi_next = yi_current + 1;
// If the current index is between the start and the end of the Vec
// simply calculate the derivative using the central difference method
if (yi_current > yistart && yi_current < yiend - 1) {
yi_prev = yi_current - 1;
ierr = VecGetValues(y,1,&yi_prev,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_next,&y_2);CHKERRQ(ierr);
slope = ((y_2 - y_1) / (2 * spacing));
// This is where I calculate the derivative at the beginning
// of the Vec. I use coefficients and 3 points to obtain
// second-order accuracy.
} else if (yi_current == yistart) {
ierr = VecGetValues(y,1,&yi_current,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_next,&y_2);CHKERRQ(ierr);
yi_extra = yi_next + 1;
ierr = VecGetValues(y,1,&yi_extra,&y_3);CHKERRQ(ierr);
slope = (((-y_3) + (4 * y_2) + (-3 * y_1)) / (2 * spacing));
// This is where I calculate the derivative at the end of the
// Vec. I use coefficients and 3 points at the end of the Vec
// to obtain second-order accuracy.
} else if (yi_current == yiend - 1) {
yi_prev = yi_current - 1;
ierr = VecGetValues(y,1,&yi_prev,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_current,&y_2);CHKERRQ(ierr);
yi_extra = yi_prev - 1;
ierr = VecGetValues(y,1,&yi_extra,&y_3);CHKERRQ(ierr);
slope = (((y_3) + (-4 * y_1) + (3 * y_2)) / (2 * spacing));
}
// This sets the Vec value to the calculated derivative
ierr = VecSetValues(calc_diff,1,&fi,&slope,INSERT_VALUES);CHKERRQ(ierr);
// Increment here
fi++;
yi_current++;
}
// Assemble the Vec - do we need this here? Not sure.
ierr = VecAssemblyBegin(calc_diff);CHKERRQ(ierr);
ierr = VecAssemblyEnd(calc_diff);CHKERRQ(ierr);
// Take the Vec values from the local Vecs and put them back in their respective global Vecs.
ierr = DMLocalToGlobalBegin(da,y,INSERT_VALUES,z);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da,y,INSERT_VALUES,z);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da,calc_diff,INSERT_VALUES,u);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da,calc_diff,INSERT_VALUES,u);CHKERRQ(ierr);
// Dispose of the local Vecs
VecDestroy(&y);
VecDestroy(&calc_diff);
return ierr;
}
/* Function: Dxx_1d
* ------------------------------------
* This function takes in a derivative matrix (in the form of a vector)
* that it will fill. It also takes in a grid spacing interval (PetscScalar)
* and the values at each interval (which is a matrix placed in the form
* of a vector). The vectors are passed in by reference. One
* also needs to pass in the DMDA associated with the given Vecs.
*
* Vecs:
* - u is the vector that one passes in to hold the calculated derivative.
* - z is the vector that holds the sampled values of the function
*/
PetscErrorCode Dxx_1d(Vec &u, Vec &z, PetscScalar spacing, DM &da) {
PetscErrorCode ierr = 0;
// Creating local Vecs y (function values) and calc_diff (derivative)
Vec y, calc_diff;
// Values that hold specific indices for iteration
PetscInt yistart, yiend, fistart, fiend, yi_extra;
// Creates local vectors using the DMDA to ensure correct partitioning
DMCreateLocalVector(da,&y);
DMCreateLocalVector(da,&calc_diff);
// Make it such that the DMDA splits the global Vecs into local Vecs
ierr = DMGlobalToLocalBegin(da,z,INSERT_VALUES,y);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da,z,INSERT_VALUES,y);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da,u,INSERT_VALUES,calc_diff);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da,u,INSERT_VALUES,calc_diff);CHKERRQ(ierr);
// Obtains the ownership range of both the function-value Vec and the derivative Vec
ierr = VecGetOwnershipRange(y,&yistart,&yiend);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(calc_diff,&fistart,&fiend);CHKERRQ(ierr);
// Here we set the current to the beginning and the previous to the beginning
// We set the next to the one directly after the start.
PetscInt yi_current = yistart;
PetscInt yi_prev = yistart;
PetscInt yi_next = yistart + 1;
PetscScalar slope = 0; // This will contain the derivative on each calculation
PetscScalar y_1, y_2, y_3; // These are used to keep the derivative values we pull from the function Vec
PetscInt fi = fistart; // We start the current iteration on the first value in the function Vec
while(yi_current < yiend) {
yi_next = yi_current + 1;
// If the current index is between the start and the end of the Vec
// simply calculate the derivative using the central difference method
if (yi_current > yistart && yi_current < yiend - 1) {
yi_prev = yi_current - 1;
ierr = VecGetValues(y,1,&yi_prev,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_current,&y_2);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_next,&y_3);CHKERRQ(ierr);
slope = ((y_1 - (2 * y_2) + y_3) / (spacing * spacing));
// This is where I calculate the derivative at the beginning
// of the Vec. I use coefficients and 3 points to obtain
// second-order accuracy.
} else if (yi_current == yistart) {
ierr = VecGetValues(y,1,&yi_current,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_next,&y_2);CHKERRQ(ierr);
yi_extra = yi_next + 1;
ierr = VecGetValues(y,1,&yi_extra,&y_3);CHKERRQ(ierr);
slope = (y_1 - (2 * y_2) + y_3) / (spacing * spacing);
// This is where I calculate the derivative at the end of the
// Vec. I use coefficients and 3 points at the end of the Vec
// to obtain second-order accuracy.
} else if (yi_current == yiend - 1) {
yi_prev = yi_current - 1;
ierr = VecGetValues(y,1,&yi_prev,&y_1);CHKERRQ(ierr);
ierr = VecGetValues(y,1,&yi_current,&y_2);CHKERRQ(ierr);
yi_extra = yi_prev - 1;
ierr = VecGetValues(y,1,&yi_extra,&y_3);CHKERRQ(ierr);
slope = (y_2 - (2 * (y_1)) + y_3) / (spacing * spacing);
}
// This sets the Vec value to the calculated derivative
ierr = VecSetValues(calc_diff,1,&fi,&slope,INSERT_VALUES);CHKERRQ(ierr);
// Increment here
fi++;
yi_current++;
}
// Assemble the Vec - do we need this here? Not sure.
ierr = VecAssemblyBegin(calc_diff);CHKERRQ(ierr);
ierr = VecAssemblyEnd(calc_diff);CHKERRQ(ierr);
// Take the Vec values from the local Vecs and put them back in their respective global Vecs.
ierr = DMLocalToGlobalBegin(da,y,INSERT_VALUES,z);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da,y,INSERT_VALUES,z);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da,calc_diff,INSERT_VALUES,u);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da,calc_diff,INSERT_VALUES,u);CHKERRQ(ierr);
// Dispose of the local Vecs
VecDestroy(&y);
VecDestroy(&calc_diff);
return ierr;
}
/* Function: calculate_Dx_1d
* -----------------------------
* This function calculates the first
* derivative of a Vec using only
* the number of entries (n), the minimum value (x_min),
* and the maximum value (x_max). It calculates
* all other need values.
*/
PetscErrorCode calculate_Dx_1d(PetscInt n, PetscInt x_min, PetscInt x_max)
{
PetscErrorCode ierr = 0;
PetscInt i = 0, xistart, xiend, yistart, yiend, diff_start, diff_end; /* iteration values */
PetscScalar v = 0, mult = 0; /* v is my temp value I use to fill Vecs, mult is the spacing between each value of the Vec (h, dx) */
Vec w = NULL, x = NULL, y = NULL, calc_diff = NULL, diff = NULL; /* vectors */
mult = ((PetscReal)(x_max - x_min))/(n - 1); // evenly partitioning the Vec to have equally sized spacing between values
// MUST CREATE DMDA - STENCIL WIDTH 1 FOR BOUNDARIES
// IMPORTANT: SINCE STENCIL WIDTH IS 1, BE SURE THAT THERE ARE AT LEAST 3 END VALUES ON THE END OF A PARTITIONED VEC
DM da;
DMDACreate1d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE,n,1,1,NULL,&da);
// Create first Vec, this one holds the values at specific points (at every spacing)
ierr = DMCreateGlobalVector(da,&x); // Holds spacing values
// Same Vec format, duplicated.
ierr = VecDuplicate(x,&w);CHKERRQ(ierr); // Will eventually be used to hold the difference between the actual derivative and the calculated one.
ierr = VecDuplicate(x,&y);CHKERRQ(ierr); // Holds function values
ierr = VecDuplicate(x,&calc_diff);CHKERRQ(ierr); // Holds calculated derivative
ierr = VecDuplicate(x,&diff);CHKERRQ(ierr); // Holds actual derivative
ierr = PetscObjectSetName((PetscObject) x, "x (spacing values)");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) w, "w");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "y (func. values)");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) calc_diff, "calculated derivative");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff, "actual derivative");CHKERRQ(ierr);
/* This is where I fill in the x vector.
* I put in multiples defined by the grid
* spacing from the minimum value to the maximum.
*/
VecGetOwnershipRange(x,&xistart,&xiend);
for(i = xistart; i < xiend; i++) {
v = (i*mult);
VecSetValues(x,1,&i,&v,INSERT_VALUES);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
/* This is where I fill in the y vector.
* Its values can be defined by a hard-coded
* function below. Comment out a single
* function to dictate what will be in the y Vec.
*/
ierr = VecGetOwnershipRange(y,&yistart,&yiend);CHKERRQ(ierr);
for(i = yistart; i < yiend; i++) {
ierr = VecGetValues(x,1,&i,&v);CHKERRQ(ierr);
// v *= v; // x^2
// v = (v*v*v); // x^3
v = sin(v); // sine function
// v = cos(v); // cosine function
ierr = VecSetValues(y,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(y);CHKERRQ(ierr);
ierr = VecAssemblyEnd(y);CHKERRQ(ierr);
/* This is where I fill in the true
* analytical derivative. It's hard-coded
* as well.
*/
ierr = VecGetOwnershipRange(diff,&diff_start,&diff_end);CHKERRQ(ierr);
for(i = diff_start; i < diff_end; i++) {
ierr = VecGetValues(x,1,&i,&v);CHKERRQ(ierr);
// v = 2*v; // 2x
// v = (3)*(v*v); //3x^2
v = cos(v); // cosine function
// v = -sin(v); // -sine function
ierr = VecSetValues(diff,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(diff);CHKERRQ(ierr);
ierr = VecAssemblyEnd(diff);CHKERRQ(ierr);
/* Here we pass in the calculated derivative Vec (to be filled),
* our spacing, our Vec with function values (y), and the DMDA.
* It will fill the calc_diff Vec with our calculated derivative.
*/
ierr = Dx_1d(calc_diff, y, mult, da);CHKERRQ(ierr);
/* This is where we calculate norm using the difference between
* the analytical (true) derivative and the calculated derivative and print
* out the error. Below here, we print out information (number of entries,
* the current spacing).
*/
PetscPrintf(PETSC_COMM_WORLD, "Nx: %15i Spacing: % .15e ", n, mult);
ierr = calculate_two_norm(w, calc_diff, diff, n);CHKERRQ(ierr);
/* To print out any of the Vecs, uncomment one of the lines below */
// ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(y,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(calc_diff,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(diff,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// BE SURE TO DISPOSE OF ALL VECS AND DMDAS!
ierr = VecDestroy(&w);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&calc_diff);CHKERRQ(ierr);
ierr = VecDestroy(&diff);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
return ierr;
}
/* Function: calculate_Dxx_1d
* -----------------------------
* This function calculates the second
* derivative of a Vec using only
* the number of entries (n), the minimum value (x_min),
* and the maximum value (x_max). It calculates
* all other need values.
*/
PetscErrorCode calculate_Dxx_1d(PetscInt n, PetscInt x_min, PetscInt x_max)
{
PetscErrorCode ierr = 0;
PetscInt i = 0, xistart, xiend, yistart, yiend, diff_start, diff_end; /* iteration values */
PetscScalar v = 0, mult = 0; /* v is my temp value I use to fill Vecs, mult is the spacing between each value of the Vec (h, dx) */
Vec w = NULL, x = NULL, y = NULL, calc_diff = NULL, diff = NULL; /* vectors */
mult = ((PetscReal)(x_max - x_min))/(n - 1); // evenly partitioning the Vec to have equally sized spacing between values
// MUST CREATE DMDA - STENCIL WIDTH 1 FOR BOUNDARIES
// IMPORTANT: SINCE STENCIL WIDTH IS 1, BE SURE THAT THERE ARE AT LEAST 3 END VALUES ON THE END OF A PARTITIONED VEC
DM da;
DMDACreate1d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE,n,1,1,NULL,&da);
// Create first Vec, this one holds the values at specific points (at every spacing)
ierr = DMCreateGlobalVector(da,&x); // Holds spacing values
// Same Vec format, duplicated.
ierr = VecDuplicate(x,&w);CHKERRQ(ierr); // Will eventually be used to hold the difference between the actual derivative and the calculated one.
ierr = VecDuplicate(x,&y);CHKERRQ(ierr); // Holds function values
ierr = VecDuplicate(x,&calc_diff);CHKERRQ(ierr); // Holds calculated derivative
ierr = VecDuplicate(x,&diff);CHKERRQ(ierr); // Holds actual derivative
ierr = PetscObjectSetName((PetscObject) x, "x (spacing values)");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) w, "w");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "y (func. values)");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) calc_diff, "calculated derivative");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff, "actual derivative");CHKERRQ(ierr);
/* This is where I fill in the x vector.
* I put in multiples defined by the grid
* spacing from the minimum value to the maximum.
*/
VecGetOwnershipRange(x,&xistart,&xiend);
for(i = xistart; i < xiend; i++) {
v = (i*mult);
VecSetValues(x,1,&i,&v,INSERT_VALUES);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
/* This is where I fill in the y vector.
* Its values can be defined by a hard-coded
* function below. Comment out a single
* function to dictate what will be in the y Vec.
*/
ierr = VecGetOwnershipRange(y,&yistart,&yiend);CHKERRQ(ierr);
for(i = yistart; i < yiend; i++) {
ierr = VecGetValues(x,1,&i,&v);CHKERRQ(ierr);
// v *= v; // x^2
// v = (v*v*v); // x^3
v = sin(v); // sine function
// v = cos(v); // cosine function
ierr = VecSetValues(y,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(y);CHKERRQ(ierr);
ierr = VecAssemblyEnd(y);CHKERRQ(ierr);
/* This is where I fill in the true
* analytical derivative. It's hard-coded
* as well.
*/
ierr = VecGetOwnershipRange(diff,&diff_start,&diff_end);CHKERRQ(ierr);
for(i = diff_start; i < diff_end; i++) {
ierr = VecGetValues(x,1,&i,&v);CHKERRQ(ierr);
// v = 2*v; // 2x
// v = (3)*(v*v); //3x^2
// v = cos(v); // cosine function
v = -sin(v); // -sine function
ierr = VecSetValues(diff,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(diff);CHKERRQ(ierr);
ierr = VecAssemblyEnd(diff);CHKERRQ(ierr);
/* Here we pass in the calculated derivative Vec (to be filled),
* our spacing, our Vec with function values (y), and the DMDA.
* It will fill the calc_diff Vec with our calculated derivative.
*/
ierr = Dxx_1d(calc_diff, y, mult, da);CHKERRQ(ierr);
/* This is where we calculate norm using the difference between
* the analytical (true) derivative and the calculated derivative and print
* out the error. Below here, we print out information (number of entries,
* the current spacing).
*/
PetscPrintf(PETSC_COMM_WORLD, "Nx: %15i Spacing: % .15e ", n, mult);
ierr = calculate_two_norm(w, calc_diff, diff, n);CHKERRQ(ierr);
/* To print out any of the Vecs, uncomment one of the lines below */
// ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(y,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(calc_diff,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(diff,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// BE SURE TO DISPOSE OF ALL VECS AND DMDAS!
ierr = VecDestroy(&w);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&calc_diff);CHKERRQ(ierr);
ierr = VecDestroy(&diff);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
return ierr;
}
/* Function: truncation_error
* --------------------------
* This function serves as a test function to see where the convergence fails.
*/
PetscErrorCode truncation_error(Vec &diff_x, PetscScalar &mult_x, DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M;
DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_x;
PetscScalar** local_diff_x_arr;
ierr = DMCreateLocalVector(da, &local_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, diff_x, INSERT_VALUES, local_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, diff_x, INSERT_VALUES, local_diff_x);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
PetscInt x_index = (((int)M/5));
PetscPrintf(PETSC_COMM_WORLD, "Spacing: % .15e At index ([j][i]) [%i][%5i]F'(0.0001) = % .15e\n", mult_x, 2, x_index, local_diff_x_arr[2][x_index]);
return ierr;
}
/* Function: Dy_2d
* ----------------------------------
* 1st derivative solve in the y-direction for 2-D.
*
* diff_y - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* dy - the spacing between each point in the y-direction
* da - DMDA object
*/
PetscErrorCode Dy_2d(Vec &diff_y, Vec &grid, PetscScalar dy, DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, N;
DMDAGetInfo(da,NULL,NULL,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_y, local_grid;
PetscScalar** local_diff_y_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_y);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (j > 0 && j < N - 1) { local_diff_y_arr[j][i] = (local_grid_arr[j+1][i] - local_grid_arr[j-1][i])/(2.0 * dy); }
else if (j == 0) { local_diff_y_arr[j][i] = (-1.5 * local_grid_arr[0][i] + 2.0 * local_grid_arr[1][i] - 0.5 * local_grid_arr[2][i])/ dy; }
else if (j == N - 1) { local_diff_y_arr[j][i] = (0.5 * local_grid_arr[N-3][i] - 2.0 *
local_grid_arr[N-2][i] + 1.5 * local_grid_arr[N-1][i]) / dy; }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
VecDestroy(&local_diff_y);
VecDestroy(&local_grid);
return ierr;
}
/* Function: Dx_2d
* ----------------------------------
*
* diff_x - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* dx - the spacing between each point in the x-direction
* da - DMDA object
*/
//~PetscErrorCode Dx_2d(Vec &diff_x, Vec &grid, PetscScalar dx, DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M;
DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_x, local_grid;
PetscScalar** local_diff_x_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_x);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (i > 0 && i < M - 1) {local_diff_x_arr[j][i] = (local_grid_arr[j][i+1] -
local_grid_arr[j][i-1])/(2.0 * dx); }
else if (i == 0) { local_diff_x_arr[j][i] = (-1.5 * local_grid_arr[j][0] +
2.0 * local_grid_arr[j][1] - 0.5 * local_grid_arr[j][2])/ dx; }
else if (i == M - 1) { local_diff_x_arr[j][i] = (0.5 * local_grid_arr[j][M-3] -
2.0 * local_grid_arr[j][M-2] + 1.5 * local_grid_arr[j][M-1]) / dx; }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
VecDestroy(&local_diff_x);
VecDestroy(&local_grid);
return ierr;
}
/* Function: Dyy_2d
* ----------------------------------
* diff_y - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* dy - the spacing between each point in the y-direction
* da - DMDA object
*/
PetscErrorCode Dyy_2d(Vec &diff_y, const Vec &grid, const PetscScalar dy, const DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, N;
DMDAGetInfo(da,NULL,NULL,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_y, local_grid;
PetscScalar** local_diff_y_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_y);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_y, &local_diff_y_arr); CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0); CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (j > 0 && j < N - 1) { local_diff_y_arr[j][i] = (local_grid_arr[j+1][i] - (2*local_grid_arr[j][i]) + local_grid_arr[j-1][i])/(dy * dy); }
else if (j == 0) { local_diff_y_arr[j][i] = (local_grid_arr[0][i] - (2 * local_grid_arr[1][i]) + local_grid_arr[2][i])/(dy * dy); }
else if (j == N - 1) { local_diff_y_arr[j][i] = (local_grid_arr[N-1][i] - (2 * local_grid_arr[N-2][i]) + local_grid_arr[N-3][i])/(dy * dy); }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
VecDestroy(&local_diff_y);
VecDestroy(&local_grid);
return ierr;
}
/* Function: Dxx_2d
* --------------------------------------
* diff_x - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* dx - the spacing between each point in the x-direction
* da - DMDA object
*/
PetscErrorCode Dxx_2d(Vec &diff_x, const Vec &grid, const PetscScalar dx, const DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M;
DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
VecSet(diff_x,0.0);
Vec local_diff_x, local_grid;
PetscScalar** local_diff_x_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_x);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (i > 0 && i < M - 1) {local_diff_x_arr[j][i] = (local_grid_arr[j][i+1] -
(2 * local_grid_arr[j][i]) + local_grid_arr[j][i-1])/(dx * dx); }
else if (i == 0) { local_diff_x_arr[j][i] = (local_grid_arr[j][0] -
(2 * local_grid_arr[j][1]) + local_grid_arr[j][2])/(dx * dx); }
else if (i == M - 1) { local_diff_x_arr[j][i] = (local_grid_arr[j][M-1] -
(2 * local_grid_arr[j][M-2]) + local_grid_arr[j][M-3])/(dx * dx); }
//PetscPrintf(PETSC_COMM_SELF, "[%i][%i] = %g\n", j, i, local_diff_x_arr[j][i]);
}
}
ierr = DMDAVecRestoreArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
VecDestroy(&local_diff_x);
VecDestroy(&local_grid);
return ierr;
}
/* Function: Dmuyy_2d
* ------------------
* diff_y - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* mu - the Vec that holds the values of mu
* dy - the spacing between each point in the y-direction
* da - DMDA object
*/
PetscErrorCode Dmuyy_2d(Vec &diff_y, const Vec &grid, const Vec &mu, const PetscScalar dy, const DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, N;
DMDAGetInfo(da,NULL,NULL,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_y = NULL, local_grid = NULL, local_mu = NULL;
PetscScalar** local_diff_y_arr;
PetscScalar** local_grid_arr;
PetscScalar** local_mu_arr;
ierr = DMCreateLocalVector(da, &local_diff_y);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_mu);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_mu, &local_mu_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (j > 0 && j < N - 1) { local_diff_y_arr[j][i] = (0.5 * (((local_mu_arr[j][i] + local_mu_arr[j-1][i]) * local_grid_arr[j-1][i])
- ((local_mu_arr[j+1][i] + 2 * local_mu_arr[j][i] + local_mu_arr[j-1][i]) * local_grid_arr[j][i])
+ ((local_mu_arr[j][i] + local_mu_arr[j+1][i]) * local_grid_arr[j+1][i])
))/(dy * dy); }
else if (j == 0) { local_diff_y_arr[j][i] = (0.5 * (((local_mu_arr[1][i] + local_mu_arr[0][i]) * local_grid_arr[0][i])
- ((local_mu_arr[2][i] + 2 * local_mu_arr[1][i] + local_mu_arr[0][i]) * local_grid_arr[1][i])
+ ((local_mu_arr[1][i] + local_mu_arr[2][i]) * local_grid_arr[2][i])
))/(dy * dy); }
else if (j == N - 1) { local_diff_y_arr[j][i] = (0.5 * (((local_mu_arr[N-2][i] + local_mu_arr[N-1][i]) * local_grid_arr[N-1][i])
- ((local_mu_arr[N-3][i] + 2 * local_mu_arr[N-2][i] + local_mu_arr[N-1][i]) * local_grid_arr[N-2][i])
+ ((local_mu_arr[N-2][i] + local_mu_arr[N-3][i]) * local_grid_arr[N-3][i])
))/(dy * dy); }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_mu, &local_mu_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
VecDestroy(&local_diff_y);
VecDestroy(&local_grid);
VecDestroy(&local_mu);
return ierr;
}
/* Function: Dmuxx_2d
* --------------------------------------
* diff_x - the output Vec (it will hold the calculated derivative)
* grid - the input Vec (it holds the function values to draw from)
* mu - the Vec that holds the values of mu
* dx - the spacing between each point in the x-direction
* da - DMDA object
*/
PetscErrorCode Dmuxx_2d(Vec &diff_x, const Vec &grid, const Vec &mu, const PetscScalar dx, const DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M;
DMDAGetInfo(da,NULL,&M,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_x = NULL, local_grid = NULL, local_mu = NULL;
PetscScalar** local_diff_x_arr;
PetscScalar** local_grid_arr;
PetscScalar** local_mu_arr;
ierr = DMCreateLocalVector(da, &local_diff_x);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_mu);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_x, &local_diff_x_arr); CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr); CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_mu, &local_mu_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0); CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (i > 0 && i < M - 1) {local_diff_x_arr[j][i] = (0.5 * (((local_mu_arr[j][i] + local_mu_arr[j][i-1]) * local_grid_arr[j][i-1])
- ((local_mu_arr[j][i+1] + 2 * local_mu_arr[j][i] + local_mu_arr[j][i-1]) * local_grid_arr[j][i])
+ ((local_mu_arr[j][i] + local_mu_arr[j][i+1]) * local_grid_arr[j][i+1])
))/(dx * dx); }
else if (i == 0) { local_diff_x_arr[j][i] = (0.5 * (((local_mu_arr[j][1] + local_mu_arr[j][0]) * local_grid_arr[j][0])
- ((local_mu_arr[j][2] + 2 * local_mu_arr[j][1] + local_mu_arr[j][0]) * local_grid_arr[j][1])
+ ((local_mu_arr[j][1] + local_mu_arr[j][2]) * local_grid_arr[j][2])
))/(dx * dx); }
else if (i == M - 1) { local_diff_x_arr[j][i] = (0.5 * (((local_mu_arr[j][M-2] + local_mu_arr[j][M-1]) * local_grid_arr[j][M-1])
- ((local_mu_arr[j][M-3] + 2 * local_mu_arr[j][M-2] + local_mu_arr[j][M-1]) * local_grid_arr[j][M-2])
+ ((local_mu_arr[j][M-2] + local_mu_arr[j][M-3]) * local_grid_arr[j][M-3])
))/(dx * dx); }
//PetscPrintf(PETSC_COMM_SELF, "[%i][%i] = %g\n", j, i, local_diff_x_arr[j][i]);
}
}
ierr = DMDAVecRestoreArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_mu, &local_mu_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
VecDestroy(&local_diff_x);
VecDestroy(&local_grid);
VecDestroy(&local_mu);
return ierr;
}
/* Function: calculate_Dx_Dy_2D
* ---------------------------------------
* Calculates both the first derivative in x and y for a 2-D grid.
* x_len - number of points in the x direction
* y_len - number of points in the y direction
* x_max - maximum value in the x direction
* x_min - minimum value in the x_direction
* y_max - maximum value in the y direction
* y_min - minimum value in the y direction
*/
PetscErrorCode calculate_Dx_Dy_2D(PetscInt x_len, PetscInt y_len, PetscScalar x_max, PetscScalar x_min, PetscScalar y_max, PetscScalar y_min) {
PetscErrorCode ierr = 0;
double t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
t1 = MPI_Wtime();
PetscInt i = 0, j = 0, mStart = 0, m = 0, nStart = 0, n = 0,
grid_istart, grid_iend, diff_x_start, diff_x_end, diff_y_start, diff_y_end;
PetscScalar v = 0, mult_x = 0, mult_y = 0;
Vec grid = NULL, diff_x = NULL, diff_y = NULL, act_diff_x = NULL, act_diff_y = NULL, grid_error_diff = NULL, /* vectors */
local_coords = NULL, local_grid = NULL, local_act_diff_x = NULL, local_act_diff_y = NULL;
// first row, global vectors, second row, local vectors
PetscInt num_grid_entries = (x_len) * (y_len); // total number of entries on the grid
mult_x = ((PetscReal)(x_max - x_min))/(x_len - 1); // spacing in the x direction
mult_y = ((PetscReal)(y_max - y_min))/(y_len - 1); // spacing in the y direction
DM da;
DM cda;
DMDACoor2d **coords; // 2D array containing x and y data members
// FIXME should I use DMDA_STENCIL_STAR && do we need a stencil width of 2?
ierr = DMDACreate2d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_BOX, x_len, y_len, PETSC_DECIDE, PETSC_DECIDE, 1, 2, NULL, NULL, &da); CHKERRQ(ierr);
DMDASetUniformCoordinates(da, x_min, x_max, y_min, y_max, 0.0, 0.0);
DMGetCoordinateDM(da, &cda);
DMGetCoordinatesLocal(da, &local_coords);
DMDAVecGetArray(cda, local_coords, &coords);
DMDAGetCorners(cda, &mStart, &nStart, 0, &m, &n, 0);
ierr = DMCreateGlobalVector(da,&grid);
ierr = VecDuplicate(grid, &diff_x);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &diff_y);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &act_diff_x);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &act_diff_y);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &grid_error_diff);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) grid, "global grid");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff_x, "diff_x");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff_y, "diff_y");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) act_diff_x, "act_diff_x");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) act_diff_y, "act_diff_y");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) grid_error_diff, "grid_error_diff");CHKERRQ(ierr);
// Set up GRID
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
//FIXME
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
//FIXME
PetscInt x_index = x_len/5;
bool printed = false;
PetscScalar **local_grid_arr;
DMDAVecGetArray(da, local_grid, &local_grid_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_grid_arr[j][i] = coords[j][i].y;
// FIXME
//if(i == x_index && printed == false) {
// PetscPrintf(PETSC_COMM_WORLD, "\nx_index: %i SHOULD BE 0.1 = % .5e\n", x_index, coords[j][x_index].x);
// printed = true;
//}
//local_grid_arr[j][i] = (.01*(coords[j][i].x * coords[j][i].x * coords[j][i].x) + (coords[j][i].y * coords[j][i].y * coords[j][i].y));
local_grid_arr[j][i] = cos(coords[j][i].x) * sin(coords[j][i].y);//sin(coords[j][i].x) + cos(coords[j][i].y);
}
}
DMDAVecRestoreArray(da, local_grid, &local_grid_arr);
ierr = DMLocalToGlobalBegin(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
// SET UP ACT_DIFF_X
ierr = DMCreateLocalVector(da, &local_act_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, act_diff_x, INSERT_VALUES, local_act_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, act_diff_x, INSERT_VALUES, local_act_diff_x);CHKERRQ(ierr);
PetscScalar **local_act_diff_x_arr;
DMDAVecGetArray(da, local_act_diff_x, &local_act_diff_x_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_act_diff_x_arr[j][i] = coords[j][i].x;
local_act_diff_x_arr[j][i] = -sin(coords[j][i].x) * sin(coords[j][i].y);//cos(coords[j][i].x);
//local_act_diff_x_arr[j][i] = .01*(3 * coords[j][i].x * coords[j][i].x);
}
}
DMDAVecRestoreArray(da, local_act_diff_x, &local_act_diff_x_arr);
ierr = DMLocalToGlobalBegin(da, local_act_diff_x, INSERT_VALUES, act_diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_act_diff_x, INSERT_VALUES, act_diff_x);CHKERRQ(ierr);
// SET UP ACT_DIFF_Y
ierr = DMCreateLocalVector(da, &local_act_diff_y);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, act_diff_y, INSERT_VALUES, local_act_diff_y);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, act_diff_y, INSERT_VALUES, local_act_diff_y);CHKERRQ(ierr);
PetscScalar **local_act_diff_y_arr;
DMDAVecGetArray(da, local_act_diff_y, &local_act_diff_y_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
//local_act_diff_y_arr[j][i] = .01*(3 * coords[j][i].y * coords[j][i].y);
local_act_diff_y_arr[j][i] = cos(coords[j][i].y) * cos(coords[j][i].x);
}
}
DMDAVecRestoreArray(da, local_act_diff_y, &local_act_diff_y_arr);
ierr = DMLocalToGlobalBegin(da, local_act_diff_y, INSERT_VALUES, act_diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_act_diff_y, INSERT_VALUES, act_diff_y);CHKERRQ(ierr);
t2 = MPI_Wtime();
ierr = Dy_2d(diff_y, grid, mult_y, da);CHKERRQ(ierr);
t3 = MPI_Wtime();
ierr = Dx_2d(diff_x, grid, mult_x, da);CHKERRQ(ierr);
t4 = MPI_Wtime();
PetscPrintf(PETSC_COMM_WORLD, "Ny: %5i Spacing: % .5e Log of Spacing: % .5e ", y_len, mult_y, log2(mult_y)); // I used to have %15!
calculate_two_norm(grid_error_diff, diff_y, act_diff_y, num_grid_entries);
PetscPrintf(PETSC_COMM_WORLD, " Nx: %5i Spacing: % .5e Log of Spacing: % .5e ", x_len, mult_x, log2(mult_x));
calculate_two_norm(grid_error_diff, diff_x, act_diff_x, num_grid_entries);
t5 = MPI_Wtime();
// writeVec(grid, "grid_file");
// writeVec(diff_x, "calc_diff_x_file");
// writeVec(diff_y, "calc_diff_y_file");
// writeVec(act_diff_x, "actual_diff_x_file");
// writeVec(act_diff_y, "actual_diff_y_file");
// Truncation Error Test!!!
//ierr = truncation_error(diff_x, mult_x, da);CHKERRQ(ierr);
// FIXME make sure all Vecs and DMs are being destroyed - go to other functions as well!
ierr = VecDestroy(&grid);CHKERRQ(ierr);
ierr = VecDestroy(&diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&diff_x);CHKERRQ(ierr);
ierr = VecDestroy(&act_diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&act_diff_x);CHKERRQ(ierr);
ierr = VecDestroy(&grid_error_diff);CHKERRQ(ierr);
ierr = VecDestroy(&local_grid);CHKERRQ(ierr);
ierr = VecDestroy(&local_act_diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&local_act_diff_x);CHKERRQ(ierr);
//ierr = VecDestroy(&local_coords);CHKERRQ(ierr);
//ierr = DMDestroy(&cda);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
t6 = MPI_Wtime();
PetscPrintf(PETSC_COMM_WORLD, "\nTime spent setting up and filling grid/actual derivative Vecs: % 8g\n", t2 - t1);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating 2Dy derivative: % 8g\n", t3 - t2);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating 2Dx derivative: % 8g\n", t4 - t3);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating norms: % 8g\n", t5 - t4);
PetscPrintf(PETSC_COMM_WORLD, "Total time for this iteration: % 8g\n\n", t6 - t1);
return ierr;
}
/* Function: calculate_Dxx_Dyy_2D
* -------------------------------------------
* Calculates both second derivatives in x and y for a 2-D grid.
* IMPORTANT: Depending on the global set at the top of this program,
* the function will either solve the second derivative WITH coefficient or WITHOUT.
*
* x_len - number of points in the x direction
* y_len - number of points in the y direction
* x_max - maximum value in the x direction
* x_min - minimum value in the x_direction
* y_max - maximum value in the y direction
* y_min - minimum value in the y direction
*/
PetscErrorCode calculate_Dxx_Dyy_2D(PetscInt x_len, PetscInt y_len, PetscScalar x_max, PetscScalar x_min, PetscScalar y_max, PetscScalar y_min) {
PetscErrorCode ierr = 0;
double t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0;
t1 = MPI_Wtime();
PetscInt i = 0, j = 0, mStart = 0, m = 0, nStart = 0, n = 0,
grid_istart, grid_iend, diff_x_start, diff_x_end, diff_y_start, diff_y_end;
PetscScalar v = 0, mult_x = 0, mult_y = 0;
Vec grid = NULL, diff_x = NULL, diff_y = NULL, act_diff_x = NULL, act_diff_y = NULL, grid_error_diff = NULL, /* vectors */
local_coords = NULL, local_grid = NULL, local_act_diff_x = NULL, local_act_diff_y = NULL,
mu = NULL, local_mu = NULL, dxxmu = NULL, local_dxxmu = NULL, dyymu = NULL, local_dyymu = NULL;
// first row, global vectors | second row, local vectors | third row, mu
PetscInt num_grid_entries = (x_len) * (y_len); // total number of entries on the grid
mult_x = ((PetscReal)(x_max - x_min))/(x_len - 1); // spacing in the x direction
mult_y = ((PetscReal)(y_max - y_min))/(y_len - 1); // spacing in the y direction
DM da;
DM cda;
DMDACoor2d **coords; // 2D array containing x and y data members
// FIXME should I use DMDA_STENCIL_STAR?? DMDA Set Up
ierr = DMDACreate2d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_BOX, x_len, y_len, PETSC_DECIDE, PETSC_DECIDE, 1, 2, NULL, NULL, &da); CHKERRQ(ierr);
DMDASetUniformCoordinates(da, x_min, x_max, y_min, y_max, 0.0, 0.0);
DMGetCoordinateDM(da, &cda);
DMGetCoordinatesLocal(da, &local_coords);
DMDAVecGetArray(cda, local_coords, &coords);
DMDAGetCorners(cda, &mStart, &nStart, 0, &m, &n, 0);
ierr = DMCreateGlobalVector(da,&grid);
ierr = VecDuplicate(grid, &diff_x);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &diff_y);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &act_diff_x);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &act_diff_y);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &grid_error_diff);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &mu);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &dxxmu);CHKERRQ(ierr);
ierr = VecDuplicate(grid, &dyymu);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) grid, "global grid");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff_x, "diff_x");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) diff_y, "diff_y");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) act_diff_x, "act_diff_x");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) act_diff_y, "act_diff_y");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) grid_error_diff, "grid_error_diff");CHKERRQ(ierr);
//FIXME
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
// Set up GRID
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
PetscScalar **local_grid_arr;
DMDAVecGetArray(da, local_grid, &local_grid_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_grid_arr[j][i] = coords[j][i].y;
// local_grid_arr[j][i] = (coords[j][i].x * coords[j][i].x * coords[j][i].x) + (coords[j][i].y * coords[j][i].y * coords[j][i].y);
local_grid_arr[j][i] = cos(coords[j][i].x) + sin(coords[j][i].y);
// PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_grid_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_grid, &local_grid_arr);
ierr = DMLocalToGlobalBegin(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
// SET UP ACT_DIFF_X
ierr = DMCreateLocalVector(da, &local_act_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, act_diff_x, INSERT_VALUES, local_act_diff_x);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, act_diff_x, INSERT_VALUES, local_act_diff_x);CHKERRQ(ierr);
PetscScalar **local_act_diff_x_arr;
DMDAVecGetArray(da, local_act_diff_x, &local_act_diff_x_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_act_diff_x_arr[j][i] = coords[j][i].x;
local_act_diff_x_arr[j][i] = -cos(coords[j][i].x);
// PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_act_diff_x_arr[j][i]);
// local_act_diff_x_arr[j][i] = (6 * coords[j][i].x);
}
}
DMDAVecRestoreArray(da, local_act_diff_x, &local_act_diff_x_arr);
ierr = DMLocalToGlobalBegin(da, local_act_diff_x, INSERT_VALUES, act_diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_act_diff_x, INSERT_VALUES, act_diff_x);CHKERRQ(ierr);
// SET UP ACT_DIFF_Y
ierr = DMCreateLocalVector(da, &local_act_diff_y);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, act_diff_y, INSERT_VALUES, local_act_diff_y);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, act_diff_y, INSERT_VALUES, local_act_diff_y);CHKERRQ(ierr);
PetscScalar **local_act_diff_y_arr;
DMDAVecGetArray(da, local_act_diff_y, &local_act_diff_y_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_act_diff_y_arr[j][i] = (6 * coords[j][i].y);
local_act_diff_y_arr[j][i] = -sin(coords[j][i].y);
}
}
DMDAVecRestoreArray(da, local_act_diff_y, &local_act_diff_y_arr);
ierr = DMLocalToGlobalBegin(da, local_act_diff_y, INSERT_VALUES, act_diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_act_diff_y, INSERT_VALUES, act_diff_y);CHKERRQ(ierr);
// SET UP MU
ierr = DMCreateLocalVector(da, &local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
PetscScalar **local_mu_arr;
DMDAVecGetArray(da, local_mu, &local_mu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_mu_arr[j][i] = sin(coords[j][i].x)*(sin(coords[j][i].y)) + 2;
//cos(coords[j][i].x + coords[j][i].y) + 4;
// local_mu_arr[j][i] = 1;
}
}
DMDAVecRestoreArray(da, local_mu, &local_mu_arr);
ierr = DMLocalToGlobalBegin(da, local_mu, INSERT_VALUES, mu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_mu, INSERT_VALUES, mu);CHKERRQ(ierr);
// SET UP DxxMU
ierr = DMCreateLocalVector(da, &local_dxxmu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, dxxmu, INSERT_VALUES, local_dxxmu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, dxxmu, INSERT_VALUES, local_dxxmu);CHKERRQ(ierr);
PetscScalar **local_dxxmu_arr;
DMDAVecGetArray(da, local_dxxmu, &local_dxxmu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_dxxmu_arr[j][i] = 0;
//(-sin(coords[j][i].x + coords[j][i].y) * cos(coords[j][i].x)) +
//((cos(coords[j][i].x + coords[j][i].y) + 4) * (-sin(coords[j][i].x)));
// local_dxxmu_arr[j][i] = -sin(coords[j][i].x);
}
}
DMDAVecRestoreArray(da, local_dxxmu, &local_dxxmu_arr);
ierr = DMLocalToGlobalBegin(da, local_dxxmu, INSERT_VALUES, dxxmu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_dxxmu, INSERT_VALUES, dxxmu);CHKERRQ(ierr);
// SET UP DyyMU
ierr = DMCreateLocalVector(da, &local_dyymu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, dyymu, INSERT_VALUES, local_dyymu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, dyymu, INSERT_VALUES, local_dyymu);CHKERRQ(ierr);
PetscScalar **local_dyymu_arr;
DMDAVecGetArray(da, local_dyymu, &local_dyymu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_dyymu_arr[j][i] = 0;
//(-sin(coords[j][i].x + coords[j][i].y) * (-sin(coords[j][i].y))) +
//((cos(coords[j][i].x + coords[j][i].y) + 4) * (-cos(coords[j][i].y)));
// local_dyymu_arr[j][i] = -cos(coords[j][i].y);
}
}
DMDAVecRestoreArray(da, local_dyymu, &local_dyymu_arr);
ierr = DMLocalToGlobalBegin(da, local_dyymu, INSERT_VALUES, dyymu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_dyymu, INSERT_VALUES, dyymu);CHKERRQ(ierr);
// derivative calculations & error calculations
if(COEFFICIENT_SOLVE) {
t2 = MPI_Wtime();
ierr = Dmuyy_2d(diff_y, grid, mu, mult_y, da);CHKERRQ(ierr);
t3 = MPI_Wtime();
ierr = Dmuxx_2d(diff_x, grid, mu, mult_x, da);CHKERRQ(ierr);
t4 = MPI_Wtime();
PetscPrintf(PETSC_COMM_WORLD, "Ny: %5i Spacing: % .5e Log of Spacing: % .5e ", y_len, mult_y, log2(mult_y)); // I used to have %15!
calculate_two_norm(grid_error_diff, diff_y, dyymu, num_grid_entries);
// PetscPrintf(PETSC_COMM_WORLD, "Nx: %5i Spacing: % .5e Log of Spacing: % .5e ", x_len, mult_x, log2(mult_x));
PetscPrintf(PETSC_COMM_WORLD, " Nx: %5i Spacing: % .5e Log of Spacing: % .5e ", x_len, mult_x, log2(mult_x));
calculate_two_norm(grid_error_diff, diff_x, dxxmu, num_grid_entries);
} else {
t2 = MPI_Wtime();
ierr = Dyy_2d(diff_y, grid, mult_y, da);CHKERRQ(ierr);
t3 = MPI_Wtime();
ierr = Dxx_2d(diff_x, grid, mult_x, da);CHKERRQ(ierr);
t4 = MPI_Wtime();
PetscPrintf(PETSC_COMM_WORLD, "Ny: %5i Spacing: % .5e Log of Spacing: % .5e ", y_len, mult_y, log2(mult_y)); // I used to have %15!
calculate_two_norm(grid_error_diff, diff_y, act_diff_y, num_grid_entries);
//PetscPrintf(PETSC_COMM_WORLD, "Nx: %5i Spacing: % .5e Log of Spacing: % .5e ", x_len, mult_x, log2(mult_x));
PetscPrintf(PETSC_COMM_WORLD, " Nx: %5i Spacing: % .5e Log of Spacing: % .5e ", x_len, mult_x, log2(mult_x));
calculate_two_norm(grid_error_diff, diff_x, act_diff_x, num_grid_entries);
}
t5 = MPI_Wtime();
// writeVec(grid, "grid_file");
// writeVec(diff_x, "calc_diff_x_file");
// writeVec(diff_y, "calc_diff_y_file");
// writeVec(act_diff_x, "actual_diff_x_file");
// writeVec(act_diff_y, "actual_diff_y_file");
// FIXME make sure all Vecs and DMs are being destroyed - go to other functions as well!
ierr = VecDestroy(&grid);CHKERRQ(ierr);
ierr = VecDestroy(&diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&diff_x);CHKERRQ(ierr);
ierr = VecDestroy(&act_diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&act_diff_x);CHKERRQ(ierr);
ierr = VecDestroy(&grid_error_diff);CHKERRQ(ierr);
ierr = VecDestroy(&local_grid);CHKERRQ(ierr);
ierr = VecDestroy(&local_act_diff_y);CHKERRQ(ierr);
ierr = VecDestroy(&local_act_diff_x);CHKERRQ(ierr);
ierr = VecDestroy(&mu);CHKERRQ(ierr);
ierr = VecDestroy(&dxxmu);CHKERRQ(ierr);
ierr = VecDestroy(&dyymu);CHKERRQ(ierr);
ierr = VecDestroy(&local_mu);CHKERRQ(ierr);
ierr = VecDestroy(&local_dxxmu);CHKERRQ(ierr);
ierr = VecDestroy(&local_dyymu);CHKERRQ(ierr);
//ierr = DMDestroy(&cda);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
t6 = MPI_Wtime();
PetscPrintf(PETSC_COMM_WORLD, "\nTime spent setting up and filling grid/actual derivative Vecs: % 8g\n", t2 - t1);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating 2Dy derivative: % 8g\n", t3 - t2);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating 2Dx derivative: % 8g\n", t4 - t3);
PetscPrintf(PETSC_COMM_WORLD, "Time spent calculating norms: % 8g\n", t5 - t4);
PetscPrintf(PETSC_COMM_WORLD, "Total time for this iteration: % 8g\n\n", t6 - t1);
return ierr;
}
/* Function: MMSTest()
* -------------------
*
*/
PetscErrorCode MMSTest() {
PetscErrorCode ierr = 0;
PetscInt n = STARTING_GRID_SPACING, min = MIN_GRID_POINT, max = MAX_GRID_POINT, x_len = NUM_X_PTS, y_len = NUM_Y_PTS;
PetscScalar x_min = X_MIN, x_max = X_MAX, y_max = Y_MAX, y_min = Y_MIN;
assert(n > 2);
PetscPrintf(PETSC_COMM_WORLD, "1-D 1ST DERIVATIVES\n");
for(int i = 0; i < NUM_GRID_SPACE_CALCULATIONS; i++) {
PetscPrintf(PETSC_COMM_WORLD, "Iteration: %15i ", i+1);
ierr = calculate_Dx_1d(n, min, max);CHKERRQ(ierr);
n = ((n - 1) * 2) + 1;
}
PetscPrintf(PETSC_COMM_WORLD, "1-D 2ND DERIVATIVES\n");
for(int i = 0; i < NUM_2ND_GRID_SPACE_CALCULATIONS; i++) {
PetscPrintf(PETSC_COMM_WORLD, "Iteration: %15i ", i+1);
ierr = calculate_Dxx_1d(n, min, max);CHKERRQ(ierr);
n = ((n - 1) * 2) + 1;
}
PetscPrintf(PETSC_COMM_WORLD, "2-D 1ST DERIVATIVES\n");
assert(x_len > 3);
assert(y_len > 3);
for(int i = 0; i < NUM_2D_GRID_SPACE_CALCULATIONS; i++) {
PetscPrintf(PETSC_COMM_WORLD, "Iteration: %15i ", i+1);
calculate_Dx_Dy_2D(x_len, y_len, x_max, x_min, y_max, y_min);
x_len = ((x_len - 1) * 2) + 1;
y_len = ((y_len - 1) * 2) + 1;
}
PetscPrintf(PETSC_COMM_WORLD, "2-D 2ND DERIVATIVES\n");
x_len = NUM_X_PTS;
y_len = NUM_Y_PTS;
x_min = X_MIN;
x_max = X_MAX;
y_max = Y_MAX;
y_min = Y_MIN;
assert(x_len > 3);
assert(y_len > 3);
for(int i = 0; i < NUM_2D_2ND_GRID_SPACE_CALCULATIONS; i++) {
PetscPrintf(PETSC_COMM_WORLD, "Iteration: %15i ", i+1);
calculate_Dxx_Dyy_2D(x_len, y_len, x_max, x_min, y_max, y_min);
x_len = ((x_len - 1) * 2) + 1;
y_len = ((y_len - 1) * 2) + 1;
}
PetscPrintf(PETSC_COMM_WORLD, "\n");
return ierr;
}
/* Function: setRHS_R
* ------------------
*
*/
PetscErrorCode setRHS_R(Vec &RHS, const Vec &r, const PetscScalar &h_11,
const PetscScalar alpha_R, const DM &da) {
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M = NULL, N = NULL, ristart, riend;
PetscScalar v;
DMDAGetInfo(da, NULL, &M, &N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);
ierr = VecGetOwnershipRange(r,&ristart,&riend);CHKERRQ(ierr);
for(i = ristart; i < riend; i++) {
ierr = VecGetValues(r,1,&i,&v);CHKERRQ(ierr);
v = v * h_11 * alpha_R;
ierr = VecSetValues(r,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(r);CHKERRQ(ierr);
ierr = VecAssemblyEnd(r);CHKERRQ(ierr);
//ierr = VecView(r,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// VecScatter routine! IMPORTANT!
VecScatter scatter; // scatter context
IS from,to; // index sets that define the scatter
int idx_from[M], idx_to[M];
for(i = 0; i < M; i++) {
idx_from[i] = i;
}
for(i = 0; i < M; i++) {
idx_to[i] = i + ((N-1) * M);
}
AO ao;
DMDAGetAO(da,&ao);
AOApplicationToPetsc(ao,M,idx_to);
ISCreateGeneral(PETSC_COMM_SELF,M,idx_from,PETSC_COPY_VALUES,&from);
ISCreateGeneral(PETSC_COMM_SELF,M,idx_to,PETSC_COPY_VALUES,&to);
VecScatterCreate(r,from,RHS,to,&scatter); // gx = source vector, gy = destination vector
VecScatterBegin(scatter,r,RHS,INSERT_VALUES,SCATTER_FORWARD);
VecScatterEnd(scatter,r,RHS,INSERT_VALUES,SCATTER_FORWARD);
//VecView(RHS,PETSC_VIEWER_STDOUT_WORLD);
ISDestroy(&from);
ISDestroy(&to);
VecScatterDestroy(&scatter);
// PRINT OUT RHS
/*
Vec local_RHS;
ierr = DMCreateLocalVector(da, &local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
PetscScalar **local_RHS_arr;
DMDAVecGetArray(da, local_RHS, &local_RHS_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_RHS_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_RHS, &local_RHS_arr);
ierr = DMLocalToGlobalBegin(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
VecDestroy(&local_RHS);
*/
return ierr;
}
/* Function: setRHS_B
* ------------------
*
*/
PetscErrorCode setRHS_B(Vec &RHS, const Vec &b, const PetscScalar &h_11,
const PetscScalar alpha_B, const DM &da) {
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M = NULL, N = NULL, bistart, biend;
PetscScalar v;
DMDAGetInfo(da, NULL, &M, &N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);
ierr = VecGetOwnershipRange(b,&bistart,&biend);CHKERRQ(ierr);
for(i = bistart; i < biend; i++) {
ierr = VecGetValues(b,1,&i,&v);CHKERRQ(ierr);
v = v * h_11 * alpha_B;
ierr = VecSetValues(b,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(b);CHKERRQ(ierr);
ierr = VecAssemblyEnd(b);CHKERRQ(ierr);
//ierr = VecView(b,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// VecScatter routine! IMPORTANT!
VecScatter scatter; // scatter context
IS from,to; // index sets that define the scatter
int idx_from[N], idx_to[N];
for(i = 0; i < N; i++) {
idx_from[i] = i;
}
for(i = 0; i < N; i++) {
idx_to[i] = i * M + (M-1);
}
AO ao;
DMDAGetAO(da,&ao);
AOApplicationToPetsc(ao,N,idx_to);
ISCreateGeneral(PETSC_COMM_SELF,N,idx_from,PETSC_COPY_VALUES,&from);
ISCreateGeneral(PETSC_COMM_SELF,N,idx_to,PETSC_COPY_VALUES,&to);
VecScatterCreate(b,from,RHS,to,&scatter); // gx = source vector, gy = destination vector
VecScatterBegin(scatter,b,RHS,INSERT_VALUES,SCATTER_FORWARD);
VecScatterEnd(scatter,b,RHS,INSERT_VALUES,SCATTER_FORWARD);
//VecView(RHS,PETSC_VIEWER_STDOUT_WORLD);
ISDestroy(&from);
ISDestroy(&to);
VecScatterDestroy(&scatter);
// PRINT OUT RHS
/*
Vec local_RHS;
ierr = DMCreateLocalVector(da, &local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
PetscScalar **local_RHS_arr;
DMDAVecGetArray(da, local_RHS, &local_RHS_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_RHS_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_RHS, &local_RHS_arr);
ierr = DMLocalToGlobalBegin(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
VecDestroy(&local_RHS);
*/
return ierr;
}
/* Function: setRHS_T
* --------------
*
*/
PetscErrorCode setRHS_T(Vec &RHS, const Vec &g, const PetscScalar &h_11,
const PetscScalar alpha_T, const DM &da) {
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M = NULL, N = NULL, gistart, giend;
PetscScalar v;
DMDAGetInfo(da, NULL, &M, &N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);
ierr = VecGetOwnershipRange(g,&gistart,&giend);CHKERRQ(ierr);
for(i = gistart; i < giend; i++) {
ierr = VecGetValues(g,1,&i,&v);CHKERRQ(ierr);
v = (v + i) * (1/h_11) * alpha_T;
//v = (double) i;
ierr = VecSetValues(g,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(g);CHKERRQ(ierr);
ierr = VecAssemblyEnd(g);CHKERRQ(ierr);
//ierr = VecView(g,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// VecScatter routine! IMPORTANT!
VecScatter scatter; // scatter context
IS from,to; // index sets that define the scatter
//int idx_from[] = {0,1,2,3,4}, idx_to[] = {0,11,22,33,44};
int idx_from[N], idx_to[N];
for(i = 0; i < N; i++) {
idx_from[i] = i;
}
for(i = 0; i < N; i++) {
idx_to[i] = i * M;
}
AO ao;
DMDAGetAO(da,&ao);
AOApplicationToPetsc(ao,N,idx_to);
ISCreateGeneral(PETSC_COMM_SELF,N,idx_from,PETSC_COPY_VALUES,&from);
ISCreateGeneral(PETSC_COMM_SELF,N,idx_to,PETSC_COPY_VALUES,&to);
VecScatterCreate(g,from,RHS,to,&scatter); // gx = source vector, gy = destination vector
VecScatterBegin(scatter,g,RHS,INSERT_VALUES,SCATTER_FORWARD);
VecScatterEnd(scatter,g,RHS,INSERT_VALUES,SCATTER_FORWARD);
//VecView(RHS,PETSC_VIEWER_STDOUT_WORLD);
ISDestroy(&from);
ISDestroy(&to);
VecScatterDestroy(&scatter);
// PRINT OUT RHS
/*
Vec local_RHS;
ierr = DMCreateLocalVector(da, &local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
PetscScalar **local_RHS_arr;
DMDAVecGetArray(da, local_RHS, &local_RHS_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_RHS_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_RHS, &local_RHS_arr);
ierr = DMLocalToGlobalBegin(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
VecDestroy(&local_RHS);
*/
return ierr;
}
/* Function: Dy_2d_Boundary
* ----------------------------------
* 1st derivative solve in the y-direction for 2-D.
*
* diff_y - the output Vec (it will hold the calculated derivative on the boundary in y-direction)
* grid - the input Vec (it holds the function values to draw from)
* dy - the spacing between each point in the y-direction
* da - DMDA object
*/
PetscErrorCode Dy_2d_Boundary(Vec &diff_y, Vec &grid, PetscScalar dy, DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M, N;
DMDAGetInfo(da,NULL,&M,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_y, local_grid;
PetscScalar** local_diff_y_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_y);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (j > 0 && j < N - 1 && i > 0 && i < M - 1) { local_diff_y_arr[j][i] = 0; }
else if (j == 0) { local_diff_y_arr[j][i] = -(-1.5 * local_grid_arr[0][i] + 2.0 * local_grid_arr[1][i] - 0.5 * local_grid_arr[2][i])/ dy; }
else if (j == N - 1) { local_diff_y_arr[j][i] = (0.5 * local_grid_arr[N-3][i] - 2.0 *
local_grid_arr[N-2][i] + 1.5 * local_grid_arr[N-1][i]) / dy; }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_y, &local_diff_y_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_y, INSERT_VALUES, diff_y);CHKERRQ(ierr);
VecDestroy(&local_diff_y);
VecDestroy(&local_grid);
return ierr;
}
/* Function: Dx_2d_Boundary
* ----------------------------------
*
* diff_x - the output Vec (it will hold the calculated derivative on the boundary in x-direction)
* grid - the input Vec (it holds the function values to draw from)
* dx - the spacing between each point in the x-direction
* da - DMDA object
*/
PetscErrorCode Dx_2d_Boundary(Vec &diff_x, Vec &grid, PetscScalar dx, DM &da) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M, N;
DMDAGetInfo(da,NULL,&M,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_diff_x, local_grid;
PetscScalar** local_diff_x_arr;
PetscScalar** local_grid_arr;
ierr = DMCreateLocalVector(da, &local_diff_x);CHKERRQ(ierr);
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMDAVecGetArray(da, local_grid, &local_grid_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (i > 0 && i < M - 1 && j > 0 && j < N - 1) {local_diff_x_arr[j][i] = 0; }
else if (i == 0) { local_diff_x_arr[j][i] = -(-1.5 * local_grid_arr[j][0] +
2.0 * local_grid_arr[j][1] - 0.5 * local_grid_arr[j][2])/ dx; }
else if (i == M - 1) { local_diff_x_arr[j][i] = (0.5 * local_grid_arr[j][M-3] -
2.0 * local_grid_arr[j][M-2] + 1.5 * local_grid_arr[j][M-1]) / dx; }
}
}
ierr = DMDAVecRestoreArray(da, local_diff_x, &local_diff_x_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(da, local_grid, &local_grid_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_diff_x, INSERT_VALUES, diff_x);CHKERRQ(ierr);
VecDestroy(&local_diff_x);
VecDestroy(&local_grid);
return ierr;
}
PetscErrorCode multiplyByHinvx(Vec &out, Vec &in, PetscScalar h, PetscInt order, AppCtx* ctx) {
PetscErrorCode ierr = 0;
ierr = VecSet(out, 0);CHKERRQ(ierr);
if(order == 2) {
PetscInt m, n, mStart, nStart, j, i, M, N;
DMDAGetInfo(ctx->da,NULL,&M,&N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_out, local_in;
PetscScalar** local_out_arr;
PetscScalar** local_in_arr;
ierr = DMCreateLocalVector(ctx->da, &local_out);CHKERRQ(ierr);
ierr = DMCreateLocalVector(ctx->da, &local_in);CHKERRQ(ierr);
ierr = DMDAVecGetArray(ctx->da, local_out, &local_out_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx->da, in, INSERT_VALUES, local_in);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx->da, in, INSERT_VALUES, local_in);CHKERRQ(ierr);
ierr = DMDAVecGetArray(ctx->da, local_in, &local_in_arr); CHKERRQ(ierr);
ierr = DMDAGetCorners(ctx->da, &mStart, &nStart, 0, &m, &n, 0);CHKERRQ(ierr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
if (j > 0 && j < N - 1)
local_out_arr[j][i] = 1/h * local_in_arr[j][i];
else
local_out_arr[j][i] = 2/h * local_in_arr[j][i];
/*
else if (i == 0) {
//local_out_arr[j][i] = -(-1.5 * local_in_arr[j][0] +
//2.0 * local_in_arr[j][1] - 0.5 * local_in_arr[j][2])/ h; }
else if (i == M - 1) { local_out_arr[j][i] = (0.5 * local_in_arr[j][M-3] -
2.0 * local_in_arr[j][M-2] + 1.5 * local_in_arr[j][M-1]) / h; }*/
}
}
ierr = DMDAVecRestoreArray(ctx->da, local_out, &local_out_arr);CHKERRQ(ierr);
ierr = DMDAVecRestoreArray(ctx->da, local_in, &local_in_arr);CHKERRQ(ierr);
ierr = DMLocalToGlobalBegin(ctx->da, local_out, INSERT_VALUES, out);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx->da, local_out, INSERT_VALUES, out);CHKERRQ(ierr);
VecDestroy(&local_out);
VecDestroy(&local_in);
return ierr;
} else if (order == 4) {
}
return -1;
}
PetscErrorCode multiplyBy_BSx_IyT_s(Vec &ADisp2, Vec& mu, Vec &fx, PetscScalar h) {
//, string& Stype, string& Btype) {
PetscErrorCode ierr = 0;
return ierr;
}
PetscErrorCode SetLeftToMult(Vec& ADisp1, Vec& mu, Vec& temp, AppCtx* ctx) {
PetscErrorCode ierr = 0;
PetscInt m, n, mStart, nStart, j, i, M, N;
DMDAGetInfo(ctx->da, NULL, &M, &N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
Vec local_ADisp1, local_mu, local_temp;
PetscScalar **local_ADisp1_arr;
PetscScalar** local_mu_arr;
PetscScalar** local_temp_arr;
ierr = DMCreateLocalVector(ctx->da, &local_ADisp1);CHKERRQ(ierr);
ierr = DMCreateLocalVector(ctx->da, &local_mu);CHKERRQ(ierr);
ierr = DMCreateLocalVector(ctx->da, &local_temp);CHKERRQ(ierr);
DMDAGetCorners(ctx->da, &mStart, &nStart, 0, &m, &n, 0);
//rank
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
ierr = DMGlobalToLocalBegin(ctx->da, ADisp1, INSERT_VALUES, local_ADisp1);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx->da, ADisp1, INSERT_VALUES, local_ADisp1);CHKERRQ(ierr);
ierr = DMDAVecGetArray(ctx->da, local_ADisp1, &local_ADisp1_arr);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx->da, temp, INSERT_VALUES, local_temp);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx->da, temp, INSERT_VALUES, local_temp);CHKERRQ(ierr);
ierr = DMDAVecGetArray(ctx->da, local_temp, &local_temp_arr); CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx->da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx->da, mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMDAVecGetArray(ctx->da, local_mu, &local_mu_arr); CHKERRQ(ierr);
j = nStart + n - 1;
for (i = mStart; i < mStart + m; i++) {
local_ADisp1_arr[j][i] = local_mu_arr[j][i] * local_temp_arr[j][i];
}
DMDAVecRestoreArray(ctx->da, local_ADisp1, &local_ADisp1_arr);
ierr = DMLocalToGlobalBegin(ctx->da, local_ADisp1, INSERT_VALUES, ADisp1);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx->da, local_ADisp1, INSERT_VALUES, ADisp1);CHKERRQ(ierr);
VecDestroy(&local_ADisp1);
VecDestroy(&local_mu);
VecDestroy(&local_temp);
return ierr;
}
PetscErrorCode setRHS_L(Vec &RHS, const Vec &fx, const PetscScalar &h_11,
const PetscScalar alpha_L, const DM &da) {
PetscErrorCode ierr = 0;
/*
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
Vec temp;
Vec rhs_disp1;
ierr = VecDuplicate(fx, &rhs_disp1);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &temp);CHKERRQ(ierr);
ierr = VecSet(rhs_disp1, 0);CHKERRQ(ierr);
ierr = multiplyByHinvx(temp, fx, da, 2, ctx);CHKERRQ(ierr);
Vec rhs_disp2;
ierr = VecDuplicate(fx, &rhs_disp2);CHKERRQ(ierr);
ierr = VecSet(rhs_disp2, 0);CHKERRQ(ierr);
*/
return ierr;
}
/* Function: MyMatMult
* -------------------
*
*
*/
PetscErrorCode MyMatMult(Mat A, Vec fx, Vec ans) {
PetscErrorCode ierr = 0;
void *ptr;
AppCtx *ctx;
MatShellGetContext(A,&ptr);
ctx = (AppCtx*)ptr;
// Below is what the multiplication operation should do!
Vec sum = NULL, dmuxx = NULL, dmuyy = NULL;
ierr = VecDuplicate(fx, &sum);
ierr = VecDuplicate(fx, &dmuxx);
ierr = VecDuplicate(fx, &dmuyy);
ierr = Dmuxx_2d(dmuxx, fx, ctx->mu, ctx->dx_spacing, ctx->da);CHKERRQ(ierr);
//writeVec(dmuxx, "Uxx");
ierr = Dmuyy_2d(dmuyy, fx, ctx->mu, ctx->dy_spacing, ctx->da);CHKERRQ(ierr);
//writeVec(dmuyy, "Uxx");
PetscScalar one = 1.0;
ierr = VecAXPY(dmuyy, one, dmuxx);CHKERRQ(ierr);
ierr = VecCopy(dmuyy, ans);CHKERRQ(ierr);
Vec Dx, Dy, DxDyBoundary;
ierr = VecDuplicate(fx, &Dx);
ierr = VecDuplicate(fx, &Dy);
ierr = VecDuplicate(fx, &DxDyBoundary);
ierr = Dx_2d_Boundary(Dx, fx, ctx->dx_spacing, ctx->da);CHKERRQ(ierr);
ierr = Dy_2d_Boundary(Dy, fx, ctx->dx_spacing, ctx->da);CHKERRQ(ierr);
ierr = VecAXPY(Dy, one, Dx);CHKERRQ(ierr);
ierr = VecCopy(Dy, DxDyBoundary);CHKERRQ(ierr);
ierr = VecAXPY(dmuyy, one, DxDyBoundary);CHKERRQ(ierr);
ierr = VecCopy(dmuyy, ans);CHKERRQ(ierr);
// BOUNDARY CONDITIONS
Vec out;
ierr = VecDuplicate(fx, &out);CHKERRQ(ierr);
ierr = VecSet(out, 0);CHKERRQ(ierr);
Vec temp;
ierr = VecDuplicate(fx, &temp);CHKERRQ(ierr);
ierr = VecSet(temp, 0);CHKERRQ(ierr);
// DISPLACEMENT
// LEFT BOUNDARY
Vec ADisp1;
ierr = VecDuplicate(fx, &ADisp1);CHKERRQ(ierr);
ierr = VecSet(ADisp1, 0);CHKERRQ(ierr);
ierr = multiplyByHinvx(temp, fx, ctx->dx_spacing, ctx->order, ctx);CHKERRQ(ierr);
ierr = SetLeftToMult(ADisp1, ctx->mu, temp, ctx);CHKERRQ(ierr);
Vec ADisp2;
ierr = VecDuplicate(fx, &ADisp1);CHKERRQ(ierr);
ierr = VecSet(ADisp1, 0);CHKERRQ(ierr);
//string Stype = ""; // = ctx.Stype
//string Btype = "";
ierr = multiplyBy_BSx_IyT_s(ADisp2, ctx->mu, fx, ctx->dx_spacing);//, Stype, Btype);
// RIGHT BOUNDARY
// TRACTION
// TOP BOUNDARY
// BOTTOM BOUNDARY
//print
/*
PetscInt m, n, mStart, nStart, j, i, M = NULL, N = NULL;
DMDAGetInfo(ctx->da, NULL, &M, &N,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
DMDAGetCorners(ctx->da, &mStart, &nStart, 0, &m, &n, 0);
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
Vec DxDyBoundary_print;
ierr = DMCreateLocalVector(ctx->da, &DxDyBoundary_print);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx->da, DxDyBoundary, INSERT_VALUES, DxDyBoundary_print);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx->da, DxDyBoundary, INSERT_VALUES, DxDyBoundary_print);CHKERRQ(ierr);
PetscScalar **DxDyBoundary_print_arr;
DMDAVecGetArray(ctx->da, DxDyBoundary_print, &DxDyBoundary_print_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, DxDyBoundary_print_arr[j][i]);
}
}
DMDAVecRestoreArray(ctx->da, DxDyBoundary_print, &DxDyBoundary_print_arr);
ierr = DMLocalToGlobalBegin(ctx->da, DxDyBoundary_print, INSERT_VALUES, DxDyBoundary);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx->da, DxDyBoundary_print, INSERT_VALUES, DxDyBoundary);CHKERRQ(ierr);
VecDestroy(&DxDyBoundary_print);
*/
//writeVec(DxDyBoundary, "DxDyBoundary");
//endprint
//FIXME!!!! DO WE ADD THE BOUNDARY TO EXISTING VALUES FROM THE DERIVATIVE, OR DO WE ZERO
// THEM OUT BEFORE ADDING???
//calculate RHS with 1st derivative on borders
//Vec RHS = NULL;
//ierr = VecDuplicate(fx, &RHS);
//PetscScalar h_11 = 1;
//PetscScalar alpha_R = 2;
//setRHS_R(RHS, ans, h_11,
// alpha_R, ctx->da);
//setRHS_L(RHS, ans, h_11,
// alpha_R, ctx->da);
//setRHS_T(RHS, ans, h_11,
// alpha_R, ctx->da);
//setRHS_B(RHS, ans, h_11,
// alpha_R, ctx->da);
ierr = VecDestroy(&Dx);CHKERRQ(ierr);
ierr = VecDestroy(&Dy);CHKERRQ(ierr);
ierr = VecDestroy(&DxDyBoundary);CHKERRQ(ierr);
ierr = VecDestroy(&sum);CHKERRQ(ierr);
ierr = VecDestroy(&dmuxx);CHKERRQ(ierr);
ierr = VecDestroy(&dmuyy);CHKERRQ(ierr);
return ierr;
}
PetscErrorCode testMyMatMult() {
PetscErrorCode ierr = 0;
AppCtx ctx;
PetscScalar x_len = NUM_X_PTS, y_len = NUM_Y_PTS;
PetscScalar x_min = X_MIN, x_max = X_MAX, y_max = Y_MAX, y_min = Y_MIN;
for(int i = 0; i < NUM_2D_2ND_GRID_SPACE_CALCULATIONS; i++) {
x_len = ((x_len - 1) * 2) + 1;
y_len = ((y_len - 1) * 2) + 1;
}
PetscPrintf(PETSC_COMM_WORLD, "Test for MyMatMult\n");
PetscInt i = 0, j = 0, mStart = 0, m = 0, nStart = 0, n = 0,
fx_istart, fx_iend, dx_start, dx_end, dy_start, dy_end;
PetscScalar v = 0;
Vec fx = NULL, dx = NULL, dy = NULL, a_dx = NULL, a_dy = NULL, fx_err = NULL, /* vectors */
local_coords = NULL, local_fx = NULL, local_a_dx = NULL, local_a_dy = NULL,
/* mu = NULL, */ local_mu = NULL, dxxmu = NULL, local_dxxmu = NULL, dyymu = NULL, local_dyymu = NULL,
ans = NULL, a_ans = NULL;
// first row, global vecs, second row, local vecs, third row, mu and 2nd derivatives
// last row, answer vector
PetscInt num_entries = (x_len) * (y_len); //total number of entries on the grid
ctx.dx_spacing = ((PetscReal)(x_max - x_min))/(x_len - 1); // spacing in the x direction
ctx.dy_spacing = ((PetscReal)(y_max - y_min))/(y_len - 1); // spacing in the y direction
ctx.n_x = x_len;
ctx.n_y = y_len;
ctx.alphaDx = -4/ctx.dx_spacing;
ctx.alphaDy = -4/ctx.dy_spacing;
ctx.alphaT = -1;
ctx.beta = 1;
ctx.order = 2;
DMDACoor2d **coords;
DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_BOX, ctx.n_x, ctx.n_y, PETSC_DECIDE, PETSC_DECIDE, 1, 2, NULL, NULL, &ctx.da);
DMDASetUniformCoordinates(ctx.da, x_min, x_max, y_min, y_max, 0.0, 0.0);
DMGetCoordinateDM(ctx.da, &ctx.cda);
DMGetCoordinatesLocal(ctx.da, &local_coords);
DMDAVecGetArray(ctx.cda, local_coords, &coords);
DMDAGetCorners(ctx.cda, &mStart, &nStart, 0, &m, &n, 0);
// allows us to have information about the DMDA
DMDALocalInfo info;
ierr = DMDAGetLocalInfo(ctx.da, &info);
ierr = DMCreateGlobalVector(ctx.da, &fx);
ierr = VecDuplicate(fx, &dx);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &dy);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &a_dx);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &a_dy);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &fx_err);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &ctx.mu);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &dxxmu);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &dyymu);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &ans);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &a_ans);CHKERRQ(ierr);
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
// Set up fx to pull values from
ierr = DMCreateLocalVector(ctx.da, &local_fx);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, fx, INSERT_VALUES, local_fx);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, fx, INSERT_VALUES, local_fx);CHKERRQ(ierr);
PetscScalar **local_fx_arr;
DMDAVecGetArray(ctx.da, local_fx, &local_fx_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
//PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_fx_arr[j][i] = coords[j][i].y;
// local_fx_arr[j][i] = (coords[j][i].x * coords[j][i].x * coords[j][i].x) + (coords[j][i].y * coords[j][i].y * coords[j][i].y);
// local_fx_arr[j][i] = coords[j][i].x;
local_fx_arr[j][i] = MMS_uA(coords[j][i].x, coords[j][i].y);
// local_fx_arr[j][i] = cos(coords[j][i].x) * sin(coords[j][i].y);
// PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_grid_arr[j][i]);
}
}
DMDAVecRestoreArray(ctx.da, local_fx, &local_fx_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_fx, INSERT_VALUES, fx);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_fx, INSERT_VALUES, fx);CHKERRQ(ierr);
//set up a_dx
ierr = DMCreateLocalVector(ctx.da, &local_a_dx);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, a_dx, INSERT_VALUES, local_a_dx);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, a_dx, INSERT_VALUES, local_a_dx);CHKERRQ(ierr);
PetscScalar **local_a_dx_arr;
DMDAVecGetArray(ctx.da, local_a_dx, &local_a_dx_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_act_diff_x_arr[j][i] = coords[j][i].x;
local_a_dx_arr[j][i] = MMS_uA_dx(coords[j][i].x, coords[j][i].y);
//local_a_dx_arr[j][i] = -sin(coords[j][i].x);
// PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_act_diff_x_arr[j][i]);
// local_act_diff_x_arr[j][i] = (6 * coords[j][i].x);
}
}
DMDAVecRestoreArray(ctx.da, local_a_dx, &local_a_dx_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_a_dx, INSERT_VALUES, a_dx);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_a_dx, INSERT_VALUES, a_dx);CHKERRQ(ierr);
// SET UP ACT_DIFF_Y
ierr = DMCreateLocalVector(ctx.da, &local_a_dy);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, a_dy, INSERT_VALUES, local_a_dy);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, a_dy, INSERT_VALUES, local_a_dy);CHKERRQ(ierr);
PetscScalar **local_a_dy_arr;
DMDAVecGetArray(ctx.da, local_a_dy, &local_a_dy_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
// PetscPrintf(PETSC_COMM_SELF, "%i: (coords[%i][%i].x, coords[%i][%i].y) = (%g, %g)\n)", rank, j, i, j, i, coords[j][i].x, coords[j][i].y);
// local_act_diff_y_arr[j][i] = (6 * coords[j][i].y);
//local_a_dy_arr[j][i] = -cos(coords[j][i].y);
local_a_dy_arr[j][i] = MMS_uA_dy(coords[j][i].x, coords[j][i].y);
}
}
DMDAVecRestoreArray(ctx.da, local_a_dy, &local_a_dy_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_a_dy, INSERT_VALUES, a_dy);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_a_dy, INSERT_VALUES, a_dy);CHKERRQ(ierr);
// SET UP MU
ierr = DMCreateLocalVector(ctx.da, &local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, ctx.mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, ctx.mu, INSERT_VALUES, local_mu);CHKERRQ(ierr);
PetscScalar **local_mu_arr;
DMDAVecGetArray(ctx.da, local_mu, &local_mu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_mu_arr[j][i] = MMS_mu(coords[j][i].x, coords[j][i].y);
//local_mu_arr[j][i] = sin(coords[j][i].x) * sin(coords[j][i].y) + 2;
// local_mu_arr[j][i] = 1;
}
}
DMDAVecRestoreArray(ctx.da, local_mu, &local_mu_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_mu, INSERT_VALUES, ctx.mu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_mu, INSERT_VALUES, ctx.mu);CHKERRQ(ierr);
// SET UP DxxMU
ierr = DMCreateLocalVector(ctx.da, &local_dxxmu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, dxxmu, INSERT_VALUES, local_dxxmu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, dxxmu, INSERT_VALUES, local_dxxmu);CHKERRQ(ierr);
PetscScalar **local_dxxmu_arr;
DMDAVecGetArray(ctx.da, local_dxxmu, &local_dxxmu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_dxxmu_arr[j][i] = MMS_uA_dmuxx(coords[j][i].x, coords[j][i].y);
//local_dxxmu_arr[j][i] = (-sin(coords[j][i].x + coords[j][i].y) * cos(coords[j][i].x)) +
// ((cos(coords[j][i].x + coords[j][i].y) + 4) * (-sin(coords[j][i].x)));
// local_dxxmu_arr[j][i] = -sin(coords[j][i].x);
}
}
DMDAVecRestoreArray(ctx.da, local_dxxmu, &local_dxxmu_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_dxxmu, INSERT_VALUES, dxxmu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_dxxmu, INSERT_VALUES, dxxmu);CHKERRQ(ierr);
// SET UP DyyMU
ierr = DMCreateLocalVector(ctx.da, &local_dyymu);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, dyymu, INSERT_VALUES, local_dyymu);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, dyymu, INSERT_VALUES, local_dyymu);CHKERRQ(ierr);
PetscScalar **local_dyymu_arr;
DMDAVecGetArray(ctx.da, local_dyymu, &local_dyymu_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_dyymu_arr[j][i] = MMS_uA_dmuyy(coords[j][i].x, coords[j][i].y);
//local_dyymu_arr[j][i] = (-sin(coords[j][i].x + coords[j][i].y) * (-sin(coords[j][i].y))) +
// ((cos(coords[j][i].x + coords[j][i].y) + 4) * (-cos(coords[j][i].y)));
// local_dyymu_arr[j][i] = -cos(coords[j][i].y);
}
}
DMDAVecRestoreArray(ctx.da, local_dyymu, &local_dyymu_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_dyymu, INSERT_VALUES, dyymu);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_dyymu, INSERT_VALUES, dyymu);CHKERRQ(ierr);
//writeVec(fx,"fx");
//Vec dfx;
//ierr = VecDuplicate(fx, &dfx);
//ierr = Dx_2d(dfx, fx, ctx.dx_spacing, ctx.da);
//writeVec(dfx, "dfx");
PetscInt vec_size = NULL;
VecGetLocalSize(fx, &vec_size);
// set up linear solve context (matrices, etc.)
Mat H_Shell;
//MatCreateAIJ(MPI_COMM_WORLD,info.xm,info.ym,info.mx,info.my,7,NULL,3,NULL,&(user.H));
MatCreateShell(PETSC_COMM_WORLD, vec_size, vec_size,
num_entries, num_entries,(void*)&ctx,&H_Shell);
MatShellSetOperation(H_Shell,MATOP_MULT,
(void(*)(void))MyMatMult);
MatMult(H_Shell, fx, ans);
//writeVec(ans, "ans");
// calculate analytical answer
ierr = VecCopy(a_dy, a_ans);CHKERRQ(ierr);
PetscScalar one = 1.0;
ierr = VecAXPY(a_ans, one, a_dx);
calculate_two_norm(fx_err, ans, a_ans, num_entries);
MatDestroy(&H_Shell);
VecDestroy(&fx);
VecDestroy(&dx);
VecDestroy(&dy);
VecDestroy(&a_dx);
VecDestroy(&a_dy);
VecDestroy(&fx_err);
//VecDestroy(&local_coords);
VecDestroy(&local_fx);
VecDestroy(&local_a_dx);
VecDestroy(&local_a_dy);
VecDestroy(&local_mu);
VecDestroy(&dxxmu);
VecDestroy(&local_dxxmu);
VecDestroy(&dyymu);
VecDestroy(&local_dyymu);
VecDestroy(&ans);
VecDestroy(&a_ans);
VecDestroy(&ctx.mu);
DMDestroy(&ctx.da);
PetscPrintf(PETSC_COMM_WORLD, "\n");
return ierr;
}
/* Function: Solve_Linear_Equation
* -------------------------------
*
*/
PetscErrorCode Solve_Linear_Equation() {
PetscErrorCode ierr = 0;
PetscInt num_x_pts = NUM_X_PTS, num_y_pts = NUM_Y_PTS;
PetscScalar x_min = X_MINIMUM, x_max = X_MAXIMUM, y_max = Y_MAXIMUM, y_min = Y_MINIMUM;
PetscInt i = 0, j = 0, mStart = 0, m = 0, nStart = 0, n = 0;
PetscScalar v = 0, mult_x = 0, mult_y = 0, alpha_T = -1, alpha_B = -2, alpha_L = -3, alpha_R = -4, h_11 = 2;
Vec grid = NULL, RHS = NULL, g = NULL, b = NULL, l = NULL, r = NULL,
local_grid = NULL, local_RHS = NULL, local_coords = NULL;
PetscInt num_grid_entries = (num_x_pts) * (num_y_pts); // total number of entries on the grid
mult_x = ((PetscReal)(x_max - x_min))/(num_x_pts - 1); // spacing in the x direction
mult_y = ((PetscReal)(y_max - y_min))/(num_y_pts - 1); // spacing in the y direction
DM da;
DM cda;
DMDACoor2d **coords; // 2D array containing x and y data members
ierr = DMDACreate2d(PETSC_COMM_WORLD,DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_BOX, num_x_pts, num_y_pts, PETSC_DECIDE, PETSC_DECIDE, 1, 2, NULL, NULL, &da); CHKERRQ(ierr);
DMDASetUniformCoordinates(da, x_min, x_max, y_min, y_max, 0.0, 0.0);
DMGetCoordinateDM(da, &cda);
DMGetCoordinatesLocal(da, &local_coords);
DMDAVecGetArray(cda, local_coords, &coords);
DMDAGetCorners(cda, &mStart, &nStart, 0, &m, &n, 0);
ierr = DMCreateGlobalVector(da,&grid);
ierr = VecDuplicate(grid, &RHS);CHKERRQ(ierr);
//FIXME
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
// FILL GRID
ierr = DMCreateLocalVector(da, &local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, grid, INSERT_VALUES, local_grid);CHKERRQ(ierr);
PetscScalar **local_grid_arr;
DMDAVecGetArray(da, local_grid, &local_grid_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_grid_arr[j][i] = (coords[j][i].x);
}
}
DMDAVecRestoreArray(da, local_grid, &local_grid_arr);
ierr = DMLocalToGlobalBegin(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_grid, INSERT_VALUES, grid);CHKERRQ(ierr);
//FILL RHS
ierr = DMCreateLocalVector(da, &local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, RHS, INSERT_VALUES, local_RHS);CHKERRQ(ierr);
PetscScalar **local_RHS_arr;
DMDAVecGetArray(da, local_RHS, &local_RHS_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_RHS_arr[j][i] = 0;
// PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_RHS_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_RHS, &local_RHS_arr);
ierr = DMLocalToGlobalBegin(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_RHS, INSERT_VALUES, RHS);CHKERRQ(ierr);
// FILL g
VecCreate(PETSC_COMM_WORLD,&g);
VecSetSizes(g,PETSC_DECIDE,num_y_pts);
VecSetFromOptions(g);
PetscObjectSetName((PetscObject) g, "g");
VecSet(g,1.0);
// FILL b
VecCreate(PETSC_COMM_WORLD,&b);
VecSetSizes(b,PETSC_DECIDE,num_y_pts);
VecSetFromOptions(b);
PetscObjectSetName((PetscObject) b, "b");
VecSet(b,1.0);
// FILL l
VecCreate(PETSC_COMM_WORLD,&l);
VecSetSizes(l,PETSC_DECIDE,num_x_pts);
VecSetFromOptions(l);
PetscObjectSetName((PetscObject) l, "l");
VecSet(l,1.0);
// FILL r
VecCreate(PETSC_COMM_WORLD,&r);
VecSetSizes(r,PETSC_DECIDE,num_x_pts);
VecSetFromOptions(r);
PetscObjectSetName((PetscObject) r, "r");
VecSet(r,1.0);
ierr = setRHS_T(RHS, g, h_11, alpha_T, da);CHKERRQ(ierr);
ierr = setRHS_B(RHS, b, h_11, alpha_B, da);CHKERRQ(ierr);
ierr = setRHS_L(RHS, l, h_11, alpha_L, da);CHKERRQ(ierr);
ierr = setRHS_R(RHS, r, h_11, alpha_R, da);CHKERRQ(ierr);
// PRINT RHS
/*
Vec local_RHS_print;
ierr = DMCreateLocalVector(da, &local_RHS_print);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(da, RHS, INSERT_VALUES, local_RHS_print);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(da, RHS, INSERT_VALUES, local_RHS_print);CHKERRQ(ierr);
PetscScalar **local_RHS_print_arr;
DMDAVecGetArray(da, local_RHS_print, &local_RHS_print_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
PetscPrintf(PETSC_COMM_SELF, "%i: [%i][%i] = %g\n", rank, j, i, local_RHS_print_arr[j][i]);
}
}
DMDAVecRestoreArray(da, local_RHS_print, &local_RHS_print_arr);
ierr = DMLocalToGlobalBegin(da, local_RHS_print, INSERT_VALUES, RHS);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(da, local_RHS_print, INSERT_VALUES, RHS);CHKERRQ(ierr);
VecDestroy(&local_RHS_print);
// writeVec(RHS, "RHS");
*/
VecDestroy(&grid);
VecDestroy(&RHS);
VecDestroy(&g);
VecDestroy(&b);
VecDestroy(&l);
VecDestroy(&r);
VecDestroy(&local_grid);
VecDestroy(&local_RHS);
DMDestroy(&da);
DMDestroy(&cda);
return ierr;
}
PetscErrorCode testMultiplyByHinvx() {
PetscErrorCode ierr = 0;
AppCtx ctx;
PetscScalar x_len = NUM_X_PTS, y_len = NUM_Y_PTS;
PetscScalar x_min = X_MIN, x_max = X_MAX, y_max = Y_MAX, y_min = Y_MIN;
Vec fx = NULL, dx = NULL, /* vectors */ temp,
local_coords = NULL, local_fx = NULL;
for(int i = 0; i < NUM_2D_2ND_GRID_SPACE_CALCULATIONS; i++) {
x_len = ((x_len - 1) * 2) + 1;
y_len = ((y_len - 1) * 2) + 1;
}
PetscInt num_entries = (x_len) * (y_len); //total number of entries on the grid
ctx.dx_spacing = ((PetscReal)(x_max - x_min))/(x_len - 1); // spacing in the x direction
ctx.dy_spacing = ((PetscReal)(y_max - y_min))/(y_len - 1); // spacing in the y direction
ctx.n_x = x_len;
ctx.n_y = y_len;
ctx.alphaDx = -4/ctx.dx_spacing;
ctx.alphaDy = -4/ctx.dy_spacing;
ctx.alphaT = -1;
ctx.beta = 1;
ctx.order = 2;
DMDACoor2d **coords;
DMDACreate2d(PETSC_COMM_WORLD, DMDA_BOUNDARY_NONE, DMDA_BOUNDARY_NONE,
DMDA_STENCIL_BOX, ctx.n_x, ctx.n_y, PETSC_DECIDE, PETSC_DECIDE, 1, 2, NULL, NULL, &ctx.da);
PetscInt i = 0, j = 0, mStart = 0, m = 0, nStart = 0, n = 0,
fx_istart, fx_iend, dx_start, dx_end, dy_start, dy_end;
PetscScalar v = 0;
ierr = DMCreateGlobalVector(ctx.da, &fx);CHKERRQ(ierr);
ierr = VecDuplicate(fx, &temp);CHKERRQ(ierr);
DMDASetUniformCoordinates(ctx.da, x_min, x_max, y_min, y_max, 0.0, 0.0);
DMGetCoordinateDM(ctx.da, &ctx.cda);
DMGetCoordinatesLocal(ctx.da, &local_coords);
DMDAVecGetArray(ctx.cda, local_coords, &coords);
DMDAGetCorners(ctx.cda, &mStart, &nStart, 0, &m, &n, 0);
// allows us to have information about the DMDA
DMDALocalInfo info;
ierr = DMDAGetLocalInfo(ctx.da, &info);
PetscMPIInt rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
// Set up fx to pull values from
ierr = DMCreateLocalVector(ctx.da, &local_fx);CHKERRQ(ierr);
ierr = DMGlobalToLocalBegin(ctx.da, fx, INSERT_VALUES, local_fx);CHKERRQ(ierr);
ierr = DMGlobalToLocalEnd(ctx.da, fx, INSERT_VALUES, local_fx);CHKERRQ(ierr);
PetscScalar **local_fx_arr;
DMDAVecGetArray(ctx.da, local_fx, &local_fx_arr);
for (j = nStart; j < nStart + n; j++) {
for (i = mStart; i < mStart + m; i++) {
local_fx_arr[j][i] = MMS_uA(coords[j][i].x, coords[j][i].y);
}
}
DMDAVecRestoreArray(ctx.da, local_fx, &local_fx_arr);
ierr = DMLocalToGlobalBegin(ctx.da, local_fx, INSERT_VALUES, fx);CHKERRQ(ierr);
ierr = DMLocalToGlobalEnd(ctx.da, local_fx, INSERT_VALUES, fx);CHKERRQ(ierr);
ierr = multiplyByHinvx(temp, fx, ctx.dx_spacing, ctx.order, &ctx);CHKERRQ(ierr);
writeVec(temp, "Hinvx_C");
return ierr;
}
/* Function: main
* --------------
*
*/
int main(int argc,char **argv)
{
PetscErrorCode ierr = 0;
PetscInitialize(&argc,&argv,(char*)0,NULL);
//ierr = MMSTest();CHKERRQ(ierr);
//ierr = Solve_Linear_Equation();CHKERRQ(ierr);
//testMyMatMult();
testMultiplyByHinvx();
PetscFinalize();
return ierr;
}
| 42.986425 | 154 | 0.65533 | kali-allison |
28e4dd08d57b29ea49ce0da075a25972d028a369 | 599 | cpp | C++ | ares/msx/cartridge/slot.cpp | moon-chilled/Ares | 909fb098c292f8336d0502dc677050312d8b5c81 | [
"0BSD"
] | 7 | 2020-07-25T11:44:39.000Z | 2021-01-29T13:21:31.000Z | ares/msx/cartridge/slot.cpp | jchw-forks/ares | d78298a1e95fd0ce65feabfd4f13b60e31210a7a | [
"0BSD"
] | null | null | null | ares/msx/cartridge/slot.cpp | jchw-forks/ares | d78298a1e95fd0ce65feabfd4f13b60e31210a7a | [
"0BSD"
] | 1 | 2021-03-22T16:15:30.000Z | 2021-03-22T16:15:30.000Z | CartridgeSlot cartridgeSlot{"Cartridge Slot"};
CartridgeSlot expansionSlot{"Expansion Slot"};
CartridgeSlot::CartridgeSlot(string name) : name(name) {
}
auto CartridgeSlot::load(Node::Object parent) -> void {
port = parent->append<Node::Port>(name);
port->setFamily(interface->name());
port->setType("Cartridge");
port->setAllocate([&](auto name) { return cartridge.allocate(port); });
port->setConnect([&] { return cartridge.connect(); });
port->setDisconnect([&] { return cartridge.disconnect(); });
}
auto CartridgeSlot::unload() -> void {
cartridge.disconnect();
port = {};
}
| 29.95 | 73 | 0.692821 | moon-chilled |
28e8e12c7fd4e9a32413e89bc05840b200afbfb8 | 2,939 | hpp | C++ | include/conjunctive.hpp | taboege/libpropcalc | b64dbf66a6d58fb8ec8e646530b482bbd96b0ba6 | [
"Artistic-2.0"
] | 1 | 2021-06-01T01:08:56.000Z | 2021-06-01T01:08:56.000Z | include/conjunctive.hpp | taboege/libpropcalc | b64dbf66a6d58fb8ec8e646530b482bbd96b0ba6 | [
"Artistic-2.0"
] | null | null | null | include/conjunctive.hpp | taboege/libpropcalc | b64dbf66a6d58fb8ec8e646530b482bbd96b0ba6 | [
"Artistic-2.0"
] | null | null | null | /*
* conjunctive.hpp - Clause and Conjunctive
*
* Copyright (C) 2019-2020 Tobias Boege
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the Artistic License 2.0
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Artistic License 2.0 for more details.
*/
#ifndef PROPCALC_CONJUNCTIVE_HPP
#define PROPCALC_CONJUNCTIVE_HPP
#include <propcalc/varmap.hpp>
#include <propcalc/stream.hpp>
#include <propcalc/assignment.hpp>
namespace Propcalc {
/**
* A clause represents a collection of literals, that is a mapping of
* variables to signs. A variable mapping to true is a positive literal,
* one mapping to false a negative literal.
*
* Put another way, the value a variable maps to is the assignment to
* that variable which would satisfy the clause.
*/
class Clause : public VarMap {
public:
/** Create a dummy clause on no variables. */
Clause(void) : VarMap() { }
/** Create the any-false clause on the given variables. */
Clause(std::vector<VarRef> vars) : VarMap(vars) { }
/** Initialize the mapping with the given data. */
Clause(std::initializer_list<std::pair<VarRef, bool>> il) : VarMap(il) { }
/** Initialize the clause from a VarMap object. */
Clause(VarMap&& vm) : VarMap(vm) { }
/** Flip all signs in the clause. */
Clause operator~(void) const {
Clause neg(order);
for (auto& v : order)
neg[v] = !vmap.at(v);
return neg;
}
/**
* Evaluate the Clause on an Assignment. This uses the natural partial
* assignment semantics, that is when a variable in the assignment is
* not mentioned in the clause, this fact is ignored. Such a variable
* cannot make the clause true.
*
* In particular an empty clause always yields false (the identity
* element with respect to disjunction).
*/
bool eval(const Assignment& assign) const {
for (auto v : assign.vars()) {
if (exists(v) && (*this)[v] == assign[v])
return true;
}
return false;
}
};
namespace {
[[maybe_unused]]
std::ostream& operator<<(std::ostream& os, const Clause& cl) {
os << "{ ";
for (auto& v : cl.vars())
os << (cl[v] ? "" : "-") << v->name << " ";
return os << "}";
}
}
class Conjunctive : public Stream<Clause> {
public:
/**
* Evaluate the conjunction of clauses enumerated. If there is no
* clause, returns true (the identity element with respect to
* conjunction), as all clauses are satisfied.
*
* If you want to evaluate the Conjunctive multiple times, it must
* be put into caching mode before the first clause is iterated..
*/
bool eval(const Assignment& assign) {
for (auto cl : *this) {
if (!cl.eval(assign))
return false;
}
return true;
}
};
}
#endif /* PROPCALC_CONJUNCTIVE_HPP */
| 29.686869 | 76 | 0.668935 | taboege |
28ea17e10746395d1ce39607211a0cdb94805391 | 4,221 | cpp | C++ | core/3d/CCFrustum.cpp | DelinWorks/adxe | 0f1ba3a086d744bb52e157e649fa986ae3c7ab05 | [
"MIT"
] | 76 | 2021-05-20T12:27:10.000Z | 2022-03-23T15:27:42.000Z | core/3d/CCFrustum.cpp | DelinWorks/adxe | 0f1ba3a086d744bb52e157e649fa986ae3c7ab05 | [
"MIT"
] | 171 | 2021-05-18T11:07:25.000Z | 2022-03-29T20:53:27.000Z | core/3d/CCFrustum.cpp | DelinWorks/adxe | 0f1ba3a086d744bb52e157e649fa986ae3c7ab05 | [
"MIT"
] | 42 | 2021-05-18T10:05:06.000Z | 2022-03-22T05:40:56.000Z | /****************************************************************************
Copyright (c) 2014-2016 Chukong Technologies Inc.
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
https://adxeproject.github.io/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "3d/CCFrustum.h"
#include "2d/CCCamera.h"
NS_CC_BEGIN
bool Frustum::initFrustum(const Camera* camera)
{
_initialized = true;
createPlane(camera);
return true;
}
bool Frustum::isOutOfFrustum(const AABB& aabb) const
{
if (_initialized)
{
Vec3 point;
int plane = _clipZ ? 6 : 4;
for (int i = 0; i < plane; i++)
{
const Vec3& normal = _plane[i].getNormal();
point.x = normal.x < 0 ? aabb._max.x : aabb._min.x;
point.y = normal.y < 0 ? aabb._max.y : aabb._min.y;
point.z = normal.z < 0 ? aabb._max.z : aabb._min.z;
if (_plane[i].getSide(point) == PointSide::FRONT_PLANE)
return true;
}
}
return false;
}
bool Frustum::isOutOfFrustum(const OBB& obb) const
{
if (_initialized)
{
Vec3 point;
int plane = _clipZ ? 6 : 4;
Vec3 obbExtentX = obb._xAxis * obb._extents.x;
Vec3 obbExtentY = obb._yAxis * obb._extents.y;
Vec3 obbExtentZ = obb._zAxis * obb._extents.z;
for (int i = 0; i < plane; i++)
{
const Vec3& normal = _plane[i].getNormal();
point = obb._center;
point = normal.dot(obb._xAxis) > 0 ? point - obbExtentX : point + obbExtentX;
point = normal.dot(obb._yAxis) > 0 ? point - obbExtentY : point + obbExtentY;
point = normal.dot(obb._zAxis) > 0 ? point - obbExtentZ : point + obbExtentZ;
if (_plane[i].getSide(point) == PointSide::FRONT_PLANE)
return true;
}
}
return false;
}
void Frustum::createPlane(const Camera* camera)
{
const Mat4& mat = camera->getViewProjectionMatrix();
// ref http://www.lighthouse3d.com/tutorials/view-frustum-culling/clip-space-approach-extracting-the-planes/
// extract frustum plane
_plane[0].initPlane(-Vec3(mat.m[3] + mat.m[0], mat.m[7] + mat.m[4], mat.m[11] + mat.m[8]),
(mat.m[15] + mat.m[12])); // left
_plane[1].initPlane(-Vec3(mat.m[3] - mat.m[0], mat.m[7] - mat.m[4], mat.m[11] - mat.m[8]),
(mat.m[15] - mat.m[12])); // right
_plane[2].initPlane(-Vec3(mat.m[3] + mat.m[1], mat.m[7] + mat.m[5], mat.m[11] + mat.m[9]),
(mat.m[15] + mat.m[13])); // bottom
_plane[3].initPlane(-Vec3(mat.m[3] - mat.m[1], mat.m[7] - mat.m[5], mat.m[11] - mat.m[9]),
(mat.m[15] - mat.m[13])); // top
_plane[4].initPlane(-Vec3(mat.m[3] + mat.m[2], mat.m[7] + mat.m[6], mat.m[11] + mat.m[10]),
(mat.m[15] + mat.m[14])); // near
_plane[5].initPlane(-Vec3(mat.m[3] - mat.m[2], mat.m[7] - mat.m[6], mat.m[11] - mat.m[10]),
(mat.m[15] - mat.m[14])); // far
}
NS_CC_END
| 40.980583 | 112 | 0.57285 | DelinWorks |
28f640562ad99b13585c57fbf97d8b1e249ecc96 | 12,024 | cpp | C++ | src/ledger/LedgerTxnClaimableBalanceSQL.cpp | V5DF8/stellar-core | 3fb2dc6bea41ed9160313f856e57451897f68cd9 | [
"Apache-2.0",
"BSD-2-Clause",
"MIT",
"ECL-2.0",
"BSL-1.0",
"BSD-3-Clause"
] | 10 | 2017-09-23T08:25:40.000Z | 2022-01-04T10:28:02.000Z | src/ledger/LedgerTxnClaimableBalanceSQL.cpp | V5DF8/stellar-core | 3fb2dc6bea41ed9160313f856e57451897f68cd9 | [
"Apache-2.0",
"BSD-2-Clause",
"MIT",
"ECL-2.0",
"BSL-1.0",
"BSD-3-Clause"
] | 1 | 2021-11-10T00:25:10.000Z | 2021-11-10T02:50:40.000Z | src/ledger/LedgerTxnClaimableBalanceSQL.cpp | V5DF8/stellar-core | 3fb2dc6bea41ed9160313f856e57451897f68cd9 | [
"Apache-2.0",
"BSD-2-Clause",
"MIT",
"ECL-2.0",
"BSL-1.0",
"BSD-3-Clause"
] | 2 | 2021-10-21T20:34:04.000Z | 2021-11-21T14:13:54.000Z | // Copyright 2020 Stellar Development Foundation and contributors. Licensed
// under the Apache License, Version 2.0. See the COPYING file at the root
// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0
#include "ledger/LedgerTxnImpl.h"
#include "util/GlobalChecks.h"
#include "util/types.h"
namespace stellar
{
std::shared_ptr<LedgerEntry const>
LedgerTxnRoot::Impl::loadClaimableBalance(LedgerKey const& key) const
{
auto balanceID = toOpaqueBase64(key.claimableBalance().balanceID);
std::string claimableBalanceEntryStr;
LedgerEntry le;
std::string sql = "SELECT ledgerentry "
"FROM claimablebalance "
"WHERE balanceid= :balanceid";
auto prep = mDatabase.getPreparedStatement(sql);
auto& st = prep.statement();
st.exchange(soci::into(claimableBalanceEntryStr));
st.exchange(soci::use(balanceID));
st.define_and_bind();
st.execute(true);
if (!st.got_data())
{
return nullptr;
}
fromOpaqueBase64(le, claimableBalanceEntryStr);
releaseAssert(le.data.type() == CLAIMABLE_BALANCE);
return std::make_shared<LedgerEntry const>(std::move(le));
}
class BulkLoadClaimableBalanceOperation
: public DatabaseTypeSpecificOperation<std::vector<LedgerEntry>>
{
Database& mDb;
std::vector<std::string> mBalanceIDs;
std::vector<LedgerEntry>
executeAndFetch(soci::statement& st)
{
std::string balanceIdStr, claimableBalanceEntryStr;
st.exchange(soci::into(balanceIdStr));
st.exchange(soci::into(claimableBalanceEntryStr));
st.define_and_bind();
{
auto timer = mDb.getSelectTimer("claimablebalance");
st.execute(true);
}
std::vector<LedgerEntry> res;
while (st.got_data())
{
res.emplace_back();
auto& le = res.back();
fromOpaqueBase64(le, claimableBalanceEntryStr);
releaseAssert(le.data.type() == CLAIMABLE_BALANCE);
st.fetch();
}
return res;
}
public:
BulkLoadClaimableBalanceOperation(Database& db,
UnorderedSet<LedgerKey> const& keys)
: mDb(db)
{
mBalanceIDs.reserve(keys.size());
for (auto const& k : keys)
{
releaseAssert(k.type() == CLAIMABLE_BALANCE);
mBalanceIDs.emplace_back(
toOpaqueBase64(k.claimableBalance().balanceID));
}
}
std::vector<LedgerEntry>
doSqliteSpecificOperation(soci::sqlite3_session_backend* sq) override
{
std::vector<char const*> cstrBalanceIDs;
cstrBalanceIDs.reserve(mBalanceIDs.size());
for (size_t i = 0; i < mBalanceIDs.size(); ++i)
{
cstrBalanceIDs.emplace_back(mBalanceIDs[i].c_str());
}
std::string sql = "WITH r AS (SELECT value FROM carray(?, ?, 'char*')) "
"SELECT balanceid, ledgerentry "
"FROM claimablebalance "
"WHERE balanceid IN r";
auto prep = mDb.getPreparedStatement(sql);
auto be = prep.statement().get_backend();
if (be == nullptr)
{
throw std::runtime_error("no sql backend");
}
auto sqliteStatement =
dynamic_cast<soci::sqlite3_statement_backend*>(be);
auto st = sqliteStatement->stmt_;
sqlite3_reset(st);
sqlite3_bind_pointer(st, 1, cstrBalanceIDs.data(), "carray", 0);
sqlite3_bind_int(st, 2, static_cast<int>(cstrBalanceIDs.size()));
return executeAndFetch(prep.statement());
}
#ifdef USE_POSTGRES
std::vector<LedgerEntry>
doPostgresSpecificOperation(soci::postgresql_session_backend* pg) override
{
std::string strBalanceIDs;
marshalToPGArray(pg->conn_, strBalanceIDs, mBalanceIDs);
std::string sql = "WITH r AS (SELECT unnest(:v1::TEXT[])) "
"SELECT balanceid, ledgerentry "
"FROM claimablebalance "
"WHERE balanceid IN (SELECT * from r)";
auto prep = mDb.getPreparedStatement(sql);
auto& st = prep.statement();
st.exchange(soci::use(strBalanceIDs));
return executeAndFetch(st);
}
#endif
};
UnorderedMap<LedgerKey, std::shared_ptr<LedgerEntry const>>
LedgerTxnRoot::Impl::bulkLoadClaimableBalance(
UnorderedSet<LedgerKey> const& keys) const
{
if (!keys.empty())
{
BulkLoadClaimableBalanceOperation op(mDatabase, keys);
return populateLoadedEntries(
keys, mDatabase.doDatabaseTypeSpecificOperation(op));
}
else
{
return {};
}
}
class BulkDeleteClaimableBalanceOperation
: public DatabaseTypeSpecificOperation<void>
{
Database& mDb;
LedgerTxnConsistency mCons;
std::vector<std::string> mBalanceIDs;
public:
BulkDeleteClaimableBalanceOperation(
Database& db, LedgerTxnConsistency cons,
std::vector<EntryIterator> const& entries)
: mDb(db), mCons(cons)
{
mBalanceIDs.reserve(entries.size());
for (auto const& e : entries)
{
releaseAssert(!e.entryExists());
releaseAssert(e.key().ledgerKey().type() == CLAIMABLE_BALANCE);
mBalanceIDs.emplace_back(toOpaqueBase64(
e.key().ledgerKey().claimableBalance().balanceID));
}
}
void
doSociGenericOperation()
{
std::string sql = "DELETE FROM claimablebalance WHERE balanceid = :id";
auto prep = mDb.getPreparedStatement(sql);
auto& st = prep.statement();
st.exchange(soci::use(mBalanceIDs));
st.define_and_bind();
{
auto timer = mDb.getDeleteTimer("claimablebalance");
st.execute(true);
}
if (static_cast<size_t>(st.get_affected_rows()) != mBalanceIDs.size() &&
mCons == LedgerTxnConsistency::EXACT)
{
throw std::runtime_error("Could not update data in SQL");
}
}
void
doSqliteSpecificOperation(soci::sqlite3_session_backend* sq) override
{
doSociGenericOperation();
}
#ifdef USE_POSTGRES
void
doPostgresSpecificOperation(soci::postgresql_session_backend* pg) override
{
std::string strBalanceIDs;
marshalToPGArray(pg->conn_, strBalanceIDs, mBalanceIDs);
std::string sql = "WITH r AS (SELECT unnest(:v1::TEXT[])) "
"DELETE FROM claimablebalance "
"WHERE balanceid IN (SELECT * FROM r)";
auto prep = mDb.getPreparedStatement(sql);
auto& st = prep.statement();
st.exchange(soci::use(strBalanceIDs));
st.define_and_bind();
{
auto timer = mDb.getDeleteTimer("claimablebalance");
st.execute(true);
}
if (static_cast<size_t>(st.get_affected_rows()) != mBalanceIDs.size() &&
mCons == LedgerTxnConsistency::EXACT)
{
throw std::runtime_error("Could not update data in SQL");
}
}
#endif
};
void
LedgerTxnRoot::Impl::bulkDeleteClaimableBalance(
std::vector<EntryIterator> const& entries, LedgerTxnConsistency cons)
{
BulkDeleteClaimableBalanceOperation op(mDatabase, cons, entries);
mDatabase.doDatabaseTypeSpecificOperation(op);
}
class BulkUpsertClaimableBalanceOperation
: public DatabaseTypeSpecificOperation<void>
{
Database& mDb;
std::vector<std::string> mBalanceIDs;
std::vector<std::string> mClaimableBalanceEntrys;
std::vector<int32_t> mLastModifieds;
void
accumulateEntry(LedgerEntry const& entry)
{
releaseAssert(entry.data.type() == CLAIMABLE_BALANCE);
mBalanceIDs.emplace_back(
toOpaqueBase64(entry.data.claimableBalance().balanceID));
mClaimableBalanceEntrys.emplace_back(toOpaqueBase64(entry));
mLastModifieds.emplace_back(
unsignedToSigned(entry.lastModifiedLedgerSeq));
}
public:
BulkUpsertClaimableBalanceOperation(
Database& Db, std::vector<EntryIterator> const& entryIter)
: mDb(Db)
{
for (auto const& e : entryIter)
{
releaseAssert(e.entryExists());
accumulateEntry(e.entry().ledgerEntry());
}
}
void
doSociGenericOperation()
{
std::string sql = "INSERT INTO claimablebalance "
"(balanceid, ledgerentry, lastmodified) "
"VALUES "
"( :id, :v1, :v2 ) "
"ON CONFLICT (balanceid) DO UPDATE SET "
"balanceid = excluded.balanceid, ledgerentry = "
"excluded.ledgerentry, lastmodified = "
"excluded.lastmodified";
auto prep = mDb.getPreparedStatement(sql);
soci::statement& st = prep.statement();
st.exchange(soci::use(mBalanceIDs));
st.exchange(soci::use(mClaimableBalanceEntrys));
st.exchange(soci::use(mLastModifieds));
st.define_and_bind();
{
auto timer = mDb.getUpsertTimer("claimablebalance");
st.execute(true);
}
if (static_cast<size_t>(st.get_affected_rows()) != mBalanceIDs.size())
{
throw std::runtime_error("Could not update data in SQL");
}
}
void
doSqliteSpecificOperation(soci::sqlite3_session_backend* sq) override
{
doSociGenericOperation();
}
#ifdef USE_POSTGRES
void
doPostgresSpecificOperation(soci::postgresql_session_backend* pg) override
{
std::string strBalanceIDs, strClaimableBalanceEntry, strLastModifieds;
PGconn* conn = pg->conn_;
marshalToPGArray(conn, strBalanceIDs, mBalanceIDs);
marshalToPGArray(conn, strClaimableBalanceEntry,
mClaimableBalanceEntrys);
marshalToPGArray(conn, strLastModifieds, mLastModifieds);
std::string sql = "WITH r AS "
"(SELECT unnest(:ids::TEXT[]), unnest(:v1::TEXT[]), "
"unnest(:v2::INT[]))"
"INSERT INTO claimablebalance "
"(balanceid, ledgerentry, lastmodified) "
"SELECT * FROM r "
"ON CONFLICT (balanceid) DO UPDATE SET "
"balanceid = excluded.balanceid, ledgerentry = "
"excluded.ledgerentry, "
"lastmodified = excluded.lastmodified";
auto prep = mDb.getPreparedStatement(sql);
soci::statement& st = prep.statement();
st.exchange(soci::use(strBalanceIDs));
st.exchange(soci::use(strClaimableBalanceEntry));
st.exchange(soci::use(strLastModifieds));
st.define_and_bind();
{
auto timer = mDb.getUpsertTimer("claimablebalance");
st.execute(true);
}
if (static_cast<size_t>(st.get_affected_rows()) != mBalanceIDs.size())
{
throw std::runtime_error("Could not update data in SQL");
}
}
#endif
};
void
LedgerTxnRoot::Impl::bulkUpsertClaimableBalance(
std::vector<EntryIterator> const& entries)
{
BulkUpsertClaimableBalanceOperation op(mDatabase, entries);
mDatabase.doDatabaseTypeSpecificOperation(op);
}
void
LedgerTxnRoot::Impl::dropClaimableBalances()
{
throwIfChild();
mEntryCache.clear();
mBestOffers.clear();
std::string coll = mDatabase.getSimpleCollationClause();
mDatabase.getSession() << "DROP TABLE IF EXISTS claimablebalance;";
mDatabase.getSession() << "CREATE TABLE claimablebalance ("
<< "balanceid VARCHAR(48) " << coll
<< " PRIMARY KEY, "
<< "ledgerentry TEXT NOT NULL, "
<< "lastmodified INT NOT NULL);";
}
}
| 32.585366 | 80 | 0.603127 | V5DF8 |
28fa9a0f35c465b171eff066be2899cb0884efe2 | 8,494 | cpp | C++ | mbed-os/drivers/QSPI.cpp | h7ga40/PeachCam | 06d023a908dc38228e77b47f80bc8496a4d35806 | [
"Apache-2.0"
] | 1 | 2019-12-13T05:51:34.000Z | 2019-12-13T05:51:34.000Z | mbed-os/drivers/QSPI.cpp | h7ga40/PeachCam | 06d023a908dc38228e77b47f80bc8496a4d35806 | [
"Apache-2.0"
] | null | null | null | mbed-os/drivers/QSPI.cpp | h7ga40/PeachCam | 06d023a908dc38228e77b47f80bc8496a4d35806 | [
"Apache-2.0"
] | 1 | 2021-09-17T15:41:36.000Z | 2021-09-17T15:41:36.000Z | /* mbed Microcontroller Library
* Copyright (c) 2006-2018 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "drivers/QSPI.h"
#include "platform/mbed_critical.h"
#include <string.h>
#if DEVICE_QSPI
namespace mbed {
QSPI *QSPI::_owner = NULL;
SingletonPtr<PlatformMutex> QSPI::_mutex;
QSPI::QSPI(PinName io0, PinName io1, PinName io2, PinName io3, PinName sclk, PinName ssel, int mode) : _qspi()
{
_qspi_io0 = io0;
_qspi_io1 = io1;
_qspi_io2 = io2;
_qspi_io3 = io3;
_qspi_clk = sclk;
_qspi_cs = ssel;
_inst_width = QSPI_CFG_BUS_SINGLE;
_address_width = QSPI_CFG_BUS_SINGLE;
_address_size = QSPI_CFG_ADDR_SIZE_24;
_alt_width = QSPI_CFG_BUS_SINGLE;
_alt_size = QSPI_CFG_ALT_SIZE_8;
_data_width = QSPI_CFG_BUS_SINGLE;
_num_dummy_cycles = 0;
_mode = mode;
_hz = ONE_MHZ;
_initialized = false;
//Go ahead init the device here with the default config
bool success = _initialize();
MBED_ASSERT(success);
}
qspi_status_t QSPI::configure_format(qspi_bus_width_t inst_width, qspi_bus_width_t address_width, qspi_address_size_t address_size, qspi_bus_width_t alt_width, qspi_alt_size_t alt_size, qspi_bus_width_t data_width, int dummy_cycles)
{
qspi_status_t ret_status = QSPI_STATUS_OK;
lock();
_inst_width = inst_width;
_address_width = address_width;
_address_size = address_size;
_alt_width = alt_width;
_alt_size = alt_size;
_data_width = data_width;
_num_dummy_cycles = dummy_cycles;
unlock();
return ret_status;
}
qspi_status_t QSPI::set_frequency(int hz)
{
qspi_status_t ret_status = QSPI_STATUS_OK;
if (_initialized) {
lock();
_hz = hz;
//If the same owner, just change freq.
//Otherwise we may have to change mode as well, so call _acquire
if (_owner == this) {
if (QSPI_STATUS_OK != qspi_frequency(&_qspi, _hz)) {
ret_status = QSPI_STATUS_ERROR;
}
} else {
_acquire();
}
unlock();
} else {
ret_status = QSPI_STATUS_ERROR;
}
return ret_status;
}
qspi_status_t QSPI::read(int address, char *rx_buffer, size_t *rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
if (_initialized) {
if ((rx_length != NULL) && (rx_buffer != NULL)) {
if (*rx_length != 0) {
lock();
if (true == _acquire()) {
_build_qspi_command(-1, address, -1);
if (QSPI_STATUS_OK == qspi_read(&_qspi, &_qspi_command, rx_buffer, rx_length)) {
ret_status = QSPI_STATUS_OK;
}
}
unlock();
}
} else {
ret_status = QSPI_STATUS_INVALID_PARAMETER;
}
}
return ret_status;
}
qspi_status_t QSPI::write(int address, const char *tx_buffer, size_t *tx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
if (_initialized) {
if ((tx_length != NULL) && (tx_buffer != NULL)) {
if (*tx_length != 0) {
lock();
if (true == _acquire()) {
_build_qspi_command(-1, address, -1);
if (QSPI_STATUS_OK == qspi_write(&_qspi, &_qspi_command, tx_buffer, tx_length)) {
ret_status = QSPI_STATUS_OK;
}
}
unlock();
}
} else {
ret_status = QSPI_STATUS_INVALID_PARAMETER;
}
}
return ret_status;
}
qspi_status_t QSPI::read(int instruction, int alt, int address, char *rx_buffer, size_t *rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
if (_initialized) {
if ((rx_length != NULL) && (rx_buffer != NULL)) {
if (*rx_length != 0) {
lock();
if (true == _acquire()) {
_build_qspi_command(instruction, address, alt);
if (QSPI_STATUS_OK == qspi_read(&_qspi, &_qspi_command, rx_buffer, rx_length)) {
ret_status = QSPI_STATUS_OK;
}
}
unlock();
}
} else {
ret_status = QSPI_STATUS_INVALID_PARAMETER;
}
}
return ret_status;
}
qspi_status_t QSPI::write(int instruction, int alt, int address, const char *tx_buffer, size_t *tx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
if (_initialized) {
if ((tx_length != NULL) && (tx_buffer != NULL)) {
if (*tx_length != 0) {
lock();
if (true == _acquire()) {
_build_qspi_command(instruction, address, alt);
if (QSPI_STATUS_OK == qspi_write(&_qspi, &_qspi_command, tx_buffer, tx_length)) {
ret_status = QSPI_STATUS_OK;
}
}
unlock();
}
} else {
ret_status = QSPI_STATUS_INVALID_PARAMETER;
}
}
return ret_status;
}
qspi_status_t QSPI::command_transfer(int instruction, int address, const char *tx_buffer, size_t tx_length, const char *rx_buffer, size_t rx_length)
{
qspi_status_t ret_status = QSPI_STATUS_ERROR;
if (_initialized) {
lock();
if (true == _acquire()) {
_build_qspi_command(instruction, address, -1); //We just need the command
if (QSPI_STATUS_OK == qspi_command_transfer(&_qspi, &_qspi_command, (const void *)tx_buffer, tx_length, (void *)rx_buffer, rx_length)) {
ret_status = QSPI_STATUS_OK;
}
}
unlock();
}
return ret_status;
}
void QSPI::lock()
{
_mutex->lock();
}
void QSPI::unlock()
{
_mutex->unlock();
}
// Note: Private helper function to initialize qspi HAL
bool QSPI::_initialize()
{
if (_mode != 0 && _mode != 1) {
_initialized = false;
return _initialized;
}
qspi_status_t ret = qspi_init(&_qspi, _qspi_io0, _qspi_io1, _qspi_io2, _qspi_io3, _qspi_clk, _qspi_cs, _hz, _mode);
if (QSPI_STATUS_OK == ret) {
_initialized = true;
} else {
_initialized = false;
}
return _initialized;
}
// Note: Private function with no locking
bool QSPI::_acquire()
{
if (_owner != this) {
//This will set freq as well
_initialize();
_owner = this;
}
return _initialized;
}
void QSPI::_build_qspi_command(int instruction, int address, int alt)
{
memset(&_qspi_command, 0, sizeof(qspi_command_t));
//Set up instruction phase parameters
_qspi_command.instruction.bus_width = _inst_width;
if (instruction != -1) {
_qspi_command.instruction.value = instruction;
_qspi_command.instruction.disabled = false;
} else {
_qspi_command.instruction.disabled = true;
}
//Set up address phase parameters
_qspi_command.address.bus_width = _address_width;
_qspi_command.address.size = _address_size;
if (address != -1) {
_qspi_command.address.value = address;
_qspi_command.address.disabled = false;
} else {
_qspi_command.address.disabled = true;
}
//Set up alt phase parameters
_qspi_command.alt.bus_width = _alt_width;
_qspi_command.alt.size = _alt_size;
if (alt != -1) {
_qspi_command.alt.value = alt;
_qspi_command.alt.disabled = false;
} else {
_qspi_command.alt.disabled = true;
}
_qspi_command.dummy_count = _num_dummy_cycles;
//Set up bus width for data phase
_qspi_command.data.bus_width = _data_width;
}
} // namespace mbed
#endif
| 29.391003 | 233 | 0.585708 | h7ga40 |
28fc02a851e81e019b0eca73e0ce310b05bacffc | 1,765 | cpp | C++ | week2/6_sinExample_circlePlusPath/src/ofApp.cpp | evejweinberg/algo2012 | 7e13c20bab94e1769f6751c4e124964ae05b7087 | [
"MIT"
] | 94 | 2015-01-12T16:07:57.000Z | 2021-12-24T06:48:04.000Z | week2/6_sinExample_circlePlusPath/src/ofApp.cpp | theomission/algo2012 | 7e13c20bab94e1769f6751c4e124964ae05b7087 | [
"MIT"
] | null | null | null | week2/6_sinExample_circlePlusPath/src/ofApp.cpp | theomission/algo2012 | 7e13c20bab94e1769f6751c4e124964ae05b7087 | [
"MIT"
] | 18 | 2015-03-12T23:11:08.000Z | 2022-02-05T05:43:51.000Z | #include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup(){
ofSetVerticalSync(true);
ofBackground(0,0,0);
ofSetCircleResolution(100);
radius = 50;
}
//--------------------------------------------------------------
void ofApp::update(){
radius = radius + 0.1;
}
//--------------------------------------------------------------
void ofApp::draw(){
float xorig = 500;
float yorig = 300;
float angle = ofGetElapsedTimef()*3.5;
float x = xorig + radius * cos(angle);
float y = yorig + radius * -sin(angle);
ofPoint temp;
temp.x = x;
temp.y = y;
points.push_back(temp);
if (points.size() > 1000){
points.erase(points.begin());
}
ofSetRectMode(OF_RECTMODE_CENTER);
ofSetColor(255,0,127);
ofFill();
ofCircle(x,y,10);
ofSetColor(255,255,255);
ofNoFill();
ofBeginShape();
for (int i = 0; i < points.size(); i++){
ofVertex(points[i].x, points[i].y);
}
ofEndShape();
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
}
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
| 17.65 | 64 | 0.398867 | evejweinberg |
28fc99035e0c7318fc6617c3c8d037dd9c7adecb | 2,602 | cpp | C++ | unit_tests/stencil_composition/test_make_loop_intervals.cpp | mbianco/gridtools | 1abef09881a31495a3d02a15d3fe21620c6dde98 | [
"BSD-3-Clause"
] | null | null | null | unit_tests/stencil_composition/test_make_loop_intervals.cpp | mbianco/gridtools | 1abef09881a31495a3d02a15d3fe21620c6dde98 | [
"BSD-3-Clause"
] | null | null | null | unit_tests/stencil_composition/test_make_loop_intervals.cpp | mbianco/gridtools | 1abef09881a31495a3d02a15d3fe21620c6dde98 | [
"BSD-3-Clause"
] | 1 | 2019-06-14T10:35:50.000Z | 2019-06-14T10:35:50.000Z | /*
* GridTools
*
* Copyright (c) 2014-2019, ETH Zurich
* All rights reserved.
*
* Please, refer to the LICENSE file in the root directory.
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <gridtools/stencil_composition/make_loop_intervals.hpp>
#include <gtest/gtest.h>
#include <gridtools/common/defs.hpp>
#include <gridtools/meta.hpp>
#include <gridtools/stencil_composition/interval.hpp>
#include <gridtools/stencil_composition/level.hpp>
namespace gridtools {
namespace {
using meta::list;
template <uint_t Splitter, int_t Offset>
using lev = level<Splitter, Offset, 3>;
using from_t = lev<0, 1>;
using to_t = lev<3, -1>;
using axis_interval_t = interval<from_t, to_t>;
struct stage1 {};
struct stage2 {};
template <template <class...> class StagesMaker>
GT_META_DEFINE_ALIAS(testee, make_loop_intervals, (StagesMaker, axis_interval_t));
namespace no_stages {
using testee_t = GT_META_CALL(testee, meta::always<list<>>::apply);
static_assert(std::is_same<testee_t, list<>>{}, "");
} // namespace no_stages
namespace simple {
using testee_t = GT_META_CALL(testee, meta::always<list<stage1>>::apply);
static_assert(std::is_same<testee_t, list<loop_interval<from_t, to_t, list<stage1>>>>{}, "");
} // namespace simple
namespace overlap {
template <uint_t Splitter, int_t Offset>
constexpr int_t idx() {
return level_to_index<lev<Splitter, Offset>>::value;
}
constexpr bool has_stage1(int_t i) { return i >= idx<0, 2>() && i < idx<2, 1>(); }
constexpr bool has_stage2(int_t i) { return i >= idx<1, 1>() && i < idx<3, -1>(); }
template <class Index>
GT_META_DEFINE_ALIAS(stages_maker,
meta::filter,
(meta::not_<std::is_void>::apply,
meta::list<conditional_t<has_stage1(Index::value), stage1, void>,
conditional_t<has_stage2(Index::value), stage2, void>>));
using testee_t = GT_META_CALL(testee, stages_maker);
using expected_t = list<loop_interval<lev<0, 2>, lev<1, -1>, list<stage1>>,
loop_interval<lev<1, 1>, lev<2, -1>, list<stage1, stage2>>,
loop_interval<lev<2, 1>, lev<3, -2>, list<stage2>>>;
static_assert(std::is_same<testee_t, expected_t>{}, "");
} // namespace overlap
TEST(dummy, dummy) {}
} // namespace
} // namespace gridtools
| 35.162162 | 105 | 0.60146 | mbianco |
e9005849663072c857de6b3ce39173f8d237bd98 | 6,361 | cpp | C++ | src/appleseed/renderer/modeling/bsdf/bsdfsample.cpp | joelbarmettlerUZH/appleseed | 6da8ff684aa33648a247a4d4005bb4595862e0b3 | [
"MIT"
] | 1,907 | 2015-01-04T00:13:22.000Z | 2022-03-30T15:14:00.000Z | src/appleseed/renderer/modeling/bsdf/bsdfsample.cpp | joelbarmettlerUZH/appleseed | 6da8ff684aa33648a247a4d4005bb4595862e0b3 | [
"MIT"
] | 1,196 | 2015-01-04T10:50:01.000Z | 2022-03-04T09:18:22.000Z | src/appleseed/renderer/modeling/bsdf/bsdfsample.cpp | joelbarmettlerUZH/appleseed | 6da8ff684aa33648a247a4d4005bb4595862e0b3 | [
"MIT"
] | 373 | 2015-01-06T10:08:53.000Z | 2022-03-12T10:25:57.000Z |
//
// This source file is part of appleseed.
// Visit https://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2015-2018 Esteban Tovagliari, The appleseedhq Organization
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// Interface header.
#include "bsdfsample.h"
// appleseed.foundation headers.
#include "foundation/math/basis.h"
// Standard headers.
#include <cmath>
using namespace foundation;
namespace renderer
{
namespace
{
void compute_normal_derivatives(
const BSDF::LocalGeometry& local_geometry,
const Vector3f& o,
const Vector3f& dodx,
const Vector3f& dody,
foundation::Vector3f& dndx,
foundation::Vector3f& dndy,
float& ddndx,
float& ddndy)
{
//
// Reference:
//
// Physically Based Rendering, first edition, page 513.
//
const Vector3f dndu(local_geometry.m_shading_point->get_dndu(0));
const Vector3f dndv(local_geometry.m_shading_point->get_dndv(0));
const Vector2f duvdx(local_geometry.m_shading_point->get_duvdx(0));
const Vector2f duvdy(local_geometry.m_shading_point->get_duvdy(0));
dndx = dndu * duvdx[0] + dndv * duvdx[1];
dndy = dndu * duvdy[0] + dndv * duvdy[1];
const Vector3f& n = local_geometry.m_shading_basis.get_normal();
ddndx = dot(dodx, n) + dot(o, dndx);
ddndy = dot(dody, n) + dot(o, dndy);
}
}
//
// BSDFSample class implementation.
//
void BSDFSample::compute_specular_reflected_differentials(
const BSDF::LocalGeometry& local_geometry,
const Dual3f& outgoing)
{
if (outgoing.has_derivatives())
{
//
// Reference:
//
// Physically Based Rendering, first edition, page 513.
//
const Vector3f dodx = -(outgoing.get_dx() - outgoing.get_value());
const Vector3f dody = -(outgoing.get_dy() - outgoing.get_value());
Vector3f dndx, dndy;
float ddndx, ddndy;
compute_normal_derivatives(
local_geometry,
outgoing.get_value(),
dodx,
dody,
dndx,
dndy,
ddndx,
ddndy);
const Vector3f& n = local_geometry.m_shading_basis.get_normal();
const float dot_on = dot(outgoing.get_value(), n);
const Vector3f& i = m_incoming.get_value();
m_incoming.set_derivatives(
i - dodx + 2.0f * Vector3f(dot_on * dndx + ddndx * n),
i - dody + 2.0f * Vector3f(dot_on * dndy + ddndy * n));
}
}
void BSDFSample::compute_specular_transmitted_differentials(
const BSDF::LocalGeometry& local_geometry,
const float eta,
const bool is_entering,
const Dual3f& outgoing)
{
if (outgoing.has_derivatives())
{
const Vector3f dodx = -(outgoing.get_dx() - outgoing.get_value());
const Vector3f dody = -(outgoing.get_dy() - outgoing.get_value());
Vector3f dndx, dndy;
float ddndx, ddndy;
compute_normal_derivatives(
local_geometry,
outgoing.get_value(),
dodx,
dody,
dndx,
dndy,
ddndx,
ddndy);
const Vector3f& n = local_geometry.m_shading_basis.get_normal();
const float dot_on = dot(-outgoing.get_value(), n);
const float dot_in = std::abs(dot(m_incoming.get_value(), n));
const float mu = eta * dot_on - dot_in;
const float a = eta - (square(eta) * dot_on) / dot_in;
const float dmudx = a * ddndx;
const float dmudy = a * ddndy;
const Vector3f& i = m_incoming.get_value();
m_incoming.set_derivatives(
i - eta * dodx - Vector3f(mu * dndx + dmudx * n),
i - eta * dody - Vector3f(mu * dndy + dmudy * n));
}
}
void BSDFSample::compute_glossy_reflected_differentials(
const BSDF::LocalGeometry& local_geometry,
const float roughness,
const Dual3f& outgoing)
{
// TODO: scale differentials based on roughness.
compute_specular_reflected_differentials(local_geometry, outgoing);
}
void BSDFSample::compute_glossy_transmitted_differentials(
const BSDF::LocalGeometry& local_geometry,
const float eta,
const float roughness,
const bool is_entering,
const Dual3f& outgoing)
{
// TODO: scale differentials based on roughness.
compute_specular_transmitted_differentials(
local_geometry,
eta,
is_entering,
outgoing);
}
void BSDFSample::compute_diffuse_differentials(const Dual3f& outgoing)
{
if (outgoing.has_derivatives())
{
// 1/25 of the hemisphere.
// Reference: https://www.pbrt.org/texcache.pdf
const auto& i = m_incoming.get_value();
const Basis3f basis(m_incoming.get_value());
m_incoming.set_derivatives(
normalize(i + 0.2f * basis.get_tangent_u()),
normalize(i + 0.2f * basis.get_tangent_v()));
}
}
} // namespace renderer
| 32.454082 | 80 | 0.622386 | joelbarmettlerUZH |
e90096d4600be5ce516dff8cb5d49840032d3696 | 4,037 | cpp | C++ | src/rschol/geometry/FiniteDifference.cpp | jeffc71/rank_structured_cholesky | 1b5df69bd6b9187435897786e7461cdd341e8db0 | [
"Unlicense"
] | 3 | 2017-09-07T16:14:33.000Z | 2021-09-18T04:47:06.000Z | src/rschol/geometry/FiniteDifference.cpp | jeffchadwick/rank_structured_cholesky | 1b5df69bd6b9187435897786e7461cdd341e8db0 | [
"Unlicense"
] | null | null | null | src/rschol/geometry/FiniteDifference.cpp | jeffchadwick/rank_structured_cholesky | 1b5df69bd6b9187435897786e7461cdd341e8db0 | [
"Unlicense"
] | null | null | null | //////////////////////////////////////////////////////////////////////
// Copyright (c) 2015, Jeff Chadwick and David Bindel
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// FiniteDifference.cpp: Implementation
//
//////////////////////////////////////////////////////////////////////
#include "FiniteDifference.h"
//////////////////////////////////////////////////////////////////////
// Stencils for finite difference laplacian operator
//////////////////////////////////////////////////////////////////////
const Real FiniteDifference::LAPLACIAN_STENCIL[] = { -1.0, 2.0, -1.0 };
const int FiniteDifference::LAPLACIAN_STENCIL_INDEX[] = { -1, 0, 1 };
const int FiniteDifference::LAPLACIAN_STENCIL_SZ = 3;
//////////////////////////////////////////////////////////////////////
// Generates a finite difference Laplacian matrix with Dirichlet
// boundary conditions, assuming a constant grid cell spacing of h
//////////////////////////////////////////////////////////////////////
void FiniteDifference::generateLaplacian( SPARSE_MATRIX &L,
Tuple3i gridDivisions,
Real h )
{
int sz = GRID_SIZE( gridDivisions );
Real inv_h2 = 1.0 / ( h * h );
L.resize( sz, sz );
L.clear();
FOR_ALL_3D_POINTS( gridDivisions, idx )
{
// Apply the Laplacian along each dimension
for ( int d = 0; d < 3; d++ )
{
for ( int lap_idx = 0; lap_idx < LAPLACIAN_STENCIL_SZ; lap_idx++ )
{
Tuple3i entry_idx = idx;
int row_idx = INDEX_3D_GRID( gridDivisions, idx );
int offset = LAPLACIAN_STENCIL_INDEX[ lap_idx ];
entry_idx[d] += offset;
if ( !checkFDIndex( gridDivisions, entry_idx ) )
continue;
int col_idx = INDEX_3D_GRID( gridDivisions, entry_idx );
L( row_idx, col_idx ) += LAPLACIAN_STENCIL[ lap_idx ] * inv_h2;
}
}
}
}
// Evaluates a function at all points of a finite difference grid
void FiniteDifference::evaluateGridEntries( const Tuple3i &gridDivisions, Real h,
const ScalarEvaluator &f,
VECTOR &x )
{
int sz = GRID_SIZE( gridDivisions );
VEC3F p;
int x_idx = 0;
x.resizeAndWipe( sz );
FOR_ALL_3D_POINTS( gridDivisions, idx )
{
p = assignPoint( idx, h );
x( x_idx ) = f( p );
x_idx++;
}
}
| 36.369369 | 81 | 0.583354 | jeffc71 |
e902b84a9cfaa34c2c09dffbd1740b49dbc860ff | 2,122 | hpp | C++ | file_access.hpp | piccolo255/mhd2d-solver | be635bb6f5f8d3d06a9fa02a15801eedd1f50306 | [
"Unlicense"
] | null | null | null | file_access.hpp | piccolo255/mhd2d-solver | be635bb6f5f8d3d06a9fa02a15801eedd1f50306 | [
"Unlicense"
] | null | null | null | file_access.hpp | piccolo255/mhd2d-solver | be635bb6f5f8d3d06a9fa02a15801eedd1f50306 | [
"Unlicense"
] | null | null | null | #ifndef FILE_ACCESS_HPP_INCLUDED
#define FILE_ACCESS_HPP_INCLUDED
// Read value of a key, show warning and default value if the key is missing
template <class T>
T readEntry
( boost::property_tree::ptree pt
, std::string section
, std::string name
, T defaultValue );
// Read settings from property tree: Div B corrector
void readParamsDivBCorrector
( boost::property_tree::ptree &pt
, t_params ¶ms );
// Read settings from property tree: Shock tube problem
void readProblemShockTube
( boost::property_tree::ptree &pt
, t_params ¶ms
, t_data &data );
// Read settings from property tree: Explosion problem
void readProblemExplosion
( boost::property_tree::ptree &pt
, t_params ¶ms
, t_data &data );
// Read settings from property tree: Orszag-Tang vortex problem
void readProblemOTVortex
( boost::property_tree::ptree &pt
, t_params ¶ms
, t_data &data );
// Read settings from property tree: Plasma sheet problem
void readProblemPlasmaSheet
( boost::property_tree::ptree &pt
, t_params ¶ms
, t_data &data );
// Read settings from property tree: Wave test problem
void readProblemWaveTest
( boost::property_tree::ptree &pt
, t_params ¶ms
, t_data &data );
// Print info about the binary file structure (with hints for plotting with GNUplot)
void outputBinaryHintFile
( const std::string filename
, const t_params ¶ms
, const t_output &output_grid );
// Output grid data file in binary format
void outputGridDataBinary
( const t_output &output
, const t_params ¶ms
, const t_data &data
, int step
, int index
, int divb_nxfirst
, int divb_nxlast
, int divb_nyfirst
, int divb_nylast
, double uumax );
// Output grid data file in textual format
void outputGridDataText
( const t_output &output
, const t_params ¶ms
, const t_data &data
, int step
, int index
, int divb_nxfirst
, int divb_nxlast
, int divb_nyfirst
, int divb_nylast
, double uumax );
#endif // FILE_ACCESS_HPP_INCLUDED
| 26.525 | 84 | 0.696984 | piccolo255 |
e90363efe24449aee213324e34ea26d2fc0605bd | 644 | cpp | C++ | NotSoFAT32/Fat32Directory.cpp | Rohansi/NotSoFAT32 | fd6b6a5528b5af00518a83b3d1c2061a87b007e3 | [
"MIT"
] | 1 | 2020-11-03T16:11:59.000Z | 2020-11-03T16:11:59.000Z | NotSoFAT32/Fat32Directory.cpp | Rohansi/NotSoFAT32 | fd6b6a5528b5af00518a83b3d1c2061a87b007e3 | [
"MIT"
] | 1 | 2020-11-04T11:34:44.000Z | 2020-11-04T11:34:44.000Z | NotSoFAT32/Fat32Directory.cpp | Rohansi/NotSoFAT32 | fd6b6a5528b5af00518a83b3d1c2061a87b007e3 | [
"MIT"
] | null | null | null | #include "Interface/IFat32Directory.hpp"
#include "Fat32Directory.hpp"
#include "Fat32Root.hpp"
#include "Fat32File.hpp"
#include <algorithm>
#include <string>
Fat32Directory::Fat32Directory(std::weak_ptr<Fat32Disk> fat32, std::shared_ptr<DirectoryEntry> entry)
: IFat32Directory(fat32)
{
m_fat32 = fat32;
m_entry = entry;
}
Fat32Directory::Fat32Directory(Fat32Directory &&other)
: IFat32Directory(std::move(other))
{
m_fat32 = std::move(other.m_fat32);
m_entry = std::move(other.m_entry);
}
void Fat32Directory::initialize()
{
IFat32Directory::m_entry = std::move(m_entry);
IFat32Directory::initialize();
}
| 23 | 101 | 0.728261 | Rohansi |
e9086e1fbdc59a6691aded7cb2e54cb31b51dba5 | 15,212 | cpp | C++ | nfc/src/DOOM/doomclassic/timidity/resample.cpp | 1337programming/leviathan | ca9a31b45c25fd23f361d67136ae5ac6b98d2628 | [
"Apache-2.0"
] | null | null | null | nfc/src/DOOM/doomclassic/timidity/resample.cpp | 1337programming/leviathan | ca9a31b45c25fd23f361d67136ae5ac6b98d2628 | [
"Apache-2.0"
] | null | null | null | nfc/src/DOOM/doomclassic/timidity/resample.cpp | 1337programming/leviathan | ca9a31b45c25fd23f361d67136ae5ac6b98d2628 | [
"Apache-2.0"
] | null | null | null | /*
TiMidity -- Experimental MIDI to WAVE converter
Copyright (C) 1995 Tuukka Toivonen <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
resample.c
*/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "common.h"
#include "instrum.h"
#include "playmidi.h"
#include "output.h"
#include "controls.h"
#include "tables.h"
#include "resample.h"
#ifdef LINEAR_INTERPOLATION
# if defined(LOOKUP_HACK) && defined(LOOKUP_INTERPOLATION)
# define RESAMPLATION \
v1=src[ofs>>FRACTION_BITS];\
v2=src[(ofs>>FRACTION_BITS)+1];\
*dest++ = v1 + (iplookup[(((v2-v1)<<5) & 0x03FE0) | \
((ofs & FRACTION_MASK) >> (FRACTION_BITS-5))]);
# else
# define RESAMPLATION \
v1=src[ofs>>FRACTION_BITS];\
v2=src[(ofs>>FRACTION_BITS)+1];\
*dest++ = v1 + (((v2-v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS);
# endif
# define INTERPVARS sample_t v1, v2
#else
/* Earplugs recommended for maximum listening enjoyment */
# define RESAMPLATION *dest++=src[ofs>>FRACTION_BITS];
# define INTERPVARS
#endif
#define FINALINTERP if (ofs == le) *dest++=src[ofs>>FRACTION_BITS];
/* So it isn't interpolation. At least it's final. */
extern sample_t *resample_buffer;
void Real_Tim_Free( void *pt );
/*************** resampling with fixed increment *****************/
static sample_t *rs_plain(int v, int32_t *countptr)
{
/* Play sample until end, then free the voice. */
INTERPVARS;
Voice
*vp=&voice[v];
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
int32_t
ofs=vp->sample_offset,
incr=vp->sample_increment,
le=vp->sample->data_length,
count=*countptr;
#ifdef PRECALC_LOOPS
int32_t i;
if (incr<0) incr = -incr; /* In case we're coming out of a bidir loop */
/* Precalc how many times we should go through the loop.
NOTE: Assumes that incr > 0 and that ofs <= le */
i = (le - ofs) / incr + 1;
if (i > count)
{
i = count;
count = 0;
}
else count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
if (ofs >= le)
{
FINALINTERP;
vp->status=VOICE_FREE;
ctl->note(v);
*countptr-=count+1;
}
#else /* PRECALC_LOOPS */
while (count--)
{
RESAMPLATION;
ofs += incr;
if (ofs >= le)
{
FINALINTERP;
vp->status=VOICE_FREE;
ctl->note(v);
*countptr-=count+1;
break;
}
}
#endif /* PRECALC_LOOPS */
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
static sample_t *rs_loop(Voice *vp, int32_t count)
{
/* Play sample until end-of-loop, skip back and continue. */
INTERPVARS;
int32_t
ofs=vp->sample_offset,
incr=vp->sample_increment,
le=vp->sample->loop_end,
ll=le - vp->sample->loop_start;
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
#ifdef PRECALC_LOOPS
int32_t i;
while (count)
{
if (ofs >= le)
/* NOTE: Assumes that ll > incr and that incr > 0. */
ofs -= ll;
/* Precalc how many times we should go through the loop */
i = (le - ofs) / incr + 1;
if (i > count)
{
i = count;
count = 0;
}
else count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
}
#else
while (count--)
{
RESAMPLATION;
ofs += incr;
if (ofs>=le)
ofs -= ll; /* Hopefully the loop is longer than an increment. */
}
#endif
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
static sample_t *rs_bidir(Voice *vp, int32_t count)
{
INTERPVARS;
int32_t
ofs=vp->sample_offset,
incr=vp->sample_increment,
le=vp->sample->loop_end,
ls=vp->sample->loop_start;
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
#ifdef PRECALC_LOOPS
int32_t
le2 = le<<1,
ls2 = ls<<1,
i;
/* Play normally until inside the loop region */
if (ofs <= ls)
{
/* NOTE: Assumes that incr > 0, which is NOT always the case
when doing bidirectional looping. I have yet to see a case
where both ofs <= ls AND incr < 0, however. */
i = (ls - ofs) / incr + 1;
if (i > count)
{
i = count;
count = 0;
}
else count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
}
/* Then do the bidirectional looping */
while(count)
{
/* Precalc how many times we should go through the loop */
i = ((incr > 0 ? le : ls) - ofs) / incr + 1;
if (i > count)
{
i = count;
count = 0;
}
else count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
if (ofs>=le)
{
/* fold the overshoot back in */
ofs = le2 - ofs;
incr *= -1;
}
else if (ofs <= ls)
{
ofs = ls2 - ofs;
incr *= -1;
}
}
#else /* PRECALC_LOOPS */
/* Play normally until inside the loop region */
if (ofs < ls)
{
while (count--)
{
RESAMPLATION;
ofs += incr;
if (ofs>=ls)
break;
}
}
/* Then do the bidirectional looping */
if (count>0)
while (count--)
{
RESAMPLATION;
ofs += incr;
if (ofs>=le)
{
/* fold the overshoot back in */
ofs = le - (ofs - le);
incr = -incr;
}
else if (ofs <= ls)
{
ofs = ls + (ls - ofs);
incr = -incr;
}
}
#endif /* PRECALC_LOOPS */
vp->sample_increment=incr;
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
/*********************** vibrato versions ***************************/
/* We only need to compute one half of the vibrato sine cycle */
static int vib_phase_to_inc_ptr(int phase)
{
if (phase < VIBRATO_SAMPLE_INCREMENTS/2)
return VIBRATO_SAMPLE_INCREMENTS/2-1-phase;
else if (phase >= 3*VIBRATO_SAMPLE_INCREMENTS/2)
return 5*VIBRATO_SAMPLE_INCREMENTS/2-1-phase;
else
return phase-VIBRATO_SAMPLE_INCREMENTS/2;
}
static int32_t update_vibrato(Voice *vp, int sign)
{
int32_t depth;
int phase, pb;
double a;
if (vp->vibrato_phase++ >= 2*VIBRATO_SAMPLE_INCREMENTS-1)
vp->vibrato_phase=0;
phase=vib_phase_to_inc_ptr(vp->vibrato_phase);
if (vp->vibrato_sample_increment[phase])
{
if (sign)
return -vp->vibrato_sample_increment[phase];
else
return vp->vibrato_sample_increment[phase];
}
/* Need to compute this sample increment. */
depth=vp->sample->vibrato_depth<<7;
if (vp->vibrato_sweep)
{
/* Need to update sweep */
vp->vibrato_sweep_position += vp->vibrato_sweep;
if (vp->vibrato_sweep_position >= (1<<SWEEP_SHIFT))
vp->vibrato_sweep=0;
else
{
/* Adjust depth */
depth *= vp->vibrato_sweep_position;
depth >>= SWEEP_SHIFT;
}
}
a = FSCALE(((double)(vp->sample->sample_rate) *
(double)(vp->frequency)) /
((double)(vp->sample->root_freq) *
(double)(play_mode->rate)),
FRACTION_BITS);
pb=(int)((sine(vp->vibrato_phase *
(SINE_CYCLE_LENGTH/(2*VIBRATO_SAMPLE_INCREMENTS)))
* (double)(depth) * VIBRATO_AMPLITUDE_TUNING));
if (pb<0)
{
pb=-pb;
a /= bend_fine[(pb>>5) & 0xFF] * bend_coarse[pb>>13];
}
else
a *= bend_fine[(pb>>5) & 0xFF] * bend_coarse[pb>>13];
/* If the sweep's over, we can store the newly computed sample_increment */
if (!vp->vibrato_sweep)
vp->vibrato_sample_increment[phase]=(int32_t) a;
if (sign)
a = -a; /* need to preserve the loop direction */
return (int32_t) a;
}
static sample_t *rs_vib_plain(int v, int32_t *countptr)
{
/* Play sample until end, then free the voice. */
INTERPVARS;
Voice *vp=&voice[v];
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
int32_t
le=vp->sample->data_length,
ofs=vp->sample_offset,
incr=vp->sample_increment,
count=*countptr;
int
cc=vp->vibrato_control_counter;
/* This has never been tested */
if (incr<0) incr = -incr; /* In case we're coming out of a bidir loop */
while (count--)
{
if (!cc--)
{
cc=vp->vibrato_control_ratio;
incr=update_vibrato(vp, 0);
}
RESAMPLATION;
ofs += incr;
if (ofs >= le)
{
FINALINTERP;
vp->status=VOICE_FREE;
ctl->note(v);
*countptr-=count+1;
break;
}
}
vp->vibrato_control_counter=cc;
vp->sample_increment=incr;
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
static sample_t *rs_vib_loop(Voice *vp, int32_t count)
{
/* Play sample until end-of-loop, skip back and continue. */
INTERPVARS;
int32_t
ofs=vp->sample_offset,
incr=vp->sample_increment,
le=vp->sample->loop_end,
ll=le - vp->sample->loop_start;
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
int
cc=vp->vibrato_control_counter;
#ifdef PRECALC_LOOPS
int32_t i;
int
vibflag=0;
while (count)
{
/* Hopefully the loop is longer than an increment */
if(ofs >= le)
ofs -= ll;
/* Precalc how many times to go through the loop, taking
the vibrato control ratio into account this time. */
i = (le - ofs) / incr + 1;
if(i > count) i = count;
if(i > cc)
{
i = cc;
vibflag = 1;
}
else cc -= i;
count -= i;
while(i--)
{
RESAMPLATION;
ofs += incr;
}
if(vibflag)
{
cc = vp->vibrato_control_ratio;
incr = update_vibrato(vp, 0);
vibflag = 0;
}
}
#else /* PRECALC_LOOPS */
while (count--)
{
if (!cc--)
{
cc=vp->vibrato_control_ratio;
incr=update_vibrato(vp, 0);
}
RESAMPLATION;
ofs += incr;
if (ofs>=le)
ofs -= ll; /* Hopefully the loop is longer than an increment. */
}
#endif /* PRECALC_LOOPS */
vp->vibrato_control_counter=cc;
vp->sample_increment=incr;
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
static sample_t *rs_vib_bidir(Voice *vp, int32_t count)
{
INTERPVARS;
int32_t
ofs=vp->sample_offset,
incr=vp->sample_increment,
le=vp->sample->loop_end,
ls=vp->sample->loop_start;
sample_t
*dest=resample_buffer,
*src=vp->sample->data;
int
cc=vp->vibrato_control_counter;
#ifdef PRECALC_LOOPS
int32_t
le2=le<<1,
ls2=ls<<1,
i;
int
vibflag = 0;
/* Play normally until inside the loop region */
while (count && (ofs <= ls))
{
i = (ls - ofs) / incr + 1;
if (i > count) i = count;
if (i > cc)
{
i = cc;
vibflag = 1;
}
else cc -= i;
count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
if (vibflag)
{
cc = vp->vibrato_control_ratio;
incr = update_vibrato(vp, 0);
vibflag = 0;
}
}
/* Then do the bidirectional looping */
while (count)
{
/* Precalc how many times we should go through the loop */
i = ((incr > 0 ? le : ls) - ofs) / incr + 1;
if(i > count) i = count;
if(i > cc)
{
i = cc;
vibflag = 1;
}
else cc -= i;
count -= i;
while (i--)
{
RESAMPLATION;
ofs += incr;
}
if (vibflag)
{
cc = vp->vibrato_control_ratio;
incr = update_vibrato(vp, (incr < 0));
vibflag = 0;
}
if (ofs >= le)
{
/* fold the overshoot back in */
ofs = le2 - ofs;
incr *= -1;
}
else if (ofs <= ls)
{
ofs = ls2 - ofs;
incr *= -1;
}
}
#else /* PRECALC_LOOPS */
/* Play normally until inside the loop region */
if (ofs < ls)
{
while (count--)
{
if (!cc--)
{
cc=vp->vibrato_control_ratio;
incr=update_vibrato(vp, 0);
}
RESAMPLATION;
ofs += incr;
if (ofs>=ls)
break;
}
}
/* Then do the bidirectional looping */
if (count>0)
while (count--)
{
if (!cc--)
{
cc=vp->vibrato_control_ratio;
incr=update_vibrato(vp, (incr < 0));
}
RESAMPLATION;
ofs += incr;
if (ofs>=le)
{
/* fold the overshoot back in */
ofs = le - (ofs - le);
incr = -incr;
}
else if (ofs <= ls)
{
ofs = ls + (ls - ofs);
incr = -incr;
}
}
#endif /* PRECALC_LOOPS */
vp->vibrato_control_counter=cc;
vp->sample_increment=incr;
vp->sample_offset=ofs; /* Update offset */
return resample_buffer;
}
sample_t *resample_voice(int v, int32_t *countptr)
{
int32_t ofs;
uint8_t modes;
Voice *vp=&voice[v];
if (!(vp->sample->sample_rate))
{
/* Pre-resampled data -- just update the offset and check if
we're out of data. */
ofs=vp->sample_offset >> FRACTION_BITS; /* Kind of silly to use
FRACTION_BITS here... */
if (*countptr >= (vp->sample->data_length>>FRACTION_BITS) - ofs)
{
/* Note finished. Free the voice. */
vp->status = VOICE_FREE;
ctl->note(v);
/* Let the caller know how much data we had left */
*countptr = (vp->sample->data_length>>FRACTION_BITS) - ofs;
}
else
vp->sample_offset += *countptr << FRACTION_BITS;
return vp->sample->data+ofs;
}
/* Need to resample. Use the proper function. */
modes=vp->sample->modes;
if (vp->vibrato_control_ratio)
{
if ((modes & MODES_LOOPING) &&
((modes & MODES_ENVELOPE) ||
(vp->status==VOICE_ON || vp->status==VOICE_SUSTAINED)))
{
if (modes & MODES_PINGPONG)
return rs_vib_bidir(vp, *countptr);
else
return rs_vib_loop(vp, *countptr);
}
else
return rs_vib_plain(v, countptr);
}
else
{
if ((modes & MODES_LOOPING) &&
((modes & MODES_ENVELOPE) ||
(vp->status==VOICE_ON || vp->status==VOICE_SUSTAINED)))
{
if (modes & MODES_PINGPONG)
return rs_bidir(vp, *countptr);
else
return rs_loop(vp, *countptr);
}
else
return rs_plain(v, countptr);
}
}
void pre_resample(Sample * sp)
{
double a, xdiff;
int32_t incr, ofs, newlen, count;
int16_t *newdata, *dest, *src = (int16_t *) sp->data;
int16_t v1, v2, v3, v4, *vptr;
static const char note_name[12][3] =
{
"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
};
ctl->cmsg(CMSG_INFO, VERB_NOISY, " * pre-resampling for note %d (%s%d)",
sp->note_to_use,
note_name[sp->note_to_use % 12], (sp->note_to_use & 0x7F) / 12);
a = ((double) (sp->sample_rate) * freq_table[(int) (sp->note_to_use)]) /
((double) (sp->root_freq) * play_mode->rate);
newlen = (int32_t)(sp->data_length / a);
dest = newdata = (int16_t*)safe_malloc(newlen >> (FRACTION_BITS - 1));
count = (newlen >> FRACTION_BITS) - 1;
ofs = incr = (sp->data_length - (1 << FRACTION_BITS)) / count;
if (--count)
*dest++ = src[0];
/* Since we're pre-processing and this doesn't have to be done in
real-time, we go ahead and do the full sliding cubic interpolation. */
while (--count)
{
vptr = src + (ofs >> FRACTION_BITS);
v1 = *(vptr - 1);
v2 = *vptr;
v3 = *(vptr + 1);
v4 = *(vptr + 2);
xdiff = FSCALENEG(ofs & FRACTION_MASK, FRACTION_BITS);
*dest++ = (int16_t)(v2 + (xdiff / 6.0) * (-2 * v1 - 3 * v2 + 6 * v3 - v4 +
xdiff * (3 * (v1 - 2 * v2 + v3) + xdiff * (-v1 + 3 * (v2 - v3) + v4))));
ofs += incr;
}
if (ofs & FRACTION_MASK)
{
v1 = src[ofs >> FRACTION_BITS];
v2 = src[(ofs >> FRACTION_BITS) + 1];
*dest++ = v1 + (((v2 - v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS);
}
else
*dest++ = src[ofs >> FRACTION_BITS];
sp->data_length = newlen;
sp->loop_start = (int32_t)(sp->loop_start / a);
sp->loop_end = (int32_t)(sp->loop_end / a);
Real_Tim_Free(sp->data);
sp->data = (sample_t *) newdata;
sp->sample_rate = 0;
}
| 20.584574 | 76 | 0.619445 | 1337programming |
e90ae0565c37d5f0e74b9139ce7411ccba6f1ba1 | 604 | cpp | C++ | C-C++/activitySelection(Greedy).cpp | psinha30/dataStructure-Algorithms | a5b097f9136cf458d8b95350a05ac19a99f3cbf3 | [
"MIT"
] | 1 | 2019-12-30T18:07:07.000Z | 2019-12-30T18:07:07.000Z | C-C++/activitySelection(Greedy).cpp | psinha30/dataStructure-Algorithms | a5b097f9136cf458d8b95350a05ac19a99f3cbf3 | [
"MIT"
] | null | null | null | C-C++/activitySelection(Greedy).cpp | psinha30/dataStructure-Algorithms | a5b097f9136cf458d8b95350a05ac19a99f3cbf3 | [
"MIT"
] | 1 | 2018-12-20T04:58:26.000Z | 2018-12-20T04:58:26.000Z | #include <bits/stdc++.h>
using namespace std;
int i, n;
struct activity
{
int s,f;
};
bool compare(activity a1, activity a2)
{
return (a1.f < a2.f);
}
void activity_greedy(activity a[], int m)
{
if(m >= n)
return;
if(a[m].s >= a[i].f)
{
if(i == 0)
cout << "{" << a[i].s << "," << a[i].f << "} ";
cout << "{" << a[m].s << "," << a[m].f << "} ";
i = m;
activity_greedy(a, m + 1);
}
else
activity_greedy(a, m + 1);
}
int main()
{
cin >> n;
activity a[n];
for(int i = 0; i < n; i++)
cin >> a[i].s >> a[i].f;
sort(a, a+n, compare);
activity_greedy(a, 0);
return 0;
} | 13.422222 | 50 | 0.488411 | psinha30 |
e90c56f98148e6359b1636cd2dd13aff6c42f4cd | 6,985 | cpp | C++ | Cursor.cpp | JermSmith/TDGame | 198599ef229eb6c852dabc7ea72f5537dd10ab5c | [
"MIT"
] | null | null | null | Cursor.cpp | JermSmith/TDGame | 198599ef229eb6c852dabc7ea72f5537dd10ab5c | [
"MIT"
] | null | null | null | Cursor.cpp | JermSmith/TDGame | 198599ef229eb6c852dabc7ea72f5537dd10ab5c | [
"MIT"
] | null | null | null | #include "Cursor.h"
#include "Util\Math.h"
Cursor::Cursor(const sf::RenderWindow& window) : Tower(window) {}
void Cursor::update(const sf::RenderWindow& window, const Path& path,
const std::vector<std::unique_ptr<Tower>>& towers, bool bTowerBeingPlaced)
{
if (bTowerBeingPlaced)
{
// place dummy tower at the current mouse position to check what color the cursor circle should be
m_position = sf::Vector2f(window.mapPixelToCoords(sf::Mouse::getPosition(window)));
if (!bInterferesWithScene(towers, path))
{
updatePositive(); //possible to place tower here
}
else
{
updateNegative(); //not possible to place tower here
}
}
else
{
hide(); //do not show a cursor, since no tower is being placed
}
}
void Cursor::render(sf::RenderTarget& renderer)
{
InteractableShape::render(renderer);
renderer.draw(m_rangeCircle);
}
bool Cursor::bInterferesWithScene(const std::vector<std::unique_ptr<Tower>>& towers, const Path& path)
{
// depends on tower properties m_position and m_size
float t_ = path.getWidth() / 2; // t_ is half width
std::vector<sf::Vector2f> corners = {}; // vector containing all points to check for potential collision
// the following assignment assumes m_position takes centre of circle (and that circle is aligned with axes, although doesn't matter for circles)
corners.push_back(m_position); // centre
int numOfPointsOnCircle = 16; // number of points on circle to check for possible collisions; power of 2 allows top and bottom of circle to be included
for (int angle = (-numOfPointsOnCircle / 2 + 1); angle <= numOfPointsOnCircle; angle++)
{
corners.push_back(sf::Vector2f(
m_position.x + cos(angle * PI * 2 / numOfPointsOnCircle) * getPrimaryDim(),
m_position.y + sin(angle * PI * 2 / numOfPointsOnCircle) * getPrimaryDim())); // e.g. for increments of PI/4, # of divisions is 8
}
/* could specify different "corners" for a square, diamond, etc. */
for (unsigned int i = 1; i < path.getVertices().size(); i++)
{
sf::Vector2f vo = path.getVertices().at(i - 1);
sf::Vector2f vi = path.getVertices().at(i);
float theta = atan2f(vi.y - vo.y, vi.x - vo.x); // angle of path segment in radians (CW is +ve from +ve x-axis)
// ol is back left corner of the rectangle, ir is front right corner of the rectangle
sf::Vector2f ol = sf::Vector2f(vo.x - t_*cos(theta) + t_*sin(theta), vo.y - t_*cos(theta) - t_*sin(theta));
sf::Vector2f or = sf::Vector2f(vo.x - t_*cos(theta) - t_*sin(theta), vo.y + t_*cos(theta) - t_*sin(theta));
sf::Vector2f il = sf::Vector2f(vi.x + t_*cos(theta) + t_*sin(theta), vi.y - t_*cos(theta) + t_*sin(theta));
sf::Vector2f ir = sf::Vector2f(vi.x + t_*cos(theta) - t_*sin(theta), vi.y + t_*cos(theta) + t_*sin(theta));
float m_; // slope of path segment ("down-right" is positive, "up-right" is negative)
for (sf::Vector2f& corner : corners)
{
// check vertex interference
if (i != path.getVertices().size() - 1) // NOT last vertex
{
if (distanceBetweenPoints(corner, vo) <= path.getVertexWidth() / sqrtf(2))
{
return true; // a "corner" interferes with a vertex
}
}
else //
{
if (distanceBetweenPoints(corner, vo) <= path.getVertexWidth() / sqrtf(2))
{
return true; // a "corner" interferes with second-last vertex
}
if (distanceBetweenPoints(corner, vi) <= path.getVertexWidth() / sqrtf(2))
{
return true; // a "corner" interferes with last vertex
}
}
// check straight section interference
if (theta == 0 || theta == PI || theta == -PI)
{
if (cos(theta) * corner.y >= cos(theta) * ol.y &&
cos(theta) * corner.y <= cos(theta) * ir.y &&
cos(theta) * corner.x >= cos(theta) * ol.x &&
cos(theta) * corner.x <= cos(theta) * ir.x)
{
return true; // a "corner" is inside the path space
}
}
else if (theta == PI / 2 || theta == -PI / 2)
{
if (sin(theta) * corner.y >= sin(theta) * ol.y &&
sin(theta) * corner.y <= sin(theta) * ir.y &&
sin(theta) * corner.x <= sin(theta) * ol.x &&
sin(theta) * corner.x >= sin(theta) * ir.x)
{
return true; // a "corner" is inside the path space
}
}
else // theta != 0, pi/2, pi, -pi/2, -pi
{
m_ = (vi.y - vo.y) / (vi.x - vo.x); // slope of path segment
if (cos(theta) * (corner.y - m_*corner.x) > cos(theta) * (ol.y - m_*ol.x) &&
cos(theta) * (corner.y - m_*corner.x) < cos(theta) * (ir.y - m_*ir.x) &&
sin(theta) * (corner.y + (1 / m_)*corner.x) > sin(theta) * (ol.y + (1 / m_)*ol.x) &&
sin(theta) * (corner.y + (1 / m_)*corner.x) < sin(theta) * (ir.y + (1 / m_)*ir.x))
{
return true; // a "corner" is inside the path space
}
}
}
}
// above here is checking for interference between newObj and path
// below here is checking for interference between newObj and other objects, assuming all objects are circles (size.x = size.y for circles)
for (unsigned int i = 0; i < towers.size(); i++)
{
if (distanceBetweenPoints(m_position, towers.at(i)->getPosition()) <
(getPrimaryDim() + towers.at(i)->getRadius()))
{
return true;
}
}
// below here is checking for interference with menu
if (m_position.x > sizes::WORLD_SIZE_X - (sizes::PLAYINGMENU_X + getPrimaryDim()) || // menu width + 1/2 tower radius
(m_position.x < getPrimaryDim()) ||
m_position.y < getPrimaryDim() ||
m_position.y > sizes::WORLD_SIZE_Y - getPrimaryDim())
{
return true;
}
return false;
}
// private methods below this line
void Cursor::hide()
{
InteractableShape::setFillColour(sf::Color::Transparent);
InteractableShape::setOutlineThickness(0);
m_rangeCircle.setRadius(0);
}
void Cursor::updatePositive()
{
InteractableShape::setOutlineThickness(-2);
InteractableShape::setOutlineColour(sf::Color::Cyan);
InteractableShape::setPosition(m_position);
m_rangeCircle.setRadius(m_range);
m_rangeCircle.setFillColor(sf::Color(255, 255, 255, 63));
m_rangeCircle.setOutlineThickness(-2);
m_rangeCircle.setOutlineColor(sf::Color::Green);
m_rangeCircle.setPosition(m_position);
}
void Cursor::updateNegative()
{
InteractableShape::setFillColour(sf::Color::Transparent);
InteractableShape::setOutlineThickness(-2);
InteractableShape::setOutlineColour(sf::Color::Red);
InteractableShape::setPosition(m_position);
m_rangeCircle.setOutlineColor(sf::Color::Transparent);
m_rangeCircle.setFillColor(sf::Color::Transparent);
}
void Cursor::generateWidgets(const sf::RenderWindow& window)
{
bnrCursorNote.setText("Click to place tower");
}
void Cursor::populateHoverMenu()
{
m_hoverMenu.addWidget(bnrCursorNote);
m_hoverMenu.showOutline();
}
void Cursor::populateUpgradeMenu()
{
}
void Cursor::hideHoverMenu()
{
m_hoverMenu.clearWidgets();
m_hoverMenu.hideOutline();
}
| 32.041284 | 153 | 0.644094 | JermSmith |
e90ddfc73a37d14850a6693e7f8f62f8cecc169b | 9,227 | cpp | C++ | lib/ofsocket.cpp | timmyw/ofsystem | 6f955d53dc3025148763333bea0a11d0bce28c06 | [
"MIT"
] | null | null | null | lib/ofsocket.cpp | timmyw/ofsystem | 6f955d53dc3025148763333bea0a11d0bce28c06 | [
"MIT"
] | null | null | null | lib/ofsocket.cpp | timmyw/ofsystem | 6f955d53dc3025148763333bea0a11d0bce28c06 | [
"MIT"
] | null | null | null | /*
Copyright (C) 1997-2011 by Suntail.com AS, Tim Whelan
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation files
(the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <ofsys.h>
#include <ofsocket.h>
#include <ofutility.h>
#include <oflogservice.h>
#include <ofplatform.h>
#if defined(OFOPSYS_WIN32)
typedef LINGER OFLINGER;
#else
typedef struct linger OFLINGER;
#if defined(OFOPSYS_LINUX)
#include <netinet/tcp.h>
#endif
#endif
OFSocket::OFSocket( ) :
m_addr( 0 ),
m_open( false )
{
m_socket = socket( AF_INET, SOCK_STREAM, 0 );
set_options_();
}
OFSocket::OFSocket( const OFAddress &remote ) :
m_addr( remote ),
m_open( false )
{
m_socket = socket( AF_INET, SOCK_STREAM, 0 );
set_options_();
}
OFSocket::OFSocket( OFOS::of_socket_t socketHandle ) :
m_addr( 0 ),
m_open( true )
{
m_socket = socketHandle;
set_options_();
}
OFSocket::~OFSocket( )
{
closeSocket( );
}
ofint32
OFSocket::connect( const OFAddress &remote )
{
m_addr = remote;
if ( m_socket == -1 )
return ERR_INVAL_SOCKET;
sockaddr *addr = (sockaddr*)m_addr.address();
ofint32 retv = ::connect( m_socket, addr, sizeof(sockaddr) );
if ( retv == -1 )
return OFUtility::translateLastSystemError( );
m_open = true;
#if defined(OFOPSYS_WIN32)
oflong param = 1;
if (ioctlsocket(m_socket, FIONBIO, ¶m) == SOCKET_ERROR)
#else
ofuint32 param = fcntl(m_socket, F_GETFL);
if (fcntl(m_socket, F_SETFL, param | O_NONBLOCK))
#endif
OFLogService::debugLine("Error setting NBIO: %s",
retrieveMsg(OFUtility::translateLastSystemError()));
return ERR_SUCCESS;
}
ofint32
OFSocket::listen( )
{
ofint32 ret = 0;
ofint32 temp = 1;
ret = setsockopt( m_socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char *>(&temp), sizeof(temp) );
if ( ret == -1 )
return ret;
ret = bind( m_socket, (struct sockaddr *)m_addr.address(), sizeof(*m_addr.address()) );
if ( !ret )
ret = ::listen( m_socket, 5 );
return ret;
}
void
OFSocket::closeSocket( )
{
// cout << "OFSocket::closeSocket" << endl;
if ( m_open )
{
m_open = false;
shutdown( m_socket, 2 );
#if defined(OFOPSYS_WIN32)
closesocket( m_socket );
#else
close( m_socket );
#endif
}
else
{
#if defined(OFOPSYS_WIN32)
if ( m_socket != OFOS::OF_INVALID_SOCKET )
{
shutdown( m_socket, 2 );
closesocket( m_socket );
}
#else
if (m_socket != OFOS::OF_INVALID_SOCKET)
{
shutdown( m_socket, 2 );
close( m_socket );
}
#endif
}
m_socket = OFOS::OF_INVALID_SOCKET;
}
ofint32
OFSocket::send( void *buffer,
ofuint32 bufferLength,
bool *terminate /* = NULL */,
ofuint32 chunkSize /* = 2048 */,
ofuint32 timeOut /* = 30 */ )
{
ofint32 leftToSend = bufferLength;
char *tempBuf = static_cast<char*>(buffer);
ofint32 cursent = 0;
time_t timenow;
time_t timestart;
time( ×tart );
struct timeval tv;
fd_set fdwrite;
for(;;)
{
ofint32 rc = 0;
FD_ZERO( &fdwrite );
FD_SET( m_socket, &fdwrite );
tv.tv_sec = 1;
tv.tv_usec = 0;
rc = select( m_socket+1, 0, &fdwrite, 0, &tv );
if ( terminate != 0 && *terminate ) return 1;
if ( rc > 0 && FD_ISSET( m_socket, &fdwrite ) )
{
time( ×tart );
ofint32 chunkToSend = (leftToSend < (ofint32)chunkSize)
?leftToSend:chunkSize;
cursent = ::send( m_socket, tempBuf, chunkToSend, 0 );
if ( terminate != 0 && *terminate ) return 1;
if ( cursent < 0 ) return -1;
leftToSend -= cursent;
tempBuf += cursent;
if ( leftToSend <= 0 )
return 0;
}
time( &timenow );
if ( (ofuint32)timenow > timestart + timeOut ) break;
}
return 1;
}
ofint32
OFSocket::recv( void *buffer,
ofuint32 bufferLength,
ofuint32 &bytesReceived,
bool *terminate /* = NULL */,
ofuint32 chunkSize /* = 2048 */,
ofuint32 timeOut /* = 30 */ )
{
bytesReceived = 0;
time_t timenow;
time_t timestart;
time( ×tart );
struct timeval tv;
fd_set fdread;
for(;;)
{
ofint32 rc = 0;
FD_ZERO( &fdread );
FD_SET( m_socket, &fdread );
tv.tv_sec = 1;
tv.tv_usec = 0;
rc = select( m_socket+1, &fdread, 0, 0, &tv );
if ( terminate != 0 && *terminate ) return 1;
if ( rc > 0 && FD_ISSET( m_socket, &fdread ) ) break;
time( &timenow );
if ( (ofuint32)timenow > timestart + timeOut ) return 1;
}
ofint32 chunkToRead = (bufferLength < (ofuint32)chunkSize)
?bufferLength:chunkSize;
ofint32 curRecv = ::recv( m_socket, static_cast<char *>(buffer),
chunkToRead, 0 );
#if defined(VERBOSE_NETWORK)
cout << "Socket:" << m_socket
<< " received " << curRecv
<< " bytes" << endl;
#endif
if ( terminate != 0 && *terminate ) return 1;
if (curRecv < 0)
{
#if defined(VERBOSE_NETWORK)
cout << "Socket:" << m_socket
<< " received -1" << endl;
return -1;
#endif
}
if ( curRecv > 0 )
{
bytesReceived = curRecv;
return 0;
}
return -1;
}
void
OFSocket::startup( )
{
#if defined(OFOPSYS_WIN32)
WSADATA data;
WSAStartup( MAKEWORD(2,0), &data );
#endif
}
void
OFSocket::closedown()
{
#if defined(OFOPSYS_WIN32)
WSACleanup();
#endif
}
ofuint32 OFSocket::getnamefromaddr(char* peerName,
ofuint32 peerNameLen,
struct in_addr* addr,
ofuint32 addrLen,
char useDNS /*=0*/)
{
const char* pn = "unknown";
if (!useDNS)
{
pn = inet_ntoa(*addr);
}
else
{
#if defined(OFOPSYS_WIN32)
struct hostent* he = gethostbyaddr((char*)addr, addrLen, AF_INET);
#else
struct hostent* he = gethostbyaddr(addr, addrLen, AF_INET);
#endif
if (he && he->h_name)
pn = he->h_name;
}
OFOS::strncpy2(peerName, pn, peerNameLen);
return 0;
}
ofuint32 OFSocket::getpeername(char* peerName,
ofuint32 peerNameLen,
char useDNS /*= 0*/)
{
struct sockaddr_in pa;
OFOS::of_socklen_t sl = sizeof(pa);
int r = ::getpeername(m_socket, (sockaddr*)&pa, &sl);
if (r != -1)
{
OFSocket::getnamefromaddr(peerName, peerNameLen,
&pa.sin_addr, sizeof(pa.sin_addr),
useDNS);
}
return r==0?ERR_SUCCESS:OFUtility::translateSystemError(r);
}
/* static */
void
OFSocket::getHostName( char *host, ofuint32 length )
{
RESETSTRING( host );
char x[1024];
gethostname( x, 1024 );
struct hostent *he = gethostbyname( x );
if ( he )
{
OFOS::strncpy2( host, he->h_name, length );
}
}
/* static */
ofuint32
OFSocket::getLocalIP( )
{
char name[1025];
gethostname( name, 1024 );
return OFPlatform::getHostIP(name);
}
void
OFSocket::set_options_()
{
#if defined(OFOPSYS_LINUX) || defined(OFOPSYS_WIN32)
ofuint32 f = 1;
setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, (char *)&f, sizeof(f));
setsockopt(m_socket, SOL_SOCKET, SO_KEEPALIVE, (char*)&f, sizeof(f));
f = OF_SOCK_SEND_BUFSIZE;
setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (char*)&f, sizeof(f));
f = OF_SOCK_RECV_BUFSIZE;
setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (char*)&f, sizeof(f));
struct timeval tv;
memset(&tv, 0, sizeof(tv));
tv.tv_sec = 180;
setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(tv));
setsockopt(m_socket, SOL_SOCKET, SO_SNDTIMEO, (char*)&tv, sizeof(tv));
#endif
}
#if defined(UNIT_TEST)
#include "UnitTest.h"
int
main( ofint32 argc, char *argv[] )
{
UT_BATCH_START( "OFSocket class unit test" );
UT_TEST_START( 1, "OFSocket::getLocalIP" );
ofuint32 la = OFSocket::getLocalIP();
printf("local address: %08lx", la);
UT_BATCH_END;
return 0;
}
#endif // #if defined(UNIT_TEST)
| 24.671123 | 112 | 0.60117 | timmyw |
e90fd826c539b8636606798846eaecad36402fdb | 529 | cpp | C++ | Synthesizer/MainScreen.cpp | 161563/Sylph-Synthesizer | 548e62f1353f254af874d2d06fd6216b808edfd6 | [
"MIT"
] | null | null | null | Synthesizer/MainScreen.cpp | 161563/Sylph-Synthesizer | 548e62f1353f254af874d2d06fd6216b808edfd6 | [
"MIT"
] | null | null | null | Synthesizer/MainScreen.cpp | 161563/Sylph-Synthesizer | 548e62f1353f254af874d2d06fd6216b808edfd6 | [
"MIT"
] | null | null | null | #include "MainScreen.h"
#include "Song.h"
#include "Music.h"
#include <string>
using namespace System;
using namespace System::Windows::Forms;
[STAThread]
void main(array<String^>^ args) {
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false);
for (int i = 0; i < args->Length; i++) {
//MessageBox::Show(args[i]);
}
Synthesizer::MainScreen screen;
if (args->Length == 1) {
screen.setSong(new Song(args[0]));
}
else {
screen.setSong(new Song());
}
Application::Run(%screen);
} | 21.16 | 55 | 0.691871 | 161563 |
e9176cffaec1e7d5f5a498abdb09a3fe2ae6dc3c | 1,072 | cpp | C++ | WirelessThermometer/TimerSwitchWithServo/ServoMotion.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | 1 | 2019-11-07T22:44:27.000Z | 2019-11-07T22:44:27.000Z | WirelessThermometer/TimerSwitchWithServo/ServoMotion.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | null | null | null | WirelessThermometer/TimerSwitchWithServo/ServoMotion.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | null | null | null | #include "ServoMotion.h"
#include "DataStore.h"
#define START_DELAY 200
#define RUNNING_HOLD_PERIOD 1000
enum ServoMotionState_t {
SS_OFF,
SS_JUST_ON,
SS_RUNNING,
};
static void s_powerOff(uint8_t powerPin) {
digitalWrite(powerPin, LOW);
}
static void s_powerOn(uint8_t powerPin) {
digitalWrite(powerPin, HIGH);
}
void ServoMotion::setup() {
pinMode(this->powerPin, OUTPUT);
s_powerOff(this->powerPin);
this->servo.attach(this->controlPin);
}
void ServoMotion::loop() {
switch (this->state) {
case SS_OFF:
if (ds.getCurrentServoValueReadyToSend()) {
this->servo.write(ds.getCurrentServoValue());
ds.clearCurrentServoValueReadyToSend();
this->state = SS_JUST_ON;
this->lastMillis = millis();
}
break;
case SS_JUST_ON:
if (millis() - this->lastMillis > START_DELAY) {
s_powerOn(this->powerPin);
this->state = SS_RUNNING;
this->lastMillis = millis();
}
break;
case SS_RUNNING:
if (millis() - this->lastMillis > RUNNING_HOLD_PERIOD) {
s_powerOff(this->powerPin);
this->state = SS_OFF;
}
break;
}
}
| 19.490909 | 58 | 0.697761 | anders-liu |
e917d0a96f269a8a0fb6cc14e7c1320b3cf3a3f7 | 700 | hpp | C++ | android-29/android/media/MediaRecorder_AudioEncoder.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/media/MediaRecorder_AudioEncoder.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-30/android/media/MediaRecorder_AudioEncoder.hpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #pragma once
#include "../../JObject.hpp"
namespace android::media
{
class MediaRecorder;
}
namespace android::media
{
class MediaRecorder_AudioEncoder : public JObject
{
public:
// Fields
static jint AAC();
static jint AAC_ELD();
static jint AMR_NB();
static jint AMR_WB();
static jint DEFAULT();
static jint HE_AAC();
static jint OPUS();
static jint VORBIS();
// QJniObject forward
template<typename ...Ts> explicit MediaRecorder_AudioEncoder(const char *className, const char *sig, Ts...agv) : JObject(className, sig, std::forward<Ts>(agv)...) {}
MediaRecorder_AudioEncoder(QJniObject obj);
// Constructors
// Methods
};
} // namespace android::media
| 20 | 167 | 0.692857 | YJBeetle |
e91a18927dc83eb1469e3ebc933d4917f5b0214b | 944 | cc | C++ | jax/training/21-09/29/b_precessing_queries.cc | JaxVanYang/acm | ee41f1cbf692b7b1463a9467401bb6e7d38aecce | [
"MIT"
] | 2 | 2022-01-01T16:55:02.000Z | 2022-03-16T14:47:29.000Z | jax/training/21-09/29/b_precessing_queries.cc | JaxVanYang/acm | ee41f1cbf692b7b1463a9467401bb6e7d38aecce | [
"MIT"
] | null | null | null | jax/training/21-09/29/b_precessing_queries.cc | JaxVanYang/acm | ee41f1cbf692b7b1463a9467401bb6e7d38aecce | [
"MIT"
] | null | null | null | #include <iostream>
#include <queue>
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
ll ans[N];
struct Node {
int t, d, id;
};
int main() {
int n, b;
scanf("%d%d", &n, &b);
ll ed = 0;
queue<Node> q;
for (int i = 0; i < n; ++i) {
int t, d;
scanf("%d%d", &t, &d);
if (q.size() == b + 1) {
ll lmt = max(ed, (ll)q.front().t) + q.front().d;
if (lmt > t) {
ans[i] = -1;
} else {
ans[q.front().id] = lmt;
q.pop();
ed = lmt;
q.push({t, d, i});
}
} else {
q.push({t, d, i});
}
}
while (q.size()) {
ed = max(ed, (ll)q.front().t) + q.front().d;
ans[q.front().id] = ed;
q.pop();
}
for (int i = 0; i < n; ++i) {
printf("%lld ", ans[i]);
}
puts("");
} | 17.811321 | 60 | 0.347458 | JaxVanYang |
e91ac1f5e22f7be38a8ace97a06691abd2c9b452 | 27,860 | cpp | C++ | libqd/qd.cpp | philippeb8/fcalc | b62a78e02b56dc4319e06d8eb36bb3d6fdafd256 | [
"MIT"
] | 2 | 2020-10-24T01:15:51.000Z | 2020-10-25T04:07:30.000Z | libqd/qd.cpp | philippeb8/fcalc | b62a78e02b56dc4319e06d8eb36bb3d6fdafd256 | [
"MIT"
] | null | null | null | libqd/qd.cpp | philippeb8/fcalc | b62a78e02b56dc4319e06d8eb36bb3d6fdafd256 | [
"MIT"
] | null | null | null | /*
* src/qd.cc
*
* This work was supported by the Director, Office of Science, Division
* of Mathematical, Information, and Computational Sciences of the
* U.S. Department of Energy under contract number DE-AC03-76SF00098.
*
* Copyright (c) 2000-2001
*
* Contains implementation of non-inlined functions of quad-double
* package. Inlined functions are found in qd_inline.h (in include directory).
*/
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <iostream>
//#include "config.h"
//#include "bits.h"
#include "qd.h"
#ifndef QD_INLINE
#include "qd_inline.h"
#endif
#ifdef _MSC_VER
#define STD_RAND ::rand
#else
#define STD_RAND std::rand
#endif
using std::cout;
using std::cerr;
using std::endl;
using std::istream;
using std::ostream;
using std::ios_base;
using namespace qd;
static const char *digits = "0123456789*";
void qd_real::abort() {
exit(-1);
}
/********** Multiplications **********/
qd_real nint(const qd_real &a) {
real x0, x1, x2, x3;
x0 = nint(a[0]);
x1 = x2 = x3 = real(0.0);
if (x0 == a[0]) {
/* First real is already an integer. */
x1 = nint(a[1]);
if (x1 == a[1]) {
/* Second real is already an integer. */
x2 = nint(a[2]);
if (x2 == a[2]) {
/* Third real is already an integer. */
x3 = nint(a[3]);
} else {
if (fabsl(x2 - a[2]) == real(0.5) && a[3] < real(0.0)) {
x2 -= real(1.0);
}
}
} else {
if (fabsl(x1 - a[1]) == real(0.5) && a[2] < real(0.0)) {
x1 -= real(1.0);
}
}
} else {
/* First real is not an integer. */
if (fabsl(x0 - a[0]) == real(0.5) && a[1] < real(0.0)) {
x0 -= real(1.0);
}
}
renorm(x0, x1, x2, x3);
return qd_real(x0, x1, x2, x3);
}
qd_real floor(const qd_real &a) {
real x0, x1, x2, x3;
x1 = x2 = x3 = real(0.0);
x0 = floorl(a[0]);
if (x0 == a[0]) {
x1 = floorl(a[1]);
if (x1 == a[1]) {
x2 = floorl(a[2]);
if (x2 == a[2]) {
x3 = floorl(a[3]);
}
}
renorm(x0, x1, x2, x3);
return qd_real(x0, x1, x2, x3);
}
return qd_real(x0, x1, x2, x3);
}
qd_real ceil(const qd_real &a) {
real x0, x1, x2, x3;
x1 = x2 = x3 = real(0.0);
x0 = ceill(a[0]);
if (x0 == a[0]) {
x1 = ceill(a[1]);
if (x1 == a[1]) {
x2 = ceill(a[2]);
if (x2 == a[2]) {
x3 = ceill(a[3]);
}
}
renorm(x0, x1, x2, x3);
return qd_real(x0, x1, x2, x3);
}
return qd_real(x0, x1, x2, x3);
}
/********** Divisions **********/
/* quad-real / real */
qd_real operator/(const qd_real &a, real b) {
/* Strategy: compute approximate quotient using high order
reals, and then correct it 3 times using the remainder.
(Analogous to long division.) */
real t0, t1;
real q0, q1, q2, q3;
qd_real r;
q0 = a[0] / b; /* approximate quotient */
/* Compute the remainder a - q0 * b */
t0 = two_prod(q0, b, t1);
r = a - dd_real(t0, t1);
/* Compute the first correction */
q1 = r[0] / b;
t0 = two_prod(q1, b, t1);
r -= dd_real(t0, t1);
/* Second correction to the quotient. */
q2 = r[0] / b;
t0 = two_prod(q2, b, t1);
r -= dd_real(t0, t1);
/* Final correction to the quotient. */
q3 = r[0] / b;
renorm(q0, q1, q2, q3);
return qd_real(q0, q1, q2, q3);
}
/*
qd_real::qd_real(const char *s) {
int r = qd_real::read(s, *this);
if (r != 0) {
qd_real::abort();
cerr << "ERROR (qd_real::qd_real): INPUT ERROR." << endl;
}
}
*/
istream &operator>>(istream &s, qd_real &qd) {
char str[255];
s >> str;
qd.read(str, qd);
return s;
}
ostream &operator<<(ostream &s, const qd_real &qd) {
char str[255];
qd.write(str, s.precision(), s.flags());
return s << str;
}
/* Read a quad-real from s. */
int qd_real::read(const char *s, qd_real &qd) {
const char *p = s;
char ch;
int sign = 0;
int point = -1; /* location of decimal point */
int nd = 0; /* number of digits read */
int e = 0; /* exponent. */
bool done = false;
qd_real r = real(0.0); /* number being read */
/* Skip any leading spaces */
while (*p == ' ') p++;
while (!done && (ch = *p) != '\0') {
if (ch >= '0' && ch <= '9') {
/* It's a digit */
int d = ch - '0';
r *= real(10.0);
r += (real) d;
nd++;
} else {
/* Non-digit */
switch (ch) {
case '.':
if (point >= 0)
return -1; /* we've already encountered a decimal point. */
point = nd;
break;
case '-':
case '+':
if (sign != 0 || nd > 0)
return -1; /* we've already encountered a sign, or if its
not at first position. */
sign = (ch == '-') ? -1 : 1;
break;
case 'E':
case 'e':
int nread;
nread = sscanf(p+1, "%d", &e);
done = true;
if (nread != 1)
return -1; /* read of exponent failed. */
break;
case ' ':
done = true;
break;
default:
return -1;
}
}
p++;
}
/* Adjust exponent to account for decimal point */
if (point >= 0) {
e -= (nd - point);
}
/* Multiply the the exponent */
if (e != 0) {
r *= (qd_real(10.0) ^ e);
}
qd = (sign < 0) ? -r : r;
return 0;
}
/* Converts a quad-real to a string.
d is the number of (decimal) significant digits.
The string s must be able to hold d+8 characters. */
void qd_real::write(char *s, int d, ios_base::fmtflags l) const {
qd_real r = fabs(*this);
qd_real p;
int e; /* exponent */
int i = 0, j = 0;
/* First determine the (approximate) exponent. */
e = (int) floorl(log10l(fabsl(x[0])));
/* Find dimensions. */
bool m = (l & qd_real::showmagnitude), n = (l & std::ios_base::showpoint), is = (l & qd_real::imperialsystem);
int D = (n ? d : e + (d < 1 ? d : 1)) + 1;
if (x[0] == real(0.0))
{
/* this == real(0.0) */
s[i ++] = digits[0];
if (n)
{
s[i ++] = '.';
}
s[i ++] = '\0';
return;
}
/* Test for infinity and nan. */
if (isinf())
{
sprintf(s, "NAN");
return;
}
if (isnan())
{
sprintf(s, "NAN");
return;
}
/* Digits */
int *a = new int[D];
if (e < -4000)
{
r *= qd_real(10.0) ^ 4000;
p = qd_real(10.0) ^ (e + 4000);
r /= p;
}
else
{
p = qd_real(10.0) ^ e;
r /= p;
}
/* Fix exponent if we are off by one */
if ((real const &)(r) >= real(10.0))
{
r /= real(10.0);
e++;
}
else if ((real const &)(r) < real(1.0))
{
r *= real(10.0);
e--;
}
if ((real const &)(r) >= real(10.0) || (real const &)(r) < real(1.0))
{
//cerr << "ERROR (qd_real::to_str): can't compute exponent." << endl;
delete [] a;
//qd_real::abort();
return;
}
/* Extract the digits */
for (i = 0; i < D; i++)
{
a[i] = (int) r[0];
r -= (real) a[i];
r *= real(10.0);
}
/* Fix negative digits. */
for (i = D-1; i > 0; i--)
{
if (a[i] < 0)
{
a[i-1]--;
a[i] += 10;
}
}
if (a[0] <= 0)
{
//cerr << "ERROR (qd_real::to_str): non-positive leading digit." << endl;
delete [] a;
//qd_real::abort();
return;
}
/* Round, handle carry */
if (a[D - 1] >= 5)
{
a[D - 2] ++;
int i = D - 2;
while (i > 0 && a[i] >= 10)
{
a[i] -= 10;
a[-- i] ++;
}
if (a[0] == 10)
{
++ e;
a[0] = 1;
}
}
/* Start fill in the string. */
if (x[0] < real(0.0))
{
s[i ++] = '-';
}
bool scientific = (l & std::ios_base::scientific) || ! (e > -4 && e < D - 1);
long f = scientific ? 0 : e, t = (f > 0 ? f : 0);
if (! m)
{
// C/C++ notation
for (; j < D - 1; -- f, ++ j)
{
if (a[j] != 0)
{
// Feed in leading zeros (0.0001...; 1.000...01)
for (; t != f; -- t)
{
s[i ++] = digits[0];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
}
s[i ++] = digits[a[j]];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
-- t;
}
}
// Dangling zeros (10000...)
for (; t >= 0; -- t)
{
s[i ++] = digits[0];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
}
}
else if (! is)
{
// Metric notation
for (bool first = true; j < D - 1; first = false, -- f, ++ j)
{
if (a[j] != 0)
{
// Feed in leading zeros (0.0001...; 1.000...01)
for (; t != f; -- t)
{
if ((t + 1) % 3 == 0)
if (t == -1 && (scientific || n))
s[i ++] = ',';
else if (! first)
s[i ++] = ' ';
s[i ++] = digits[0];
}
if ((t + 1) % 3 == 0)
if (t == -1 && (scientific || n))
s[i ++] = ',';
else if (! first)
s[i ++] = ' ';
s[i ++] = digits[a[j]];
-- t;
}
}
// Dangling zeros (10000...)
for (bool first = true; t >= 0; first = false, -- t)
{
if ((t + 1) % 3 == 0)
if (t == -1 && (scientific || n))
s[i ++] = ',';
else if (! first)
s[i ++] = ' ';
s[i ++] = digits[0];
}
}
else
{
// Imperial notation
for (; j < D - 1; -- f, ++ j)
{
if (a[j] != 0)
{
// Feed in leading zeros (0.0001...; 1.000...01)
for (; t != f; -- t)
{
s[i ++] = digits[0];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
else if (t > 0)
s[i ++] = ',';
}
s[i ++] = digits[a[j]];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
else if (t > 0)
s[i ++] = ',';
-- t;
}
}
// Dangling zeros (10000...)
for (; t >= 0; -- t)
{
s[i ++] = digits[0];
if (t % 3 == 0)
if (t == 0 && (scientific || n))
s[i ++] = '.';
else if (t > 0)
s[i ++] = ',';
}
}
if (! scientific)
{
s[i ++] = '\0';
}
else
{
s[i ++] = 'e';
sprintf(&s[i], "%d", e);
}
delete [] a;
}
/* Computes qd^n, where n is an integer. */
qd_real npwr(const qd_real &a, int n) {
if (n == 0)
return real(1.0);
qd_real r = a; /* odd-case multiplier */
qd_real s = real(1.0); /* current answer */
int N = abs(n);
if (N > 1) {
/* Use binary exponentiation. */
while (N > 0) {
if (N % 2 == 1) {
/* If odd, multiply by r. Note eventually N = 1, so this
eventually executes. */
s *= r;
}
N /= 2;
if (N > 0)
r = sqr(r);
}
} else {
s = r;
}
if (n < 0)
return (real(1.0) / s);
return s;
}
/* Computes real-real ^ real-real. */
qd_real pow(const qd_real &a, const qd_real &n) {
if (n == floor(n))
{
return npwr(a, n);
}
return exp(n * log(a));
}
#ifdef QD_DEBUG
/* Debugging routines */
void qd_real::dump_bits() const {
cout << "[ ";
print_real_info(x[0]);
cout << endl << " ";
print_real_info(x[1]);
cout << endl << " ";
print_real_info(x[2]);
cout << endl << " ";
print_real_info(x[3]);
cout << " ]" << endl;
}
void qd_real::dump_components() const {
printf("[ %.18e %.18e %.18e %.18e ]\n", x[0], x[1], x[2], x[3]);
}
void qd_real::dump() const {
cout << "[ ";
printf(" %25.19e ", x[0]);
print_real_info(x[0]);
cout << endl << " ";
printf(" %25.19e ", x[1]);
print_real_info(x[1]);
cout << endl << " ";
printf(" %25.19e ", x[2]);
print_real_info(x[2]);
cout << endl << " ";
printf(" %25.19e ", x[3]);
print_real_info(x[3]);
cout << " ]" << endl;
}
#endif
/* Divisions */
/* quad-real / real-real */
qd_real operator/ (const qd_real &a, const dd_real &b) {
real q0, q1, q2, q3;
qd_real r;
q0 = a[0] / b._hi();
r = a - q0 * b;
q1 = r[0] / b._hi();
r -= (q1 * b);
q2 = r[0] / b._hi();
r -= (q2 * b);
q3 = r[0] / b._hi();
#ifdef QD_SLOPPY_DIV
renorm(q0, q1, q2, q3);
#else
r -= (q3 * b);
real q4 = r[0] / b._hi();
renorm(q0, q1, q2, q3, q4);
#endif
return qd_real(q0, q1, q2, q3);
}
/* quad-real / quad-real */
qd_real operator/(const qd_real &a, const qd_real &b) {
real q0, q1, q2, q3;
qd_real r;
q0 = a[0] / b[0];
r = a - (b * q0);
q1 = r[0] / b[0];
r -= (b * q1);
q2 = r[0] / b[0];
r -= (b * q2);
q3 = r[0] / b[0];
#ifdef QD_SLOPPY_DIV
renorm(q0, q1, q2, q3);
#else
r -= (b * q3);
real q4 = r[0] / b[0];
renorm(q0, q1, q2, q3, q4);
#endif
return qd_real(q0, q1, q2, q3);
}
qd_real sqrt(const qd_real &a) {
/* Strategy:
Perform the following Newton iteration:
x' = x + (1 - a * x^2) * x / 2;
which converges to 1/sqrt(a), starting with the
real precision approximation to 1/sqrt(a).
Since Newton's iteration more or less reals the
number of correct digits, we only need to perform it
twice.
*/
if (a == real(0.0)) {
return qd_real(0.0);
}
qd_real r = (real(1.0) / sqrtl(a[0]));
qd_real h = a * real(0.5);
r += ((real(0.5) - h * sqr(r)) * r);
r += ((real(0.5) - h * sqr(r)) * r);
r += ((real(0.5) - h * sqr(r)) * r);
r *= a;
return r;
}
/* Computes the n-th root of a */
qd_real nroot(const qd_real &a, int n) {
/* Strategy: Use Newton's iteration to solve
1/(x^n) - a = 0
Newton iteration becomes
x' = x + x * (1 - a * x^n) / n
Since Newton's iteration converges quadratically,
we only need to perform it twice.
*/
if (a == real(0.0)) {
return qd_real(0.0);
}
qd_real r = powl(a[0], -real(1.0)/n);
r += r * (real(1.0) - a * (r ^ n)) / (real) n;
r += r * (real(1.0) - a * (r ^ n)) / (real) n;
r += r * (real(1.0) - a * (r ^ n)) / (real) n;
return real(1.0) / r;
}
qd_real exp(const qd_real &a) {
/* Strategy: We first reduce the size of x by noting that
exp(kr + m) = exp(m) * exp(r)^k
Thus by choosing m to be a multiple of log(2) closest
to x, we can make |kr| <= log(2) / 2 = 0.3466. Now
we can set k = 256, so that |r| <= 0.00136. Then
exp(x) = exp(kr + s log 2) = (2^s) * [exp(r)]^256
Then exp(r) is evaluated using the familiar Taylor series.
Reducing the argument substantially speeds up the convergence.
*/
const int k = 256;
if (a[0] <= real(-11335.0))
return real(0.0);
if (a[0] >= real(11335.0)) {
//cerr << "ERROR (qd_real::exp): Argument too large." << endl;
//qd_real::abort();
return qd_real::_inf;
}
if (a.is_zero()) {
return real(1.0);
}
if (a.is_one()) {
return qd_real::_e;
}
const int z = (int) nint(a / qd_real::_log2)[0];
qd_real r = (a - qd_real::_log2 * (real) z) / (real) k;
qd_real s, p;
real m;
real thresh = qd_real::_eps;
p = sqr(r) / real(2.0);
s = real(1.0) + r + p;
m = real(2.0);
do {
m += real(1.0);
p *= r;
p /= m;
s += p;
} while (fabsl((real) p) > thresh);
r = npwr(s, k);
r = mul_pwr2(r, ldexpl(real(1.0), z));
return r;
}
/* Logarithm. Computes log(x) in quad-real precision.
This is a natural logarithm (i.e., base e). */
qd_real log(const qd_real &a) {
/* Strategy. The Taylor series for log converges much more
slowly than that of exp, due to the lack of the factorial
term in the denominator. Hence this routine instead tries
to determine the root of the function
f(x) = exp(x) - a
using Newton iteration. The iteration is given by
x' = x - f(x)/f'(x)
= x - (1 - a * exp(-x))
= x + a * exp(-x) - 1.
Two iteration is needed, since Newton's iteration
approximately reals the number of digits per iteration. */
if (a.is_one()) {
return real(0.0);
}
if (a[0] <= real(0.0)) {
//cerr << "ERROR (qd_real::log): Non-positive argument." << endl;
//qd_real::abort();
return qd_real::_nan;
}
qd_real x = logl(a[0]); /* Initial approximation */
x = x + a * exp(-x) - real(1.0);
x = x + a * exp(-x) - real(1.0);
x = x + a * exp(-x) - real(1.0);
return x;
}
qd_real log10(const qd_real &a) {
return log(a) / qd_real::_log10;
}
/* Computes sin(a) and cos(a) using Taylor series.
Assumes |a| <= pi/2048. */
static void sincos_taylor(const qd_real &a,
qd_real &sin_a, qd_real &cos_a) {
const real thresh = qd_real::_eps * fabsl((real) a);
qd_real p; /* Current power of a. */
qd_real s; /* Current partial sum. */
qd_real x; /* = -sqr(a) */
real m;
if (a.is_zero()) {
sin_a = real(0.0);
cos_a = real(1.0);
return;
}
x = -sqr(a);
s = a;
p = a;
m = real(1.0);
do {
p *= x;
m += real(2.0);
p /= (m*(m-1));
s += p;
} while (fabsl((real) p) > thresh);
sin_a = s;
cos_a = sqrt(real(1.0) - sqr(s));
}
qd_real sin(const qd_real &a) {
/* Strategy. To compute sin(x), we choose integers a, b so that
x = s + a * (pi/2) + b * (pi/1024)
and |s| <= pi/2048. Using a precomputed table of
sin(k pi / 1024) and cos(k pi / 1024), we can compute
sin(x) from sin(s) and cos(s). This greatly increases the
convergence of the sine Taylor series. */
if (a.is_zero()) {
return real(0.0);
}
/* First reduce modulo 2*pi so that |r| <= pi. */
qd_real r = drem(a, qd_real::_2pi);
/* Now reduce by modulo pi/2 and then by pi/1024 so that
we obtain numbers a, b, and t. */
qd_real t;
qd_real sin_t, cos_t;
qd_real s, c;
int j = (int) divrem(r, qd_real::_pi2, t);
int abs_j = abs(j);
int k = (int) divrem(t, qd_real::_pi1024, t);
int abs_k = abs(k);
if (abs_j > 2) {
//cerr << "ERROR (qd_real::sin): Cannot reduce modulo pi/2." << endl;
//qd_real::abort();
return qd_real::_nan;
}
if (abs_k > 256) {
//cerr << "ERROR (qd_real::sin): Cannot reduce modulo pi/1024." << endl;
//qd_real::abort();
return qd_real::_nan;
}
sincos_taylor(t, sin_t, cos_t);
if (abs_k == 0) {
s = sin_t;
c = cos_t;
} else {
qd_real u = qd_real::cos_table[abs_k-1];
qd_real v = qd_real::sin_table[abs_k-1];
if (k > 0) {
s = u * sin_t + v * cos_t;
c = u * cos_t - v * sin_t;
} else {
s = u * sin_t - v * cos_t;
c = u * cos_t + v * sin_t;
}
}
if (abs_j == 0) {
r = s;
} else if (j == 1) {
r = c;
} else if (j == -1) {
r = -c;
} else {
r = -s;
}
return r;
}
qd_real cos(const qd_real &a) {
if (a.is_zero()) {
return real(1.0);
}
/* First reduce modulo 2*pi so that |r| <= pi. */
qd_real r = drem(a, qd_real::_2pi);
/* Now reduce by modulo pi/2 and then by pi/1024 so that
we obtain numbers a, b, and t. */
qd_real t;
qd_real sin_t, cos_t;
qd_real s, c;
int j = (int) divrem(r, qd_real::_pi2, t);
int abs_j = abs(j);
int k = (int) divrem(t, qd_real::_pi1024, t);
int abs_k = abs(k);
if (abs_j > 2) {
//cerr << "ERROR (qd_real::cos): Cannot reduce modulo pi/2." << endl;
//qd_real::abort();
return qd_real::_nan;
}
if (abs_k > 256) {
//cerr << "ERROR (qd_real::cos): Cannot reduce modulo pi/1024." << endl;
//qd_real::abort();
return qd_real::_nan;
}
sincos_taylor(t, sin_t, cos_t);
if (abs_k == 0) {
s = sin_t;
c = cos_t;
} else {
qd_real u = qd_real::cos_table[abs_k-1];
qd_real v = qd_real::sin_table[abs_k-1];
if (k > 0) {
s = u * sin_t + v * cos_t;
c = u * cos_t - v * sin_t;
} else {
s = u * sin_t - v * cos_t;
c = u * cos_t + v * sin_t;
}
}
if (abs_j == 0) {
r = c;
} else if (j == 1) {
r = -s;
} else if (j == -1) {
r = s;
} else {
r = -c;
}
return r;
}
void sincos(const qd_real &a, qd_real &sin_a, qd_real &cos_a) {
if (a.is_zero()) {
sin_a = real(0.0);
cos_a = real(1.0);
return;
}
/* First reduce modulo 2*pi so that |r| <= pi. */
qd_real r = drem(a, qd_real::_2pi);
/* Now reduce by modulo pi/2 and then by pi/1024 so that
we obtain numbers a, b, and t. */
qd_real t;
qd_real sin_t, cos_t;
qd_real s, c;
int j = (int) divrem(r, qd_real::_pi2, t);
int abs_j = abs(j);
int k = (int) divrem(t, qd_real::_pi1024, t);
int abs_k = abs(k);
if (abs_j > 2) {
//cerr << "ERROR (qd_real::sincos): Cannot reduce modulo pi/2." << endl;
//qd_real::abort();
return;
}
if (abs_k > 256) {
//cerr << "ERROR (qd_real::sincos): Cannot reduce modulo pi/1024." << endl;
//qd_real::abort();
return;
}
sincos_taylor(t, sin_t, cos_t);
if (abs_k == 0) {
s = sin_t;
c = cos_t;
} else {
qd_real u = qd_real::cos_table[abs_k-1];
qd_real v = qd_real::sin_table[abs_k-1];
if (k > 0) {
s = u * sin_t + v * cos_t;
c = u * cos_t - v * sin_t;
} else {
s = u * sin_t - v * cos_t;
c = u * cos_t + v * sin_t;
}
}
if (abs_j == 0) {
sin_a = s;
cos_a = c;
} else if (j == 1) {
sin_a = c;
cos_a = -s;
} else if (j == -1) {
sin_a = -c;
cos_a = s;
} else {
sin_a = -s;
cos_a = -c;
}
}
qd_real atan(const qd_real &a) {
return atan2(a, qd_real(1.0));
}
qd_real atan2(const qd_real &y, const qd_real &x) {
/* Strategy: Instead of using Taylor series to compute
arctan, we instead use Newton's iteration to solve
the equation
sin(z) = y/r or cos(z) = x/r
where r = sqrt(x^2 + y^2).
The iteration is given by
z' = z + (y - sin(z)) / cos(z) (for equation 1)
z' = z - (x - cos(z)) / sin(z) (for equation 2)
Here, x and y are normalized so that x^2 + y^2 = 1.
If |x| > |y|, then first iteration is used since the
denominator is larger. Otherwise, the second is used.
*/
if (x.is_zero()) {
if (y.is_zero()) {
/* Both x and y is zero. */
//cerr << "ERROR (qd_real::atan2): Both arguments zero." << endl;
//qd_real::abort();
return qd_real::_nan;
}
return (y.is_positive()) ? qd_real::_pi2 : -qd_real::_pi2;
} else if (y.is_zero()) {
return (x.is_positive()) ? qd_real(0.0) : qd_real::_pi;
}
if (x == y) {
return (y.is_positive()) ? qd_real::_pi4 : -qd_real::_3pi4;
}
if (x == -y) {
return (y.is_positive()) ? qd_real::_3pi4 : -qd_real::_pi4;
}
qd_real r = sqrt(sqr(x) + sqr(y));
qd_real xx = x / r;
qd_real yy = y / r;
/* Compute real precision approximation to atan. */
qd_real z = atan2((real) y, (real) x);
qd_real sin_z, cos_z;
if (xx > yy) {
/* Use Newton iteration 1. z' = z + (y - sin(z)) / cos(z) */
sincos(z, sin_z, cos_z);
z += (yy - sin_z) / cos_z;
sincos(z, sin_z, cos_z);
z += (yy - sin_z) / cos_z;
sincos(z, sin_z, cos_z);
z += (yy - sin_z) / cos_z;
} else {
/* Use Newton iteration 2. z' = z - (x - cos(z)) / sin(z) */
sincos(z, sin_z, cos_z);
z -= (xx - cos_z) / sin_z;
sincos(z, sin_z, cos_z);
z -= (xx - cos_z) / sin_z;
sincos(z, sin_z, cos_z);
z -= (xx - cos_z) / sin_z;
}
return z;
}
qd_real drem(const qd_real &a, const qd_real &b) {
qd_real n = nint(a/b);
return (a - n * b);
}
qd_real divrem(const qd_real &a, const qd_real &b, qd_real &r) {
qd_real n = nint(a/b);
r = a - n * b;
return n;
}
qd_real tan(const qd_real &a) {
qd_real s, c;
sincos(a, s, c);
return s/c;
}
qd_real asin(const qd_real &a) {
qd_real abs_a = fabs(a);
if (abs_a > real(1.0)) {
//cerr << "ERROR (qd_real::asin): Argument out of domain." << endl;
//qd_real::abort();
return qd_real::_nan;
}
if (abs_a.is_one()) {
return (a.is_positive()) ? qd_real::_pi2 : -qd_real::_pi2;
}
return atan2(a, sqrt(real(1.0) - sqr(a)));
}
qd_real acos(const qd_real &a) {
qd_real abs_a = fabs(a);
if (abs_a > real(1.0)) {
//cerr << "ERROR (qd_real::acos): Argument out of domain." << endl;
//qd_real::abort();
return qd_real::_nan;
}
if (abs_a.is_one()) {
return (a.is_positive()) ? qd_real(0.0) : qd_real::_pi;
}
return atan2(sqrt(real(1.0) - sqr(a)), a);
}
qd_real sinh(const qd_real &a) {
if (a.is_zero()) {
return real(0.0);
}
if (fabs(a) > real(0.05)) {
qd_real ea = exp(a);
return mul_pwr2(ea - inv(ea), real(0.5));
}
/* Since a is small, using the above formula gives
a lot of cancellation. So use Taylor series. */
qd_real s = a;
qd_real t = a;
qd_real r = sqr(t);
real m = real(1.0);
real thresh = fabsl(((real) a) * qd_real::_eps);
do {
m += real(2.0);
t *= r;
t /= (m-1) * m;
s += t;
} while (fabs(t) > thresh);
return s;
}
qd_real cosh(const qd_real &a) {
if (a.is_zero()) {
return real(1.0);
}
qd_real ea = exp(a);
return mul_pwr2(ea + inv(ea), real(0.5));
}
qd_real tanh(const qd_real &a) {
if (a.is_zero()) {
return real(0.0);
}
if (fabsl((real) a) > real(0.05)) {
qd_real ea = exp(a);
qd_real inv_ea = inv(ea);
return (ea - inv_ea) / (ea + inv_ea);
} else {
qd_real s, c;
s = sinh(a);
c = sqrt(real(1.0) + sqr(s));
return s / c;
}
}
void sincosh(const qd_real &a, qd_real &s, qd_real &c) {
if (fabs((real) a) <= real(0.05)) {
s = sinh(a);
c = sqrt(real(1.0) + sqr(s));
} else {
qd_real ea = exp(a);
qd_real inv_ea = inv(ea);
s = mul_pwr2(ea - inv_ea, real(0.5));
c = mul_pwr2(ea + inv_ea, real(0.5));
}
}
qd_real asinh(const qd_real &a) {
return log(a + sqrt(sqr(a) + real(1.0)));
}
qd_real acosh(const qd_real &a) {
if (a < real(1.0)) {
//cerr << "ERROR (qd_real::acosh): Argument out of domain." << endl;
//qd_real::abort();
return qd_real::_nan;
}
return log(a + sqrt(sqr(a) - real(1.0)));
}
qd_real atanh(const qd_real &a) {
if (fabs(a) >= real(1.0)) {
//cerr << "ERROR (qd_real::atanh): Argument out of domain." << endl;
//qd_real::abort();
return qd_real::_nan;
}
return mul_pwr2(log((real(1.0) + a) / (real(1.0) - a)), real(0.5));
}
qd_real qdrand() {
static const real m_const = 4.6566128730773926e-10; /* = 2^{-31} */
real m = m_const;
qd_real r = real(0.0);
real d;
/* Strategy: Generate 31 bits at a time, using lrand48
random number generator. Shift the bits, and repeat
7 times. */
for (int i = 0; i < 7; i++, m *= m_const) {
d = STD_RAND() * m;
r += d;
}
return r;
}
/* polyeval(c, n, x)
Evaluates the given n-th degree polynomial at x.
The polynomial is given by the array of (n+1) coefficients. */
qd_real polyeval(const qd_real *c, int n, const qd_real &x) {
/* Just use Horner's method of polynomial evaluation. */
qd_real r = c[n];
for (int i = n-1; i >= 0; i--) {
r *= x;
r += c[i];
}
return r;
}
/* polyroot(c, n, x0)
Given an n-th degree polynomial, finds a root close to
the given guess x0. Note that this uses simple Newton
iteration scheme, and does not work for multiple roots. */
qd_real polyroot(const qd_real *c, int n, const qd_real &x0,
real thresh) {
qd_real x = x0;
qd_real f;
qd_real *d = new qd_real[n];
bool conv = false;
int i;
/* Compute the coefficients of the derivatives. */
for (i = 0; i < n; i++) {
d[i] = c[i+1] * (real) (i+1);
}
/* Newton iteration. */
for (i = 0; i < 20; i++) {
f = polyeval(c, n, x);
if (abs(f) < thresh) {
conv = true;
break;
}
x -= (f / polyeval(d, n-1, x));
}
delete [] d;
if (!conv) {
//cerr << "ERROR (qd_real::polyroot): Failed to converge." << endl;
//qd_real::abort();
return qd_real::_nan;
}
return x;
}
#ifdef QD_DEBUG
qd_real qd_real::debug_rand() {
if (STD_RAND() % 2 == 0)
return qdrand();
int expn = 0;
qd_real a = real(0.0);
real d;
for (int i = 0; i < 4; i++) {
d = ldexpl(STD_RAND() / (real) RAND_MAX, -expn);
a += d;
expn = expn + 54 + STD_RAND() % 200;
}
return a;
}
#endif
void qd_real::renorm() {
::renorm(x[0], x[1], x[2], x[3]);
}
void qd_real::renorm(real &e) {
::renorm(x[0], x[1], x[2], x[3], e);
}
| 20.380395 | 112 | 0.5 | philippeb8 |
e91ae89244ea57fb12b75ad7443543f1ad1c40a1 | 17,668 | cpp | C++ | src/CommandSet.cpp | jacobussystems/IoTJackAC1 | c1ad8c13d984362c1bbf1232cbfc34e64fc039ac | [
"MIT"
] | null | null | null | src/CommandSet.cpp | jacobussystems/IoTJackAC1 | c1ad8c13d984362c1bbf1232cbfc34e64fc039ac | [
"MIT"
] | null | null | null | src/CommandSet.cpp | jacobussystems/IoTJackAC1 | c1ad8c13d984362c1bbf1232cbfc34e64fc039ac | [
"MIT"
] | null | null | null | /*
CommandSet.cpp
By Jim Davies
Jacobus Systems, Brighton & Hove, UK
http://www.jacobus.co.uk
Provided under the MIT license: https://github.com/jacobussystems/ArdJack/blob/master/LICENSE
Copyright (c) 2019 James Davies, Jacobus Systems, Brighton & Hove, UK
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
*/
#include "pch.h"
#ifdef ARDUINO
#else
#include "stdafx.h"
#endif
#include "Beacon.h"
#include "BeaconManager.h"
#include "Bridge.h"
#include "BridgeManager.h"
#include "CmdInterpreter.h"
#include "DeviceCodec1.h"
#include "CommandSet.h"
#include "Connection.h"
#include "ConnectionManager.h"
#include "Device.h"
#include "DeviceManager.h"
#include "Displayer.h"
#include "Globals.h"
#include "IoTMessage.h"
#include "Log.h"
#include "Part.h"
#include "Utils.h"
#ifdef ARDJACK_INCLUDE_PERSISTENCE
#include "PersistentFile.h"
#include "PersistentFileManager.h"
#endif
#ifdef ARDJACK_NETWORK_AVAILABLE
#include "NetworkInterface.h"
#include "NetworkManager.h"
#endif
#ifdef ARDJACK_INCLUDE_TESTS
#include "Tests.h"
#endif
CommandSet::CommandSet()
{
if (Globals::Verbosity > 7)
Log::LogInfo(PRM("CommandSet ctor"));
_CommandCount = 0;
#ifdef ARDJACK_INCLUDE_PERSISTENCE
_CurrentPersistentFile = NULL;
#endif
for (int i = 0; i < ARDJACK_MAX_COMMANDS; i++)
_Commands[i] = NULL;
AddCommand(PRM("ACTIVATE"), &CommandSet::command_activate);
AddCommand(PRM("ADD"), &CommandSet::command_add);
AddCommand(PRM("BEEP"), &CommandSet::command_beep);
AddCommand(PRM("CONFIGURE"), &CommandSet::command_configure);
AddCommand(PRM("CONNECTION"), &CommandSet::command_connection);
AddCommand(PRM("DEACTIVATE"), &CommandSet::command_deactivate);
AddCommand(PRM("DEFINE"), &CommandSet::command_define);
AddCommand(PRM("DELAY"), &CommandSet::command_delay);
AddCommand(PRM("DELETE"), &CommandSet::command_delete);
AddCommand(PRM("DEVICE"), &CommandSet::command_device);
AddCommand(PRM("DISPLAY"), &CommandSet::command_display);
AddCommand(PRM("EXIT"), &CommandSet::command_exit);
#ifdef ARDJACK_INCLUDE_PERSISTENCE
AddCommand(PRM("FILE"), &CommandSet::command_file);
#endif
AddCommand(PRM("HELP"), &CommandSet::command_help);
AddCommand(PRM("MEM"), &CommandSet::command_mem);
#ifdef ARDJACK_NETWORK_AVAILABLE
AddCommand(PRM("NET"), &CommandSet::command_net);
#endif
//AddCommand(PRM("PING"), &CommandSet::command_nyi); //&command_ping);
AddCommand(PRM("REACTIVATE"), &CommandSet::command_reactivate);
AddCommand(PRM("REPEAT"), &CommandSet::command_repeat);
AddCommand(PRM("RESET"), &CommandSet::command_reset);
#ifdef ARDJACK_INCLUDE_PERSISTENCE
AddCommand(PRM("RESTORE"), &CommandSet::command_restore);
AddCommand(PRM("SAVE"), &CommandSet::command_save);
#endif
AddCommand(PRM("SEND"), &CommandSet::command_send);
AddCommand(PRM("SET"), &CommandSet::command_set);
AddCommand(PRM("TEST"), &CommandSet::command_test);
#ifdef ARDJACK_INCLUDE_TESTS
AddCommand(PRM("TESTS"), &CommandSet::command_tests);
#endif
}
CommandSet::~CommandSet()
{
for (int i = 0; i < ARDJACK_MAX_COMMANDS; i++)
{
if (NULL != _Commands[i])
{
delete _Commands[i];
_Commands[i] = NULL;
}
}
}
CommandInfo* CommandSet::AddCommand(const char* name, CommandSetCallback callback)
{
if (_CommandCount >= ARDJACK_MAX_COMMANDS)
{
return NULL;
}
CommandInfo *result = _Commands[_CommandCount];
if (NULL == result)
{
result = new CommandInfo();
_Commands[_CommandCount] = result;
}
_CommandCount++;
strcpy(result->Name, name);
result->Callback = callback;
return result;
}
bool CommandSet::Handle(const char* line, const char* verb, const char* remainder)
{
if (_CommandCount == 0)
{
Log::LogWarning(PRM("Command Set has no commands: '"), line, "'");
return false;
}
// Is this command in '_Commands'?
if (strlen(verb) >= ARDJACK_MAX_VERB_LENGTH)
return false;
char ucVerb[ARDJACK_MAX_VERB_LENGTH];
strcpy(ucVerb, verb);
_strupr(ucVerb);
bool (CommandSet::*pCallback)(const char* args);
for (int i = 0; i < _CommandCount; i++)
{
CommandInfo* info = _Commands[i];
if (strcmp(ucVerb, info->Name) == 0)
{
pCallback = info->Callback;
if (pCallback == &CommandSet::command_nyi)
Log::LogWarning("NOT YET IMPLEMENTED:", ucVerb);
else
(*this.*pCallback)(remainder);
return true;
}
}
return false;
}
bool CommandSet::command_activate(const char* args)
{
// Activate zero or more 'IoTObjects'.
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("ACTIVATE command: No arguments"));
return true;
}
return Globals::ActivateObjects(args, true);
}
bool CommandSet::command_add(const char* args)
{
// Add an 'IoTObject'.
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("ADD command: No arguments"));
return true;
}
IoTObject* obj = Globals::AddObject(args);
if (NULL == obj) return false;
return true;
}
bool CommandSet::command_beep(const char* args)
{
// beep 1800 200 3
int freqHz = 1000;
int durMs = 200;
int beepCount = 1;
char fields[3][ARDJACK_MAX_VALUE_LENGTH];
int count = Utils::SplitText2Array(args, ' ', fields, 3, ARDJACK_MAX_VALUE_LENGTH);
if (count >= 1)
freqHz = Utils::String2Int(fields[0], freqHz);
if (count >= 2)
durMs = Utils::String2Int(fields[1], durMs);
if (count >= 3)
beepCount = Utils::String2Int(fields[2], beepCount);
for (int i = 0; i < beepCount; i++)
Utils::DoBeep(freqHz, durMs);
return true;
}
bool CommandSet::command_configure(const char* args)
{
// Configure an Object (Bridge, Connection, DataLogger or Device), -or- a Device's Part(s).
// Syntax:
// configure object item1=value1 item2=value2
// configure device.part item1=value1 item2=value2
// E.g.
// 'configure ard shield=thinker'
// 'configure ard.button0 name=value'
// 'configure udp0 inputport=2390'
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("CONFIGURE command: No arguments"));
return true;
}
StringList fields;
int count = Utils::SplitText(args, ' ', &fields, ARDJACK_MAX_VALUES, ARDJACK_MAX_VALUE_LENGTH);
// TEMPORARY: why?
if (count < 2)
{
Log::LogError(PRM("Configure: Less than 2 fields: "), args);
return false;
}
// Parse the first field - is it in 'obj.partExpr' format?
char fields2[2][ARDJACK_MAX_VALUE_LENGTH];
int count2 = Utils::SplitText2Array(fields.Get(0), '.', fields2, 2, ARDJACK_MAX_VALUE_LENGTH);
bool dotSyntax = (count2 > 1);
char objName[ARDJACK_MAX_NAME_LENGTH];
char partExpr[ARDJACK_MAX_NAME_LENGTH];
if (dotSyntax)
{
strcpy(objName, fields2[0]);
strcpy(partExpr, fields2[1]);
}
else
{
strcpy(objName, fields2[0]);
partExpr[0] = NULL;
}
// Check the Object name.
IoTObject* obj = Globals::ObjectRegister->LookupName(objName);
if (NULL == obj)
{
Log::LogError(PRM("Configure: Unknown object: '"), objName, "'");
return false;
}
if (Globals::Verbosity > 6)
{
char temp[102];
Log::LogInfoF(PRM("Configure: '%s', partExpr '%s'"), obj->ToString(temp), partExpr);
}
return obj->Configure(partExpr, &fields, 1, count - 1);
}
bool CommandSet::command_connection(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("CONNECTION command: No arguments"));
return true;
}
return Globals::ConnectionMgr->Interact(args);
}
bool CommandSet::command_deactivate(const char* args)
{
// Deactivate zero or more 'IoTObjects'.
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("DEACTIVATE command: No arguments"));
return true;
}
return Globals::ActivateObjects(args, false);
}
bool CommandSet::command_define(const char* args)
{
// Define a Macro.
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("DEFINE command: No arguments"));
return true;
}
char name[ARDJACK_MAX_NAME_LENGTH];
const char* content = NULL;
Utils::GetArgs(args, name, &content);
if (Utils::StringIsNullOrEmpty(content))
Globals::Interpreter->RemoveMacro(name);
else
Globals::Interpreter->AddMacro(name, content);
return true;
}
bool CommandSet::command_delay(const char* args)
{
// Delay for a number of milliseconds.
int delay_ms;
char fields[2][ARDJACK_MAX_VALUE_LENGTH];
int count = Utils::SplitText2Array(args, ' ', fields, 2, ARDJACK_MAX_VALUE_LENGTH);
if (count == 0) return false;
delay_ms = Utils::String2Int(fields[0], 1000);
Utils::DelayMs(delay_ms);
return true;
}
bool CommandSet::command_delete(const char* args)
{
// Delete zero or more 'IoTObjects'.
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("DELETE command: No arguments"));
return true;
}
return Globals::DeleteObjects(args);
}
bool CommandSet::command_device(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("DEVICE command: No arguments"));
return true;
}
return Globals::DeviceMgr->Interact(args);
}
bool CommandSet::command_display(const char* args)
{
return Displayer::DisplayItem(args);
}
bool CommandSet::command_exit(const char* args)
{
Globals::UserExit = true;
return true;
}
#ifdef ARDJACK_INCLUDE_PERSISTENCE
bool CommandSet::command_file(const char* args)
{
// file open settings open file 'settings' for writing
// file write name1=value1
// file write "name2=value 2"
// file close
// file open startup open file 'startup' for writing
// file write "command1 yy zz"
// file write "command2 yy zz"
// file close
// file clear clears all files
// file list list the current files
// file scan scan the flash storage (Arduino) / disk folder (Windows)
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("FILE command: No arguments"));
return true;
}
StringList fields;
int count = Utils::SplitText(args, ' ', &fields, ARDJACK_MAX_VALUES, ARDJACK_MAX_VALUE_LENGTH);
if (count == 0)
{
Log::LogError(PRM("FILE command: No arguments"));
return false;
}
char action[20];
strcpy(action, fields.Get(0));
_strupr(action);
if (Utils::StringEquals(action, "CLEAR", true))
{
return Globals::PersistentFileMgr->Clear();
}
if (Utils::StringEquals(action, "CLOSE", true))
{
if (NULL == _CurrentPersistentFile)
{
Log::LogError(PRM("FILE CLOSE command: No file open"));
return false;
}
return _CurrentPersistentFile->Close();
}
if (Utils::StringEquals(action, "LIST", true))
{
return Globals::PersistentFileMgr->List();
}
if (Utils::StringEquals(action, "LOADINI", true))
{
// Load the specified INI file.
if (count < 2)
{
Log::LogError(PRM("FILE LOAD command: Insufficient arguments in '"), args, "'");
return false;
}
return Globals::PersistentFileMgr->LoadIniFile(fields.Get(1));
}
if (Utils::StringEquals(action, "OPEN", true))
{
if (count < 2)
{
Log::LogError(PRM("FILE OPEN command: Insufficient arguments in '"), args, "'");
return false;
}
if (NULL != _CurrentPersistentFile)
{
_CurrentPersistentFile->Close();
_CurrentPersistentFile = NULL;
}
char name[ARDJACK_MAX_NAME_LENGTH];
strcpy(name, fields.Get(1));
_CurrentPersistentFile = Globals::PersistentFileMgr->Lookup(name, true);
if (NULL == _CurrentPersistentFile)
{
Log::LogError(PRM("FILE OPEN command: No such file: "), name);
return false;
}
return _CurrentPersistentFile->Open("w");
}
if (Utils::StringEquals(action, "SCAN", true))
{
#ifdef ARDUINO
return Globals::PersistentFileMgr->Scan();
#else
return Globals::PersistentFileMgr->Scan(Globals::AppDocsFolder);
#endif
}
if (Utils::StringEquals(action, "WRITE", true))
{
if (NULL == _CurrentPersistentFile)
{
Log::LogError(PRM("FILE WRITE command: No file open"));
return false;
}
if (!_CurrentPersistentFile->IsOpen())
{
Log::LogError(PRM("FILE WRITE command: File not open: "), _CurrentPersistentFile->Name);
return false;
}
if (count < 2)
return _CurrentPersistentFile->Puts("");
else
return _CurrentPersistentFile->Puts(fields.Get(1));
}
Log::LogError(PRM("FILE command: Invalid option: "), action);
return false;
}
#endif
bool CommandSet::command_help(const char* args)
{
Log::LogInfo(PRM("Available commands:"));
for (int i = 0; i < _CommandCount; i++)
{
CommandInfo* info = _Commands[i];
Log::LogInfo(" ", info->Name);
}
return true;
}
bool CommandSet::command_mem(const char* args)
{
return Displayer::DisplayMemory();
}
#ifdef ARDJACK_NETWORK_AVAILABLE
bool CommandSet::command_net(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("NET command: No arguments"));
return true;
}
return Globals::NetworkMgr->Interact(args);
}
#endif
bool CommandSet::command_nyi(const char* args)
{
// NOT YET IMPLEMENTED.
return false;
}
bool CommandSet::command_reactivate(const char* args)
{
// Rectivate zero or more 'IoTObjects' (reactivate = deactivate + activate).
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("REACTIVATE command: No arguments"));
return true;
}
return Globals::ReactivateObjects(args);
}
bool CommandSet::command_repeat(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("REPEAT command: No arguments"));
return true;
}
char firstPart[ARDJACK_MAX_VERB_LENGTH];
const char* remainder = NULL;
Utils::GetArgs(args, firstPart, &remainder);
int count = atoi(firstPart);
char temp[20];
for (int i = 1; i <= count; i++)
{
if (Globals::Verbosity > 3)
{
sprintf(temp, PRM("%d of %d"), i, count);
Log::LogInfo(PRM("command_repeat: Cycle "), temp);
}
Globals::Interpreter->Execute(remainder);
}
return true;
}
bool CommandSet::command_reset(const char* args)
{
Log::LogInfo(PRM("command_reset"));
void(*resetFunc) (void) = 0; // declare reset function at address 0
resetFunc();
return true;
}
#ifdef ARDJACK_INCLUDE_PERSISTENCE
bool CommandSet::command_restore(const char* args)
{
// Reload the configuration file (if any).
return Globals::LoadIniFile("configuration");
}
bool CommandSet::command_save(const char* args)
{
// Save some basic items of the current configuration to file "configuration".
return Globals::SaveIniFile("configuration");
}
#endif
bool CommandSet::command_send(const char* args)
{
// Send text via the specified Connection.
// Syntax:
// send conn "text"
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("SEND command: No arguments"));
return true;
}
char fields[2][ARDJACK_MAX_VALUE_LENGTH];
int count = Utils::SplitText2Array(args, ' ', fields, 2, ARDJACK_MAX_VALUE_LENGTH);
if (count < 2)
{
Log::LogError(PRM("Insufficient fields for SEND command: '"), args, "'");
return false;
}
Connection* conn = Globals::ConnectionMgr->LookupConnection(fields[0]);
if (NULL == conn)
{
Log::LogError(PRM("No such Connection: '"), fields[0], "'");
return false;
}
return conn->SendText(fields[1]);
}
bool CommandSet::command_set(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("SET command: No arguments"));
return true;
}
char fields[2][ARDJACK_MAX_VALUE_LENGTH];
bool handled;
int count = Utils::SplitText2Array(args, ' ', fields, 2, ARDJACK_MAX_VALUE_LENGTH);
return Globals::Set(fields[0], fields[1], &handled);
}
#ifdef ARDJACK_INCLUDE_TESTS
bool CommandSet::command_test(const char* args)
{
if (Utils::StringIsNullOrEmpty(args))
{
Log::LogWarning(PRM("TEST command: No arguments"));
return true;
}
// "test number arg1 arg2 verbosity"
char fields[4][ARDJACK_MAX_VALUE_LENGTH];
int count = Utils::SplitText2Array(args, ' ', fields, 4, ARDJACK_MAX_VALUE_LENGTH);
int number = 1;
int arg1 = 0;
int arg2 = 0;
int verbosity = 10;
if (count >= 1)
{
number = atoi(fields[0]);
if (count >= 2)
{
arg1 = atoi(fields[1]);
if (count >= 3)
{
arg2 = atoi(fields[2]);
if (count >= 4)
verbosity = atoi(fields[3]);
}
}
}
RunTest(number, arg1, arg2, verbosity);
return true;
}
bool CommandSet::command_tests(const char* args)
{
// TEMPORARY:
RunTests(10);
return true;
}
#else
bool CommandSet::command_test(const char* args)
{
Log::LogInfoF(PRM("Entry"));
int save = Globals::Verbosity;
Globals::Verbosity = 10;
Log::LogInfoF(PRM("--- STRING LISTS ---"));
StringList* sl1 = new StringList();
for (int i = 0; i < 3; i++)
{
StringList* sl2 = new StringList();
delete sl2;
StringList* sl3 = new StringList();
delete sl3;
}
delete sl1;
Log::LogInfoF(PRM("--- MESSAGES ---"));
IoTMessage* msg = new IoTMessage();
delete msg;
Log::LogInfoF(PRM("--- BEACONS ---"));
Beacon* beacon = new Beacon("beacon");
delete beacon;
Globals::Verbosity = save;
Log::LogInfoF(PRM("Exit"));
return true;
}
#endif
| 21.467801 | 114 | 0.698325 | jacobussystems |
e91b95a988d5806fc6591bb8e7c17a03fe79ecec | 2,716 | cpp | C++ | src/Interpreters/InterpreterExternalDDLQuery.cpp | athom/ClickHouse | 4f4cc9d7404fd489a7229633b22b5ea1889bd8c0 | [
"Apache-2.0"
] | 15,577 | 2019-09-23T11:57:53.000Z | 2022-03-31T18:21:48.000Z | src/Interpreters/InterpreterExternalDDLQuery.cpp | athom/ClickHouse | 4f4cc9d7404fd489a7229633b22b5ea1889bd8c0 | [
"Apache-2.0"
] | 16,476 | 2019-09-23T11:47:00.000Z | 2022-03-31T23:06:01.000Z | src/Interpreters/InterpreterExternalDDLQuery.cpp | athom/ClickHouse | 4f4cc9d7404fd489a7229633b22b5ea1889bd8c0 | [
"Apache-2.0"
] | 3,633 | 2019-09-23T12:18:28.000Z | 2022-03-31T15:55:48.000Z | #if !defined(ARCADIA_BUILD)
# include "config_core.h"
#endif
#include <Interpreters/InterpreterExternalDDLQuery.h>
#include <Interpreters/Context.h>
#include <Parsers/IAST.h>
#include <Parsers/ASTDropQuery.h>
#include <Parsers/ASTRenameQuery.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTExternalDDLQuery.h>
#ifdef USE_MYSQL
# include <Interpreters/MySQL/InterpretersMySQLDDLQuery.h>
# include <Parsers/MySQL/ASTAlterQuery.h>
# include <Parsers/MySQL/ASTCreateQuery.h>
#endif
namespace DB
{
namespace ErrorCodes
{
extern const int SYNTAX_ERROR;
extern const int BAD_ARGUMENTS;
}
InterpreterExternalDDLQuery::InterpreterExternalDDLQuery(const ASTPtr & query_, ContextMutablePtr context_)
: WithMutableContext(context_), query(query_)
{
}
BlockIO InterpreterExternalDDLQuery::execute()
{
const ASTExternalDDLQuery & external_ddl_query = query->as<ASTExternalDDLQuery &>();
if (getContext()->getClientInfo().query_kind != ClientInfo::QueryKind::SECONDARY_QUERY)
throw Exception("Cannot parse and execute EXTERNAL DDL FROM.", ErrorCodes::SYNTAX_ERROR);
if (external_ddl_query.from->name == "MySQL")
{
#ifdef USE_MYSQL
const ASTs & arguments = external_ddl_query.from->arguments->children;
if (arguments.size() != 2 || !arguments[0]->as<ASTIdentifier>() || !arguments[1]->as<ASTIdentifier>())
throw Exception("MySQL External require two identifier arguments.", ErrorCodes::BAD_ARGUMENTS);
if (external_ddl_query.external_ddl->as<ASTDropQuery>())
return MySQLInterpreter::InterpreterMySQLDropQuery(
external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
getIdentifierName(arguments[1])).execute();
else if (external_ddl_query.external_ddl->as<ASTRenameQuery>())
return MySQLInterpreter::InterpreterMySQLRenameQuery(
external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
getIdentifierName(arguments[1])).execute();
else if (external_ddl_query.external_ddl->as<MySQLParser::ASTAlterQuery>())
return MySQLInterpreter::InterpreterMySQLAlterQuery(
external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
getIdentifierName(arguments[1])).execute();
else if (external_ddl_query.external_ddl->as<MySQLParser::ASTCreateQuery>())
return MySQLInterpreter::InterpreterMySQLCreateQuery(
external_ddl_query.external_ddl, getContext(), getIdentifierName(arguments[0]),
getIdentifierName(arguments[1])).execute();
#endif
}
return BlockIO();
}
}
| 37.722222 | 110 | 0.716495 | athom |
11e8215b2b9ab33162d6c0be79765fb86481e4c3 | 5,260 | cpp | C++ | examples/freverb.cpp | vlazzarini/aurora | 4990d81a6873beace4a39d6584cc77afbda82cf4 | [
"BSD-3-Clause"
] | 11 | 2021-11-26T16:23:40.000Z | 2022-01-19T21:36:35.000Z | examples/freverb.cpp | vlazzarini/aurora | 4990d81a6873beace4a39d6584cc77afbda82cf4 | [
"BSD-3-Clause"
] | null | null | null | examples/freverb.cpp | vlazzarini/aurora | 4990d81a6873beace4a39d6584cc77afbda82cf4 | [
"BSD-3-Clause"
] | null | null | null | // freverb.cpp:
// reverb processing example
// depends on libsndfile
//
// (c) V Lazzarini, 2021
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors
// may be used to endorse or promote products derived from this software without
// specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE
#include "Del.h"
#include <array>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <sndfile.h>
#include <vector>
using namespace Aurora;
template <typename S> inline S scl(S a, S b) { return a * b; }
template <typename S> struct Reverb {
static constexpr S dt[4] = {0.037, 0.031, 0.029, 0.023};
static constexpr S adt[2] = {0.01, 0.0017};
std::array<Del<S, lp_delay>, 4> combs;
std::array<Del<S>, 2> apfs;
Mix<S> mix;
BinOp<S, scl> gain;
std::array<std::vector<S>, 4> mem;
std::array<S, 4> g;
S rvt;
void reverb_time(S rvt) {
std::size_t n = 0;
for (auto &gs : g)
gs = std::pow(.001, dt[n++] / rvt);
}
void lp_freq(S lpf, S fs) {
for (auto &m : mem) {
m[0] = 0;
double c = 2. - std::cos(2 * M_PI * lpf / fs);
m[1] = sqrt(c * c - 1.f) - c;
}
}
void reset(S rvt, S lpf, S fs) {
std::size_t n = 0;
for (auto &obj : combs)
obj.reset(dt[n++], fs);
apfs[0].reset(adt[0], fs);
apfs[1].reset(adt[1], fs);
reverb_time(rvt);
lp_freq(lpf, fs);
}
Reverb(S rvt, S lpf, S fs = def_sr, std::size_t vsize = def_vsize)
: combs({Del<S, lp_delay>(dt[0], fs, vsize),
Del<S, lp_delay>(dt[1], fs, vsize),
Del<S, lp_delay>(dt[2], fs, vsize),
Del<S, lp_delay>(dt[3], fs, vsize)}),
apfs({Del<S>(adt[0], fs, vsize), Del<S>(adt[1], fs, vsize)}),
mix(vsize), gain(vsize), mem({std::vector<S>(2), std::vector<S>(2),
std::vector<S>(2), std::vector<S>(2)}),
g({0, 0, 0, 0}) {
reverb_time(rvt);
lp_freq(lpf, fs);
};
const std::vector<S> &operator()(const std::vector<S> &in, S rmx) {
S ga0 = 0.7;
S ga1 = 0.7;
auto &s = gain(0.25, mix(combs[0](in, 0, g[0], 0, &mem[0]),
combs[1](in, 0, g[1], 0, &mem[1]),
combs[2](in, 0, g[2], 0, &mem[2]),
combs[3](in, 0, g[3], 0, &mem[3])));
return mix(in, gain(rmx, apfs[1](apfs[0](s, 0, ga0, -ga0), 0, ga1, -ga1)));
}
};
int main(int argc, const char **argv) {
SF_INFO sfinfo;
SNDFILE *fpin, *fpout;
int n;
if (argc > 5) {
if ((fpin = sf_open(argv[1], SFM_READ, &sfinfo)) != NULL) {
if (sfinfo.channels < 2) {
fpout = sf_open(argv[2], SFM_WRITE, &sfinfo);
float rvt = atof(argv[3]);
float rmx = atof(argv[4]);
float cf = atof(argv[5]);
std::vector<float> buffer(def_vsize);
Reverb<float> reverb(rvt, cf, sfinfo.samplerate);
do {
std::fill(buffer.begin(), buffer.end(), 0);
n = sf_read_float(fpin, buffer.data(), def_vsize);
if (n) {
buffer.resize(n);
auto &out = reverb(buffer, rmx);
sf_write_float(fpout, out.data(), n);
} else
break;
} while (1);
std::cout << buffer.size() << std::endl;
buffer.resize(def_vsize);
std::cout << buffer.size() << std::endl;
n = sfinfo.samplerate * rvt;
std::fill(buffer.begin(), buffer.end(), 0);
do {
auto &out = reverb(buffer, rmx);
sf_write_float(fpout, out.data(), def_vsize);
n -= def_vsize;
} while (n > 0);
sf_close(fpin);
sf_close(fpout);
return 0;
} else
std::cout << "only mono soundfiles permitted\n";
sf_close(fpin);
return 1;
} else
std::cout << "could not open " << argv[1] << std::endl;
return 1;
}
std::cout << "usage: " << argv[0]
<< " infile outfile reverb_time reverb_amount lpf \n"
<< std::endl;
return -1;
}
| 35.066667 | 80 | 0.585551 | vlazzarini |
11e891310680f0eb1585c118d56651afab914aaa | 11,927 | cc | C++ | modules/perception/obstacle/fusion/probabilistic_fusion/pbf_kalman_motion_fusion.cc | berthu/apollo | 5da49a293e3ad60856448fd61bf6548714cde854 | [
"Apache-2.0"
] | 22 | 2018-10-10T14:46:32.000Z | 2022-02-28T12:43:43.000Z | modules/perception/obstacle/fusion/probabilistic_fusion/pbf_kalman_motion_fusion.cc | berthu/apollo | 5da49a293e3ad60856448fd61bf6548714cde854 | [
"Apache-2.0"
] | 1 | 2021-03-09T16:46:45.000Z | 2021-03-09T16:46:45.000Z | modules/perception/obstacle/fusion/probabilistic_fusion/pbf_kalman_motion_fusion.cc | berthu/apollo | 5da49a293e3ad60856448fd61bf6548714cde854 | [
"Apache-2.0"
] | 12 | 2018-12-24T02:17:19.000Z | 2021-12-06T01:54:09.000Z | /******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "modules/perception/obstacle/fusion/probabilistic_fusion/pbf_kalman_motion_fusion.h"
#include "modules/common/log.h"
#include "modules/perception/common/geometry_util.h"
#include "modules/perception/common/perception_gflags.h"
#include "modules/perception/obstacle/base/types.h"
namespace apollo {
namespace perception {
PbfKalmanMotionFusion::PbfKalmanMotionFusion() {
initialized_ = false;
name_ = "PbfKalmanMotionFusion";
}
PbfKalmanMotionFusion::~PbfKalmanMotionFusion() {}
void PbfKalmanMotionFusion::Initialize(const Eigen::Vector3d &anchor_point,
const Eigen::Vector3d &velocity) {
belief_anchor_point_ = anchor_point;
belief_velocity_ = velocity;
belief_acceleration_ = Eigen::Vector3d(0, 0, 0);
}
void PbfKalmanMotionFusion::Initialize(
const std::shared_ptr<PbfSensorObject> new_object) {
ACHECK(new_object != nullptr && new_object->object != nullptr)
<< "Initialize PbfKalmanMotionFusion with null sensor object";
if (is_lidar(new_object->sensor_type)) {
belief_anchor_point_ = new_object->object->anchor_point;
belief_velocity_ = new_object->object->velocity;
belief_acceleration_ = Eigen::Vector3d(0, 0, 0);
initialized_ = true;
} else if (is_radar(new_object->sensor_type)) {
belief_anchor_point_ = new_object->object->anchor_point;
belief_velocity_ = new_object->object->velocity;
belief_acceleration_ = Eigen::Vector3d(0, 0, 0);
initialized_ = true;
} else if (is_camera(new_object->sensor_type)) {
belief_anchor_point_ = new_object->object->anchor_point;
belief_velocity_ = new_object->object->velocity;
belief_acceleration_ = Eigen::Vector3d(0, 0, 0);
initialized_ = true;
}
a_matrix_.setIdentity();
a_matrix_(0, 2) = FLAGS_a_matrix_covariance_coeffcient_1;
a_matrix_(1, 3) = FLAGS_a_matrix_covariance_coeffcient_2;
// initialize states to the states of the detected obstacle
posteriori_state_(0) = belief_anchor_point_(0);
posteriori_state_(1) = belief_anchor_point_(1);
posteriori_state_(2) = belief_velocity_(0);
posteriori_state_(3) = belief_velocity_(1);
priori_state_ = posteriori_state_;
q_matrix_.setIdentity();
q_matrix_ *= FLAGS_q_matrix_coefficient_amplifier;
r_matrix_.setIdentity();
r_matrix_.topLeftCorner(2, 2) =
FLAGS_r_matrix_amplifier *
new_object->object->position_uncertainty.topLeftCorner(2, 2);
r_matrix_.block<2, 2>(2, 2) =
FLAGS_r_matrix_amplifier *
new_object->object->velocity_uncertainty.topLeftCorner(2, 2);
p_matrix_.setIdentity();
p_matrix_.topLeftCorner(2, 2) =
FLAGS_p_matrix_amplifier *
new_object->object->position_uncertainty.topLeftCorner(2, 2);
p_matrix_.block<2, 2>(2, 2) =
FLAGS_p_matrix_amplifier *
new_object->object->velocity_uncertainty.topLeftCorner(2, 2);
c_matrix_.setIdentity();
}
void PbfKalmanMotionFusion::Predict(Eigen::Vector3d *anchor_point,
Eigen::Vector3d *velocity,
const double time_diff) {
*anchor_point = belief_anchor_point_ + belief_velocity_ * time_diff;
*velocity = belief_velocity_;
}
void PbfKalmanMotionFusion::UpdateWithObject(
const std::shared_ptr<PbfSensorObject> new_object, const double time_diff) {
ACHECK(new_object != nullptr && new_object->object != nullptr)
<< "update PbfKalmanMotionFusion with null sensor object";
// predict and then correct
a_matrix_.setIdentity();
a_matrix_(0, 2) = time_diff;
a_matrix_(1, 3) = time_diff;
priori_state_ = a_matrix_ * posteriori_state_;
priori_state_(2) += belief_acceleration_(0) * time_diff;
priori_state_(3) += belief_acceleration_(1) * time_diff;
p_matrix_ = ((a_matrix_ * p_matrix_) * a_matrix_.transpose()) + q_matrix_;
p_matrix_.block<2, 2>(2, 0) = Eigen::Matrix2d::Zero();
p_matrix_.block<2, 2>(0, 2) = Eigen::Matrix2d::Zero();
Eigen::Vector3d measured_acceleration = Eigen::Vector3d::Zero();
if (new_object->sensor_type == SensorType::VELODYNE_64) {
belief_anchor_point_ = new_object->object->center;
belief_velocity_ = new_object->object->velocity;
if (GetLidarHistoryLength() >= 3) {
int old_velocity_index = GetLidarHistoryIndex(3);
Eigen::Vector3d old_velocity = history_velocity_[old_velocity_index];
double old_timediff =
GetHistoryTimediff(old_velocity_index, new_object->timestamp);
measured_acceleration = (belief_velocity_ - old_velocity) / old_timediff;
}
if ((GetLidarHistoryLength() >= 3 && GetRadarHistoryLength() >= 3) ||
history_velocity_.size() > 20) {
history_velocity_.pop_front();
history_time_diff_.pop_front();
history_velocity_is_radar_.pop_front();
}
history_velocity_.push_back(belief_velocity_);
history_time_diff_.push_back(new_object->timestamp);
history_velocity_is_radar_.push_back(false);
} else if (new_object->sensor_type == SensorType::RADAR) {
belief_anchor_point_(0) = new_object->object->center(0);
belief_anchor_point_(1) = new_object->object->center(1);
belief_velocity_(0) = new_object->object->velocity(0);
belief_velocity_(1) = new_object->object->velocity(1);
if (GetRadarHistoryLength() >= 3) {
int old_velocity_index = GetRadarHistoryIndex(3);
Eigen::Vector3d old_velocity = history_velocity_[old_velocity_index];
double old_timediff =
GetHistoryTimediff(old_velocity_index, new_object->timestamp);
measured_acceleration = (belief_velocity_ - old_velocity) / old_timediff;
}
if ((GetLidarHistoryLength() >= 3 && GetRadarHistoryLength() >= 3) ||
history_velocity_.size() > 20) {
history_velocity_.pop_front();
history_time_diff_.pop_front();
history_velocity_is_radar_.pop_front();
}
history_velocity_.push_back(belief_velocity_);
history_time_diff_.push_back(new_object->timestamp);
history_velocity_is_radar_.push_back(true);
} else if (new_object->sensor_type == SensorType::CAMERA) {
belief_anchor_point_(0) = new_object->object->center(0);
belief_anchor_point_(1) = new_object->object->center(1);
belief_velocity_(0) = new_object->object->velocity(0);
belief_velocity_(1) = new_object->object->velocity(1);
history_velocity_.push_back(belief_velocity_);
history_time_diff_.push_back(new_object->timestamp);
history_velocity_is_radar_.push_back(false);
} else {
AERROR << "unsupported sensor type for PbfKalmanMotionFusion: "
<< static_cast<int>(new_object->sensor_type);
return;
}
Eigen::Vector4d measurement;
measurement(0) = belief_anchor_point_(0);
measurement(1) = belief_anchor_point_(1);
measurement(2) = belief_velocity_(0);
measurement(3) = belief_velocity_(1);
// r_matrix_ = new_object.uncertainty_mat;
r_matrix_.setIdentity();
r_matrix_.topLeftCorner(2, 2) =
new_object->object->position_uncertainty.topLeftCorner(2, 2);
r_matrix_.block<2, 2>(2, 2) =
new_object->object->velocity_uncertainty.topLeftCorner(2, 2);
// Use lidar when there is no radar yet
if (GetRadarHistoryLength() == 0 && GetLidarHistoryLength() > 1) {
r_matrix_.setIdentity();
r_matrix_ *= 0.01;
}
k_matrix_ =
p_matrix_ * c_matrix_.transpose() *
(c_matrix_ * p_matrix_ * c_matrix_.transpose() + r_matrix_).inverse();
Eigen::Vector4d predict_measurement(priori_state_(0), priori_state_(1),
priori_state_(2), priori_state_(3));
posteriori_state_ =
priori_state_ + k_matrix_ * (measurement - predict_measurement);
p_matrix_ =
(Eigen::Matrix4d::Identity() - k_matrix_ * c_matrix_) * p_matrix_ *
(Eigen::Matrix4d::Identity() - k_matrix_ * c_matrix_).transpose() +
k_matrix_ * r_matrix_ * k_matrix_.transpose();
belief_anchor_point_(0) = posteriori_state_(0);
belief_anchor_point_(1) = posteriori_state_(1);
belief_velocity_(0) = posteriori_state_(2);
belief_velocity_(1) = posteriori_state_(3);
UpdateAcceleration(measured_acceleration);
if (belief_velocity_.head(2).norm() < 0.05) {
belief_velocity_ = Eigen::Vector3d(0, 0, 0);
}
}
void PbfKalmanMotionFusion::UpdateWithoutObject(const double time_diff) {
belief_anchor_point_ = belief_anchor_point_ + belief_velocity_ * time_diff;
}
void PbfKalmanMotionFusion::GetState(Eigen::Vector3d *anchor_point,
Eigen::Vector3d *velocity) {
*anchor_point = belief_anchor_point_;
*velocity = belief_velocity_;
}
void PbfKalmanMotionFusion::SetState(const Eigen::Vector3d &anchor_point,
const Eigen::Vector3d &velocity) {
belief_anchor_point_ = anchor_point;
belief_velocity_ = velocity;
}
int PbfKalmanMotionFusion::GetRadarHistoryLength() {
int history_length = 0;
for (size_t i = 0; i < history_velocity_is_radar_.size(); ++i) {
if (history_velocity_is_radar_[i]) {
history_length++;
}
}
return history_length;
}
int PbfKalmanMotionFusion::GetLidarHistoryLength() {
int history_length = history_velocity_is_radar_.size();
history_length -= GetRadarHistoryLength();
return history_length;
}
int PbfKalmanMotionFusion::GetLidarHistoryIndex(const int &history_seq) {
int history_index = 0;
int history_count = 0;
for (size_t i = 1; i <= history_velocity_is_radar_.size(); ++i) {
history_index = history_velocity_is_radar_.size() - i;
if (!history_velocity_is_radar_[history_index]) {
history_count++;
}
if (history_count == history_seq) {
break;
}
}
return history_index;
}
int PbfKalmanMotionFusion::GetRadarHistoryIndex(const int &history_seq) {
int history_index = 0;
int history_count = 0;
for (size_t i = 1; i <= history_velocity_is_radar_.size(); ++i) {
history_index = history_velocity_is_radar_.size() - i;
if (history_velocity_is_radar_[history_index]) {
history_count++;
}
if (history_count == history_seq) {
break;
}
}
return history_index;
}
double PbfKalmanMotionFusion::GetHistoryTimediff(
const int &history_index, const double ¤t_timestamp) {
double history_timestamp = history_time_diff_[history_index];
double history_timediff = current_timestamp - history_timestamp;
return history_timediff;
}
void PbfKalmanMotionFusion::UpdateAcceleration(
const Eigen::VectorXd &measured_acceleration) {
Eigen::Matrix2d mat_c = Eigen::Matrix2d::Identity();
Eigen::Matrix2d mat_q = Eigen::Matrix2d::Identity() * 0.5;
Eigen::Matrix2d mat_k =
p_matrix_.block<2, 2>(2, 2) * mat_c.transpose() *
(mat_c * p_matrix_.block<2, 2>(2, 2) * mat_c.transpose() + mat_q)
.inverse();
Eigen::Vector2d acceleration_gain =
mat_k *
(measured_acceleration.head(2) - mat_c * belief_acceleration_.head(2));
// breakdown
float breakdown_threshold = 2;
if (acceleration_gain.norm() > breakdown_threshold) {
acceleration_gain.normalize();
acceleration_gain *= breakdown_threshold;
}
belief_acceleration_(0) += acceleration_gain(0);
belief_acceleration_(1) += acceleration_gain(1);
}
} // namespace perception
} // namespace apollo
| 38.598706 | 93 | 0.707722 | berthu |
Subsets and Splits