splatclient::splatclient(string windowstyle,nCursesWindow *window, string ip, unsigned int port)
{
//SSL stuff
SSL_library_init();
ERR_load_crypto_strings();
ERR_load_SSL_strings();
OpenSSL_add_all_algorithms();
// init receive buffer
recv_buff.iMessageid=recv_buff.tSize=0;
memset(&(recv_buff.cMesg), '\0',CHUNK);
sessionID=0;
win=window;
sockfd=-1;
log= new cLogfile("splatclient.log",false);
msgID=0;
server_ip=ip;
server_port=port;
// vParseWindowstyle(windowstyle, window);
if (!win)
{
sLogelement C1(-1, "Keine Windowfunktion übergeben", false);
(*log)<<C1;
exit(1);
}
sLogelement C1(0, "Splatclient erschaffen", true);
(*log)<<C1;
*win<<C1;
if (!bConnect(port, ip))
{
win->windowstack.back()->nCgetwin().~nCursesWindow();
exit(1);
}
else
{
sLogelement C1(-1, "Verbindung hergestellt", true);
*win<<C1;
}
keypad(stdscr,true);
nodelay(win->windowstack.back()->win, true);
if (!iGetsocket())
{
sLogelement t1(-1,"No socket found!",false);//FATAL
*win<<t1;
win->windowstack.back()->nCgetwin().~nCursesWindow();
(*log) << t1;
exit(1);
}
//cFlow_client
bkgactive=true; //still need to be active for ping/pong messages
//MENU
menu=NULL;
vCreateMenu();
bDirty=true;
}
void foo(int coin) {
C1 c1 = coin ? C1(1) : C1(2);
if (coin) {
clang_analyzer_eval(c1.getX() == 1); // expected-warning{{TRUE}}
} else {
clang_analyzer_eval(c1.getX() == 2); // expected-warning{{TRUE}}
}
C2 c2 = coin ? C2(3, 4) : C2(5, 6);
if (coin) {
clang_analyzer_eval(c2.getX() == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(c2.getY() == 4); // expected-warning{{TRUE}}
} else {
clang_analyzer_eval(c2.getX() == 5); // expected-warning{{TRUE}}
clang_analyzer_eval(c2.getY() == 6); // expected-warning{{TRUE}}
}
}
int main()
{
C0().f0();
C1().f0();
C1().f1();
C2().f0();
C2().f1();
C2().f2();
C3().f0();
C3().f1();
C3().f2();
C3().f3();
}
int test_vector_add()
{
// Blog: http://blog.csdn.net/fengbingchun/article/details/74120057
// Vector addition: C = A + B, implements element by element vector addition
const int numElements{ 50000 };
std::vector<float> A(numElements), B(numElements), C1(numElements), C2(numElements);
// Initialize vector
for (int i = 0; i < numElements; ++i) {
A[i] = rand() / (float)RAND_MAX;
B[i] = rand() / (float)RAND_MAX;
}
float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds
int ret = vector_add_cpu(A.data(), B.data(), C1.data(), numElements, &elapsed_time1);
if (ret != 0) PRINT_ERROR_INFO(vectorAdd_cpu);
ret = vector_add_gpu(A.data(), B.data(), C2.data(), numElements, &elapsed_time2);
if (ret != 0) PRINT_ERROR_INFO(vectorAdd_gpu);
for (int i = 0; i < numElements; ++i) {
if (fabs(C1[i] - C2[i]) > EPS_) {
fprintf(stderr, "Result verification failed at element %d!\n", i);
return -1;
}
}
fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2);
return 0;
}
int test_long_vector_add()
{
// Blog: http://blog.csdn.net/fengbingchun/article/details/75570546
const int length{ 100000000 };
std::unique_ptr<float[]> A(new float[length]);
std::unique_ptr<float[]> B(new float[length]);
std::unique_ptr<float[]> C1(new float[length]);
std::unique_ptr<float[]> C2(new float[length]);
generator_random_number(A.get(), length, -1000.f, 1000.f);
generator_random_number(B.get(), length, -1000.f, 1000.f);
float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds
int ret = long_vector_add_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1);
if (ret != 0) PRINT_ERROR_INFO(long_vector_add_cpu);
ret = long_vector_add_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2);
if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu);
int count_error{ 0 };
for (int i = 0; i < length; ++i) {
if (count_error > 100) return -1;
if (fabs(C1[i] - C2[i]) > EPS_) {
fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f\n",
i, C1[i], C2[i]);
++count_error;
}
}
fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2);
return 0;
}
//--------------------------------------------------------------
void ofApp::setup(){
ofSetFrameRate(60.0f);
for(int i=0;i<12;i++)
{
randColorDrop();
}
Attractor.reset(new ColorDropAttractor());
Merger.reset(new ColorDropMerger());
Dragger.reset(new ColorDropDragger());
ofPtr<ColorHole> H;
ofFloatColor C0(ofFloatColor::yellow);
C0.setBrightness(0.7f);
H.reset(new ColorHole(
ofVec2f(200,200),
C0,2600));
Holes.push_back(H);
ofFloatColor C1(ofFloatColor::cyan);
C1.setBrightness(0.7f);
H.reset(new ColorHole(
ofVec2f(750,240),
ofFloatColor(0.8f,0.0f,0.8f,1),3000));
Holes.push_back(H);
ofFloatColor C2(ofFloatColor::violet);
C2.setBrightness(0.7f);
H.reset(new ColorHole(
ofVec2f(450,500),
ofFloatColor(0.0f,0.9f,0.9f,1),3800));
Holes.push_back(H);
}
int test_matrix_mul()
{
// Blog: http://blog.csdn.net/fengbingchun/article/details/76618165
// Matrix multiplication: C = A * B
// 矩阵A、B的宽、高应是32的整数倍
const int rowsA{ 352 }, colsA{ 672 }, rowsB = colsA, colsB{ 384 };
std::unique_ptr<float[]> A(new float[colsA*rowsA]);
std::unique_ptr<float[]> B(new float[colsB*rowsB]);
std::unique_ptr<float[]> C1(new float[rowsA*colsB]);
std::unique_ptr<float[]> C2(new float[rowsA*colsB]);
generator_random_number(A.get(), colsA*rowsA, -1.f, 1.f);
generator_random_number(B.get(), colsB*rowsB, -1.f, 1.f);
float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds
int ret = matrix_mul_cpu(A.get(), B.get(), C1.get(), colsA, rowsA, colsB, rowsB, &elapsed_time1);
if (ret != 0) PRINT_ERROR_INFO(matrix_mul_cpu);
ret = matrix_mul_gpu(A.get(), B.get(), C2.get(), colsA, rowsA, colsB, rowsB, &elapsed_time2);
if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu);
int count{ 0 };
for (int i = 0; i < rowsA*colsB; ++i) {
if (count > 100) return -1;
if (fabs(C1[i] - C2[i]) > EPS_) {
fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f\n",
i, C1[i], C2[i]);
++count;
}
}
fprintf(stderr, "test matrix mul: cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2);
return 0;
}
void graphics::NgoiLang(QPainter& painter,int x,int y,int c,int r)
{
QPoint A(x-r/2,y+c);
QPoint B(x+r/2,y+c);
QPoint C(x+r/2,y+c/3);
QPoint D(x,y);
QPoint E(x-r/2,y+c/3);
QPolygon poly1;
poly1 << D << E << A << B << C;
painter.drawPolygon(poly1);
// ve cai cua
QPoint A1(x,y+c);
QPoint B1(x,y+2*c/3);
QPoint C1(x-r/4,y+2*c/3);
QPoint D1(x-r/4,y+c);
QPolygon poly2;
poly2 << A1 << B1 << C1 << D1;
painter.drawPolyline(poly2);
// ve cua so
QPoint A11(x-r/4,y+c/6);
QPoint B11(x-r/4,y);
QPoint C11(x-r/8,y);
QPoint D11(x-r/8,y+c/12);
QPolygon poly21;
poly21 << A11 << B11 << C11 << D11;
painter.drawPolygon(poly21);
painter.drawRect(x+r/4,y+c/2.5,c/10,r/10);
}
void graphics::NgoiNhaTiHon(QPainter& painter)
{
QPoint A(150,450);
QPoint B(350,450);
QPoint C(350,200);
QPoint D(250,100);
QPoint E(150,200);
QPolygon poly1;
poly1 << A << B << C << D << E;
painter.drawPolygon(poly1);
// cai cua
QPoint A1(250,450);
QPoint B1(250,300);
QPoint C1(200,300);
QPoint D1(200,450);
QPolygon poly11;
poly11 << A1 << B1 << C1 << D1;
painter.drawPolygon(poly11);
painter.drawRect(300,250,30,30);
// ong khoi
QPoint A12(200,150);
QPoint B12(200,90);
QPoint C12(175,90);
QPoint D12(175,175);
QPolygon poly12;
poly12 << A12 << B12 << C12 << D12;
painter.drawPolyline(poly12);
}
void ViewmdaModel::setC1(int i) {
if (m_d1<0) return;
if (C1()==i) return;
if ((i<0)||(i>=N1())) return;
m_current_index[m_d1]=i;
emit currentIndexChanged();
}
int sc_main (int argc , char *argv[])
{
#ifdef KASCPAR
veri_signal<bool> s1;
veri_signal<bool> s2;
veri_signal<bool> s3;
#else
sc_core::sc_signal<bool> s1("s1"), s2("s2");//, s3("s3");
#endif
Component C1("C1");
Component C2("C2");
// Component C3("C3");
// // superclass* C;
// // C = dynamic_cast<superclass*>(&C3);
// // superclass* S = C;
// // Component* res = dynamic_cast<Component*>(S);
C1.out(s1);
C2.out(s2);
// // (*res).out(s3);
// C3.out(s3);
C1.in(s2);
C2.in(s1);
// C3.in(s2);
// C1.isHead = true;
//Run the Simulation for "200 nanosecnds"
sc_start(200, SC_NS);
return 0;
}
int main(int argc, char** argv){
irqSet(IRQ_VBLANK, &vblank);
#ifdef TEXTMODE
videoSetMode(MODE_0_2D);
videoSetModeSub(MODE_0_2D);
vramSetBankA(VRAM_A_MAIN_BG);
vramSetBankC(VRAM_C_SUB_BG);
#endif//TEXTMODE
Display::init();
keysSetRepeat(30, 12);
srand(time(NULL));
Player P1(FGrave);
Player P2(FMidori);
ControlLocal C1(P1);
ControlAI C2(P2);
//DisplayPlayerOverview a(0, 0, 0, 32, 1, P1);
//DisplayContainer b(0, 0, 1, 32, 21, P1.hand());
//DisplayCard c(1, 0, 0, 32, 24, P1.hand().at(0), false);
Game(&C1, &C2);
while(1){
update();
}
return 0;
}
// Run a single benchmark for multiplying m x k x n with num_steps of recursion.
// To just call GEMM, set num_steps to zero.
// The median of five trials is printed to std::cout.
// If run_check is true, then it also
void SingleBenchmark(int m, int k, int n, int num_steps, int algorithm) {
// Run a set number of trials and pick the median time.
int num_trials = 1;
std::vector<double> times(num_trials);
for (int trial = 0; trial < num_trials; ++trial) {
Matrix<double> A = RandomMatrix<double>(m, k);
Matrix<double> B = RandomMatrix<double>(k, n);
Matrix<double> C1(m, n);
if (algorithm == SMIRNOV54) {
times[trial] = square54_1::FastMatmul(A, B, C1, 3);
} else if (algorithm == MKL) {
times[trial] = strassen::FastMatmul(A, B, C1, 0);
} else if (algorithm == STRASSEN) {
times[trial] = strassen::FastMatmul(A, B, C1, num_steps);
} else if (algorithm == SCHONHAGE333_21_117_APPROX) {
times[trial] = schonhage333_21_117_approx::FastMatmul(A, B, C1, num_steps);
}
}
// Spit out the median time
std::sort(times.begin(), times.end());
size_t ind = num_trials / 2;
std::cout << " " << m << " " << k << " " << n << " "
<< num_steps << " " << times[ind] << " "
<< "; ";
}
int test_streams()
{
// Blog: http://blog.csdn.net/fengbingchun/article/details/76532198
const int length{ 1024 * 1024 * 20};
std::unique_ptr<int[]> A(new int[length]);
std::unique_ptr<int[]> B(new int[length]);
std::unique_ptr<int[]> C1(new int[length]);
std::unique_ptr<int[]> C2(new int[length]);
generator_random_number<int>(A.get(), length, -100, 100);
generator_random_number<int>(B.get(), length, -100, 100);
std::for_each(C1.get(), C1.get() + length, [](int& n) {n = 0; });
std::for_each(C2.get(), C2.get() + length, [](int& n) {n = 0; });
float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds
int ret = streams_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1);
if (ret != 0) PRINT_ERROR_INFO(streams_cpu);
ret = streams_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2);
if (ret != 0) PRINT_ERROR_INFO(streams_gpu);
for (int i = 0; i < length; ++i) {
if (C1[i] != C2[i]) {
fprintf(stderr, "their values are different at: %d, val1: %d, val2: %d\n",
i, C1[i], C2[i]);
return -1;
}
}
fprintf(stderr, "test streams' usage: cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2);
return 0;
}
bool intersectsRect(Vector2 A, Vector2 B, double x, double y, double width, double height) {
Vector2 C0(x, y);
Vector2 D0(x + width, y);
Vector2 C1(x + width, y);
Vector2 D1(x + width, y + height);
Vector2 C2(x + width, y + height);
Vector2 D2(x, y + height);
Vector2 C3(x, y + height);
Vector2 D3(x, y);
bool I0, I1, I2, I3;
Vector2 buf;
I0 = intersects(A, B, C0, D0, buf);
I1 = intersects(A, B, C1, D1, buf);
I2 = intersects(A, B, C2, D2, buf);
I3 = intersects(A, B, C3, D3, buf);
if(I0 || I1 || I2 || I3) {
return false;
}
return true;
}
void inter_sphere(t_caster *caster, t_object *sphere)
{
double delt;
double a;
double b;
double c;
init_temp_pos(caster, sphere);
a = A1(caster->temp_vec.x, caster->temp_vec.y, caster->temp_vec.z);
b = B1(caster->temp_vec.x, caster->temp_pos.x, caster->temp_vec.y,
caster->temp_pos.y, caster->temp_vec.z, caster->temp_pos.z);
c = C1(sphere->data.radius, caster->temp_pos.x, caster->temp_pos.y
, caster->temp_pos.z);
delt = (pow(b, 2.0) - 4.0 * (a * c));
if (delt >= 0.0)
{
sphere->dist = get_nearest((- b - sqrt(delt)) / (2.0 * a),
(- b + sqrt(delt)) / (2.0 * a));
if (sphere->dist > 0.0 && sphere->dist < caster->intersection.dist)
{
caster->intersection.brightness = sphere->brightness;
init_intersection(caster, sphere);
rotate_caster(caster, sphere);
}
}
}
double SpinAdapted::StackCreCreDesDes::redMatrixElement(Csf c1, vector<Csf>& ladder, const StackSpinBlock* b)
{
assert( build_pattern == "(((CC)(D))(D))" );
double element = 0.0;
int I = get_orbs()[0];
int J = get_orbs()[1];
int K = get_orbs()[2];
int L = get_orbs()[3];
int Slaterlength = c1.det_rep.begin()->first.size();
vector<bool> backupSlater1(Slaterlength,0), backupSlater2(Slaterlength,0);
// Must take into account how the 4-index is built from a combination of the 2-index ops
std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(D))(D))");
assert( quantum_ladder.size() == 3 );
SpinQuantum deltaQuantum12 = quantum_ladder.at(0);
SpinQuantum deltaQuantum123 = quantum_ladder.at(1);
SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);
//FIXME components != 0
deltaQuantum[0] = deltaQuantum1234;
// Spin quantum data for CC
IrrepSpace sym12 = deltaQuantum12.get_symm();
int irrep12 = deltaQuantum12.get_symm().getirrep();
int spin12 = deltaQuantum12.get_s().getirrep();
// Spin quantum data for (CC)D
IrrepSpace sym123 = deltaQuantum123.get_symm();
int irrep123 = deltaQuantum123.get_symm().getirrep();
int spin123= deltaQuantum123.get_s().getirrep();
// Spin quantum data for total operator
IrrepSpace sym1234 = deltaQuantum1234.get_symm();
int irrep1234 = deltaQuantum1234.get_symm().getirrep();
int spin1234 = deltaQuantum1234.get_s().getirrep();
TensorOp C1(I, 1);
TensorOp C2(J, 1);
TensorOp D3(K,-1);
TensorOp D4(L,-1);
TensorOp CC = C1.product(C2, spin12, irrep12);
TensorOp CCD = CC.product(D3, spin123, irrep123);
TensorOp CCDD = CCD.product(D4, spin1234, irrep1234);
//FIXME loop over deltaQuantum components
int j = 0;
for (int i=0; i<ladder.size(); i++)
{
int index = 0; double cleb=0.0;
if (nonZeroTensorComponent(c1, deltaQuantum[j], ladder[i], index, cleb)) {
std::vector<double> MatElements = calcMatrixElements(c1, CCDD, ladder[i], backupSlater1, backupSlater2) ;
element = MatElements[index]/cleb;
break;
}
else
continue;
}
return element;
}
bool collision(const CircleHitBox &cercleBox1, const CircleHitBox &cercleBox2)
{
sf::Vector2f C1(cercleBox1.p), C2(cercleBox2.p);
float d2 = (C1.x-C2.x)*(C1.x-C2.x) + (C1.y-C2.y)*(C1.y-C2.y);
if (d2 > (cercleBox1.rayon + cercleBox2.rayon)*(cercleBox1.rayon + cercleBox2.rayon))
return false;
else
return true;
}
virtual void compute(const vd::Time& t)
{
f2 = DSAT() * C2();
f1 = C1() * p1;
grad(C3) = (f2);
grad(C1) = 0 - (f1);
grad(DSAT) = 0;
grad(C2) = (f1) - (f2);
}
void RatioNSDistanceTransform::processRow(const BinaryPixelType *imageRow) {
int col;
#define N1_SETMINUS_N2_COUNT 1
#define N2_SETMINUS_N1_COUNT 5
#define N1_CAP_N2_COUNT 3
static vect n1[N1_SETMINUS_N2_COUNT] = {{-1, 1}};
static vect n2[N2_SETMINUS_N1_COUNT] = {{1, 0}, {2, 0}, {2, 1}, {1, 2}, {2, 2}};
static vect n12[N1_CAP_N2_COUNT] = {{0, 1}, {1, 1}, {0, 2}};
for (col = 0; col < _cols; col++) {
if (imageRow[col] == 0)
dtLines[0][col + 2] = 0;
else {
GrayscalePixelType val;
GrayscalePixelType dt;
int k;
val = GRAYSCALE_MAX;
for (k = 0; k < N1_SETMINUS_N2_COUNT; k++) {
assert(n1[k].y >= 0);
assert(n1[k].y <= 2);
assert(col + 2 - n1[k].x >= 0);
assert(col + 2 - n1[k].x < _cols + 3);
val = std::min(val, dtLines[n1[k].y][col + 2 - n1[k].x]);
}
assert(C1(d.num, d.den, (int) val) == d.mbf1i(d.mbf1(val)+1)+1);
dt = std::min((int)_dMax, d.mbf1i(d.mbf1(val)+1)+1);
val = GRAYSCALE_MAX;
for (k = 0; k < N2_SETMINUS_N1_COUNT; k++) {
assert(n2[k].y >= 0);
assert(n2[k].y <= 2);
assert(col + 2 - n2[k].x >= 0);
assert(col + 2 - n2[k].x < _cols + 3);
val = std::min(val, dtLines[n2[k].y][col + 2 - n2[k].x]);
}
assert(C2(d.num, d.den, (int) val) == d.mbf2i(d.mbf2(val)+1)+1);
dt = std::min((int) dt, d.mbf2i(d.mbf2(val)+1)+1);
val = GRAYSCALE_MAX;
for (k = 0; k < N1_CAP_N2_COUNT; k++) {
assert(n12[k].y >= 0);
assert(n12[k].y <= 2);
assert(col + 2 - n12[k].x >= 0);
assert(col + 2 - n12[k].x < _cols + 3);
val = std::min(val, dtLines[n12[k].y][col + 2 - n12[k].x]);
}
dt = std::min((int) dt, val + 1);
dtLines[0][col + 2] = dt;
}
}
_consumer->processRow(dtLines[0]+2);
rotate();
}
int test_string_cast_vector()
{
int Error = 0;
glm::vec2 A1(1, 2);
std::string A2 = glm::to_string(A1);
Error += A2 != std::string("fvec2(1.000000, 2.000000)") ? 1 : 0;
glm::vec3 B1(1, 2, 3);
std::string B2 = glm::to_string(B1);
Error += B2 != std::string("fvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
glm::vec4 C1(1, 2, 3, 4);
std::string C2 = glm::to_string(C1);
Error += C2 != std::string("fvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
glm::ivec2 D1(1, 2);
std::string D2 = glm::to_string(D1);
Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0;
glm::ivec3 E1(1, 2, 3);
std::string E2 = glm::to_string(E1);
Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0;
glm::ivec4 F1(1, 2, 3, 4);
std::string F2 = glm::to_string(F1);
Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0;
glm::hvec2 G1(1, 2);
std::string G2 = glm::to_string(G1);
Error += G2 != std::string("hvec2(1.0000, 2.0000)") ? 1 : 0;
glm::hvec3 H1(1, 2, 3);
std::string H2 = glm::to_string(H1);
Error += H2 != std::string("hvec3(1.0000, 2.0000, 3.0000)") ? 1 : 0;
glm::hvec4 I1(1, 2, 3, 4);
std::string I2 = glm::to_string(I1);
Error += I2 != std::string("hvec4(1.0000, 2.0000, 3.0000, 4.0000)") ? 1 : 0;
glm::dvec2 J1(1, 2);
std::string J2 = glm::to_string(J1);
Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0;
glm::dvec3 K1(1, 2, 3);
std::string K2 = glm::to_string(K1);
Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
glm::dvec4 L1(1, 2, 3, 4);
std::string L2 = glm::to_string(L1);
Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
return Error;
}
double SpinAdapted::CreCreCreCre::redMatrixElement(Csf c1, vector<Csf>& ladder, const SpinBlock* b)
{
assert( build_pattern == "(((CC)(C))(C))" );
double element = 0.0;
int I = get_orbs()[0];
int J = get_orbs()[1];
int K = get_orbs()[2];
int L = get_orbs()[3];
// Must take into account how the 4-index is built from a combination of the 2-index ops
std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(C))(C))");
assert( quantum_ladder.size() == 3 );
SpinQuantum deltaQuantum12 = quantum_ladder.at(0);
SpinQuantum deltaQuantum123 = quantum_ladder.at(1);
SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);
deltaQuantum[0] = deltaQuantum1234;
// Spin quantum data for CC
IrrepSpace sym12 = deltaQuantum12.get_symm();
int irrep12 = deltaQuantum12.get_symm().getirrep();
int spin12 = deltaQuantum12.get_s().getirrep();
// Spin quantum data for (CC)C
IrrepSpace sym123 = deltaQuantum123.get_symm();
int irrep123 = deltaQuantum123.get_symm().getirrep();
int spin123= deltaQuantum123.get_s().getirrep();
// Spin quantum data for total operator
IrrepSpace sym1234 = deltaQuantum1234.get_symm();
int irrep1234 = deltaQuantum1234.get_symm().getirrep();
int spin1234 = deltaQuantum1234.get_s().getirrep();
TensorOp C1(I, 1);
TensorOp C2(J, 1);
TensorOp C3(K, 1);
TensorOp C4(L, 1);
TensorOp CC = C1.product(C2, spin12, irrep12);
TensorOp CCC = CC.product(C3, spin123, irrep123);
TensorOp CCCC = CCC.product(C4, spin1234, irrep1234);
for (int i=0; i<ladder.size(); i++)
{
int index = 0; double cleb=0.0;
if (nonZeroTensorComponent(c1, deltaQuantum[0], ladder[i], index, cleb)) {
std::vector<double> MatElements = calcMatrixElements(c1, CCCC, ladder[i]) ;
element = MatElements[index]/cleb;
break;
}
else
continue;
}
return element;
}
void testConstructor2()
{
MRR stdfRec;
stdfRec["DISP_COD"]=C1('M');
TS_ASSERT_EQUALS(stdfRec.storage(), 7u);
std::vector<std::basic_string<char> > str;
stdfRec.to_string(str);
TS_ASSERT_EQUALS(str[0], "7");
TS_ASSERT_EQUALS(str[1], "1");
TS_ASSERT_EQUALS(str[2], "20");
TS_ASSERT_EQUALS(str[3], "0");
TS_ASSERT_EQUALS(str[4], "M");
}
Molecule C2H4()
{
int nAtoms = 6;
Eigen::Vector3d C1(0.0000000000, 0.0000000000, 1.2578920000);
Eigen::Vector3d H1(0.0000000000, 1.7454620000, 2.3427160000);
Eigen::Vector3d H2(0.0000000000, -1.7454620000, 2.3427160000);
Eigen::Vector3d C2(0.0000000000, 0.0000000000, -1.2578920000);
Eigen::Vector3d H3(0.0000000000, 1.7454620000, -2.3427160000);
Eigen::Vector3d H4(0.0000000000, -1.7454620000, -2.3427160000);
Eigen::MatrixXd geom(3, nAtoms);
geom.col(0) = C1.transpose();
geom.col(1) = H1.transpose();
geom.col(2) = H2.transpose();
geom.col(3) = C2.transpose();
geom.col(4) = H3.transpose();
geom.col(5) = H4.transpose();
Eigen::VectorXd charges(6), masses(6);
charges << 6.0, 1.0, 1.0, 6.0, 1.0, 1.0;
masses << 12.00, 1.0078250, 1.0078250, 12.0, 1.0078250, 1.0078250;
double radiusC = (1.70 * 1.20) / convertBohrToAngstrom;
double radiusH = (1.20 * 1.20) / convertBohrToAngstrom;
std::vector<Atom> atoms;
atoms.push_back( Atom("Carbon", "C", charges(0), masses(0), radiusC, C1, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(1), masses(1), radiusH, H1, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(2), masses(2), radiusH, H2, 1.0) );
atoms.push_back( Atom("Carbon", "C", charges(3), masses(3), radiusC, C2, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(4), masses(4), radiusH, H3, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(5), masses(5), radiusH, H4, 1.0) );
std::vector<Sphere> spheres;
Sphere sph1(C1, radiusC);
Sphere sph2(H1, radiusH);
Sphere sph3(H2, radiusH);
Sphere sph4(C2, radiusC);
Sphere sph5(H3, radiusH);
Sphere sph6(H4, radiusH);
spheres.push_back(sph1);
spheres.push_back(sph2);
spheres.push_back(sph3);
spheres.push_back(sph4);
spheres.push_back(sph5);
spheres.push_back(sph6);
// D2h as generated by Oxy, Oxz, Oyz
Symmetry pGroup = buildGroup(3, 4, 2, 1);
return Molecule(nAtoms, charges, masses, geom, atoms, spheres, pGroup);
};
BOOL CARIB8CharDecode::Analyze( const BYTE* pbSrc, DWORD dwSrcSize, DWORD* pdwReadSize )
{
if( pbSrc == NULL || dwSrcSize == 0 || pdwReadSize == NULL){
return FALSE;
}
BOOL bRet = TRUE;
DWORD dwReadSize = 0;
while( dwReadSize < dwSrcSize ){
DWORD dwReadBuff = 0;
//1バイト目チェック
if( pbSrc[dwReadSize] <= 0x20 ){
//C0制御コード
bRet = C0( pbSrc+dwReadSize, &dwReadBuff );
dwReadSize += dwReadBuff;
if( bRet == FALSE ){
return FALSE;
}else if( bRet == 2 ){
bRet = TRUE;
break;
}
}else if( pbSrc[dwReadSize] > 0x20 && pbSrc[dwReadSize] < 0x7F ){
//GL符号領域
if( GL( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){
return FALSE;
}
dwReadSize += dwReadBuff;
}else if( pbSrc[dwReadSize] >= 0x7F && pbSrc[dwReadSize] <= 0xA0 ){
//C1制御コード
bRet = C1( pbSrc+dwReadSize, &dwReadBuff );
dwReadSize += dwReadBuff;
if( bRet == FALSE ){
return FALSE;
}else if( bRet == 2 ){
bRet = TRUE;
break;
}
}else if( pbSrc[dwReadSize] > 0xA0 && pbSrc[dwReadSize] < 0xFF ){
//GR符号領域
if( GR( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){
return FALSE;
}
dwReadSize += dwReadBuff;
}
}
*pdwReadSize = dwReadSize;
return bRet;
}
inline void subtractMultipleTo(DMatQQ& C,
const DMatQQ& A,
const DMatQQ& B)
{
FlintQQMat A1(A);
FlintQQMat B1(B);
FlintQQMat C1(C);
FlintQQMat result1(A.numRows(), B.numColumns());
FlintQQMat D1(A.numRows(), B.numColumns());
fmpq_mat_mul(D1.value(), A1.value(), B1.value());
fmpq_mat_sub(C1.value(), C1.value(), D1.value());
C1.toDMat(C);
}
inline void addMultipleTo(DMatZZGMP& C,
const DMatZZGMP& A,
const DMatZZGMP& B)
{
FlintZZMat A1(A);
FlintZZMat B1(B);
FlintZZMat C1(C);
FlintZZMat result1(A.numRows(), B.numColumns());
FlintZZMat D1(A.numRows(), B.numColumns());
fmpz_mat_mul(D1.value(), A1.value(), B1.value());
fmpz_mat_add(C1.value(), C1.value(), D1.value());
C1.toDMat(C);
}
void Foam::maxwellSlipUFvPatchVectorField::updateCoeffs()
{
if (updated())
{
return;
}
const fvPatchScalarField& pmu =
patch().lookupPatchField<volScalarField, scalar>(muName_);
const fvPatchScalarField& prho =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
const fvPatchField<scalar>& ppsi =
patch().lookupPatchField<volScalarField, scalar>(psiName_);
Field<scalar> C1
(
sqrt(ppsi*constant::mathematical::piByTwo)
* (2.0 - accommodationCoeff_)/accommodationCoeff_
);
Field<scalar> pnu(pmu/prho);
valueFraction() = (1.0/(1.0 + patch().deltaCoeffs()*C1*pnu));
refValue() = Uwall_;
if (thermalCreep_)
{
const volScalarField& vsfT =
this->db().objectRegistry::lookupObject<volScalarField>(TName_);
label patchi = this->patch().index();
const fvPatchScalarField& pT = vsfT.boundaryField()[patchi];
Field<vector> gradpT(fvc::grad(vsfT)().boundaryField()[patchi]);
vectorField n(patch().nf());
refValue() -= 3.0*pnu/(4.0*pT)*transform(I - n*n, gradpT);
}
if (curvature_)
{
const fvPatchTensorField& ptauMC =
patch().lookupPatchField<volTensorField, tensor>(tauMCName_);
vectorField n(patch().nf());
refValue() -= C1/prho*transform(I - n*n, (n & ptauMC));
}
mixedFixedValueSlipFvPatchVectorField::updateCoeffs();
}
int main(int argc, char **argv) {
int m = 8000;
int k = 3600;
int n = 3600;
int numsteps = 1;
Matrix<double> A = RandomMatrix<double>(m, k);
Matrix<double> B = RandomMatrix<double>(k, n);
Matrix<double> C1(m, n), C2(m, n);
Time([&] { MatMul(A, B, C1); }, "Classical gemm");
Time([&] { grey433_29_234::FastMatmul(A, B, C2, numsteps); }, "Fast (4, 3, 3)");
// Test for correctness.
std::cout << "Maximum relative difference: " << MaxRelativeDiff(C1, C2) << std::endl;
return 0;
}
/*!
* @param rxn Reaction index of the current reaction. This is used
* as an index into vectors which have length n_total_rxn.
* @param k This is a vector of integer values specifying the
* species indices. The length of this vector species
* the number of different species in the description.
* The value of the entries are the species indices.
* These are used as indexes into vectors which have
* length n_total_species.
* @param order This is a vector of the same length as vector k.
* The order is used for the routine power(), which produces
* a power law expression involving the species vector.
* @param stoich This is used to handle fractional stoichiometric coefficients
* on the product side of irreversible reactions.
*/
void StoichManagerN::add(size_t rxn, const std::vector<size_t>& k, const vector_fp& order,
const vector_fp& stoich) {
//printf ("add called\n");
if (order.size() != k.size()) {
throw CanteraError("StoichManagerN::add()", "size of order and species arrays differ");
}
if (stoich.size() != k.size()) {
throw CanteraError("StoichManagerN::add()", "size of stoich and species arrays differ");
}
bool frac = false;
for (size_t n = 0; n < stoich.size(); n++) {
if (fmod(stoich[n], 1.0) || fmod(order[n], 1.0)) {
frac = true;
break;
}
}
if (frac || k.size() > 3) {
m_cn_list.push_back(C_AnyN(rxn, k, order, stoich));
} else {
// Try to express the reaction with unity stoichiometric
// coefficients (by repeating species when necessary) so that the
// simpler 'multiply' function can be used to compute the rate
// instead of 'power'.
std::vector<size_t> kRep;
for (size_t n = 0; n < k.size(); n++) {
for (size_t i = 0; i < stoich[n]; i++)
kRep.push_back(k[n]);
}
switch (kRep.size()) {
case 1:
m_c1_list.push_back(C1(rxn, kRep[0]));
break;
case 2:
m_c2_list.push_back(C2(rxn, kRep[0], kRep[1]));
break;
case 3:
m_c3_list.push_back(C3(rxn, kRep[0], kRep[1], kRep[2]));
break;
default:
m_cn_list.push_back(C_AnyN(rxn, k, order, stoich));
}
}
}
