Kun-AI-san/stack_v2_cpjp · Datasets at Hugging Face

54b980c8ed992b4bc5065d1fb4588e60d918bd20

8c65e16ed25b02cfed0000c50c79754efa044240

/src/core/transport_virtual_layer_policies/init_packets/ssf_request.h

b7cf6df2c4f6eb74d4b5decd8264d39204325cac

[ "BSD-3-Clause", "BSL-1.0", "OpenSSL", "MIT" ]

permissive

chrisaljoudi/ssf

00641a6aaa5ddf0e45a6a3db2c2f541c5276f27b

768576185d902f40bf86b81a6dd2f1e9ae382655

refs/heads/develop

2020-04-07T15:24:19.593974

2015-10-16T14:41:11

52,850,359

0

1

null

2016-03-01T05:23:29

null

UTF-8

C++

false

848

h

ssf_request.h

#ifndef SSF_CORE_TRANSPORT_VIRTUAL_LAYER_POLICIES_INIT_PACKETS_SSF_REQUEST_H_ #define SSF_CORE_TRANSPORT_VIRTUAL_LAYER_POLICIES_INIT_PACKETS_SSF_REQUEST_H_ #include <cstdint> #include <array> #include <memory> #include <boost/asio/buffer.hpp> namespace ssf { class SSFRequest { public: typedef uint32_t version_field_type; enum { field_number = 1, total_size = sizeof(version_field_type) }; public: SSFRequest(); SSFRequest(version_field_type version); version_field_type version() const; std::array<boost::asio::const_buffer, field_number> const_buffer() const; std::array<boost::asio::mutable_buffer, field_number> buffer(); private: version_field_type version_; }; typedef std::shared_ptr<SSFRequest> SSFRequestPtr; } // ssf #endif // SSF_CORE_TRANSPORT_VIRTUAL_LAYER_POLICIES_INIT_PACKETS_SSF_REQUEST_H_

c19c5fd2192e88be34d272548ab38b343d86ecbe

0eff74b05b60098333ad66cf801bdd93becc9ea4

/second/download/CMake/CMake-gumtree/Kitware_CMake_repos_basic_block_block_6413.cpp

63d926dec104bc57ebef4326521b0f35c394d976

[]

no_license

niuxu18/logTracker-old

97543445ea7e414ed40bdc681239365d33418975

f2b060f13a0295387fe02187543db124916eb446

refs/heads/master

2021-09-13T21:39:37.686481

2017-12-11T03:36:34

null

0

null

UTF-8

C++

false

110

cpp

Kitware_CMake_repos_basic_block_block_6413.cpp

{ len = snprintf(ptr, left, " libidn2/%s", idn2_check_version(NULL)); left -= len; ptr += len; }

b3336451f86d9c030a33fe4279b2d8fef596e8fb

645d66f2b2c091e270669028d5cd74023ba3bba5

/sphIncompress.cpp

6e4a23f9529d51a7456bf3b6fadc760a607e004c

[]

no_license

ZoraSawyer/SPH-DEM

44eea86a101791dcff0c1af5904fe649798a3f8c

0ba9973e4ef2e8ffd051d14577ad9d20847d2eb0

refs/heads/master

2023-05-28T02:45:48.121880

2016-06-06T08:58:48

null

0

null

UTF-8

C++

false

9,007

cpp

sphIncompress.cpp

#include "sphIncompress.h" void CsphIncompress::start() { data->traverse<driftRAndKick,ifSphOrSphBoundaryOrImmersedDem>(); #ifdef LIQ_DEM data->traverse<driftR,ifDem>(); #endif #ifdef SLK data->globals.slkIndex0++; data->globals.slkIndexLast++; if (data->globals.slkIndex0>=SLK_NUM_TIMESTEPS) data->globals.slkIndex0 = 0; if (data->globals.slkIndexLast>=SLK_NUM_TIMESTEPS) data->globals.slkIndexLast = 0; #endif data->traverse<driftRest,ifSphOrSphBoundaryOrImmersedDem>(); data->globals.time += data->globals.dt/2; //if ((data->globals.sphStep < DAMP_STEPS)||(data->globals.sphStep%REINIT_DENS_EVERY_N_STEPS==0)) { if ((data->globals.sphStep%REINIT_DENS_EVERY_N_STEPS==0)||(data->globals.sphStep == REINIT_DENS_AT_N_STEPS)) { data->reset(); #ifdef MY_VAR_RES data->neighboursGroup<calcGradVLeastSquares,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<vect,readGradV0,writeGradV0>(); data->syncParticlesBetweenProcs<vect,readGradV1,writeGradV1>(); //data->syncParticlesBetweenProcs<vect,readGradV2,writeGradV2>(); #endif //if (data->globals.mpiRank==0) cout<<"\tRe-initialising density...sphStep="<<data->globals.sphStep<<endl; for (int i=0;i<10;i++) { data->traverse<calcHFromDens,ifSphOrSphBoundaryOrImmersedDemOrGhost>(); data->syncParticlesBetweenProcs<double,readH,writeH>(); data->neighboursGroup<calcDensity,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<double,readDens,writeDens>(); } } data->traverse<initSumsMiddle,ifSphOrSphBoundaryOrImmersedDem>(); } void CsphIncompress::middle() { data->globals.newDt = data->globals.maxdt; #ifdef SMOOTHED_VISC_VELOCITY data->reset(SMOOTH_HFAC_MULT); data->findBothNeighbours<ifSph>(); #endif #ifdef SPH_SMOOTHING data->reset(SMOOTH_HFAC_MULT); data->findBothNeighbours<ifSph>(); #endif #ifdef GRID_SMOOTHING data->reset(); #endif #ifndef SMOOTHING //cout <<"rank = "<<data->globals.mpiRank<<"before reset "<<endl; data->reset(); //cout <<"rank = "<<data->globals.mpiRank<<"after reset "<<endl; #endif timeval t1,t2; gettimeofday(&t1,NULL); #ifdef LIQ_DEM data->neighboursGroupCoupling<calcPorosity,ifSphOrSphBoundaryOrImmersedDem>(); #ifndef LIQ_DEM_ONE_WAY_COUPLE #ifdef LIQ_DEM_SEPARATE_DRAGS data->neighboursGroupCoupling<calcSPHDrag,ifSphOrSphBoundaryOrImmersedDem>(); #else data->traverse<initShepSum,ifDemOrGhost>(); data->neighboursGroupCoupling<calcShepSum,ifSphOrSphBoundaryOrImmersedDem>(); data->reverseSyncParticlesBetweenProcs<double,readShepSum,sumShepSum>(); data->syncParticlesBetweenProcs<double,readShepSum,writeShepSum>(); data->neighboursGroupCoupling<calcDEMtoSPHDrag,ifSphOrSphBoundaryOrImmersedDem>(); #endif #endif data->traverse<finalisePorosity,ifSphOrSphBoundaryOrImmersedDem>(); data->traverse<setPorosityForBoundary,ifBoundary>(); data->syncParticlesBetweenProcs<double,readPorosity,writePorosity>(); #ifdef VAR_H_CORRECTION2 /* data->traverse<initGradH,ifSphOrSphBoundaryOrDemOrGhost>(); data->neighboursGroupCoupling<calcGradPorosity,ifDem>(); data->reverseSyncParticlesBetweenProcs<vect,readGradH,sumGradH>(); */ data->neighboursGroupCoupling<calcGradPorosity2,ifSphOrSphBoundaryOrImmersedDem>(); #endif #endif #ifdef CORRECTED_GRADIENT data->neighboursGroup<calcInvM,ifSphOrSphBoundaryOrImmersedDem>(); #endif #ifdef VAR_H_CORRECTION data->neighboursGroup<calcOmega,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<double,readOmega,writeOmega>(); #endif #ifdef VAR_H_CORRECTION2 #ifdef LIQ_DEM data->traverse<finaliseGradH,ifSphOrSphBoundaryOrImmersedDem>(); #else data->neighboursGroup<calcGradH,ifSphOrSphBoundaryOrImmersedDem>(); #endif data->syncParticlesBetweenProcs<vect,readGradH,writeGradH>(); #endif data->traverse<calcPressSpsoundPdr2,ifSphOrSphBoundaryOrImmersedDemOrGhost>(); #ifdef SLK data->neighboursGroup<calcGLeastSquares,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<vectTensor,readG,writeG>(); #endif #ifdef SMOOTHED_VISC_VELOCITY data->neighboursGroupScaled<smoothViscV,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<vect,readViscV,writeViscV>(); #endif //cout <<"rank = "<<data->globals.mpiRank<<"before force "<<endl; data->neighbours<calcForce,ifSphOrSphBoundary>(); //cout <<"rank = "<<data->globals.mpiRank<<"after force"<<endl; #ifdef BACKGROUND_PRESSURE_FORCE data->traverse<addBackgroundPressure,ifSphOrSphBoundaryOrImmersedDem>(); #endif #ifdef LIQ_DEM #ifdef LIQ_DEM_TEST data->traverse<addGradPorosityTerm,ifSphOrSphBoundary>(); #endif #ifdef LIQ_DEM_VARIABLE_TIMESTEP data->globals.newDt = min(data->globals.newDt,data->globals.demDt); #else data->globals.newDt = min(data->globals.newDt,liqDemCondition()); #endif #ifndef FIXED_DEM #ifndef NO_DEM_CONTACTS if (data->globals.time > TIME_DROP_PARTICLE) { data->globals.newDt = min(data->globals.newDt,demCondition()); } #endif #endif #endif data->traverse<accelCondition,ifSphOrSphBoundaryOrImmersedDemOrDem>(); gettimeofday(&t2,NULL); data->globals.wtTotalForceCalc.tv_sec += t2.tv_sec-t1.tv_sec; data->globals.wtTotalForceCalc.tv_usec += t2.tv_usec-t1.tv_usec; double oldDt = data->globals.dt; if (data->globals.dt == 0.0) { if (data->globals.mpiRank==0) cout << "I think that this is the first timestep, reinitiallizing dt...."<<endl; data->globals.dt = data->globals.newDt; } else { //data->globals.dt = 2.0*data->globals.newDt - data->globals.dt; //data->globals.dt = data->globals.newDt*data->globals.dt/(2.0*data->globals.dt-data->globals.newDt); data->globals.dt = data->globals.newDt; } data->setGlobalTimestep(data->globals.dt); //data->neighboursGroup<calcVort,ifSphOrSphBoundary>(); data->traverse<kick,ifSphOrSphBoundary>(0.5*oldDt,0.5*data->globals.dt); data->traverse<initSumsEnd,ifSphOrSphBoundaryOrImmersedDem>(); #ifdef LIQ_DEM data->traverse<driftRAndKick,ifDem>(); data->traverse<initSumsMiddle,ifDem>(); #endif } void CsphIncompress::end() { #ifdef LIQ_DEM data->globals.demDt = data->globals.maxdt; #endif #ifndef SMOOTHING data->traverse<driftR,ifSphOrSphBoundaryOrImmersedDem>(); #endif #ifdef SLK data->globals.slkIndex0++; data->globals.slkIndexLast++; if (data->globals.slkIndex0>=SLK_NUM_TIMESTEPS) data->globals.slkIndex0 = 0; if (data->globals.slkIndexLast>=SLK_NUM_TIMESTEPS) data->globals.slkIndexLast = 0; #endif data->globals.time += data->globals.dt/2; data->reset(); #ifdef CORRECTED_GRADIENT data->neighboursGroup<calcInvM,ifSphOrSphBoundaryOrImmersedDem>(); #endif #ifdef VAR_H_CORRECTION data->neighboursGroup<calcOmega,ifSphOrSphBoundaryOrImmersedDem>(); #endif #ifdef VAR_H_CORRECTION2 #ifdef LIQ_DEM data->neighboursGroupCoupling<calcGradPorosity2,ifSphOrSphBoundaryOrImmersedDem>(); data->traverse<finaliseGradH,ifSphOrSphBoundaryOrImmersedDem>(); #else data->neighboursGroup<calcGradH,ifSphOrSphBoundaryOrImmersedDem>(); #endif data->syncParticlesBetweenProcs<vect,readGradH,writeGradH>(); #endif #ifdef LIQ_DEM_DDDT_VER2 data->neighboursGroupCoupling<calcPorosity2,ifSphOrSphBoundaryOrImmersedDem>(); data->traverse<finalisePorosity,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<double,readPorosity,writePorosity>(); data->syncParticlesBetweenProcs<double,read_dPorositydt,write_dPorositydt>(); #endif timeval t1,t2; gettimeofday(&t1,NULL); #ifdef SLK data->neighboursGroup<calcGLeastSquares,ifSphOrSphBoundaryOrImmersedDem>(); data->syncParticlesBetweenProcs<vectTensor,readG,writeG>(); #endif data->neighbours<calcDddtDudt,ifSphOrSphBoundaryOrImmersedDem>(); #ifdef LIQ_DEM //data->traverse<correctDddt,ifSphOrSphBoundary>(); data->syncParticlesBetweenProcs<vect,readF,writeF>(); data->syncParticlesBetweenProcs<vect,readFb,writeFb>(); data->syncParticlesBetweenProcs<vect,readFp,writeFp>(); data->syncParticlesBetweenProcs<vect,readFv,writeFv>(); data->neighboursGroupCoupling<calcFPI,ifDem>(); #ifndef FIXED_DEM #ifndef NO_DEM_CONTACTS data->neighboursGroup<calcDEMContacts,ifDem>(); #ifndef LIQ_DEM_CUSTOM_WALL_CONTACTS data->neighboursGroup<calcDEMWallContacts,ifDem>(); #endif #endif #endif #ifdef DEM_BLOCK vect avForce; avForce = 0.0; data->globals.tmp = 0; data->traverse<vect,calcAvForce,ifDem>(avForce); avForce = avForce/data->globals.tmp; data->traverse<vect,setAvForce,ifDem>(avForce); #endif data->traverse<kick,ifDem>(0.5*data->globals.dt,0.5*data->globals.dt); #endif gettimeofday(&t2,NULL); data->globals.wtTotalDddtCalc.tv_sec += t2.tv_sec-t1.tv_sec; data->globals.wtTotalDddtCalc.tv_usec += t2.tv_usec-t1.tv_usec; data->traverse<driftRest,ifSphOrSphBoundaryOrImmersedDem>(); data->traverse<calcEnergies,ifSphOrSphBoundaryOrImmersedDem>(); }

b898d17dcb13a8c28aa52b2217a4d76191853bcf

565b0a88c0d6f8a71d42f919613a1d166889c8bb

/Code/General/SPOJ INTSUB Interesting Subset.cpp

7264dd6f2ae3d95d716f1bf08cbef3d9fbf450e5

[]

no_license

DaDaMrX/ACM

71d7347640e745ea30518762588f6a698722295b

603cff542027db7875bfc57d92c9cdaba1f82c80

refs/heads/master

2020-04-12T06:23:25.442550

2017-07-30T11:01:48

62,130,184

3

0

null

UTF-8

C++

false

669

cpp

SPOJ INTSUB Interesting Subset.cpp

#include <cstdio> #include <cstring> #include <algorithm> using namespace std; typedef long long ll; const int INF = 0x3f3f3f3f; const int N = 1e3 + 10; const int mod = 1e9 + 7; ll power(ll a, ll n, ll m) { ll ans = 1; while (n) { if (n & 1) ans = ans * a % m; a = a * a % m; n >>= 1; } return ans; } int main() { int T; scanf("%d", &T); for (int cas = 1; cas <= T; cas++) { int n; scanf("%d", &n); ll ans = 0; for (int i = 1; i <= n; i++) { int num = 2 * n / i - 1; ll a = power(2, num, mod) - 1; ll b = power(2, 2 * n - i - num, mod); ans = (ans + a * b % mod) % mod; } printf("Case %d: %lld\n", cas, ans); } return 0; }

c6f453d60573961276a78f3027b23d677145d659

9dce8f15578d73602372e9f80e51f5f4f50ad277

/abc153/a.cpp

610f1baf73b3e6b3c66aed2387ffd947fd9cb137

[]

no_license

ikuo-suyama/competitive-programming

f638e682c144884af9672e7d7e6490ce915c1008

d9be28c169808ac5ef2a7c0ceaa152b51fe69962

refs/heads/master

2021-07-07T13:04:25.993455

2021-04-04T14:32:26

235,354,964

0

null

UTF-8

C++

false

275

cpp

a.cpp

#include <bits/stdc++.h> using namespace std; #define rep(i, n) for (int i = 0; i < (n); i++) typedef long long ll; int main() { ifstream in("abc153/a.txt"); cin.rdbuf(in.rdbuf()); int H, A; cin >> H >> A; int cnt = ceil(H / (double)A); cout << cnt << endl; }

6b911efa15dc8cc8eeddaa3fb2f6d23895cd5582

c21ea87df48ecd3f0bcdecfa300d8ac359b265ff

/Game.hpp

56185d5facbcbb24dd4a096aceac72d726c394a2

[]

no_license

ShuklaAnsh/GameCpp

55c29fa71133230cf0598fa3347054ed69daa2b7

0e5b3ef874e5a4aae3eddb5cd92b4e5b1e6dbc98

refs/heads/master

2022-02-17T19:45:33.277732

2019-08-18T04:32:19

null

0

null

UTF-8

C++

false

1,667

hpp

Game.hpp

#ifndef Game_hpp #define Game_hpp #include <SDL2/SDL.h> #include <stdio.h> class Game { // Types public: //Screen dimension constants const static int MAX_SCREEN_WIDTH = 1000; const static int MAX_SCREEN_HEIGHT = 1000; protected: private: // API public: Game(); virtual ~Game(); bool init(const char* title, int x, int y, int height, int width, bool fullscreen); bool isRunning(); void update(); protected: void stopGame(); virtual bool initPostHook(); virtual void handleKey(SDL_KeyboardEvent& key_event); virtual void handleMouse(SDL_MouseButtonEvent& mouse_button_event); virtual void handleMouse(SDL_MouseMotionEvent& mouse_motion_event); virtual void handleResize(SDL_WindowEvent& window_event); virtual void renderPreHook(); virtual void renderMidHook(); virtual void renderPostHook(); private: void eventHandler(); void render(); // Modules protected: bool m_running; /* Boolean for if the game is running */ SDL_Window* m_window; /* Pointer to the window being rendering to */ SDL_Surface* m_screen_surface; /* Pointer to the surface the window will be on */ SDL_Renderer* m_renderer; /* Pointer to the renderer */ int m_screen_width; /* int to the screen width */ int m_screen_height; /* int to the screen height */ }; #endif /* Game_hpp */

417bd55a2b4c6bb9183208d80d238a0e26a29bd4

1bc15933f0da3ba1044f77991e889c5b69d591a0

/q215.cc

8fd095d9d608338e9b9d675db7a4d2f1ffe6e87c

[]

no_license

liuxiutao/LeetCode

d7c86358d723bbc291f8144a1c7bd14fe1f3dd80

eaabefbbe8d0142d0793ec55c7537bf85735b057

refs/heads/master

2020-06-05T20:18:59.146263

2019-07-06T16:32:12

192,536,910

0

null

2019-07-06T16:32:13

2019-06-18T12:36:31

C++

UTF-8

C++

false

1,019

cc

q215.cc

#include<iostream> #include<vector> using namespace std; int partition(vector<int>& a, int start, int end) { int pivot = a[start]; int left = start, right = end; while(left < right) { while(left < right && a[right] < pivot) right--; a[left] = a[right]; while(left < right && a[left] >= pivot) left ++; a[right] = a[left]; } a[left] = pivot; return left; } int findKthLargest(vector<int>& nums, int k) { int len = nums.size(); int s = 0, e = len - 1; int m = partition(nums, s, e); while(m != k - 1) { if(m > k - 1) e = m - 1; else s = m + 1; m = partition(nums, s, e); } return nums[m]; } int main(int argc, char const *argv[]) { vector<int> a = {3, 2, 3, 1, 2, 4, 5, 5, 6}; cout << findKthLargest(a, 4) << endl; return 0; }

5e90419decde7b89823c41699ae0bf7d7e3ffa2f

3da1c543033ab5b20de0398395681011ea2c39b5

/prime/check_prime.cpp

4bda1dfe227657f026e248386dfa3363fde76993

[]

no_license

arnabs542/CP

f2a27d6134c10b60eedc5b61aed98d821a4d6126

6f585b2f8c540257c2b3605089e4608b63820d1a

refs/heads/master

2023-06-27T19:18:31.715213

2021-04-27T04:46:58

null

0

null

UTF-8

C++

false

295

cpp

check_prime.cpp

#include<bits/stdc++.h> using namespace std; #define int long long // O(sqrt(n)) bool isPrime(int N) { int count = 0; for(int i=2; i*i <=N;++i) { if( N % i == 0) { ++count; } } return ((count==0) ? 1: 0); } int main( ) { cout << isPrime(15); }

3790d0212a3c557ce5d9fb9abe021936b165fd1e

6582bd87236b815e4e48ec5be7f472d09ed288a2

/75.Preprocessing Directive include/library.h

e8f57b97a3b9800a3a421721b76563fa5546e377

[]

no_license

mridhosaputraad/Documentation-C-

baa6df1badd42f3c9bbe8c2e01a17e0e1533dcaa

4af2fcb3feb2298dad8a11146e9f2a637969ef9a

refs/heads/main

2023-06-02T00:01:27.910795

2021-06-19T12:55:53

378,411,555

0

null

UTF-8

C++

false

133

h

library.h

#include <string> #define PI 3.123456789 #define KUADRAT(X) (X * X) #define MAX(A, B) ((A > B) ? A : B) std::string data = "STRING"

d1264ae653b2dd82239565cb8602a04e64ea4a37

afc8033296af79ee039ad31e69a6dc17cd469645

/Vector2.h

fa0a40acdf14644bc0b669f1108a96f82838b365

[]

no_license

Heimish/SoftRenderer

a3d5d59b0661b986e63433fff2d6096c56824f14

658d3f01a8667f36a22197d3eecd30198064bbdc

refs/heads/master

2020-04-05T20:20:09.724083

2018-11-12T08:51:07

157,175,479

0

2

null

UTF-8

C++

false

436

h

Vector2.h

#pragma once #include "stdafx.h" #include "Matrix.h" struct Vector2 { public: float X; float Y; public: Vector2() : X(0), Y(0) {} Vector2(float InX, float InY) : X(InX), Y(InY) {} static float Dist(const Vector2 &V1, const Vector2 &V2); static float DistSquared(const Vector2 &V1, const Vector2 &V2); Vector2 operator*(const Matrix2 &Mat) const; bool Equals(const Vector2& V, float tolerance = KINDA_SMALL_NUMBER) const; };

73e308d34cd13c563ce41b46b0da94e01f85b263

d0fb46aecc3b69983e7f6244331a81dff42d9595

/eflo-controller/src/model/DescribeTaskResult.cc

ce0887eb6be3fad1099dd0e0ca0a6a320588ac46

[ "Apache-2.0" ]

permissive

aliyun/aliyun-openapi-cpp-sdk

3d8d051d44ad00753a429817dd03957614c0c66a

e862bd03c844bcb7ccaa90571bceaa2802c7f135

refs/heads/master

2023-08-29T11:54:00.525102

2023-08-29T03:32:48

115,379,460

104

82

NOASSERTION

2023-09-14T06:13:33

2017-12-26T02:53:27

C++

UTF-8

C++

false

4,654

cc

DescribeTaskResult.cc

/* * Copyright 2009-2017 Alibaba Cloud 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 <alibabacloud/eflo-controller/model/DescribeTaskResult.h> #include <json/json.h> using namespace AlibabaCloud::Eflo_controller; using namespace AlibabaCloud::Eflo_controller::Model; DescribeTaskResult::DescribeTaskResult() : ServiceResult() {} DescribeTaskResult::DescribeTaskResult(const std::string &payload) : ServiceResult() { parse(payload); } DescribeTaskResult::~DescribeTaskResult() {} void DescribeTaskResult::parse(const std::string &payload) { Json::Reader reader; Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto allStepsNode = value["Steps"]["StepsItem"]; for (auto valueStepsStepsItem : allStepsNode) { StepsItem stepsObject; if(!valueStepsStepsItem["StepName"].isNull()) stepsObject.stepName = valueStepsStepsItem["StepName"].asString(); if(!valueStepsStepsItem["StepState"].isNull()) stepsObject.stepState = valueStepsStepsItem["StepState"].asString(); if(!valueStepsStepsItem["StepType"].isNull()) stepsObject.stepType = valueStepsStepsItem["StepType"].asString(); if(!valueStepsStepsItem["StageTag"].isNull()) stepsObject.stageTag = valueStepsStepsItem["StageTag"].asString(); if(!valueStepsStepsItem["Message"].isNull()) stepsObject.message = valueStepsStepsItem["Message"].asString(); if(!valueStepsStepsItem["StartTime"].isNull()) stepsObject.startTime = valueStepsStepsItem["StartTime"].asString(); if(!valueStepsStepsItem["UpdateTime"].isNull()) stepsObject.updateTime = valueStepsStepsItem["UpdateTime"].asString(); auto allSubTasksNode = valueStepsStepsItem["SubTasks"]["SubTasksItem"]; for (auto valueStepsStepsItemSubTasksSubTasksItem : allSubTasksNode) { StepsItem::SubTasksItem subTasksObject; if(!valueStepsStepsItemSubTasksSubTasksItem["TaskId"].isNull()) subTasksObject.taskId = valueStepsStepsItemSubTasksSubTasksItem["TaskId"].asString(); if(!valueStepsStepsItemSubTasksSubTasksItem["TaskType"].isNull()) subTasksObject.taskType = valueStepsStepsItemSubTasksSubTasksItem["TaskType"].asString(); if(!valueStepsStepsItemSubTasksSubTasksItem["CreateTime"].isNull()) subTasksObject.createTime = valueStepsStepsItemSubTasksSubTasksItem["CreateTime"].asString(); if(!valueStepsStepsItemSubTasksSubTasksItem["UpdateTime"].isNull()) subTasksObject.updateTime = valueStepsStepsItemSubTasksSubTasksItem["UpdateTime"].asString(); if(!valueStepsStepsItemSubTasksSubTasksItem["Message"].isNull()) subTasksObject.message = valueStepsStepsItemSubTasksSubTasksItem["Message"].asString(); if(!valueStepsStepsItemSubTasksSubTasksItem["TaskState"].isNull()) subTasksObject.taskState = valueStepsStepsItemSubTasksSubTasksItem["TaskState"].asString(); stepsObject.subTasks.push_back(subTasksObject); } steps_.push_back(stepsObject); } if(!value["ClusterId"].isNull()) clusterId_ = value["ClusterId"].asString(); if(!value["ClusterName"].isNull()) clusterName_ = value["ClusterName"].asString(); if(!value["TaskState"].isNull()) taskState_ = value["TaskState"].asString(); if(!value["TaskType"].isNull()) taskType_ = value["TaskType"].asString(); if(!value["Message"].isNull()) message_ = value["Message"].asString(); if(!value["CreateTime"].isNull()) createTime_ = value["CreateTime"].asString(); if(!value["UpdateTime"].isNull()) updateTime_ = value["UpdateTime"].asString(); } std::vector<DescribeTaskResult::StepsItem> DescribeTaskResult::getSteps()const { return steps_; } std::string DescribeTaskResult::getMessage()const { return message_; } std::string DescribeTaskResult::getClusterId()const { return clusterId_; } std::string DescribeTaskResult::getTaskType()const { return taskType_; } std::string DescribeTaskResult::getCreateTime()const { return createTime_; } std::string DescribeTaskResult::getUpdateTime()const { return updateTime_; } std::string DescribeTaskResult::getClusterName()const { return clusterName_; } std::string DescribeTaskResult::getTaskState()const { return taskState_; }

fde1ba78b0b3e01a8ff4f6c39a5f1f7ee049a72f

9331b1bee90eabef2dd116219a46893b13895ca7

/Sources/ContactDetection.cpp

74d3b7c6ef9ff44c51f03fa95e7c82a147909be1

[]

no_license

francoisludewig/SandPanda

3275945e20d8861f873257f0ed256b4a561f3592

1ecd6a97b19df9a37e858c8a15eb8bab95248d25

refs/heads/master

2021-09-06T18:27:58.558628

2018-01-01T13:11:54

115,919,902

0

null

UTF-8

C++

false

50,478

cpp

ContactDetection.cpp

#include "../Includes/ContactDetection.h" //#include <omp.h> #include "../Includes/Velocity.h" #include "../Includes/Gravity.h" #include "../Includes/Plan.h" #include "../Includes/PlanR.h" #include "../Includes/Cone.h" #include "../Includes/Elbow.h" #include "../Includes/Sphere.h" #include "../Includes/Body.h" #include "../Includes/Contact.h" #include "../Includes/Data.h" int ContactDetection::ContactSphBody(Sphere *a, Body *b, Contact *ct, int &Nct) noexcept { int Nctfound = 0; double Nx,Ny,Nz,xc,yc,zc,norme; // Vecteur normal joignant les centres de masse Nx = a->x-b->x; Ny = a->y-b->y; Nz = a->z-b->z; norme = sqrt(Nx*Nx+Ny*Ny+Nz*Nz); Nx = Nx/norme; Ny = Ny/norme; Nz = Nz/norme; // Point central du segment joignant les centres de masse xc = a->x - Nx*a->r; yc = a->y - Ny*a->r; zc = a->z - Nz*a->r; double delta[b->Ng]; // Liste des sph de b for(int i = b->Ng ; i--;){ delta[i] = (b->xg[i]-xc)*Nx+(b->yg[i]-yc)*Ny+(b->zg[i]-zc)*Nz; } // Test Contact potentiel for(int i = b->Ng ; i--;){ if(delta[i] > -b->r[i]){ double px,py,pz,Q,P2; px = a->x - b->xg[i]; py = a->y - b->yg[i]; pz = a->z - b->zg[i]; Q = (a->r+b->r[i]); P2 = px*px+py*py+pz*pz; if(P2 < Q*Q){ P2 = sqrt(P2); ct[Nct].type = 10; ct[Nct].delta = P2-(a->r+b->r[i]); ct[Nct].nx = px/P2; ct[Nct].ny = py/P2; ct[Nct].nz = pz/P2; ct[Nct].px = b->xg[i] + px/2.; ct[Nct].py = b->yg[i] + py/2.; ct[Nct].pz = b->zg[i] + pz/2.; ct[Nct].sa = a; ct[Nct].bb = b; ct[Nct].nbb = i; Nct++; Nctfound++; } } } if(Nctfound == 0) return 0; else return 1; } int ContactDetection::ContactSphBodyPeriodic(Sphere *a, Body *b, Contact *ct, int &Nct) noexcept { int Nctfound = 0; double Nx,Ny,Nz,xc,yc,zc,norme; // Vecteur normal joignant les centres de masse Nx = a->x2-b->x; Ny = a->y2-b->y; Nz = a->z2-b->z; norme = sqrt(Nx*Nx+Ny*Ny+Nz*Nz); Nx = Nx/norme; Ny = Ny/norme; Nz = Nz/norme; // Point central du segment joignant les centres de masse xc = a->x2 - Nx*a->r; yc = a->y2 - Ny*a->r; zc = a->z2 - Nz*a->r; double delta[b->Ng]; // Liste des sph de b for(int i = b->Ng ; i--;){ delta[i] = (b->xg[i]-xc)*Nx+(b->yg[i]-yc)*Ny+(b->zg[i]-zc)*Nz; } // Test Contact potentiel for(int i = b->Ng ; i--;){ if(delta[i] > -b->r[i]){ double px,py,pz,Q,P2; px = a->x2 - b->xg[i]; py = a->y2 - b->yg[i]; pz = a->z2 - b->zg[i]; Q = (a->r+b->r[i]); P2 = px*px+py*py+pz*pz; if(P2 < Q*Q){ P2 = sqrt(P2); ct[Nct].type = 10; ct[Nct].delta = P2-(a->r+b->r[i]); ct[Nct].nx = px/P2; ct[Nct].ny = py/P2; ct[Nct].nz = pz/P2; ct[Nct].px = b->xg[i] + px/2.; ct[Nct].py = b->yg[i] + py/2.; ct[Nct].pz = b->zg[i] + pz/2.; ct[Nct].sa = a; ct[Nct].bb = b; ct[Nct].nbb = i; Nct++; Nctfound++; } } } if(Nctfound == 0) return 0; else return 1; } int ContactDetection::ContactBodyBody(Body *a, Body *b, Contact *ct, int &Nct, double ra, double rb) noexcept { int Nctfound = 0; double Nx,Ny,Nz,xc,yc,zc,norme; //printf("Ct Body Body\n"); // Vecteur normal joignant les centres de masse Nx = a->x-b->x; Ny = a->y-b->y; Nz = a->z-b->z; norme = sqrt(Nx*Nx+Ny*Ny+Nz*Nz); Nx = Nx/norme; Ny = Ny/norme; Nz = Nz/norme; // Point central du segment joignant les centres de masse xc = (ra*a->x+rb*b->x)/(ra+rb); yc = (ra*a->y+rb*b->y)/(ra+rb); zc = (ra*a->z+rb*b->z)/(ra+rb); double deltaA[a->Ng]; double deltaB[b->Ng]; double dminA = 10,dmaxB = -10; double dmaxA = a->Rmax; double dminB = -b->Rmax; int Na = 0,Nb = 0; double Min,Max; //int Nct0 = Nct; double px,py,pz,Q,P2; // Liste des sph de a for(int i = 0 ; i < a->Ng ; i++){ deltaA[i] = (a->xg[i]-xc)*Nx+(a->yg[i]-yc)*Ny+(a->zg[i]-zc)*Nz; if(deltaA[i]-a->r[i] < dminA)dminA = deltaA[i]-a->r[i]; if(deltaA[i] < dmaxA)Na++; } // Liste des sph de b for(int i = 0 ; i < b->Ng ; i++){ deltaB[i] = (b->xg[i]-xc)*Nx+(b->yg[i]-yc)*Ny+(b->zg[i]-zc)*Nz; if(deltaB[i]+b->r[i] > dmaxB)dmaxB = deltaB[i]+b->r[i]; if(deltaB[i] > dminB)Nb++; } // Tolerence de securite dminA -= a->Rmax; dminB -= b->Rmax; dmaxA += a->Rmax; dmaxB += b->Rmax; if(dmaxB > dmaxA) Max = dmaxB; else Max = dmaxA; if(dminA < dminB) Min = dminA; else Min = dminB; int Ncontrol = 0; int Ntest = 0; for(int i = 0 ; i < a->Ng ; i++){ for(int j = 0 ; j < b->Ng ; j++){ Ncontrol++; if(deltaA[i] < Max && deltaB[j] < Max && deltaA[i] > Min && deltaB[j] > Min){ Ntest++; //double px,py,pz,Q,P2; px = a->xg[i] - b->xg[j]; py = a->yg[i] - b->yg[j]; pz = a->zg[i] - b->zg[j]; Q = (a->r[i]+b->r[j]); P2 = px*px+py*py+pz*pz; if(P2 < Q*Q){ P2 = sqrt(P2); ct[Nct].type = 20; ct[Nct].delta = P2-(a->r[i]+b->r[j]); ct[Nct].nx = px/P2; ct[Nct].ny = py/P2; ct[Nct].nz = pz/P2; ct[Nct].px = b->xg[j] + px/2.; ct[Nct].py = b->yg[j] + py/2.; ct[Nct].pz = b->zg[j] + pz/2.; ct[Nct].ba = a; ct[Nct].nba = i; ct[Nct].bb = b; ct[Nct].nbb = j; Nct++; Nctfound++; } } } } if(Nctfound == 0) return 0; else return 1; } int ContactDetection::ContactSphSph(Sphere *a, Sphere *b, Contact *ct, int & Nct) noexcept { int rtn = 0; if(a->bodies == -9 && b->bodies == -9){ double px,py,pz,Q,P2; px = a->x - b->x; py = a->y - b->y; pz = a->z - b->z; Q = (a->r+b->r); P2 = px*px+py*py+pz*pz; if(P2 < Q*Q){ P2 = sqrt(P2); ct[Nct].type = 0; ct[Nct].delta = P2-Q; ct[Nct].nx = px/P2; ct[Nct].ny = py/P2; ct[Nct].nz = pz/P2; ct[Nct].px = b->x + px/2.; ct[Nct].py = b->y + py/2.; ct[Nct].pz = b->z + pz/2.; ct[Nct].sa = a; ct[Nct].sb = b; Nct++; rtn = 1; } } if(a->bodies != -9 && b->bodies == -9){ rtn = ContactSphBody(b, a->b,ct,Nct); } if(a->bodies == -9 && b->bodies != -9){ rtn = ContactSphBody(a, b->b,ct,Nct); } if(a->bodies != -9 && b->bodies != -9){ rtn = ContactBodyBody(a->b, b->b,ct,Nct,a->r,b->r); } return rtn; } void ContactDetection::ContactSphSphPeriodic(Sphere *a, Sphere *b, Contact *ct, int & Nct) noexcept { int rtn = 0; if(a->Num() != b->Num()){ if((a->bodies == -9 && b->bodies == -9)){ double px,py,pz,P2,Q; px = a->x2 - b->x; py = a->y2 - b->y; pz = a->z2 - b->z; P2 = px*px+py*py+pz*pz; Q = (a->r+b->r); if(P2 < Q*Q){ P2 = sqrt(P2); ct[Nct].type = 0; ct[Nct].delta = P2-(a->r+b->r); ct[Nct].nx = px/P2; ct[Nct].ny = py/P2; ct[Nct].nz = pz/P2; ct[Nct].px = b->x + px/2; ct[Nct].py = b->y + py/2; ct[Nct].pz = b->z + pz/2; ct[Nct].sa = a; ct[Nct].sb = b; Nct++; } } else{ if(a->bodies != -9 && b->bodies == -9){ rtn = ContactSphBodyPeriodic(b, a->b,ct,Nct); } if(a->bodies == -9 && b->bodies != -9){ rtn = ContactSphBodyPeriodic(a, b->b,ct,Nct); } if(a->bodies != -9 && b->bodies != -9){ double tpx,tpy,tpz; tpx = a->x; tpy = a->y; tpz = a->z; (a->b)->x = a->x2; (a->b)->y = a->y2; (a->b)->z = a->z2; (a->b)->UpDateLinkedSphereTp(); rtn = ContactBodyBody(a->b, b->b,ct,Nct,a->r,b->r); (a->b)->x = tpx; (a->b)->y = tpy; (a->b)->z = tpz; (a->b)->UpDateLinkedSphereTp(); } } } } void ContactDetection::ContactBodyPlan(Plan & p, Body *b, Contact *ct, int & Nct) noexcept { double px,py,pz,pn,pt,ps,nn,nnx,nny,nnz; for(int i = 0 ; i < b->Ng ; i++){ px = b->xg[i] - b->r[i]*p.nx; py = b->yg[i] - b->r[i]*p.ny; pz = b->zg[i] - b->r[i]*p.nz; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if((fabs(pt) < p.dt) && (fabs(ps) < p.ds)){ if( (pn <= 0.0) && (pn > -b->r[i])){ ct[Nct].type = 11; ct[Nct].delta = pn; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = -p.nx; ct[Nct].ny = -p.ny; ct[Nct].nz = -p.nz; ct[Nct].pa = &p; ct[Nct].ba = b; ct[Nct].nba = i; Nct++; } if(p.inAndOut == 1){ px = b->xg[i] + b->r[i]*p.nx; py = b->yg[i] + b->r[i]*p.ny; pz = b->zg[i] + b->r[i]*p.nz; pn = (px-p.x)*(-p.nx)+(py-p.y)*(-p.ny)+(pz-p.z)*(-p.nz); pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if( (pn <= 0.0) && (pn > -b->r[i])){ ct[Nct].type = 11; ct[Nct].delta = pn; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = p.nx; ct[Nct].ny = p.ny; ct[Nct].nz = p.nz; ct[Nct].pa = &p; ct[Nct].ba = b; ct[Nct].nba = i; Nct++; } } } else{ // pt ok seul if((fabs(pt) < p.dt/2) && (fabs(ps) > p.ds/2)){ ps = ps/fabs(ps)*p.ds/2; } // ps ok seul if((fabs(pt) > p.dt/2) && (fabs(ps) < p.ds/2)){ pt = pt/fabs(pt)*p.dt/2; } // aucun ok if((fabs(pt) > p.dt/2) && (fabs(ps) > p.ds/2)){ ps = ps/fabs(ps)*p.ds/2; pt = pt/fabs(pt)*p.dt/2; } // Point du plan candidat au contact px = p.x + ps*p.sx + pt*p.tx; py = p.y + ps*p.sy + pt*p.ty; pz = p.z + ps*p.sz + pt*p.tz; nnx = px-b->x; nny = py-b->y; nnz = pz-b->z; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn <= b->r[i]){ ct[Nct].delta = nn - b->r[i]; ct[Nct].type = 11; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].pa = &p; ct[Nct].ba = b; ct[Nct].nba = i; Nct++; } } } } void ContactDetection::ContactSphPlan(Plan & p, Sphere *b, Contact *ct, int & Nct) noexcept { if(b->bodies == -9){ double px,py,pz,pn,pt,ps,nn,nnx,nny,nnz; px = b->x - b->r*p.nx; py = b->y - b->r*p.ny; pz = b->z - b->r*p.nz; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if((fabs(pt) < p.dt/2) && (fabs(ps) < p.ds/2)){ if( (pn <= 0.0) && (pn > -b->r)){ ct[Nct].type = 1; ct[Nct].delta = pn; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = -p.nx; ct[Nct].ny = -p.ny; ct[Nct].nz = -p.nz; //printf("n = (%e,%e,%e)\n", ct[Nct].nx, ct[Nct].ny, ct[Nct].nz); p.Normal(&ct[Nct],b); //if(p.sigma != 0) // printf("n = (%e,%e,%e)\n\n", ct[Nct].nx, ct[Nct].ny, ct[Nct].nz); ct[Nct].pa = &p; ct[Nct].sa = b; Nct++; } else{ if(p.sigma != 0) b->ct_pl = 0; } if(p.inAndOut == 1){ px = b->x + b->r*p.nx; py = b->y + b->r*p.ny; pz = b->z + b->r*p.nz; pn = (px-p.x)*(-p.nx)+(py-p.y)*(-p.ny)+(pz-p.z)*(-p.nz); pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if( (pn <= 0.0) && (pn > -b->r)){ ct[Nct].type = 1; ct[Nct].delta = pn; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = p.nx; ct[Nct].ny = p.ny; ct[Nct].nz = p.nz; p.Normal(&ct[Nct],b); ct[Nct].pa = &p; ct[Nct].sa = b; Nct++; } else{ if(p.sigma != 0) b->ct_pl = 0; } } } else{ // pt ok seul if((fabs(pt) < p.dt/2) && (fabs(ps) > p.ds/2)){ ps = ps/fabs(ps)*p.ds/2; } // ps ok seul if((fabs(pt) > p.dt/2) && (fabs(ps) < p.ds/2)){ pt = pt/fabs(pt)*p.dt/2; } // aucun ok if((fabs(pt) > p.dt/2) && (fabs(ps) > p.ds/2)){ ps = ps/fabs(ps)*p.ds/2; pt = pt/fabs(pt)*p.dt/2; } // Point du plan candidat au contact px = p.x + ps*p.sx + pt*p.tx; py = p.y + ps*p.sy + pt*p.ty; pz = p.z + ps*p.sz + pt*p.tz; nnx = px-b->x; nny = py-b->y; nnz = pz-b->z; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn <= b->r){ ct[Nct].delta = nn - b->r; ct[Nct].type = 1; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].pa = &p; ct[Nct].sa = b; Nct++; } } } else ContactBodyPlan(p,b->b,ct,Nct); } void ContactDetection::ContactSphPlanPeriodic(Sphere *llist[], Plan & p, Plan & p2, Sphere *b, const double rmax) noexcept { double px,py,pz,pn,pt,ps; px = b->x; py = b->y; pz = b->z; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if( (pn <= (b->r+rmax)) && (pn > -2*b->r) && (fabs(pt) < p.dt/2+b->r) && (fabs(ps) < p.ds/2+b->r) ){ pt = (px-p2.x)*p2.tx+(py-p2.y)*p2.ty+(pz-p2.z)*p2.tz; ps = (px-p2.x)*p2.sx+(py-p2.y)*p2.sy+(pz-p2.z)*p2.sz; b->x2 = p2.x + (-pn)*p2.nx + pt*p2.tx + ps*p2.sx; b->y2 = p2.y + (-pn)*p2.ny + pt*p2.ty + ps*p2.sy; b->z2 = p2.z + (-pn)*p2.nz + pt*p2.tz + ps*p2.sz; llist[p.Nlist] = b; p.list[p.Nlist] = b->num; p.Nlist++; } } void ContactDetection::ContactBodyPlanR(PlanR & p, Body *b, Contact *ct, int & Nct) noexcept { double px,py,pz,pn,pt,ps; for(int i = 0 ; i < b->Ng ; i++){ px = b->xg[i] - b->r[i]*p.nx; py = b->yg[i] - b->r[i]*p.ny; pz = b->zg[i] - b->r[i]*p.nz; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if((pn >= -b->r[i]) && (pn < 0.0) && (sqrt(pt*pt+ps*ps) < p.r)){ ct[Nct].delta = pn; ct[Nct].type = 12; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = -p.nx; ct[Nct].ny = -p.ny; ct[Nct].nz = -p.nz; ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].par = &p; Nct++; } } } void ContactDetection::ContactSphPlanR(PlanR & p, Sphere *b, Contact *ct, int & Nct) noexcept { if(b->bodies == -9){ double px,py,pz,pn,pt,ps; px = b->x - b->r*p.nx; py = b->y - b->r*p.ny; pz = b->z - b->r*p.nz; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if((pn >= -b->r) && (pn < 0.0) && (sqrt(pt*pt+ps*ps) < p.r)){ ct[Nct].delta = pn; ct[Nct].type = 2; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = -p.nx; ct[Nct].ny = -p.ny; ct[Nct].nz = -p.nz; ct[Nct].sa = b; ct[Nct].par = &p; Nct++; } } else ContactBodyPlanR(p,b->b,ct,Nct); } void ContactDetection::ContactBodyCone(Cone & p, Body *b, Contact *ct, int & Nct) noexcept { double px,py,pz,pn,pt,ps,N,Tx,Ty,Tz,Nx,Ny,Nz,delta2,Qn,Qt,dr,h; double nnx,nny,nnz,nn; double a,bb,Y; for(int i = 0 ; i < b->Ng ; i++){ px = b->xg[i]; py = b->yg[i]; pz = b->zg[i]; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if(fabs(pn) <= p.h/2 + b->r[i]){ N = sqrt(pt*pt+ps*ps); Tx = (pt*p.tx + ps*p.sx)/N; Ty = (pt*p.ty + ps*p.sy)/N; Tz = (pt*p.tz + ps*p.sz)/N; Nx = p.nx; Ny = p.ny; Nz = p.nz; dr = p.r0 - p.r1; h = p.h; if(dr == 0){ if(fabs(pn) <= p.h/2){ if(fabs(N-p.r0) <= b->r[i]){ px = p.x + pn*Nx + p.r0*Tx; py = p.y + pn*Ny + p.r0*Ty; pz = p.z + pn*Nz + p.r0*Tz; ct[Nct].delta = fabs(N-p.r0) - b->r[i]; ct[Nct].type = 13; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = Tx; ct[Nct].ny = Ty; ct[Nct].nz = Tz; ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].cn = &p; Nct++; } } else{ pn = pn/fabs(pn)*p.h/2.; px = p.x + pn*Nx + p.r0*Tx; py = p.y + pn*Ny + p.r0*Ty; pz = p.z + pn*Nz + p.r0*Tz; nnx = px-b->xg[i]; nny = py-b->yg[i]; nnz = pz-b->zg[i]; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn < b->r[i]){ ct[Nct].delta = nn - b->r[i]; ct[Nct].type = 13; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].cn = &p; Nct++; } } } else{ a = -h/dr; bb = h*(p.r0/dr-0.5); Y = sqrt(dr*dr+h*h); delta2 = -(N - pn/a + bb/a)*h/Y; if(fabs(delta2) <= b->r[i]){ Qn = pn + delta2*dr/Y; Qt = N + delta2*h/Y; px = p.x + Qn*Nx + Qt*Tx; py = p.y + Qn*Ny + Qt*Ty; pz = p.z + Qn*Nz + Qt*Tz; if(Qn < h/2. && Qn > -h/2.){ ct[Nct].delta = fabs(delta2) - b->r[i]; ct[Nct].type = 13; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = (px-b->xg[i])/fabs(delta2); ct[Nct].ny = (py-b->yg[i])/fabs(delta2); ct[Nct].nz = (pz-b->zg[i])/fabs(delta2); ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].cn = &p; Nct++; } else{ if(Qn >= h/2.){ Qn = h/2.; Qt = p.r1; } else{ Qn = -h/2.; Qt = p.r0; } px = p.x + Qn*Nx + Qt*Tx; py = p.y + Qn*Ny + Qt*Ty; pz = p.z + Qn*Nz + Qt*Tz; nnx = px-b->xg[i]; nny = py-b->yg[i]; nnz = pz-b->zg[i]; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn <= b->r[i]){ ct[Nct].delta = nn - b->r[i]; ct[Nct].type = 13; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].cn = &p; Nct++; } } } } } } } void ContactDetection::ContactSphCone(Cone & p, Sphere *b, Contact *ct, int & Nct) noexcept { if(b->bodies == -9){ double px,py,pz,pn,pt,ps,N,Tx,Ty,Tz,Nx,Ny,Nz,delta2,Qn,Qt,dr,h; double nnx,nny,nnz,nn; double a,bb,Y; px = b->x; py = b->y; pz = b->z; pn = (px-p.x)*p.nx+(py-p.y)*p.ny+(pz-p.z)*p.nz; pt = (px-p.x)*p.tx+(py-p.y)*p.ty+(pz-p.z)*p.tz; ps = (px-p.x)*p.sx+(py-p.y)*p.sy+(pz-p.z)*p.sz; if(fabs(pn) <= p.h/2 + b->r){ N = sqrt(pt*pt+ps*ps); Tx = (pt*p.tx + ps*p.sx)/N; Ty = (pt*p.ty + ps*p.sy)/N; Tz = (pt*p.tz + ps*p.sz)/N; Nx = p.nx; Ny = p.ny; Nz = p.nz; dr = p.r0 - p.r1; h = p.h; if(dr == 0){ if(fabs(pn) <= p.h/2){ if(fabs(N-p.r0) <= b->r){ px = p.x + pn*Nx + p.r0*Tx; py = p.y + pn*Ny + p.r0*Ty; pz = p.z + pn*Nz + p.r0*Tz; ct[Nct].delta = fabs(N-p.r0) - b->r; ct[Nct].type = 3; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; if(p.in == 0){ ct[Nct].nx = Tx; ct[Nct].ny = Ty; ct[Nct].nz = Tz; } else{ ct[Nct].nx = -Tx; ct[Nct].ny = -Ty; ct[Nct].nz = -Tz; } ct[Nct].sa = b; ct[Nct].cn = &p; Nct++; } } else{ pn = pn/fabs(pn)*p.h/2.; px = p.x + pn*Nx + p.r0*Tx; py = p.y + pn*Ny + p.r0*Ty; pz = p.z + pn*Nz + p.r0*Tz; nnx = px-b->x; nny = py-b->y; nnz = pz-b->z; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn < b->r){ ct[Nct].delta = nn - b->r; ct[Nct].type = 3; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].sa = b; ct[Nct].cn = &p; Nct++; } } } else{ a = -h/dr; bb = h*(p.r0/dr-0.5); Y = sqrt(dr*dr+h*h); delta2 = -(N - pn/a + bb/a)*h/Y; if(fabs(delta2) <= b->r){ Qn = pn + delta2*dr/Y; Qt = N + delta2*h/Y; px = p.x + Qn*Nx + Qt*Tx; py = p.y + Qn*Ny + Qt*Ty; pz = p.z + Qn*Nz + Qt*Tz; if(Qn < h/2. && Qn > -h/2.){ ct[Nct].delta = fabs(delta2) - b->r; ct[Nct].type = 3; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; nnx = (px-b->x); nny = (py-b->y); nnz = (pz-b->z); ct[Nct].nx = (px-b->x)/fabs(delta2); ct[Nct].ny = (py-b->y)/fabs(delta2); ct[Nct].nz = (pz-b->z)/fabs(delta2); ct[Nct].sa = b; ct[Nct].cn = &p; Nct++; } else{ if(Qn >= h/2.){ Qn = h/2.; Qt = p.r1; } else{ Qn = -h/2.; Qt = p.r0; } px = p.x + Qn*Nx + Qt*Tx; py = p.y + Qn*Ny + Qt*Ty; pz = p.z + Qn*Nz + Qt*Tz; nnx = px-b->x; nny = py-b->y; nnz = pz-b->z; nn = sqrt(nnx*nnx+nny*nny+nnz*nnz); if(nn <= b->r){ ct[Nct].delta = nn - b->r; ct[Nct].type = 3; ct[Nct].px = px; ct[Nct].py = py; ct[Nct].pz = pz; ct[Nct].nx = nnx/nn; ct[Nct].ny = nny/nn; ct[Nct].nz = nnz/nn; ct[Nct].sa = b; ct[Nct].cn = &p; Nct++; } } } } } } else ContactBodyCone(p,b->b,ct,Nct); } void ContactDetection::ContactBodyElbow(Elbow & p, Body *b, Contact *ct, int & Nct) noexcept { double rl,D,pn,pt,ps,alphal; double cx,cy,cz,nx,ny,nz; for(int i = 0 ; i < b->Ng ; i++){ pn = (b->xg[i]-p.x)*p.nx + (b->yg[i]-p.y)*p.ny + (b->zg[i]-p.z)*p.nz; pt = (b->xg[i]-p.x)*p.tx + (b->yg[i]-p.y)*p.ty + (b->zg[i]-p.z)*p.tz; ps = (b->xg[i]-p.x)*p.sx + (b->yg[i]-p.y)*p.sy + (b->zg[i]-p.z)*p.sz; rl = sqrt(pn*pn+pt*pt); if(rl >= p.R-p.r && rl <= p.R+p.r && fabs(ps) <= p.r){ // Coupe entre 2 plans "epaisseur" if(pt != 0){ if(pn > 0) alphal = acos(pt/rl); else alphal = 2*M_PI-acos(pt/rl); } else{ alphal = 0; } // control angulaire if(alphal <= p.alpha){ cx = p.x + (pn*p.nx + pt*p.tx)/rl*p.R; cy = p.y + (pn*p.ny + pt*p.ty)/rl*p.R; cz = p.z + (pn*p.nz + pt*p.tz)/rl*p.R; D = sqrt(pow(b->x-cx,2)+pow(b->y-cy,2)+pow(b->z-cz,2)); if(p.r-(D+b->r[i]) < 0){ ct[Nct].delta = p.r-(D+b->r[i]); ct[Nct].type = 14; nx = -(cx - b->xg[i]); ny = -(cy - b->yg[i]); nz = -(cz - b->zg[i]); D = sqrt(nx*nx+ny*ny+nz*nz); ct[Nct].nx = nx/D; ct[Nct].ny = ny/D; ct[Nct].nz = nz/D; ct[Nct].px = b->xg[i] + b->r[i]*ct[Nct].nx; ct[Nct].py = b->yg[i] + b->r[i]*ct[Nct].ny; ct[Nct].pz = b->zg[i] + b->r[i]*ct[Nct].nz; ct[Nct].ba = b; ct[Nct].nba = i; ct[Nct].ew = &p; Nct++; } } } } } void ContactDetection::ContactSphElbow(Elbow & p, Sphere *b, Contact *ct, int & Nct) noexcept { if(b->bodies == -9){ double rl,D,pn,pt,ps,alphal; double cx,cy,cz,nx,ny,nz; pn = (b->x-p.x)*p.nx + (b->y-p.y)*p.ny + (b->z-p.z)*p.nz; pt = (b->x-p.x)*p.tx + (b->y-p.y)*p.ty + (b->z-p.z)*p.tz; ps = (b->x-p.x)*p.sx + (b->y-p.y)*p.sy + (b->z-p.z)*p.sz; rl = sqrt(pn*pn+pt*pt); if(rl >= p.R-p.r && rl <= p.R+p.r && fabs(ps) <= p.r){ // Coupe entre 2 plans "epaisseur" if(pt != 0){ if(pn > 0) alphal = acos(pt/rl); else alphal = 2*M_PI-acos(pt/rl); } else{ alphal = 0; } // control angulaire if(alphal <= p.alpha){ cx = p.x + (pn*p.nx + pt*p.tx)/rl*p.R; cy = p.y + (pn*p.ny + pt*p.ty)/rl*p.R; cz = p.z + (pn*p.nz + pt*p.tz)/rl*p.R; D = sqrt(pow(b->x-cx,2)+pow(b->y-cy,2)+pow(b->z-cz,2)); if(p.r-(D+b->r) < 0){ ct[Nct].delta = p.r-(D+b->r); ct[Nct].type = 4; nx = -(cx - b->x); ny = -(cy - b->y); nz = -(cz - b->z); D = sqrt(nx*nx+ny*ny+nz*nz); ct[Nct].nx = nx/D; ct[Nct].ny = ny/D; ct[Nct].nz = nz/D; ct[Nct].px = b->x + b->r*ct[Nct].nx; ct[Nct].py = b->y + b->r*ct[Nct].ny; ct[Nct].pz = b->z + b->r*ct[Nct].nz; ct[Nct].sa = b; ct[Nct].ew = &p; Nct++; } } } } else ContactBodyElbow(p,b->b,ct,Nct); } void ContactDetection::linkedCell(vector<Sphere> & sph, const int Nsph, const Data *dat, Sphere *cell[]) noexcept { int x,y,z; // Initialisation du tableau tdl for(int i = Nsph ; i--;) sph[i].tdl = NULL; // Initialisation du tableau Cell for(int i = dat->Ncellmax ; i--;) cell[i] = NULL; // Classement des grains dans les cellules for(int i = Nsph ; i--;){ if(sph[i].HollowballNum() == -9){ x = (int)((sph[i].x - dat->xmin)/dat->ax); y = (int)((sph[i].y - dat->ymin)/dat->ay); z = (int)((sph[i].z - dat->zmin)/dat->az); if(x < dat->Nx && y < dat->Ny && z < dat->Nz && x >= 0 && y >= 0 && z >= 0){ //printf("Found it\n"); //printf("%d in %d\n",i,x*dat->Ny*dat->Nz+y*dat->Nz+z); sph[i].tdl = cell[x*dat->Ny*dat->Nz+y*dat->Nz+z]; cell[x*dat->Ny*dat->Nz+y*dat->Nz+z] = &sph[i]; } } } } void ContactDetection::listCellForPlan(Data *dat, vector<Plan> & pl, int & Npl, Gravity& gt) noexcept { int a,b; int i,j,k; int I,num; double x,y,z,pn,pt,ps; double dn,dt,ds; double ox,oy,oz; double nx,ny,nz; double tx,ty,tz; double sx,sy,sz; double Sox,Soy,Soz; double Sq0,Sq1,Sq2,Sq3; int doublon; int *localCell; int localNcell; double Vmax,time,dtime,dist; int Nts; localCell =(int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); for(a = 0 ; a < Npl ; a++){ if(pl[a].Force == 0){ Vmax = pl[a].Vmax(); if(Vmax < pl[a].Wmax()*pl[a].dt)Vmax = pl[a].Wmax()*pl[a].dt; if(Vmax < pl[a].Wmax()*pl[a].ds)Vmax = pl[a].Wmax()*pl[a].ds; time = pl[a].Delay(); dist = dat->ax/2; if(dist > dat->ay/2)dist = dat->ay/2; if(dist > dat->az/2)dist = dat->az/2; if(Vmax != 0) dtime = dist/Vmax; else dtime = 0.0; if(time == 10000.0)time = dat->Total; if(time != 0) Nts = (int)(time/dtime)+1; else Nts = 0; localNcell = 0; for(i = dat->Nx*dat->Ny*dat->Nz ; i--;){ localCell[i] = -9; } Sox = pl[a].x; Soy = pl[a].y; Soz = pl[a].z; Sq0 = pl[a].q0; Sq1 = pl[a].q1; Sq2 = pl[a].q2; Sq3 = pl[a].q3; printf("Nts(%d) = %d\n",a,Nts); for(b = 0 ; b <= Nts ; b++){ if(b != 0){ pl[a].UpDateVelocity(b*dtime,dtime,gt); pl[a].Move(dtime); } ox = pl[a].x; oy = pl[a].y; oz = pl[a].z; nx = pl[a].nx; ny = pl[a].ny; nz = pl[a].nz; tx = pl[a].tx; ty = pl[a].ty; tz = pl[a].tz; sx = pl[a].sx; sy = pl[a].sy; sz = pl[a].sz; //printf("at b = %d => t = %e => z = %e\n",b,b*dtime,oz); dn = sqrt(dat->ax*dat->ax+dat->ay*dat->ay+dat->az*dat->az); dt = dn; ds = dn; for(i = 0 ; i < dat->Nx ; i++){ for(j = 0 ; j < dat->Ny ; j++){ for(k = 0 ; k < dat->Nz ; k++){ x = dat->xmin + dat->ax*(i+0.5); y = dat->ymin + dat->ay*(j+0.5); z = dat->zmin + dat->az*(k+0.5); pn = (x-ox)*nx+(y-oy)*ny+(z-oz)*nz; pt = (x-ox)*tx+(y-oy)*ty+(z-oz)*tz; ps = (x-ox)*sx+(y-oy)*sy+(z-oz)*sz; if( (fabs(pt) < (pl[a].dt/2+dt)) && (fabs(ps) < (pl[a].ds/2+ds)) && (pn <= dn) && pn > -dn){ // Control de doublon doublon = 0; num = (i*dat->Ny*dat->Nz+j*dat->Nz+k); for(I = 0 ; I < localNcell ; I++){ if(num == localCell[I]){ doublon++; } } if(doublon == 0){ localCell[localNcell] = num; localNcell++; } } } } } } pl[a].Cell = (int*)malloc(localNcell*sizeof(int)); pl[a].NCell = localNcell; for(i = 0 ; i < localNcell ; i++){ pl[a].Cell[i] = localCell[i]; } printf("Ncell(%d pl) = %d\n",a,pl[a].NCell); pl[a].x = Sox; pl[a].y = Soy; pl[a].z = Soz; pl[a].q0 = Sq0; pl[a].q1 = Sq1; pl[a].q2 = Sq2; pl[a].q3 = Sq3; pl[a].ComputeBase(); } else{ // Si une force est appliquee toutes les cellules sont considerees pl[a].Cell = (int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); pl[a].NCell = dat->Nx*dat->Ny*dat->Nz; printf("Ncell(%d pl) = %d\n",a,pl[a].NCell); for(i = 0 ; i < dat->Nx*dat->Ny*dat->Nz ; i++){ pl[a].Cell[i] = i; } } } free(localCell); } void ContactDetection::listCellForPlanR(Data *dat, vector<PlanR> & plr, int & Nplr, Gravity& gt) noexcept { int a,b; int i,j,k; int I,num; double x,y,z,pn,pt,ps; double dn; double ox,oy,oz; double nx,ny,nz; double tx,ty,tz; double sx,sy,sz; double Sox,Soy,Soz; double Sq0,Sq1,Sq2,Sq3; int doublon; int *localCell; int localNcell; double Vmax,time,dtime,dist; int Nts; localCell =(int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); for(a = 0 ; a < Nplr ; a++){ if(plr[a].Force == 0){ Vmax = plr[a].Vmax(); if(Vmax < plr[a].Wmax()*plr[a].r)Vmax = plr[a].Wmax()*plr[a].r; time = plr[a].Delay(); dist = dat->ax/2; if(dist > dat->ay/2)dist = dat->ay/2; if(dist > dat->az/2)dist = dat->az/2; if(Vmax != 0) dtime = dist/Vmax; else dtime = 0.0; if(time == 10000.0)time = dat->Total; if(time != 0) Nts = (int)(time/dtime)+1; else Nts = 0; localNcell = 0; for(i = dat->Nx*dat->Ny*dat->Nz ; i--;){ localCell[i] = -9; } Sox = plr[a].x; Soy = plr[a].y; Soz = plr[a].z; Sq0 = plr[a].q0; Sq1 = plr[a].q1; Sq2 = plr[a].q2; Sq3 = plr[a].q3; for(b = 0 ; b <= Nts ; b++){ if(b != 0){ plr[a].UpDateVelocity(b*dtime,dtime,gt); plr[a].Move(dtime); } ox = plr[a].x; oy = plr[a].y; oz = plr[a].z; nx = plr[a].nx; ny = plr[a].ny; nz = plr[a].nz; tx = plr[a].tx; ty = plr[a].ty; tz = plr[a].tz; sx = plr[a].sx; sy = plr[a].sy; sz = plr[a].sz; dn = sqrt(dat->ax*dat->ax+dat->ay*dat->ay+dat->az*dat->az); for(i = 0 ; i < dat->Nx ; i++){ for(j = 0 ; j < dat->Ny ; j++){ for(k = 0 ; k < dat->Nz ; k++){ x = dat->xmin + dat->ax*(i+0.5); y = dat->ymin + dat->ay*(j+0.5); z = dat->zmin + dat->az*(k+0.5); pn = (x-ox)*nx+(y-oy)*ny+(z-oz)*nz; pt = (x-ox)*tx+(y-oy)*ty+(z-oz)*tz; ps = (x-ox)*sx+(y-oy)*sy+(z-oz)*sz; if( (sqrt(pt*pt+ps*ps) < plr[a].r+2*dn) && (pn >= -dn) && (pn < 2*dn)){ // Control de doublon doublon = 0; num = (i*dat->Ny*dat->Nz+j*dat->Nz+k); for(I = 0 ; I < localNcell ; I++){ if(num == localCell[I]){ doublon++; } } if(doublon == 0){ localCell[localNcell] = num; localNcell++; } } } } } } plr[a].Cell = (int*)malloc(localNcell*sizeof(int)); plr[a].NCell = localNcell; printf("Ncell(%d plr) = %d\n",a,plr[a].NCell); for(i = 0 ; i < localNcell ; i++){ plr[a].Cell[i] = localCell[i]; } plr[a].x = Sox; plr[a].y = Soy; plr[a].z = Soz; plr[a].q0 = Sq0; plr[a].q1 = Sq1; plr[a].q2 = Sq2; plr[a].q3 = Sq3; plr[a].ComputeBase(); } else{ // Si une force est appliquee toutes les cellules sont considerees plr[a].Cell = (int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); plr[a].NCell = dat->Nx*dat->Ny*dat->Nz; printf("Ncell(%d plr) = %d\n",a,plr[a].NCell); for(i = 0 ; i < dat->Nx*dat->Ny*dat->Nz ; i++){ plr[a].Cell[i] = i; } } } free(localCell); } void ContactDetection::listCellForCone(Data *dat, vector<Cone> & co, int & Nco, Gravity& gt) noexcept { int numCone; int i,j,k; int I,num; double px,py,pz,pn,pt,ps; double dn; double ox,oy,oz; double nx,ny,nz; double tx,ty,tz; double sx,sy,sz; int doublon; int *localCell; int localNcell; double N,dr,h,b,Y,delta2,beta,a; double Sox,Soy,Soz; double Sq0,Sq1,Sq2,Sq3; double Vmax,time,dtime,dist; int Nts,b2; localCell =(int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); for(numCone = 0 ; numCone < Nco ; numCone++){ if(co[numCone].Force == 0){ Vmax = co[numCone].Vmax(); if(Vmax < co[numCone].Wmax()*co[numCone].h/2.)Vmax = co[numCone].Wmax()*co[numCone].h/2.; time = co[numCone].Delay(); dist = dat->ax/2; if(dist > dat->ay/2)dist = dat->ay/2; if(dist > dat->az/2)dist = dat->az/2; if(Vmax != 0) dtime = dist/Vmax; else dtime = 0.0; if(time == 10000.0)time = dat->Total; if(time != 0) Nts = (int)(time/dtime)+1; else Nts = 0; localNcell = 0; for(i = dat->Nx*dat->Ny*dat->Nz ; i--;){ localCell[i] = -9; } Sox = co[numCone].x; Soy = co[numCone].y; Soz = co[numCone].z; Sq0 = co[numCone].q0; Sq1 = co[numCone].q1; Sq2 = co[numCone].q2; Sq3 = co[numCone].q3; printf("Nts(%d) = %d\n",numCone,Nts); for(b2 = 0 ; b2 <= Nts ; b2++){ if(b2 != 0){ co[numCone].UpDateVelocity(b2*dtime,dtime,gt); co[numCone].Move(dtime); } ox = co[numCone].x; oy = co[numCone].y; oz = co[numCone].z; nx = co[numCone].nx; ny = co[numCone].ny; nz = co[numCone].nz; tx = co[numCone].tx; ty = co[numCone].ty; tz = co[numCone].tz; sx = co[numCone].sx; sy = co[numCone].sy; sz = co[numCone].sz; if(dat->Nx > 1) dn = sqrt(dat->ax*dat->ax+dat->ay*dat->ay+dat->az*dat->az); else{ dn = sqrt(dat->ay*dat->ay+dat->az*dat->az); } for(i = 0 ; i < dat->Nx ; i++){ for(j = 0 ; j < dat->Ny ; j++){ for(k = 0 ; k < dat->Nz ; k++){ px = dat->xmin + dat->ax*(i+0.5); py = dat->ymin + dat->ay*(j+0.5); pz = dat->zmin + dat->az*(k+0.5); pn = (px-ox)*nx+(py-oy)*ny+(pz-oz)*nz; pt = (px-ox)*tx+(py-oy)*ty+(pz-oz)*tz; ps = (px-ox)*sx+(py-oy)*sy+(pz-oz)*sz; if(fabs(pn) <= co[numCone].h/2+dn){ N = sqrt(pt*pt+ps*ps); if(ps >= 0) beta = acos(pt/N); else beta = 2*M_PI-acos(pt/N); // 3D -> 2D dr = co[numCone].r0 - co[numCone].r1; h = co[numCone].h; if(dr == 0){ if(fabs(N-co[numCone].r0) <= dn*2){ //Cellule validee // Control de doublon doublon = 0; num = (i*dat->Ny*dat->Nz+j*dat->Nz+k); for(I = 0 ; I < localNcell ; I++){ if(num == localCell[I]){ doublon++; } } if(doublon == 0){ localCell[localNcell] = num; localNcell++; } } } else{ a = -h/dr; b = h*(co[numCone].r0/dr-0.5); Y = sqrt(dr*dr+h*h); delta2 = (N - pn/a + b/a) / (dr/a/Y-h/Y); if(fabs(delta2) <= 2*dn){ //Cellule validee // Control de doublon doublon = 0; num = (i*dat->Ny*dat->Nz+j*dat->Nz+k); for(I = 0 ; I < localNcell ; I++){ if(num == localCell[I]){ doublon++; } } if(doublon == 0){ localCell[localNcell] = num; localNcell++; } } } } } } } } co[numCone].Cell = (int*)malloc(localNcell*sizeof(int)); co[numCone].NCell = localNcell; for(i = 0 ; i < localNcell ; i++){ co[numCone].Cell[i] = localCell[i]; } printf("Ncell(%d co) = %d\n",numCone,co[numCone].NCell); co[numCone].x = Sox; co[numCone].y = Soy; co[numCone].z = Soz; co[numCone].q0 = Sq0; co[numCone].q1 = Sq1; co[numCone].q2 = Sq2; co[numCone].q3 = Sq3; co[numCone].ComputeBase(); } else{ // Si une force est appliquee toutes les cellules sont considerees co[numCone].Cell = (int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); co[numCone].NCell = dat->Nx*dat->Ny*dat->Nz; printf("Ncell(%d plr) = %d\n",numCone,co[numCone].NCell); for(i = 0 ; i < dat->Nx*dat->Ny*dat->Nz ; i++){ co[numCone].Cell[i] = i; } } } free(localCell); } void ContactDetection::listCellForElbow(Data *dat, vector<Elbow> & el, int & Nelb) noexcept { int numEl; int i,j,k; int I,num; double px,py,pz,pn,pt,ps; double dn; double ox,oy,oz; double nx,ny,nz; double tx,ty,tz; double sx,sy,sz; double Sox,Soy,Soz; double Snx,Sny,Snz; double Stx,Sty,Stz; double Ssx,Ssy,Ssz; int doublon; int *localCell; int localNcell; double Vmax,time,dtime,dist; int Nts,b; double rl, alphal,cx,cy,cz,D; localCell =(int*)malloc(dat->Nx*dat->Ny*dat->Nz*sizeof(int)); for(numEl = 0 ; numEl < Nelb ; numEl++){ Vmax = el[numEl].Vmax(); if(Vmax < el[numEl].Wmax()*(el[numEl].r+el[numEl].R))Vmax = el[numEl].Wmax()*(el[numEl].r+el[numEl].R); time = el[numEl].Delay(); dist = dat->ax/2; if(dist > dat->ay/2)dist = dat->ay/2; if(dist > dat->az/2)dist = dat->az/2; if(Vmax != 0) dtime = dist/Vmax; else dtime = 0.0; if(time == 10000.0)time = dat->Total; if(time != 0) Nts = (int)(time/dtime)+1; else Nts = 0; localNcell = 0; for(i = dat->Nx*dat->Ny*dat->Nz ; i--;){ localCell[i] = -9; } Sox = el[numEl].x; Soy = el[numEl].y; Soz = el[numEl].z; Snx = el[numEl].nx; Sny = el[numEl].ny; Snz = el[numEl].nz; Stx = el[numEl].tx; Sty = el[numEl].ty; Stz = el[numEl].tz; Ssx = el[numEl].sx; Ssy = el[numEl].sy; Ssz = el[numEl].sz; for(b = 0 ; b <= Nts ; b++){ if(b != 0){ el[numEl].Move(b*dtime,dtime); } ox = el[numEl].x; oy = el[numEl].y; oz = el[numEl].z; nx = el[numEl].nx; ny = el[numEl].ny; nz = el[numEl].nz; tx = el[numEl].tx; ty = el[numEl].ty; tz = el[numEl].tz; sx = el[numEl].sx; sy = el[numEl].sy; sz = el[numEl].sz; dn = sqrt(dat->ax*dat->ax+dat->ay*dat->ay+dat->az*dat->az); for(i = 0 ; i < dat->Nx ; i++){ for(j = 0 ; j < dat->Ny ; j++){ for(k = 0 ; k < dat->Nz ; k++){ px = dat->xmin + dat->ax*(i+0.5); py = dat->ymin + dat->ay*(j+0.5); pz = dat->zmin + dat->az*(k+0.5); pn = (px-ox)*nx + (py-oy)*ny + (pz-oz)*nz; pt = (px-ox)*tx + (py-oy)*ty + (pz-oz)*tz; ps = (px-ox)*sx + (py-oy)*sy + (pz-oz)*sz; rl = sqrt(pn*pn+pt*pt); if(rl >= el[numEl].R-el[numEl].r-2*dn && rl <= el[numEl].R+el[numEl].r+2*dn && fabs(ps) <= el[numEl].r+2*dn){ // Coupe entre 2 plans "epaisseur" if(pt != 0){ if(pn > 0) alphal = acos(pt/rl); else alphal = 2*M_PI-acos(pt/rl); } else{ alphal = 0; } // control angulaire if((alphal < M_PI && alphal <= el[numEl].alpha + 2*dn/rl) || (alphal >= M_PI && alphal-2*M_PI >= -2*dn/rl)){ cx = ox + (pn*nx + pt*tx)/rl*el[numEl].R; cy = oy + (pn*ny + pt*ty)/rl*el[numEl].R; cz = oz + (pn*nz + pt*tz)/rl*el[numEl].R; D = sqrt(pow(px-cx,2)+pow(py-cy,2)+pow(pz-cz,2)); if(el[numEl].r-(D+2*dn) < 0){ //Cellule validee // Control de doublon doublon = 0; num = (i*dat->Ny*dat->Nz+j*dat->Nz+k); for(I = 0 ; I < localNcell ; I++){ if(num == localCell[I]){ doublon++; } } if(doublon == 0){ localCell[localNcell] = num; localNcell++; } } } } } } } } el[numEl].Cell = (int*)malloc(localNcell*sizeof(int)); el[numEl].NCell = localNcell; for(i = 0 ; i < localNcell ; i++){ el[numEl].Cell[i] = localCell[i]; } printf("Ncell(%d el) = %d\n",numEl,el[numEl].NCell); el[numEl].x = Sox; el[numEl].y = Soy; el[numEl].z = Soz; el[numEl].nx = Snx; el[numEl].ny = Sny; el[numEl].nz = Snz; el[numEl].tx = Stx; el[numEl].ty = Sty; el[numEl].tz = Stz; el[numEl].sx = Ssx; el[numEl].sy = Ssy; el[numEl].sz = Ssz; } free(localCell); } void ContactDetection::sphContactAll(const int & Nsph, vector<Sphere> & sph, Contact *ctl, int & Nctl) noexcept { int i,j; for(i = 0 ; i < Nsph ; i++){ for(j = i+1 ; j < Nsph ; j++){ ContactSphSph(&sph[i],&sph[j],ctl,Nctl); } } } void ContactDetection::sphContact(const int Nx0, const int Nx1, const int Nx, const int Ny0, const int Ny1, const int Ny, const int Nz, Contact *ctl, int & Nctl, Sphere **cell) noexcept { int l,m; Sphere *cand[5000],*anta; int i,j,k,Ncand; int num; for(i = Nx0 ; i < Nx1 ; i++){ for(j = Ny0 ; j < Ny1 ; j++){ for(k = 0 ; k < Nz ; k++){ // num = i*Ny*Nz+j*Nz+k num = i*Ny*Nz+j*Nz+k; Ncand = 0; //printf("(%d,%d,%d) => %d\n",i,j,k,num); if((cand[Ncand] = cell[num]) != NULL){ //printf("(%d,%d,%d) => %d\n",i,j,k,num); do{ //cand[Ncand]->affiche(); Ncand++; }while((cand[Ncand] = cand[Ncand-1]->tdl) != NULL); // test dans le meme boite for(l = 0 ; l < Ncand ; l++){ for(m = l+1 ; m < Ncand ; m++){ ContactSphSph(cand[l],cand[m],ctl,Nctl); } } // Solo if(i+1 < Nx){ //(i+1)*Ny*Nz+j*Nz+k = num+Ny*Nz if((anta = cell[num+Ny*Nz]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(j+1 < Ny){ //i*Ny*Nz+(j+1)*Nz+k = num+Nz if((anta = cell[num+Nz]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(k+1 < Nz){ //i*Ny*Nz+j*Nz+k+1 = num+1 if((anta = cell[num+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } // plan XY if(i+1 < Nx && j+1 < Ny){ //(i+1)*Ny*Nz+(j+1)*Nz+k = num + Ny*Nz + Nz = num + Nz*(Ny+1) if((anta = cell[num+Nz*(Ny+1)]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(i+1 < Nx && j-1 >= 0){ //(i+1)*Ny*Nz+(j-1)*Nz+k = num + Ny*Nz - Nz = num + Nz*(Ny-1) if((anta = cell[num+Nz*(Ny-1)]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } // plan XZ if(i+1 < Nx && k+1 < Nz){ //(i+1)*Ny*Nz+j*Nz+k+1 = num + Ny*Nz + 1 if((anta = cell[num+Ny*Nz+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(i+1 < Nx && k-1 >= 0){ //(i+1)*Ny*Nz+j*Nz+k-1 = num + Ny*Nz - 1 if((anta = cell[num+Ny*Nz-1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } // plan YZ if(j+1 < Ny && k+1 < Nz){ //i*Ny*Nz+(j+1)*Nz+k+1 = num + Nz + 1 if((anta = cell[num+Nz+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(j+1 < Ny && k-1 >= 0){ //i*Ny*Nz+(j+1)*Nz+k-1 = num + Nz - 1 if((anta = cell[num+Nz-1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } // tripple if(i+1 < Nx && j+1 < Ny && k+1 < Nz){ //(i+1)*Ny*Nz+(j+1)*Nz+k+1 = num + Nz*(Ny + 1) + 1 if((anta = cell[num+Nz*(Ny+1)+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(i+1 < Nx && j+1 < Ny && k-1 >= 0){ //(i+1)*Ny*Nz+(j+1)*Nz+k-1 = num + Nz*(Ny + 1) - 1 if((anta = cell[num+Nz*(Ny+1)-1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(i+1 < Nx && j-1 >= 0 && k+1 < Nz){ //(i+1)*Ny*Nz+(j-1)*Nz+k+1 = num + Nz*(Ny - 1) + 1 if((anta = cell[num+Nz*(Ny-1)+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } if(i-1 >= 0 && j+1 < Ny && k+1 < Nz){ //(i-1)*Ny*Nz+(j+1)*Nz+k+1 = num + Nz*(1-Ny)+1 if((anta = cell[num+Nz*(1-Ny)+1]) != NULL){ do{ for(l = 0 ; l < Ncand ; l++){ ContactSphSph(cand[l],anta,ctl,Nctl); } }while((anta = anta->tdl) != NULL); } } } } } } } void ContactDetection::sphPlanContact(const int &Nsph, const int &Npl, int & Nct, vector<Sphere> & sph, vector<Plan> & pl, Contact *ct, Sphere *cell[], const double rmax) noexcept { Sphere *anta; int control[Npl]; for(int i = 0 ; i < Npl ; i++){ if(pl[i].periodic == -9) control[i] = 1; else control[i] = 0; } for(int i = 0 ; i < Npl ; i++){ if(pl[i].periodic == -9){ for(int j = 0 ; j < pl[i].NCell ; j++){ if((anta = cell[pl[i].Cell[j]]) != NULL){ do{ ContactSphPlan(pl[i], anta, ct, Nct); }while((anta = anta->tdl) != NULL); } } } else{ if(control[i] == 0){ Sphere *llistI[Nsph]; pl[i].Nlist = 0; for(int j = 0 ; j < pl[i].NCell ; j++){ if((anta = cell[pl[i].Cell[j]]) != NULL){ do{ ContactSphPlanPeriodic(llistI, pl[i], pl[pl[i].periodic], anta, rmax); }while((anta = anta->tdl) != NULL); } } Sphere *llistK[Nsph]; int k = pl[i].periodic; pl[k].Nlist = 0; for(int j = 0 ; j < pl[k].NCell ; j++){ if((anta = cell[pl[k].Cell[j]]) != NULL){ do{ ContactSphPlanPeriodic(llistK, pl[k], pl[pl[k].periodic], anta, rmax); }while((anta = anta->tdl) != NULL); } } for(int j = 0 ; j < pl[i].Nlist ; j++){ for(int l = 0 ; l < pl[k].Nlist ; l++){ ContactSphSphPeriodic(llistI[j], llistK[l], ct, Nct); } } control[i] = 1; control[k] = 1; } } } } void ContactDetection::sphPlanContactOMP(const int &Nsph, const int &Npl, int & Nct, int & Ncta, vector<Sphere> & sph, vector<Plan> & pl, Contact *ct, Contact *cta, Sphere *cell[], const double rmax) noexcept { Sphere *anta; int control[Npl]; for(int i = 0 ; i < Npl ; i++){ if(pl[i].periodic == -9) control[i] = 1; else control[i] = 0; } for(int i = 0 ; i < Npl ; i++){ if(pl[i].periodic == -9 && pl[i].Ngb == 0){ #pragma omp parallel private(anta) { #pragma omp sections { #pragma omp section { for(int j = 0 ; j < pl[i].NCell/2 ; j++){ if((anta = cell[pl[i].Cell[j]]) != NULL){ do{ ContactSphPlan(pl[i], anta, ct, Nct); }while((anta = anta->tdl) != NULL); } } } #pragma omp section { for(int j = pl[i].NCell/2 ; j < pl[i].NCell ; j++){ if((anta = cell[pl[i].Cell[j]]) != NULL){ do{ ContactSphPlan(pl[i], anta, cta, Ncta); }while((anta = anta->tdl) != NULL); } } } } } } else{ if(control[i] == 0){ int k = pl[i].periodic; Sphere *llistK[Nsph]; Sphere *llistI[Nsph]; #pragma omp parallel private(anta) { #pragma omp sections { #pragma omp section { pl[i].Nlist = 0; for(int j = 0 ; j < pl[i].NCell ; j++){ if((anta = cell[pl[i].Cell[j]]) != NULL){ do{ ContactSphPlanPeriodic(llistI, pl[i],pl[pl[i].periodic], anta,rmax); }while((anta = anta->tdl) != NULL); } } } #pragma omp section { pl[k].Nlist = 0; for(int j = 0 ; j < pl[k].NCell ; j++){ if((anta = cell[pl[k].Cell[j]]) != NULL){ do{ ContactSphPlanPeriodic(llistK, pl[k],pl[pl[k].periodic], anta,rmax); }while((anta = anta->tdl) != NULL); } } } } } #pragma omp parallel private(anta) { #pragma omp sections { #pragma omp section { for(int j = 0 ; j < pl[i].Nlist/2 ; j++){ for(int l = 0 ; l < pl[k].Nlist ; l++){ ContactSphSphPeriodic(llistI[j],llistK[l], ct, Nct); } } } #pragma omp section { for(int j = pl[i].Nlist/2 ; j < pl[i].Nlist ; j++){ for(int l = 0 ; l < pl[k].Nlist ; l++){ ContactSphSphPeriodic(llistI[j],llistK[l] , cta, Ncta); } } } } } control[i] = 1; control[k] = 1; } } } } void ContactDetection::sphPlanRContact(const int &Nplr, int & Nct, vector<PlanR> & plr, Contact *ct, Sphere *cell[]) noexcept { Sphere *anta; for(int i = 0 ; i < Nplr ; i++){ for(int j = 0 ; j < plr[i].NCell ; j++){ if((anta = cell[plr[i].Cell[j]]) != NULL){ do{ ContactSphPlanR(plr[i], anta, ct, Nct); }while((anta = anta->tdl) != NULL); } } } } void ContactDetection::sphConeContact(const int &Nco, int & Nct, vector<Cone> & co, Contact *ct, Sphere *cell[]) noexcept { Sphere *anta; for(int i = 0 ; i < Nco ; i++){ for(int j = 0 ; j < co[i].NCell ; j++){ if((anta = cell[co[i].Cell[j]]) != NULL){ do{ ContactSphCone(co[i], anta, ct, Nct); }while((anta = anta->tdl) != NULL); } } } } void ContactDetection::sphElbowContact(const int &Nelb, int & Nct, vector<Elbow> & elb, Contact *ct, Sphere *cell[]) noexcept { Sphere *anta; for(int i = 0 ; i < Nelb ; i++){ for(int j = 0 ; j < elb[i].NCell ; j++){ if((anta = cell[elb[i].Cell[j]]) != NULL){ do{ ContactSphElbow(elb[i], anta, ct, Nct); }while((anta = anta->tdl) != NULL); } } } } void ContactDetection::sphHollowBallContact(const int &Nhb, int & Nct, vector<HollowBall> & hb, Contact *ct) noexcept { for(int i = 0 ; i < Nhb ; i++){ hb[i].ContactDetectionInHollowBall(ct,Nct); hb[i].ContactDetectionWithHollowBall(ct,Nct); } } void ContactDetection::sphContainer(const int & Nsph, const int & Npl, const int & Nplr, const int & Nco, const int & Nelb, const int & Nhb, vector<Sphere> & sph, vector<Plan> & pl, vector<PlanR> & plr, vector<Cone> & co, vector<Elbow> & elb, vector<HollowBall> & hb, int & Nct, Contact *ct, Sphere *cell[], const double rmax) noexcept { sphPlanContact(Nsph,Npl, Nct, sph, pl, ct, cell,rmax); sphPlanRContact(Nplr, Nct, plr, ct, cell); sphConeContact(Nco, Nct, co, ct, cell); sphElbowContact(Nelb, Nct, elb, ct, cell); sphHollowBallContact(Nhb, Nct, hb, ct); } void ContactDetection::sphContainerOMP(const int & Nsph, const int & Npl, const int & Nplr, const int & Nco, const int & Nelb, const int & Nhb, vector<Sphere> & sph, vector<Plan> & pl, vector<PlanR> & plr, vector<Cone> & co, vector<Elbow> & elb, vector<HollowBall> & hb, int & Nct, Contact *ct, int & Ncta, Contact *cta, Sphere *cell[], const double rmax) noexcept { sphPlanContactOMP(Nsph,Npl, Nct, Ncta, sph, pl, ct, cta, cell,rmax); sphPlanRContact(Nplr, Nct, plr, ct, cell); sphConeContact(Nco, Nct, co, ct, cell); sphElbowContact(Nelb, Nct, elb, ct, cell); sphHollowBallContact(Nhb, Nct, hb, ct); }

539e92ac4f9582cfa6799394855d844cd1c832d0

b2b6139550f9b8e4b5e2b678e78917990f9d7f5c

/utils.h

eede0a091271e5fe9f98a64db0d35505f9dcefbd

[]

no_license

holdenmc/Moria

0c4ccacead01ebc4fb134a6765e2e2db4fb7ac5b

12db2a499f6c1e30a735d69515534a2187a291ca

refs/heads/master

2021-01-21T07:53:16.275514

2014-12-04T03:27:23

27,039,678

1

0

null

UTF-8

C++

false

1,613

h

utils.h

/* Conor Ryan Holden McGinnis CIS 190 Final Project utils.h - delcarations for general utility functions to assist in basic game operation */ #ifndef UTILS_H #define UTILS_H #define AGE_MIN 1 #define AGE_MAX 99 #define MAX_PLAYER_NAME 11 #define STORE_SEP_1 3 #define STORE_SEP_2 5 #define STAT_3 3 #define STAT_4 4 #define STAT_5 5 #define STAT_7 7 #define M_HEIGHT_BASE 68 #define F_HEIGHT_BASE 62 #define HEIGHT_RANGE 20 #define M_WEIG_BASE 180 #define F_WEIG_BASE 140 #define M_WEIG_RANGE 100 #define F_WEIG_RANGE 50 #define CHAR_4 4 //for printing things properly; char width constants #define CHAR_5 5 #define CHAR_7 7 #define CHAR_11 11 #define CHAR_18 18 #define INVENT_SIZE 9 #define CHARIS_CHANGE 8 #define PRICE_REDUC 2 #define CHARIS_FACTOR 5 #include <vector> #include <string> #include "player.h" #include "town.h" #include "store.h" //Made methods capital letter first if they setup game/draw it //walks user through selection screen to make their player with statistics Player* MakePlayer(); //draws the screen given map and status bar void DrawGame(Map* theMap, Player* thePlayer); //goes through annoying details of making the stores vector vector<Store*>* MakeStores(); //Transfers an item from the store to the player void transferItemFromStore(int itemNum, Store* theStore, Player* thePlayer); //since g++ likes to be annoying with to_string -_- string toString(int number); #endif

2b4cad2628cdad2d667aae4f5d72b717357bdd8a

2089f9c4bec7e93f4f730e36cb425dbd5f1e4f60

/src/checkbox/CheckBoxObjectEditor.h

57affacefab92f8eb0210404aa57888e91901a72

[ "Zlib" ]

permissive

4ian/Widgets-Extension

8a527ecd4bcd3a5362802ab7bec74d11bd554adf

51fdd53231a6008dbbd64b82e8d1b006a2332704

refs/heads/master

2020-05-18T19:58:52.293378

2012-01-05T20:34:54

3,034,288

3

1

null

UTF-8

C++

false

3,666

h

CheckBoxObjectEditor.h

/* Widgets Extension Extension providing graphical widgets. Copyright (c) 2011-2012 Victor Levasseur <victorlevasseur01@orange.fr> This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ #if defined(GD_IDE_ONLY) #ifndef CheckBoxObjectEditor_H #define CheckBoxObjectEditor_H //(*Headers(CheckBoxObjectEditor) #include <wx/notebook.h> #include <wx/sizer.h> #include <wx/stattext.h> #include <wx/textctrl.h> #include <wx/checkbox.h> #include <wx/spinctrl.h> #include <wx/statline.h> #include <wx/panel.h> #include <wx/button.h> #include <wx/dialog.h> //*) #include "../colorSchemePanel.h" class Game; class CheckBoxObject; class MainEditorCommand; class CheckBoxObjectEditor: public wxDialog { public: CheckBoxObjectEditor( wxWindow* parent, Game & game_, CheckBoxObject & object_, MainEditorCommand & mainEditorCommand_ ); virtual ~CheckBoxObjectEditor(); //(*Declarations(CheckBoxObjectEditor) wxStaticText* StaticText9; wxSpinCtrl* sizeEdit; wxNotebook* Notebook1; wxSpinCtrl* paddingSpinCtrl; wxSpinCtrl* checkSignSizeSpinCtrl; wxStaticText* StaticText2; wxSpinCtrl* boxSizeSpinCtrl; wxPanel* Panel4; wxStaticText* StaticText14; wxTextCtrl* textEdit; wxButton* Button1; wxStaticText* StaticText6; wxSpinCtrl* borderWidthSpinCtrl; wxStaticText* StaticText11; wxCheckBox* isCheckedCheckBox; wxStaticText* StaticText1; wxButton* fontBt; wxStaticText* StaticText7; wxStaticLine* StaticLine1; wxStaticText* StaticText12; wxPanel* Panel2; wxTextCtrl* fontEdit; wxStaticText* StaticText4; wxButton* okBt; //*) protected: //(*Identifiers(CheckBoxObjectEditor) static const long ID_STATICTEXT6; static const long ID_STATICTEXT7; static const long ID_STATICTEXT14; static const long ID_TEXTCTRL1; static const long ID_CHECKBOX1; static const long ID_STATICTEXT1; static const long ID_SPINCTRL2; static const long ID_STATICTEXT11; static const long ID_SPINCTRL4; static const long ID_STATICTEXT12; static const long ID_SPINCTRL5; static const long ID_PANEL2; static const long ID_STATICTEXT9; static const long ID_SPINCTRL3; static const long ID_STATICTEXT2; static const long ID_TEXTCTRL2; static const long ID_BUTTON4; static const long ID_STATICTEXT4; static const long ID_SPINCTRL1; static const long ID_PANEL4; static const long ID_NOTEBOOK1; static const long ID_STATICLINE1; static const long ID_BUTTON19; static const long ID_BUTTON1; //*) private: //(*Handlers(CheckBoxObjectEditor) void OnokBtClick(wxCommandEvent& event); void OnfontBtClick(wxCommandEvent& event); void OnSizeEditChange(wxSpinEvent& event); void OncancelBtClick(wxCommandEvent& event); void OnButton1Click(wxCommandEvent& event); //*) Game & game; MainEditorCommand & mainEditorCommand; CheckBoxObject & object; ColorSchemePanel *colorsPanel; DECLARE_EVENT_TABLE() }; #endif #endif

39d979299b29ca960fe11b2d6aae427302fef63b

cefe4da3a249091869c08d146ce5a3d44a431621

/ThriftClient/globals.h

66613e52657e4986ee04454fbaaed62db14ef54d

[]

no_license

weithw/thrift-qt-sipesc

90d48e39a4dee53cc48a5468d6e05538c8355401

253b218eb755b1bd80b6d7312bb5a0a74c19a37e

refs/heads/master

2020-06-02T06:48:26.324649

2015-07-23T02:18:26

38,854,800

1

0

null

UTF-8

C++

false

1,030

h

globals.h

#ifndef GLOBALS_H #define GLOBALS_H #include <QObject> #include <iostream> #include <thrift/protocol/TBinaryProtocol.h> #include <thrift/transport/TSocket.h> #include <thrift/transport/TTransportUtils.h> #include <thrift/protocol/TMultiplexedProtocol.h> #include <thrift/protocol/TProtocol.h> #include "../thrift/gen-cpp/NetworkService.h" using namespace std; using namespace apache::thrift; using namespace apache::thrift::protocol; using namespace apache::thrift::transport; using namespace org::ssdut::sipesc::network::types; using namespace org::ssdut::sipesc::network::service; using boost::shared_ptr; class Globals : public QObject { Q_OBJECT public: explicit Globals(QObject *parent = 0); static shared_ptr<TTransport> transport; static shared_ptr<NetworkServiceClient> networkService; static shared_ptr<TProtocol> protocol; static void initServices(std::string host, int port); static AuthenticationResult authResult; signals: public slots: }; #endif // GLOBALS_H

882105d68d4e5d67907c5a358bfbeaf974cce92f

a3d6556180e74af7b555f8d47d3fea55b94bcbda

/chrome/browser/sync/test/integration/single_client_incoming_password_sharing_invitation_test.cc

0250d85054c2c2665edf61a610805828636398b5

[ "BSD-3-Clause" ]

permissive

chromium/chromium

aaa9eda10115b50b0616d2f1aed5ef35d1d779d6

a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c

refs/heads/main

2023-08-24T00:35:12.585945

2023-08-23T22:01:11

120,360,765

17,408

7,102

BSD-3-Clause

2023-09-10T23:44:27

2018-02-05T20:55:32

null

UTF-8

C++

false

1,034

cc

single_client_incoming_password_sharing_invitation_test.cc

// Copyright 2023 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/test/scoped_feature_list.h" #include "chrome/browser/sync/test/integration/sync_test.h" #include "components/password_manager/core/browser/features/password_features.h" #include "content/public/test/browser_test.h" namespace { class SingleClientIncomingPasswordSharingInvitationTest : public SyncTest { public: SingleClientIncomingPasswordSharingInvitationTest() : SyncTest(SINGLE_CLIENT) {} private: base::test::ScopedFeatureList override_features_{ password_manager::features::kPasswordManagerEnableReceiverService}; }; IN_PROC_BROWSER_TEST_F(SingleClientIncomingPasswordSharingInvitationTest, SanityCheck) { ASSERT_TRUE(SetupSync()); } // TODO(crbug.com/1468523): introduce integration tests for incoming password // sharing invitation once it's possible to inject encrypted entities to the // fake server. } // namespace

c08268cf65cb18599b893e7d68e599a3a4f1a99d

6b40e9dccf2edc767c44df3acd9b626fcd586b4d

/NT/printscan/faxsrv/print/faxprint/prnwzrd/abobj.h

b561591dfc250804fee5359c7656fa52b2467109

[]

no_license

jjzhang166/WinNT5_src_20201004

712894fcf94fb82c49e5cd09d719da00740e0436

b2db264153b80fbb91ef5fc9f57b387e223dbfc2

refs/heads/Win2K3

2023-08-12T01:31:59.670176

2021-10-14T15:14:37

586,134,273

1

0

null

2023-01-07T03:47:45

2023-01-07T03:47:44

null

UTF-8

C++

false

4,968

h

abobj.h

/*++ Copyright (c) 1997 Microsoft Corporation Module Name: abobj.h Abstract: Class definition for CCommonAbObj Environment: Fax send wizard --*/ #ifndef __ABOBJ_H_ #define __ABOBJ_H_ /* The following pre-processor directives were added so that fxswzrd.dll no longer depends on msvcp60.dll. That dependency raised deployment issues with point-and-print installation on down-level operating systems. Undefining _MT, _CRTIMP, and _DLL causes the STL set implementation to be non-thread-safe (no locks when accessing data). In the fax send wizard, the set is used to keep the list of recipient unique. Since the wizard (at that stage) has only a single thread, thread safety is not an issue anymore. */ #undef _MT #undef _CRTIMP #undef _DLL #pragma warning (disable: 4273) #include <set> using namespace std; typedef struct { LPTSTR DisplayName; LPTSTR BusinessFax; LPTSTR HomeFax; LPTSTR OtherFax; LPTSTR Country; } PICKFAX, * PPICKFAX; struct CRecipCmp { /* Comparison operator 'less' Compare two PRECIPIENT by recipient's name and fax number */ bool operator()(const PRECIPIENT pcRecipient1, const PRECIPIENT pcRecipient2) const; }; typedef set<PRECIPIENT, CRecipCmp> RECIPIENTS_SET; class CCommonAbObj { protected: LPADRBOOK m_lpAdrBook; LPADRLIST m_lpAdrList; LPMAILUSER m_lpMailUser; HWND m_hWnd; // DWORD m_PickNumber; RECIPIENTS_SET m_setRecipients; BOOL m_bUnicode; // The Unicode is supported by Address Book ULONG StrCoding() { return m_bUnicode ? MAPI_UNICODE : 0; } LPTSTR StrToAddrBk(LPCTSTR szStr, DWORD* pdwSize = NULL); // return allocated string converted to the Address book encoding LPTSTR StrFromAddrBk(LPSPropValue pValue); // return allocated string converted from the Address book encoding BOOL StrPropOk(LPSPropValue lpPropVals); BOOL ABStrCmp(LPSPropValue lpPropVals, LPTSTR pStr); enum eABType {AB_MAPI, AB_WAB}; virtual eABType GetABType()=0; BOOL GetAddrBookCaption(LPTSTR szCaption, DWORD dwSize); LPSPropValue FindProp(LPSPropValue rgprop, ULONG cprop, ULONG ulPropTag); virtual HRESULT ABAllocateBuffer( ULONG cbSize, LPVOID FAR * lppBuffer ) = 0; virtual ULONG ABFreeBuffer( LPVOID lpBuffer ) = 0; virtual BOOL isInitialized() const = 0; DWORD GetRecipientInfo( LPSPropValue SPropVals, ULONG cValues, PRECIPIENT pRecipient, PRECIPIENT pOldRecipList ); BOOL GetOneOffRecipientInfo( LPSPropValue SPropVals, ULONG cValues, PRECIPIENT pRecipient, PRECIPIENT pOldRecipList ); LPTSTR GetEmail( LPSPropValue SPropVals, ULONG cValues ); DWORD InterpretAddress( LPSPropValue SPropVals, ULONG cValues, PRECIPIENT *ppNewRecipList, PRECIPIENT pOldRecipList ); LPTSTR InterpretEmailAddress( LPSPropValue SPropVal, ULONG cValues ); DWORD InterpretDistList( LPSPropValue SPropVals, ULONG cValues, PRECIPIENT *ppNewRecipList, PRECIPIENT pOldRecipList ); PRECIPIENT FindRecipient( PRECIPIENT pRecipList, PICKFAX* pPickFax ); PRECIPIENT FindRecipient( PRECIPIENT pRecipient, PRECIPIENT pRecipList ); DWORD AddRecipient( PRECIPIENT* ppNewRecip, PRECIPIENT pRecipient, BOOL bFromAddressBook ); BOOL GetRecipientProps(PRECIPIENT pRecipient, LPSPropValue* pMapiProps, DWORD* pdwPropsNum); public: CCommonAbObj(HINSTANCE hInstance); ~CCommonAbObj(); BOOL Address( HWND hWnd, PRECIPIENT pRecip, PRECIPIENT * ppNewRecip ); LPTSTR AddressEmail( HWND hWnd ); static HINSTANCE m_hInstance; } ; #endif

077e28660a6d07188aa5b01a8a65d0de262f55f0

7b2ab3e644b051ef03069ec48125532d695ec1b7

/easy/FootBall/main.cpp

0e2868eca0efe4265cee94aadca7a4260ce2e849

[]

no_license

yao4ming/codeeval

93f880095abfff42d1b140968ff763887af5361f

c4eb2ecda8356194466ce17725a6ba7d84776c6e

refs/heads/master

2021-05-04T11:52:08.187142

2016-11-27T07:23:22

49,847,046

0

null

UTF-8

C++

false

1,336

cpp

main.cpp

#include <iostream> #include <fstream> #include <vector> #include <sstream> #include <map> using namespace std; string trim(string str) { string trimmedStr; int i, j; //trim left end for (i= 0; i < str.size(); ++i) { if (str[i] != ' ') break; } trimmedStr = str.substr(i); //trim right end for (j = trimmedStr.size()-1; j >=0 ; --j) { if (trimmedStr[j] != ' ') break; } return trimmedStr.substr(0, j+1); } int main(int argc, char** argv) { ifstream in(argv[1]); string line; while (getline(in, line)) { stringstream ss(line); string token; vector<string> tokens; while (getline(ss, token, '|')) tokens.push_back(trim(token)); map<int, vector<int>> m; for (int i = 0; i < tokens.size(); ++i) { stringstream ss2(tokens[i]); while (getline(ss2, token, ' ')) m[stoi(token)].push_back(i+1); } for(map<int, vector<int>>::iterator iter = m.begin(); iter != m.end(); iter++) { cout << iter->first << ":"; for (int i = 0; i < iter->second.size(); ++i) (i != iter->second.size()-1) ? cout << iter->second[i] << "," : cout << iter->second[i] << "; "; } cout << endl; } }

e8978606b887b850afb331339239b23d40736bbb

a181e4c65ccef369d4ab7e182e2818aa622debc1

/yact/system_dlls/hid_yact/hid.cpp

aa26101ff971ba4be9019037bceaaad34ee14e1f

[]

no_license

c1p31065/Win86emu

259c32eb5bac1ed9c4f5ceebe2ca0aa07fdf4843

71c723fcab44d5aae3b6b3c86c87154ad3c4abb5

refs/heads/master

2021-12-02T18:24:51.564748

2014-02-06T14:12:11

null

0

null

UTF-8

C++

false

1,592

cpp

hid.cpp

#include "dllyact_def.h" DEFINE_FUNC1(HidD_FlushQueue) DEFINE_FUNC1(HidD_FreePreparsedData) DEFINE_FUNC2(HidD_GetAttributes) DEFINE_FUNC3(HidD_GetConfiguration) DEFINE_FUNC3(HidD_GetFeature) DEFINE_FUNC1(HidD_GetHidGuid) DEFINE_FUNC4(HidD_GetIndexedString) DEFINE_FUNC3(HidD_GetInputReport) DEFINE_FUNC3(HidD_GetManufacturerString) DEFINE_FUNC3(HidD_GetMsGenreDescriptor) DEFINE_FUNC2(HidD_GetNumInputBuffers) DEFINE_FUNC3(HidD_GetPhysicalDescriptor) DEFINE_FUNC2(HidD_GetPreparsedData) DEFINE_FUNC3(HidD_GetProductString) DEFINE_FUNC3(HidD_GetSerialNumberString) DEFINE_FUNC2(HidD_Hello) DEFINE_FUNC3(HidD_SetConfiguration) DEFINE_FUNC3(HidD_SetFeature) DEFINE_FUNC2(HidD_SetNumInputBuffers) DEFINE_FUNC3(HidD_SetOutputReport) DEFINE_FUNC4(HidP_GetButtonCaps) DEFINE_FUNC2(HidP_GetCaps) DEFINE_FUNC6(HidP_GetData) DEFINE_FUNC5(HidP_GetExtendedAttributes) DEFINE_FUNC3(HidP_GetLinkCollectionNodes) DEFINE_FUNC8(HidP_GetScaledUsageValue) DEFINE_FUNC7(HidP_GetSpecificButtonCaps) DEFINE_FUNC7(HidP_GetSpecificValueCaps) DEFINE_FUNC8(HidP_GetUsageValue) DEFINE_FUNC9(HidP_GetUsageValueArray) DEFINE_FUNC8(HidP_GetUsages) DEFINE_FUNC7(HidP_GetUsagesEx) DEFINE_FUNC4(HidP_GetValueCaps) DEFINE_FUNC5(HidP_InitializeReportForID) DEFINE_FUNC2(HidP_MaxDataListLength) DEFINE_FUNC3(HidP_MaxUsageListLength) DEFINE_FUNC6(HidP_SetData) DEFINE_FUNC8(HidP_SetScaledUsageValue) DEFINE_FUNC8(HidP_SetUsageValue) DEFINE_FUNC9(HidP_SetUsageValueArray) DEFINE_FUNC8(HidP_SetUsages) DEFINE_FUNC_CB6(HidP_TranslateUsagesToI8042ScanCodes,5,3) DEFINE_FUNC8(HidP_UnsetUsages) DEFINE_FUNC5(HidP_UsageListDifference)

a220ca1933710ddb78ae87cb4bf983a1f25a8e63

067f633881b210648076cec8089e1068e9a50e6b

/CDMS/Rainman/CFileSystemStore.h

658c63f71e6ac3b1b065f4a64777c43ed5f44e68

[]

no_license

IgorTheLight/CorsixsModStudio

f3191b992f017b952992fa332e350f1f03dadc06

64acd481887f9f3359466dc51a1bfe0b03ee486b

refs/heads/main

2023-02-28T01:16:25.790688

2021-02-06T09:39:02

336,265,561

1

0

null

UTF-8

C++

false

5,002

h

CFileSystemStore.h

/* Rainman Library Copyright (C) 2006 Corsix <corsix@gmail.com> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ // #define EXTEND_FILESTORE_WITH_TRAVERSE #ifndef _C_FILESYSTEM_STORE_H_ #define _C_FILESYSTEM_STORE_H_ #include "gnuc_defines.h" #define EXTEND_FILESTORE_WITH_TRAVERSE #include "IFileStore.h" #ifdef EXTEND_FILESTORE_WITH_TRAVERSE #include "IDirectoryTraverser.h" #ifdef RAINMAN_GNUC #include <sys/types.h> #include <sys/stat.h> #include <dirent.h> #else #include <windows.h> #include <shlwapi.h> #endif #endif #include "Api.h" #include <stdio.h> #include <memory.h> class RAINMAN_API CFileSystemStore : public IFileStore #ifdef EXTEND_FILESTORE_WITH_TRAVERSE , public IDirectoryTraverser #endif { public: CFileSystemStore(void); virtual ~CFileSystemStore(void); class RAINMAN_API CStream : public IFileStore::IStream { protected: friend class CFileSystemStore; CStream(void); FILE *m_fFile; #ifdef _DEBUG char* m_sFile; #endif public: virtual ~CStream(void); virtual void VRead(unsigned long iItemCount, unsigned long iItemSize, void* pDestination); virtual void VSeek(long iPosition, IFileStore::IStream::SeekLocation SeekFrom = SL_Current); virtual long VTell(); }; class RAINMAN_API COutputStream : public IFileStore::IOutputStream { protected: friend class CFileSystemStore; COutputStream(void); FILE *m_fFile; public: virtual ~COutputStream(void); virtual void VWrite(unsigned long iItemCount, unsigned long iItemSize, const void* pSource); virtual void VRead(unsigned long iItemCount, unsigned long iItemSize, void* pDestination) ; virtual void VSeek(long iPosition, SeekLocation SeekFrom = SL_Current); virtual long VTell(); }; virtual void VInit(void* pUnused = 0); virtual IStream* VOpenStream(const char* sFile); IStream* OpenStreamW(const wchar_t* sFile); virtual IOutputStream* VOpenOutputStream(const char* sFile, bool bEraseIfPresent); IOutputStream* OpenOutputStreamW(const wchar_t* sFile, bool bEraseIfPresent); #ifdef EXTEND_FILESTORE_WITH_TRAVERSE class RAINMAN_API CIterator : public IDirectoryTraverser::IIterator { protected: friend class CFileSystemStore; CIterator(const char* sFolder,const CFileSystemStore *pStore); #ifdef RAINMAN_GNUC DIR* m_pDirectory; dirent* m_pDirEnt; #else WIN32_FIND_DATAA m_W32FD; HANDLE m_HandFD; #endif char* m_sParentPath; char* m_sFullPath; const CFileSystemStore* m_pStore; public: ~CIterator(); virtual IDirectoryTraverser::IIterator::eTypes VGetType(); virtual IDirectoryTraverser::IIterator* VOpenSubDir(); virtual IFileStore::IStream* VOpenFile(); virtual const char* VGetName(); virtual const char* VGetFullPath(); virtual const char* VGetDirectoryPath(); virtual tLastWriteTime VGetLastWriteTime(); virtual IDirectoryTraverser::IIterator::eErrors VNextItem(); }; class RAINMAN_API CIteratorW : public IDirectoryTraverser::IIterator { protected: friend class CFileSystemStore; CIteratorW(const wchar_t* sFolder,const CFileSystemStore *pStore); WIN32_FIND_DATAW m_W32FD; HANDLE m_HandFD; wchar_t* m_wParentPath; char* m_sParentPath; wchar_t* m_wFullPath; char* m_sFullPath; char* m_sFileName; const CFileSystemStore* m_pStore; public: ~CIteratorW(); static void _ensureAsciiVersionOf(const wchar_t* wString, char* &sString); virtual IDirectoryTraverser::IIterator::eTypes VGetType(); virtual IDirectoryTraverser::IIterator* VOpenSubDir(); virtual IFileStore::IStream* VOpenFile(); virtual const char* VGetName(); virtual const char* VGetFullPath(); virtual const char* VGetDirectoryPath(); const wchar_t* GetNameW(); const wchar_t* GetFullPathW(); const wchar_t* GetDirectoryPathW(); virtual tLastWriteTime VGetLastWriteTime(); virtual IDirectoryTraverser::IIterator::eErrors VNextItem(); }; virtual IDirectoryTraverser::IIterator* VIterate(const char* sPath); virtual CIteratorW* IterateW(const wchar_t* sPath); virtual unsigned long VGetEntryPointCount(); virtual const char* VGetEntryPoint(unsigned long iID); virtual void VCreateFolderIn(const char* sPath, const char* sNewFolderName); tLastWriteTime VGetLastWriteTime(const char* sPath); #endif protected: bool m_bInited; #ifdef EXTEND_FILESTORE_WITH_TRAVERSE bool m_bDrivePresent[26]; char m_sDriveStrings[26][3]; #endif }; #endif

ec3c5cad48e61979e35b34ed905f48af5b3d969e

0c6ad83017727a71da52800e5d648eaaa646f43b

/Src/Engine/Private/World/gaScene.cpp

e6fff7ba3a4083c608e9c288671da957ee71b673

[]

no_license

macieks/uberengine

4a7f707d7dad226bed172ecf9173ab72e7c37c71

090a5e4cf160da579f2ea46b839ece8e1928c724

refs/heads/master

2021-06-06T05:14:16.729673

2018-06-20T21:21:43

18,791,692

3

0

null

UTF-8

C++

false

389

cpp

gaScene.cpp

#include "World/gaScene.h" #include "World/gaActor.h" #include "World/gaEffectComponent.h" #include "World/gaLightComponent.h" #include "World/gaModelComponent.h" ueClassRegistry s_builtinGameplayModule[] = { UE_CLASS_REGISTRY(gaActor), UE_CLASS_REGISTRY(gaComponent), UE_CLASS_REGISTRY(gaEffectComponent), UE_CLASS_REGISTRY(gaLightComponent), UE_CLASS_REGISTRY(gaModelComponent) };

7ffcfe56b68764d8282148a2a554339d4c44798b

a61b99c29abc595f6e9dfe76cf764c5a93b3c9ab

/KarmanVortex/src/MyTime.h

1b2b121655448f44283113b3c795fd0635f31862

[]

no_license

meltingrabbit/CFD

597b5587bdf8c146afb5775083ecbfe261b8cb32

2ac0deac95c392fc4bbd6258bb07f4ad14f4e376

refs/heads/master

2020-03-18T08:35:34.653910

2018-07-05T15:34:27

134,518,419

1

0

null

UTF-8

C++

false

1,138

h

MyTime.h

/* 言語: C++ OS: Microsoft Windows 10 Home (64 bit) コンパイル: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall x86_amd64 & cl /EHsc /O2 /nologo $file_name 日付: 2017/01/12 */ #ifndef MY_TIME_CLASS_H #define MY_TIME_CLASS_H #include <chrono> // 時間計測 using namespace std; class MyTime { public: using ns = chrono::nanoseconds; using us = chrono::microseconds; using ms = chrono::milliseconds; using s = chrono::seconds; using m = chrono::minutes; using h = chrono::hours; private: chrono::system_clock::time_point startTime; chrono::system_clock::time_point endTime; public: MyTime(); void Start(); void End(); template <typename T> auto Elapsed(); template <typename T> auto Watch(); }; MyTime::MyTime() { startTime = chrono::system_clock::now(); } void MyTime::Start() { startTime = chrono::system_clock::now(); } void MyTime::End() { endTime = chrono::system_clock::now(); } template <typename T> auto MyTime::Elapsed() { return chrono::duration_cast<T>(endTime-startTime).count(); } template <typename T> auto MyTime::Watch() { End(); return Elapsed<T>(); } #endif

305d45a8344daeefeb33a0c78fdb8f6b38cf03be

14d5d165add507452bea06dc6f3366089e55e763

/my-finroc-proj/MLR/utils/display_PCs.cpp

8c00abc2c8df6338a04c81de8e06830e80b9b3de

[]

no_license

arasdar/Robotics

bed8221e404e0a1e78c30cccbe9f7ee369f4f5f9

0a2016dc8ed4a5a28109b893ea3a099dd6abd08d

refs/heads/master

2021-04-15T05:56:58.822963

2018-06-22T22:59:45

126,894,461

0

null

UTF-8

C++

false

2,303

cpp

display_PCs.cpp

/* * display_PCs.cpp * * Created on: Mar 29, 2016 * Author: aras */ #include "projects/stereo_traversability_experiments/mlr/tMLR.h" using namespace cv; using namespace finroc::stereo_traversability_experiments::mlr; // the implementation is there but implt for what? for tMLR void tMLR::display_PCs(/*INPUT*/ const learn_PCA::tPCA& pca, /*INPUT*/const Mat& I_scaled_sample) //there is no output since it is only displaying PCs -- debugging purposes { // make sure mean and S, V are loaded correctly - by showing them // copy the PCA results Mat mean = pca.mean.clone(); // isContinuous is one REASON LOG_PRINT(mean, "mean: ", eLOG_PRINT_STATE::eIS_ACTIVE); mean = mean.reshape(0 /*no change in number of CHANNELS*/, I_scaled_sample.rows); mean = toGrayscale(mean); namedWindow("mean", WINDOW_NORMAL); imshow("mean", mean); Mat S = pca.S.clone(); // S by col LOG_PRINT(S, "S: ", eLOG_PRINT_STATE::eIS_ACTIVE); Mat V = pca.V.clone(); // square matrix if all EigenValues are kept LOG_PRINT(V, "V: ", eLOG_PRINT_STATE::eIS_ACTIVE); Mat U = pca.U.clone(); // square matrix if all EigenValues are kept LOG_PRINT(U, "U: ", eLOG_PRINT_STATE::eIS_ACTIVE); // Display Principle Components & Feature Selection for (/*unsigned*/ int i = 0; i < S.cols; i++) { // show the singular values //string msg = format("Singular values DOUBLE precision(CV_64FC1)# %d = %20.f", i + 1, S.at<double>(i)); //2pow^64 ~ 2pow20 ==> 20 digits string msg = format("Singular values DOUBLE precision(CV_64FC1)# %d = %0.60f", i + 1, S.at<double>(i)); cout << msg << endl; // Reading the singular vectors cv::Mat eigenFeature = V.col(i).clone(); eigenFeature = eigenFeature.reshape(0 /*no change in number of CHANNELS*/, I_scaled_sample.rows); eigenFeature = toGrayscale(eigenFeature); // Displaying it with its order with respect to WRT its eigenvalues string name = format("eigenFeature_%d", i); namedWindow(name, WINDOW_NORMAL); imshow(name, eigenFeature); char key = waitKey(0); // MANUAL selection of PC --> feature selection if (key == 'q' || key == 27) { break; } }// for displaying PCs }// display_PCs (Principle Components) --> composition, decomposition, component, compartment and analysis

cd57f4eb866549a58b1954ff3b601d924292e51a

3fb39f6fd87870f4224742f2242c73ca229c332e

/vsynth/vsynth.buildv010/build_cache/desktop_release_macos/vsynth_vsynth.cpp

7b309eb59a35d7e1a5510d8a31fbab927325fad0

[]

no_license

swoolcock/m2

c22a1f04b71411cac50500a8c0b09b81697657ce

d6206431189935b5ba34e95b7100d8288cd85b64

refs/heads/master

2021-01-17T21:26:51.737642

2016-07-02T01:42:17

null

0

null

UTF-8

C++

false

5,941

cpp

vsynth_vsynth.cpp

#include "vsynth_vsynth.h" // ***** External ***** #include "../../../../../../monkey2/modules/mojo/mojo.buildv010/desktop_release_macos/mojo_app_2app.h" #include "../../../../../../monkey2/modules/mojo/mojo.buildv010/desktop_release_macos/mojo_app_2event.h" #include "../../../../../../monkey2/modules/monkey/monkey.buildv010/desktop_release_macos/monkey_math.h" #include "../../../../../../monkey2/modules/sdl2-mixer/sdl2-mixer.buildv010/desktop_release_macos/sdl2_5mixer_sdl2_5mixer.h" #include "../../../../../../monkey2/modules/std/std.buildv010/desktop_release_macos/std_geom_2vec2.h" extern bbDouble g_monkey_math_Abs_1d(bbDouble l_x); // ***** Internal ***** bbGCRootVar<t_mojo_app_AppInstance> g_default_instance; bbGCRootVar<t_default_VSynth> g_default_vsynth; bbFloat g_default_Pos; bbInt g_default_FragmentSize; bbInt g_default_AudioFrequency; void g_default_VSynth_audio_0callback(void* l_a,bbUByte* l_b,bbInt l_byteCount){ struct f0_t : public bbGCFrame{ bbArray<bbFloat>* l_buffer{}; void gcMark(){ bbGCMarkPtr(l_buffer); } }f0{}; bbInt l_samples=(l_byteCount/4); if((l_samples>g_default_FragmentSize)){ puts(BB_T("Audio Overrun").c_str());fflush( stdout ); l_samples=g_default_FragmentSize; } f0.l_buffer=g_default_vsynth->m_FillAudioBuffer(l_samples); { bbInt l_i=bbInt(0); for(;(l_i<l_samples);l_i+=1){ bbInt l_s0=bbInt((f0.l_buffer->at(((l_i*2)+bbInt(0)))*2000.0f)); l_s0=g_default_VSynth_Limit(l_s0,-32767,32767); l_b[((l_i*4)+bbInt(0))]=bbUByte((l_s0&255)); l_b[((l_i*4)+1)]=bbUByte((l_s0>>8)); bbInt l_s1=bbInt((f0.l_buffer->at(((l_i*2)+1))*2000.0f)); l_s1=g_default_VSynth_Limit(l_s1,-32767,32767); l_b[((l_i*4)+2)]=bbUByte((l_s1&255)); l_b[((l_i*4)+3)]=bbUByte((l_s1>>8)); } } } bbInt g_default_VSynth_Limit(bbInt l_value,bbInt l_lo,bbInt l_hi){ if((l_value<l_lo)){ return l_lo; } if((l_value>l_hi)){ return l_hi; } return l_value; } void bbMain(){ static bool done; if(done) return; done=true; void mx2_mojo_main();mx2_mojo_main(); void mx2_std_main();mx2_std_main(); g_default_instance=bbGCNew<t_mojo_app_AppInstance>(); bbGCNew<t_default_VSynth>(BB_T("VSynth0.01")); g_mojo_app_App->m_Run(); } void t_default_VSynth::init(){ m_left=bbGCNew<t_default_Sine>(); m_right=bbGCNew<t_default_Sine>(); } void t_default_VSynth::gcMark(){ t_mojo_app_Window::gcMark(); bbGCMark(m_audioSpec); bbGCMark(m_buffer); bbGCMark(m_left); bbGCMark(m_right); } t_default_VSynth::t_default_VSynth(bbString l_title):t_mojo_app_Window(l_title,720,560,8){ init(); g_default_vsynth=this; this->m_OpenAudio(); } void t_default_VSynth::m_OpenAudio(){ struct f0_t : public bbGCFrame{ SDL_AudioSpec l_spec{}; void gcMark(){ bbGCMark(l_spec); } }f0{}; this->m_buffer=bbArray<bbFloat>::create((g_default_FragmentSize*2)); f0.l_spec.freq=g_default_AudioFrequency; f0.l_spec.format=bbShort(AUDIO_S16); f0.l_spec.channels=2; f0.l_spec.samples=bbShort(g_default_FragmentSize); f0.l_spec.callback=g_default_VSynth_audio_0callback; Mix_CloseAudio(); bbInt l_error=SDL_OpenAudio(&f0.l_spec,&this->m_audioSpec); if(bbBool(l_error)){ puts((((BB_T("error=")+bbString(l_error))+BB_T(" "))+bbString::fromCString(((void*)(SDL_GetError())))).c_str());fflush( stdout ); }else{ puts((BB_T("Audio Open freq=")+bbString(this->m_audioSpec.freq)).c_str());fflush( stdout ); g_default_AudioFrequency=this->m_audioSpec.freq; } SDL_PauseAudio(bbInt(0)); } void t_default_VSynth::m_OnMouseEvent(t_mojo_app_MouseEvent* l_event){ this->m_mousex=l_event->m_Location().m_X(); this->m_mousey=l_event->m_Location().m_Y(); } void t_default_VSynth::m_OnKeyEvent(t_mojo_app_KeyEvent* l_event){ bbInt l_0=l_event->m_Type(); if(l_0==0){ bbInt l_1=l_event->m_Key(); if(l_1==27){ g_default_instance->m_Terminate(); } } } bbArray<bbFloat>* t_default_VSynth::m_FillAudioBuffer(bbInt l_samples){ bbFloat l_p0=bbFloat(this->m_mousey); bbFloat l_p1=bbFloat(this->m_mousex); { bbInt l_i=bbInt(0); for(;(l_i<l_samples);l_i+=1){ bbFloat l_sleft=this->m_left->m_Sample(bbDouble(l_p0)); bbFloat l_sright=this->m_right->m_Sample(bbDouble(l_p1)); this->m_buffer->at(((l_i*2)+bbInt(0)))=l_sleft; this->m_buffer->at(((l_i*2)+1))=l_sright; } } g_default_Pos+=bbFloat(l_samples); return this->m_buffer; } bbFloat t_default_Oscillator::m_Sample(bbDouble l_hz){ return 0.0f; } bbFloat t_default_Sine::m_Sample(bbDouble l_hz){ bbDouble l_t=((l_hz*g_monkey_math_Pi)/bbDouble(g_default_AudioFrequency)); this->m_r+=l_t; return bbFloat(std::sin(this->m_r)); } bbFloat t_default_Sawtooth::m_Sample(bbDouble l_hz){ bbDouble l_t=(l_hz/bbDouble(g_default_AudioFrequency)); this->m_r+=l_t; return bbFloat((std::fmod((this->m_r+1.0),2.0)-1.0)); } bbFloat t_default_Triangle::m_Sample(bbDouble l_hz){ bbDouble l_t=(l_hz/bbDouble(g_default_AudioFrequency)); this->m_r+=l_t; return bbFloat(((g_monkey_math_Abs_1d(std::fmod(this->m_r,4.0))-2.0)-1.0)); } bbFloat t_default_Square::m_Sample(bbDouble l_hz){ bbDouble l_t=(l_hz/bbDouble(g_default_AudioFrequency)); this->m_r+=l_t; bbInt l_i=bbInt(this->m_r); return bbFloat((-1+(2*(l_i&1)))); } void t_default_Voice::gcMark(){ bbGCMark(m_oscillator); } void t_default_Voice::m_SetPan(bbFloat l_value){ this->m_pan=l_value; } void t_default_Voice::m_SetOscillator(t_default_Oscillator* l_osc){ this->m_oscillator=l_osc; } void t_default_Voice::m_NoteOn(bbInt l_note){ this->m_hz=bbFloat((440.0*std::pow(2.0,bbDouble(((bbFloat(l_note)-67.0f)/12.0f))))); } void t_default_Voice::m_NoteOff(){ } void mx2_vsynth_vsynth_init(){ static bool done; if(done) return; done=true; g_default_FragmentSize=4096; g_default_AudioFrequency=44100; } bbInit mx2_vsynth_vsynth_init_v("vsynth_vsynth",&mx2_vsynth_vsynth_init);

f3a668a68121d9c2dba6651c9dbbb185db25f603

93f02e5c9c7a01089608ba5f598d0c19b1b6cfd9

/pgm17.cpp

54d0bff83cf40aa48e249c39e7e9cececbf08a8a

[]

no_license

Aleeshakurian/CPP

b4cc68cc818e9231656543be9353fcc106dda73f

3750356c513a0b0051d1d36dc113f4d2d2efa52a

refs/heads/master

2020-04-07T00:17:50.989115

2018-11-17T04:48:59

157,897,850

0

null

UTF-8

C++

false

249

cpp

pgm17.cpp

#include<iostream> #include<strstream> using namespace std; main() { char iostr[80]; strstream strio(iostr,sizeof(iostr),ios::in|ios::out); int a,b; char str[80]; strio<<"10 20 testing"; strio>>a>>b>>str; cout<<a<<" "<<b<<" "<<str<<endl; }

830301dbe69e2592bedd301b7ab63c6ec0a54013

77cde85e8990f22cc61e552bdc40ff20d7555c00

/test/exec/import_test/import_smoke_test.cpp

25e258605e4083e59722500d4d208f7ea7d299a2

[ "BSD-3-Clause" ]

permissive

blockspacer/cmakesl

823e24102890e6fc8a4072d7cf4e497d04673487

e53bffed62ae9ca68c0c2de0de8e2a94bfe4d326

refs/heads/master

2022-04-10T09:54:02.971963

2020-02-15T20:46:27

null

0

null

UTF-8

C++

false

2,108

cpp

import_smoke_test.cpp

#include "test/exec/smoke_test_fixture.hpp" #include <gmock/gmock.h> namespace cmsl::exec::test { using ::testing::Eq; using ImportSmokeTest = ExecutionSmokeTest; TEST_F(ImportSmokeTest, VariableImport) { const auto source = "import \"import_test/foo.cmsl\";" "" "int main()" "{" " return foo::bar;" "}"; const auto result = m_executor->execute(source); EXPECT_THAT(result, Eq(42)); } TEST_F(ImportSmokeTest, OneVariableInstanceDespiteMultipleImports) { const auto source = "import \"import_test/foo.cmsl\";" "import \"import_test/baz.cmsl\";" "" "int main()" "{" " auto result = (foo::bar == 24 && baz::qux == 42);" " return int(result);" "}"; const auto result = m_executor->execute(source); EXPECT_THAT(result, Eq(1)); } TEST_F(ImportSmokeTest, FunctionImport) { const auto source = "import \"import_test/foo.cmsl\";" "" "int main()" "{" " return foo::baz();" "}"; const auto result = m_executor->execute(source); EXPECT_THAT(result, Eq(42)); } TEST_F(ImportSmokeTest, ClassImport) { const auto source = "import \"import_test/foo.cmsl\";" "" "int main()" "{" " foo::qux q;" " return q.get();" "}"; const auto result = m_executor->execute(source); EXPECT_THAT(result, Eq(42)); } TEST_F(ImportSmokeTest, EnumImport) { const auto source = "import \"import_test/foo.cmsl\";" "" "int main()" "{" " return int(foo::top::kek.to_string() == \"kek\");" "}"; const auto result = m_executor->execute(source); EXPECT_THAT(result, Eq(1)); } }

c95659abd6e0f3f0dfc82ea08c176ec3b2d2f0a3

e14153f8052f8856e6471d7d06f2896d04356a41

/vector3.h

03a9036ea392c09d026987980f56b89a4118d937

[]

no_license

DearVa/Minecraft

7c57dcc1405e7c048fc190d135ebea99875a1d00

8ab3f38bb4d4abffc95f09121173ba054f6caf4d

refs/heads/master

2023-01-31T21:52:46.493090

2020-12-16T07:45:44

305,026,508

3

0

null

UTF-8

C++

false

1,246

h

vector3.h

#pragma once #include <cmath> class Vector3 { public: double x, y, z; Vector3() { x = 0.0; y = 0.0; z = 0.0; } Vector3(double x, double y, double z) { this->x = x; this->y = y; this->z = z; } Vector3(const Vector3 &v) { x = v.x; y = v.y; z = v.z; } inline double length(); Vector3 normalize(); double dotProduct(const Vector3 &v); Vector3 crossProduct(const Vector3 &v); Vector3 operator +(const Vector3 &v); Vector3 &operator +=(const Vector3 &v); Vector3 operator -(const Vector3 &v); Vector3 &operator -=(const Vector3 &v); Vector3 operator *(const double scale); Vector3 operator /(const double scale); Vector3 operator -(); bool operator == (const Vector3 &v); }; class Vector3i { public: int x, y, z; Vector3i() { x = -1; y = -1; z = -1; } Vector3i(int x, int y, int z) { this->x = x; this->y = y; this->z = z; } Vector3i(const Vector3 &v) { x = v.x; y = v.y; z = v.z; } Vector3i(const Vector3i &v) { x = v.x; y = v.y; z = v.z; } Vector3i operator + (const Vector3i &v); Vector3i operator + (const Vector3 &v); Vector3i operator - (const Vector3i &v); Vector3i operator - (const Vector3 &v); bool operator == (const Vector3i &v); operator Vector3(); };

dd1cd2284fde9648144443dfe17bf8bcfa649594

a55cec32c0191f3f99752749f8323a517be46638

/ProfessionalC++/TypeTraits/is_same.cpp

f1a839911e1bbca6d07273b3db679d6986e51c65

[ "Apache-2.0" ]

permissive

zzragida/CppExamples

e0b0d1609b2e485cbac22e0878e00cc8ebce6a94

d627b097efc04209aa4012f7b7f9d82858da3f2d

refs/heads/master

2021-01-18T15:06:57.286097

2016-03-08T00:23:31

49,173,497

0

null

UTF-8

C++

false

486

cpp

is_same.cpp

#include <iostream> #include <string> #include <type_traits> using namespace std; template <typename T1, typename T2> void same_helper(const T1& t1, const T2& t2, bool b) { cout << t1 << " and " << t2 << " "; cout << (b ? "the same types" : "different type") << endl; } template <typename T1, typename T2> void same(const T1& t1, const T2& t2) { same_helper(t1, t2, is_same<T1, T2>::value); } int main() { same(1, 32); same(1, 3.01); same(3.01, string("Test")); return 0; }

b1aa3614a63b8593bd46f3603d8d6e21be1a21c3

9dcbccd554c3aa9787eb90dc6dc6610307cb070b

/src/coefficients.cpp

0d021b041aa4acb19d5c80f0a07eedfdd75a26b9

[ "MIT" ]

permissive

nestordemeure/asgard

60a3ae2fa42638f5d8c46b3d59dec448b65aff8d

97fddc8ff3be2f9b30029cf508f366e58f9b9794

refs/heads/develop

2023-07-02T04:16:40.691701

2021-04-21T21:54:44

360,295,381

0

MIT

2021-05-26T12:00:41

2021-04-21T20:18:45

C++

UTF-8

C++

false

15,771

cpp

coefficients.cpp

#include "coefficients.hpp" #include "basis.hpp" #include "fast_math.hpp" #include "matlab_utilities.hpp" #include "pde.hpp" #include "quadrature.hpp" #include "tensors.hpp" #include "tools.hpp" #include "transformations.hpp" #include <numeric> // generate coefficient matrices for each 1D term in each dimension and // underlying partial term coefficients matrices template<typename P> void generate_all_coefficients( PDE &pde, basis::wavelet_transform<P, resource::host> const &transformer, P const time, bool const rotate) { expect(time >= 0.0); for (auto i = 0; i < pde.num_dims; ++i) { auto const &dim = pde.get_dimensions()[i]; for (auto j = 0; j < pde.num_terms; ++j) { auto const &term_1D = pde.get_terms()[j][i]; auto const &partial_terms = term_1D.get_partial_terms(); for (auto k = 0; k < static_cast<int>(partial_terms.size()); ++k) { auto const partial_term_coeff = generate_coefficients( dim, term_1D, partial_terms[k], transformer, time, rotate); pde.set_partial_coefficients(j, i, k, partial_term_coeff); } } pde.rechain_dimension(i); } } // construct 1D coefficient matrix - new conventions // this routine returns a 2D array representing an operator coefficient // matrix for a single dimension (1D). Each term in a PDE requires D many // coefficient matricies template<typename P> fk::matrix generate_coefficients( dimension const &dim, term const &term_1D, partial_term const &pterm, basis::wavelet_transform<P, resource::host> const &transformer, P const time, bool const rotate) { expect(time >= 0.0); expect(transformer.degree == dim.get_degree()); expect(transformer.max_level >= dim.get_level()); // setup jacobi of variable x and define coeff_mat auto const num_points = fm::two_raised_to(transformer.max_level); auto const grid_spacing = (dim.domain_max - dim.domain_min) / num_points; auto const degrees_freedom_1d = dim.get_degree() * num_points; fk::matrix coefficients(degrees_freedom_1d, degrees_freedom_1d); // get quadrature points and quadrature_weights. // we do the two-step store because we cannot have 'static' bindings static auto const legendre_values = legendre_weights(dim.get_degree(), -1.0, 1.0); auto const [quadrature_points, quadrature_weights] = legendre_values; auto const [legendre_poly_L, legendre_poly_R] = [&]() { auto [lP_L, lPP_L] = legendre(fk::vector{-1}, dim.get_degree()); lP_L = lP_L * (1 / std::sqrt(grid_spacing)); auto [lP_R, lPP_R] = legendre(fk::vector{+1}, dim.get_degree()); lP_R = lP_R * (1 / std::sqrt(grid_spacing)); // this is to get around unused warnings (until c++20) auto const ignore = [](auto ignored) { (void)ignored; }; ignore(lPP_L); ignore(lPP_R); return std::array<fk::matrix, 2>{lP_L, lP_R}; }(); auto const legendre_poly_L_t = fk::matrix(legendre_poly_L).transpose(); auto const legendre_poly_R_t = fk::matrix(legendre_poly_R).transpose(); // get the basis functions and derivatives for all k // this auto is std::array<fk::matrix, 2> auto const [legendre_poly, legendre_prime] = [&, quadrature_points = quadrature_points]() { auto [lP, lPP] = legendre(quadrature_points, dim.get_degree()); lP = lP * (1.0 / std::sqrt(grid_spacing)); lPP = lPP * (1.0 / std::sqrt(grid_spacing) * 2.0 / grid_spacing); return std::array<fk::matrix, 2>{lP, lPP}; }(); auto const legendre_poly_t = fk::matrix(legendre_poly).transpose(); auto const legendre_prime_t = fk::matrix(legendre_prime).transpose(); // get jacobian auto const jacobi = grid_spacing / 2; // convert term input data from wavelet space to realspace // FIXME during PDE rework, fix term's RAII issues... auto const &term_data = term_1D.get_data(); fk::vector<P, mem_type::const_view> const data(term_data, 0, degrees_freedom_1d - 1); auto const data_real = transformer.apply( data, transformer.max_level, basis::side::left, basis::transpose::trans); for (auto i = 0; i < num_points; ++i) { // get left and right locations for this element auto const x_left = dim.domain_min + i * grid_spacing; auto const x_right = x_left + grid_spacing; // get index for current, first and last element auto const current = dim.get_degree() * i; auto const first = 0; auto const last = dim.get_degree() * (num_points - 1); // map quadrature points from [-1,1] to physical domain of this i element fk::vector const quadrature_points_i = [&, quadrature_points = quadrature_points]() { fk::vector quadrature_points_copy(quadrature_points); std::transform( quadrature_points_copy.begin(), quadrature_points_copy.end(), quadrature_points_copy.begin(), [&](P const elem) { return ((elem + 1) / 2 + i) * grid_spacing + dim.domain_min; }); return quadrature_points_copy; }(); fk::vector const g_func = [&, legendre_poly = legendre_poly]() { // get realspace data at quadrature points // NOTE : this is unused pending updating G functions to accept "dat" fk::vector data_real_quad = legendre_poly * fk::vector<P, mem_type::const_view>(data_real, current, current + dim.get_degree() - 1); // get g(x,t,dat) // FIXME : add dat as a argument to the G functions fk::vector g(quadrature_points_i.size()); for (auto i = 0; i < quadrature_points_i.size(); ++i) { g(i) = pterm.g_func(quadrature_points_i(i), time); } return g; }(); auto const block = [&, legendre_poly = legendre_poly, quadrature_weights = quadrature_weights]() { fk::matrix tmp(legendre_poly.nrows(), legendre_poly.ncols()); for (int i = 0; i <= tmp.nrows() - 1; i++) { for (int j = 0; j <= tmp.ncols() - 1; j++) { tmp(i, j) = g_func(i) * legendre_poly(i, j) * quadrature_weights(i) * jacobi; } } fk::matrix block(dim.get_degree(), dim.get_degree()); if (pterm.coeff_type == coefficient_type::mass) { block = legendre_poly_t * tmp; } else if (pterm.coeff_type == coefficient_type::grad) { block = legendre_prime_t * tmp * (-1); } return block; }(); // set the block at the correct position fk::matrix const curr_block = fk::matrix<P, mem_type::view>(coefficients, current, current + dim.get_degree() - 1, current, current + dim.get_degree() - 1) + block; coefficients.set_submatrix(current, current, curr_block); if (pterm.coeff_type == coefficient_type::grad) { // setup numerical flux choice/boundary conditions // // - <funcCoef*{q},p> //---------------------------------------------- // Numerical Flux is defined as // Flux = {{f}} + C/2*[[u]] // = ( f_L + f_R )/2 + FunCoef*( u_R - u_L )/2 // [[v]] = v_R - v_L // FIXME G functions should accept G(x,p,t,dat), since we don't know how // the dat is going to be used in the G function (above it is used as // linear multuplication but this is not always true) auto const flux_left = pterm.g_func(x_left, time); auto const flux_right = pterm.g_func(x_right, time); // get the "trace" values // (values at the left and right of each element for all k) auto trace_value_1 = (legendre_poly_L_t * legendre_poly_R) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); auto trace_value_2 = (legendre_poly_L_t * legendre_poly_L) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); auto trace_value_3 = (legendre_poly_R_t * legendre_poly_R) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); auto trace_value_4 = (legendre_poly_R_t * legendre_poly_L) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); // If dirichelt // u^-_LEFT = g(LEFT) // u^+_RIGHT = g(RIGHT) if (pterm.left == boundary_condition::dirichlet) // left dirichlet { if (i == 0) { trace_value_1 = (legendre_poly_L_t * (legendre_poly_L - legendre_poly_L)) * (-1); trace_value_2 = (legendre_poly_L_t * (legendre_poly_L - legendre_poly_L)) * (-1); trace_value_3 = (legendre_poly_R_t * legendre_poly_R) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); trace_value_4 = (legendre_poly_R_t * legendre_poly_L) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); } } if (pterm.right == boundary_condition::dirichlet) // right dirichlet { if (i == num_points - 1) { trace_value_1 = (legendre_poly_L_t * legendre_poly_R) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); trace_value_2 = (legendre_poly_L_t * legendre_poly_L) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); trace_value_3 = (legendre_poly_R_t * (legendre_poly_R - legendre_poly_R)) * (+1); trace_value_4 = (legendre_poly_R_t * (legendre_poly_R - legendre_poly_R)) * (+1); } } // If neumann // (gradient u)*num_points = g // by splitting grad u = q by LDG methods, the B.C is changed to // q*num_points = g (=> q = g for 1D variable) // only work for derivatives greater than 1 if (pterm.left == boundary_condition::neumann) // left neumann { if (i == 0) { trace_value_1 = (legendre_poly_L_t * (legendre_poly_L - legendre_poly_L)) * (-1); trace_value_2 = (legendre_poly_L_t * legendre_poly_L) * (-1 * flux_left); trace_value_3 = (legendre_poly_R_t * legendre_poly_R) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); trace_value_4 = (legendre_poly_R_t * legendre_poly_L) * (+1 * flux_right / 2) + (legendre_poly_R_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_right) / 2 * +1); } } if (pterm.right == boundary_condition::neumann) // right neumann { if (i == num_points - 1) { trace_value_1 = (legendre_poly_L_t * legendre_poly_R) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_R) * (+1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); trace_value_2 = (legendre_poly_L_t * legendre_poly_L) * (-1 * flux_left / 2) + (legendre_poly_L_t * legendre_poly_L) * (-1 * pterm.get_flux_scale() * std::abs(flux_left) / 2 * -1); trace_value_3 = (legendre_poly_R_t * legendre_poly_R) * (+1 * flux_right); trace_value_4 = (legendre_poly_R_t * (legendre_poly_R - legendre_poly_R)) * (+1); } } if (pterm.coeff_type == coefficient_type::grad) { // Add trace values to matrix int row1 = current; int col1 = current - dim.get_degree(); int row2 = current; int col2 = current; int row3 = current; int col3 = current; int row4 = current; int col4 = current + dim.get_degree(); if (pterm.left == boundary_condition::periodic || pterm.right == boundary_condition::periodic) { if (i == 0) { row1 = current; col1 = last; } if (i == num_points - 1) { row4 = current; col4 = first; } } if (i != 0 || pterm.left == boundary_condition::periodic || pterm.right == boundary_condition::periodic) { // Add trace part 1 fk::matrix<P, mem_type::view> block1( coefficients, row1, row1 + dim.get_degree() - 1, col1, col1 + dim.get_degree() - 1); block1 = block1 + trace_value_1; } // Add trace part 2 fk::matrix<P, mem_type::view> block2(coefficients, row2, row2 + dim.get_degree() - 1, col2, col2 + dim.get_degree() - 1); block2 = block2 + trace_value_2; // Add trace part 3 fk::matrix<P, mem_type::view> block3(coefficients, row3, row3 + dim.get_degree() - 1, col3, col3 + dim.get_degree() - 1); block3 = block3 + trace_value_3; if (i != num_points - 1 || pterm.left == boundary_condition::periodic || pterm.right == boundary_condition::periodic) { // Add trace part 4 fk::matrix<P, mem_type::view> block4( coefficients, row4, row4 + dim.get_degree() - 1, col4, col4 + dim.get_degree() - 1); block4 = block4 + trace_value_4; } } } } if (rotate) { // transform matrix to wavelet space // These routines do the following operation: // coefficients = forward_trans * coefficients * forward_trans_transpose; coefficients = transformer.apply( transformer.apply(coefficients, transformer.max_level, basis::side::right, basis::transpose::trans), transformer.max_level, basis::side::left, basis::transpose::no_trans); } return coefficients; } template fk::matrix<float> generate_coefficients<float>( dimension<float> const &dim, term<float> const &term_1D, partial_term<float> const &pterm, basis::wavelet_transform<float, resource::host> const &transformer, float const time, bool const rotate); template fk::matrix<double> generate_coefficients<double>( dimension<double> const &dim, term<double> const &term_1D, partial_term<double> const &pterm, basis::wavelet_transform<double, resource::host> const &transformer, double const time, bool const rotate); template void generate_all_coefficients<float>( PDE<float> &pde, basis::wavelet_transform<float, resource::host> const &transformer, float const time, bool const rotate); template void generate_all_coefficients<double>( PDE<double> &pde, basis::wavelet_transform<double, resource::host> const &transformer, double const time, bool const rotate);

9689a0be18dca933cc45de3f230af58d738cf85e

2210636542ec4c8810fa8c5bc2f90948d8028f40

/unittests/collection/OrderedSetTest.cpp

f61a7fd433cc9df006774fa8de6ba0d9ca3a4024

[ "ISC" ]

permissive

GSGroup/stingraykit

516a251fb64130351cf8617e1f0cf17799db914f

c2be37f3e0108c4a05d387f9117eac0b10a4c094

refs/heads/master

2023-08-30T06:27:36.000620

2023-08-07T09:16:23

2023-08-07T10:00:19

31,662,410

13

2

null

UTF-8

C++

false

16,365

cpp

OrderedSetTest.cpp

#include <stingraykit/collection/ordered_set.h> #include <gmock/gmock-matchers.h> using namespace stingray; using ::testing::ElementsAre; namespace { using Vector = std::vector<std::string>; using Set = std::set<std::string>; using OrderedSet = ordered_set<std::string>; } TEST(OrderedSetTest, Construction) { { OrderedSet testee; ASSERT_TRUE(testee.empty()); } { OrderedSet testee((OrderedSet::key_compare())); ASSERT_TRUE(testee.empty()); } { OrderedSet testee((OrderedSet::allocator_type())); ASSERT_TRUE(testee.empty()); } { const Vector vec = { "2", "4", "3", "1", "1", "3" }; OrderedSet testee1(vec.begin(), vec.end()); OrderedSet testee2(vec.begin(), vec.end(), OrderedSet::allocator_type()); ASSERT_EQ(testee1.size(), (size_t)4); ASSERT_EQ(testee2.size(), (size_t)4); ASSERT_TRUE(!std::is_sorted(testee1.begin(), testee1.end(), testee1.value_comp())); ASSERT_TRUE(!std::is_sorted(testee2.begin(), testee2.end(), testee2.key_comp())); ASSERT_THAT(testee1, ElementsAre("2", "4", "3", "1")); ASSERT_THAT(testee2, ElementsAre("2", "4", "3", "1")); } { const Set set = { "2", "4", "3", "1", "1", "3" }; OrderedSet testee(set.begin(), set.end()); ASSERT_TRUE(std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_TRUE(std::equal(set.begin(), set.end(), testee.begin(), testee.end())); ASSERT_THAT(testee, ElementsAre("1", "2", "3", "4")); } { OrderedSet testee1{ "5", "1", "4", "2", "3" }; OrderedSet testee2(testee1); ASSERT_FALSE(testee1.empty()); OrderedSet testee3(testee1, OrderedSet::allocator_type()); ASSERT_FALSE(testee1.empty()); OrderedSet testee4(std::move(testee1)); ASSERT_TRUE(testee1.empty()); OrderedSet testee5(std::move(testee2), OrderedSet::allocator_type()); ASSERT_TRUE(testee2.empty()); ASSERT_TRUE(!std::is_sorted(testee3.begin(), testee3.end(), testee3.value_comp())); ASSERT_TRUE(std::equal(testee3.begin(), testee3.end(), testee4.begin(), testee4.end())); ASSERT_TRUE(std::equal(testee3.begin(), testee3.end(), testee5.begin(), testee5.end())); ASSERT_THAT(testee3, ElementsAre("5", "1", "4", "2", "3")); } { const std::initializer_list<OrderedSet::value_type> values{ "2", "4", "3", "1", "1", "3" }; OrderedSet testee1(values); OrderedSet testee2(values, OrderedSet::allocator_type()); ASSERT_TRUE(!std::is_sorted(testee1.begin(), testee1.end(), testee1.value_comp())); ASSERT_TRUE(std::equal(testee1.begin(), testee1.end(), testee2.begin(), testee2.end())); ASSERT_THAT(testee1, ElementsAre("2", "4", "3", "1")); } } TEST(OrderedSetTest, Assignment) { { const OrderedSet testee1{ "5", "1", "4", "2", "3" }; OrderedSet testee2; testee2 = testee1; ASSERT_TRUE(!std::is_sorted(testee2.begin(), testee2.end(), testee2.value_comp())); ASSERT_THAT(testee2, ElementsAre("5", "1", "4", "2", "3")); } { const std::initializer_list<OrderedSet::value_type> values{ "2", "4", "3", "1", "1", "3" }; OrderedSet testee; testee = values; ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("2", "4", "3", "1")); } } TEST(OrderedSetTest, Insertion) { { OrderedSet testee; OrderedSet::value_type two("2"); auto twoResult = testee.insert(two); ASSERT_EQ(two, "2"); ASSERT_TRUE(twoResult.second); ASSERT_EQ(*twoResult.first, "2"); OrderedSet::value_type four("4"); auto fourResult = testee.insert(four); ASSERT_EQ(four, "4"); ASSERT_TRUE(fourResult.second); ASSERT_EQ(*fourResult.first, "4"); OrderedSet::value_type three("3"); auto threeResult = testee.insert(three); ASSERT_EQ(three, "3"); ASSERT_TRUE(threeResult.second); ASSERT_EQ(*threeResult.first, "3"); OrderedSet::value_type one("1"); auto oneResult = testee.insert(one); ASSERT_EQ(one, "1"); ASSERT_TRUE(oneResult.second); ASSERT_EQ(*oneResult.first, "1"); OrderedSet::value_type one2("1"); auto one2Result = testee.insert(one2); ASSERT_EQ(one2, "1"); ASSERT_FALSE(one2Result.second); ASSERT_EQ(*one2Result.first, "1"); OrderedSet::value_type three2("3"); auto three2Result = testee.insert(three2); ASSERT_EQ(three2, "3"); ASSERT_FALSE(three2Result.second); ASSERT_EQ(*three2Result.first, "3"); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("2", "4", "3", "1")); } { OrderedSet testee; OrderedSet::value_type two("2"); auto twoResult = testee.insert(std::move(two)); ASSERT_TRUE(two.empty()); ASSERT_TRUE(twoResult.second); ASSERT_EQ(*twoResult.first, "2"); OrderedSet::value_type four("4"); auto fourResult = testee.insert(std::move(four)); ASSERT_TRUE(four.empty()); ASSERT_TRUE(fourResult.second); ASSERT_EQ(*fourResult.first, "4"); OrderedSet::value_type three("3"); auto threeResult = testee.insert(std::move(three)); ASSERT_TRUE(three.empty()); ASSERT_TRUE(threeResult.second); ASSERT_EQ(*threeResult.first, "3"); OrderedSet::value_type one("1"); auto oneResult = testee.insert(std::move(one)); ASSERT_TRUE(one.empty()); ASSERT_TRUE(oneResult.second); ASSERT_EQ(*oneResult.first, "1"); OrderedSet::value_type one2("1"); auto one2Result = testee.insert(std::move(one2)); ASSERT_EQ(one2, "1"); ASSERT_FALSE(one2Result.second); ASSERT_EQ(*one2Result.first, "1"); OrderedSet::value_type three2("3"); auto three2Result = testee.insert(std::move(three2)); ASSERT_EQ(three2, "3"); ASSERT_FALSE(three2Result.second); ASSERT_EQ(*three2Result.first, "3"); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("2", "4", "3", "1")); } { OrderedSet testee; OrderedSet::value_type two("2"); auto twoIt = testee.insert(testee.end(), two); ASSERT_EQ(two, "2"); ASSERT_EQ(*twoIt, "2"); OrderedSet::value_type four("4"); auto fourIt = testee.insert(testee.end(), four); ASSERT_EQ(four, "4"); ASSERT_EQ(*fourIt, "4"); OrderedSet::value_type three("3"); auto threeIt = testee.insert(testee.begin(), three); ASSERT_EQ(three, "3"); ASSERT_EQ(*threeIt, "3"); OrderedSet::value_type one("1"); auto oneIt = testee.insert(testee.begin(), one); ASSERT_EQ(one, "1"); ASSERT_EQ(*oneIt, "1"); OrderedSet::value_type one2("1"); auto one2It = testee.insert(testee.end(), one2); ASSERT_EQ(one2, "1"); ASSERT_EQ(*one2It, "1"); OrderedSet::value_type three2("3"); auto three2It = testee.insert(testee.end(), three2); ASSERT_EQ(three2, "3"); ASSERT_EQ(*three2It, "3"); OrderedSet::const_iterator twoIt2 = testee.find("2"); ASSERT_EQ(*twoIt2, "2"); OrderedSet::value_type five("5"); auto fiveIt = testee.insert(twoIt2, five); ASSERT_EQ(five, "5"); ASSERT_EQ(*fiveIt, "5"); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("1", "3", "5", "2", "4")); } { OrderedSet testee; OrderedSet::value_type two("2"); auto twoIt = testee.insert(testee.end(), std::move(two)); ASSERT_TRUE(two.empty()); ASSERT_EQ(*twoIt, "2"); OrderedSet::value_type four("4"); auto fourIt = testee.insert(testee.end(), std::move(four)); ASSERT_TRUE(four.empty()); ASSERT_EQ(*fourIt, "4"); OrderedSet::value_type three("3"); auto threeIt = testee.insert(testee.begin(), std::move(three)); ASSERT_TRUE(three.empty()); ASSERT_EQ(*threeIt, "3"); OrderedSet::value_type one("1"); auto oneIt = testee.insert(testee.begin(), std::move(one)); ASSERT_TRUE(one.empty()); ASSERT_EQ(*oneIt, "1"); OrderedSet::value_type one2("1"); auto one2It = testee.insert(testee.end(), std::move(one2)); ASSERT_EQ(one2, "1"); ASSERT_EQ(*one2It, "1"); OrderedSet::value_type three2("3"); auto three2It = testee.insert(testee.end(), std::move(three2)); ASSERT_EQ(three2, "3"); ASSERT_EQ(*three2It, "3"); OrderedSet::const_iterator twoIt2 = testee.find("2"); ASSERT_EQ(*twoIt2, "2"); OrderedSet::value_type five("5"); auto fiveIt = testee.insert(twoIt2, std::move(five)); ASSERT_TRUE(five.empty()); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("1", "3", "5", "2", "4")); } } TEST(OrderedSetTest, Emplacing) { { OrderedSet testee; OrderedSet::value_type two("2"); auto twoResult = testee.emplace(std::move(two)); ASSERT_TRUE(two.empty()); ASSERT_TRUE(twoResult.second); ASSERT_EQ(*twoResult.first, "2"); OrderedSet::value_type four("4"); auto fourResult = testee.emplace(std::move(four)); ASSERT_TRUE(four.empty()); ASSERT_TRUE(fourResult.second); ASSERT_EQ(*fourResult.first, "4"); OrderedSet::value_type three("3"); auto threeResult = testee.emplace(std::move(three)); ASSERT_TRUE(three.empty()); ASSERT_TRUE(threeResult.second); ASSERT_EQ(*threeResult.first, "3"); OrderedSet::value_type one("1"); auto oneResult = testee.emplace(std::move(one)); ASSERT_TRUE(one.empty()); ASSERT_TRUE(oneResult.second); ASSERT_EQ(*oneResult.first, "1"); OrderedSet::value_type one2("1"); auto one2Result = testee.emplace(std::move(one2)); ASSERT_TRUE(one2.empty()); ASSERT_FALSE(one2Result.second); ASSERT_EQ(*one2Result.first, "1"); OrderedSet::value_type three2("3"); auto three2Result = testee.emplace(std::move(three2)); ASSERT_TRUE(three2.empty()); ASSERT_FALSE(three2Result.second); ASSERT_EQ(*three2Result.first, "3"); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("2", "4", "3", "1")); } { OrderedSet testee; OrderedSet::value_type two("2"); auto twoIt = testee.emplace_hint(testee.end(), std::move(two)); ASSERT_TRUE(two.empty()); ASSERT_EQ(*twoIt, "2"); OrderedSet::value_type four("4"); auto fourIt = testee.emplace_hint(testee.end(), std::move(four)); ASSERT_TRUE(four.empty()); ASSERT_EQ(*fourIt, "4"); OrderedSet::value_type three("3"); auto threeIt = testee.emplace_hint(testee.begin(), std::move(three)); ASSERT_TRUE(three.empty()); ASSERT_EQ(*threeIt, "3"); OrderedSet::value_type one("1"); auto oneIt = testee.emplace_hint(testee.begin(), std::move(one)); ASSERT_TRUE(one.empty()); ASSERT_EQ(*oneIt, "1"); OrderedSet::value_type one2("1"); auto one2It = testee.emplace_hint(testee.end(), std::move(one2)); ASSERT_TRUE(one2.empty()); ASSERT_EQ(*one2It, "1"); OrderedSet::value_type three2("3"); auto three2It = testee.emplace_hint(testee.end(), std::move(three2)); ASSERT_TRUE(three2.empty()); ASSERT_EQ(*three2It, "3"); OrderedSet::const_iterator twoIt2 = testee.find("2"); ASSERT_EQ(*twoIt2, "2"); OrderedSet::key_type five("5"); auto fiveIt = testee.emplace_hint(twoIt2, std::move(five)); ASSERT_TRUE(five.empty()); ASSERT_EQ(*fiveIt, "5"); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); ASSERT_THAT(testee, ElementsAre("1", "3", "5", "2", "4")); } } TEST(OrderedSetTest, Lookup) { const Vector unsorted{ "5", "4", "8", "9", "1", "6", "3", "2", "7", "0" }; const OrderedSet testee(unsorted.begin(), unsorted.end()); const Set sample(unsorted.begin(), unsorted.end()); ASSERT_TRUE(!std::is_sorted(testee.begin(), testee.end(), testee.value_comp())); for (Set::const_iterator sampleIt = sample.begin(); sampleIt != sample.end(); ++sampleIt) { OrderedSet::const_iterator testeeIt = testee.find(*sampleIt); ASSERT_NE(testeeIt, testee.end()); ASSERT_TRUE(*testeeIt == *sampleIt); } for (OrderedSet::const_iterator testeeIt = testee.begin(); testeeIt != testee.end(); ++testeeIt) { Set::const_iterator sampleIt = sample.find(*testeeIt); ASSERT_NE(sampleIt, sample.end()); ASSERT_TRUE(*sampleIt == *testeeIt); } for (Set::const_reverse_iterator sampleIt = sample.rbegin(); sampleIt != sample.rend(); ++sampleIt) { OrderedSet::const_iterator testeeIt = testee.find(*sampleIt); ASSERT_NE(testeeIt, testee.end()); ASSERT_TRUE(*testeeIt == *sampleIt); } for (OrderedSet::const_reverse_iterator testeeIt = testee.rbegin(); testeeIt != testee.rend(); ++testeeIt) { Set::const_iterator sampleIt = sample.find(*testeeIt); ASSERT_NE(sampleIt, sample.end()); ASSERT_TRUE(*sampleIt == *testeeIt); } for (Set::const_iterator sampleIt = sample.begin(); sampleIt != sample.end(); ++sampleIt) ASSERT_EQ(testee.count(*sampleIt), 1); for (OrderedSet::const_iterator testeeIt = testee.begin(); testeeIt != testee.end(); ++testeeIt) ASSERT_EQ(sample.count(*testeeIt), 1); } TEST(OrderedSetTest, Swap) { { OrderedSet testee1{ "5", "1", "4", "2", "3" }; OrderedSet testee2; testee1.swap(testee2); ASSERT_TRUE(testee1.empty()); ASSERT_THAT(testee2, ElementsAre("5", "1", "4", "2", "3")); } } TEST(OrderedSetTest, Removal) { { OrderedSet testee{ "5", "1", "4", "2", "3" }; ASSERT_TRUE(testee.count("4")); ASSERT_TRUE(testee.erase("4")); ASSERT_FALSE(testee.count("4")); ASSERT_FALSE(testee.erase("4")); ASSERT_TRUE(testee.count("5")); ASSERT_TRUE(testee.erase("5")); ASSERT_FALSE(testee.count("5")); ASSERT_FALSE(testee.erase("5")); ASSERT_TRUE(testee.count("3")); ASSERT_TRUE(testee.erase("3")); ASSERT_FALSE(testee.count("3")); ASSERT_FALSE(testee.erase("3")); ASSERT_THAT(testee, ElementsAre("1", "2")); } { OrderedSet testee{ "5", "1", "4", "2", "3" }; OrderedSet::const_iterator fourIt = testee.find("4"); ASSERT_NE(fourIt, testee.end()); ASSERT_EQ(*fourIt, "4"); OrderedSet::const_iterator twoIt = testee.erase(fourIt); ASSERT_NE(twoIt, testee.end()); ASSERT_EQ(*twoIt, "2"); ASSERT_FALSE(testee.count("4")); OrderedSet::const_iterator fiveIt = testee.find("5"); ASSERT_NE(fiveIt, testee.end()); ASSERT_EQ(*fiveIt, "5"); OrderedSet::const_iterator oneIt = testee.erase(fiveIt); ASSERT_NE(oneIt, testee.end()); ASSERT_EQ(*oneIt, "1"); ASSERT_FALSE(testee.count("5")); OrderedSet::const_iterator threeIt = testee.find("3"); ASSERT_NE(threeIt, testee.end()); ASSERT_EQ(*threeIt, "3"); OrderedSet::const_iterator endIt = testee.erase(threeIt); ASSERT_EQ(endIt, testee.end()); ASSERT_FALSE(testee.count("5")); ASSERT_THAT(testee, ElementsAre("1", "2")); } { OrderedSet testee{ "5", "1", "4", "2", "3" }; OrderedSet::const_iterator oneIt = testee.find("1"); ASSERT_NE(oneIt, testee.end()); ASSERT_EQ(*oneIt, "1"); OrderedSet::const_iterator twoIt = testee.find("2"); ASSERT_NE(twoIt, testee.end()); ASSERT_EQ(*twoIt, "2"); OrderedSet::const_iterator two2It = testee.erase(oneIt, twoIt); ASSERT_NE(two2It, testee.end()); ASSERT_EQ(*two2It, "2"); ASSERT_FALSE(testee.count("1")); ASSERT_FALSE(testee.count("4")); ASSERT_TRUE(testee.count("2")); ASSERT_THAT(testee, ElementsAre("5", "2", "3")); OrderedSet::const_iterator endIt = testee.erase(testee.begin(), testee.end()); ASSERT_EQ(endIt, testee.end()); ASSERT_TRUE(testee.empty()); } } TEST(OrderedSetTest, Comparison) { { const OrderedSet testee1{ "5", "1", "4", "2", "3" }; const OrderedSet testee2(testee1); ASSERT_TRUE(testee1 == testee2); ASSERT_FALSE(testee1 != testee2); ASSERT_FALSE(testee1 < testee2); ASSERT_FALSE(testee1 > testee2); ASSERT_TRUE(testee1 <= testee2); ASSERT_TRUE(testee1 >= testee2); } { const OrderedSet testee1{ "5", "1", "4", "2", "3" }; const OrderedSet testee2{ "5", "1", "4", "2" }; ASSERT_FALSE(testee1 == testee2); ASSERT_TRUE(testee1 != testee2); ASSERT_FALSE(testee1 < testee2); ASSERT_TRUE(testee1 > testee2); ASSERT_FALSE(testee1 <= testee2); ASSERT_TRUE(testee1 >= testee2); ASSERT_FALSE(testee2 == testee1); ASSERT_TRUE(testee2 != testee1); ASSERT_TRUE(testee2 < testee1); ASSERT_FALSE(testee2 > testee1); ASSERT_TRUE(testee2 <= testee1); ASSERT_FALSE(testee2 >= testee1); } { const OrderedSet testee1{ "5", "4", "1", "2", "3" }; const OrderedSet testee2{ "5", "1", "4", "2", "3" }; ASSERT_FALSE(testee1 == testee2); ASSERT_TRUE(testee1 != testee2); ASSERT_FALSE(testee1 < testee2); ASSERT_TRUE(testee1 > testee2); ASSERT_FALSE(testee1 <= testee2); ASSERT_TRUE(testee1 >= testee2); ASSERT_FALSE(testee2 == testee1); ASSERT_TRUE(testee2 != testee1); ASSERT_TRUE(testee2 < testee1); ASSERT_FALSE(testee2 > testee1); ASSERT_TRUE(testee2 <= testee1); ASSERT_FALSE(testee2 >= testee1); } }

7caeec6a55955d0e26474cd63945df7a85e8673d

e926bede54cbddf08870036ae478124e0a6cec77

/src/python/pic_solver.cpp

d848190163cc8b895929aada3e9f0f17bb92e533

[ "MIT" ]

permissive

doyubkim/fluid-engine-dev

2d1228c78690191fba8ff2c107af1dd06212ca44

94c300ff5ad8a2f588e5e27e8e9746a424b29863

refs/heads/main

2023-08-14T08:04:43.513360

2022-07-09T06:24:41

58,299,041

1,725

275

MIT

2022-07-09T06:24:41

2016-05-08T06:05:38

C++

UTF-8

C++

false

3,447

cpp

pic_solver.cpp

// Copyright (c) 2018 Doyub Kim // // I am making my contributions/submissions to this project solely in my // personal capacity and am not conveying any rights to any intellectual // property of any third parties. #include "pic_solver.h" #include "pybind11_utils.h" #include <jet/pic_solver2.h> #include <jet/pic_solver3.h> namespace py = pybind11; using namespace jet; void addPicSolver2(py::module& m) { py::class_<PicSolver2, PicSolver2Ptr, GridFluidSolver2>(m, "PicSolver2") .def("__init__", [](PicSolver2& instance, py::args args, py::kwargs kwargs) { Size2 resolution{1, 1}; Vector2D gridSpacing{1, 1}; Vector2D gridOrigin{0, 0}; parseGridResizeParams(args, kwargs, resolution, gridSpacing, gridOrigin); new (&instance) PicSolver2(resolution, gridSpacing, gridOrigin); }, R"pbdoc( Constructs PicSolver2 This method constructs PicSolver2 with resolution, gridSpacing, and gridOrigin. Parameters ---------- - `*args` : resolution, gridSpacing, and gridOrigin arguments. - `**kwargs` - resolution : Grid resolution. - gridSpacing : Grid spacing. - gridOrigin : Origin point ot the grid. - domainSizeX : Domain size in x-direction. )pbdoc") .def_property_readonly("particleSystemData", &PicSolver2::particleSystemData, R"pbdoc(Returns particleSystemData.)pbdoc") .def_property("particleEmitter", &PicSolver2::particleEmitter, &PicSolver2::setParticleEmitter, R"pbdoc(Particle emitter property.)pbdoc"); } void addPicSolver3(py::module& m) { py::class_<PicSolver3, PicSolver3Ptr, GridFluidSolver3>(m, "PicSolver3") .def("__init__", [](PicSolver3& instance, py::args args, py::kwargs kwargs) { Size3 resolution{1, 1, 1}; Vector3D gridSpacing{1, 1, 1}; Vector3D gridOrigin{0, 0, 0}; parseGridResizeParams(args, kwargs, resolution, gridSpacing, gridOrigin); new (&instance) PicSolver3(resolution, gridSpacing, gridOrigin); }, R"pbdoc( Constructs PicSolver3 This method constructs PicSolver3 with resolution, gridSpacing, and gridOrigin. Parameters ---------- - `*args` : resolution, gridSpacing, and gridOrigin arguments. - `**kwargs` - resolution : Grid resolution. - gridSpacing : Grid spacing. - gridOrigin : Origin point ot the grid. - domainSizeX : Domain size in x-direction. )pbdoc") .def_property_readonly("particleSystemData", &PicSolver3::particleSystemData, R"pbdoc(Returns particleSystemData.)pbdoc") .def_property("particleEmitter", &PicSolver3::particleEmitter, &PicSolver3::setParticleEmitter, R"pbdoc(Particle emitter property.)pbdoc"); }

9a437f5e8f3c8991c35233392e9f6027f0a35835

accd5545df6c1fe34da58b9aef97e7329c55f9c5

/吉田学園情報ビジネス専門学校_増澤未来/04_Air++/02_開発環境/Air++/Air++/lap_ui.h

020b5d3172c5fd7832543d89f13f8fab8220ad83

[]

no_license

miraika4400/MiraiMasuzawa

41fff5ce74c285f230f390bd355530f139dff949

4473fc3821a244f9b7270410b178cbad59e3d185

refs/heads/master

2023-03-12T01:09:30.264778

2021-02-27T20:56:45

305,336,083

0

1

null

2020-10-22T01:04:47

2020-10-19T09:47:08

C++

SHIFT_JIS

C++

false

1,544

h

lap_ui.h

//============================================================================= // // lap_uiヘッダ [lap_ui.h] // Author : 増澤未来 // //============================================================================= //二重インクルード防止 #ifndef _LAP_UI_H_ #define _LAP_UI_H_ //***************************** // インクルード //***************************** #include "main.h" #include "scene2d.h" //***************************** // 前方宣言 //***************************** //***************************** // マクロ定義 //***************************** //***************************** // クラス定義 //***************************** // ラップ数UIロゴクラス class CLapUi : public CScene2d { public: //============ // メンバ関数 //============ CLapUi(); ~CLapUi(); static CLapUi *Create(int nPlayerNum); // クラス生成 static HRESULT Load(void); // テクスチャロード static void Unload(void); // テクスチャアンロード HRESULT Init(void); // 初期化 void Uninit(void); // 終了 void Update(void); // 更新 void Draw(void); // 描画 private: //============ // メンバ変数 //============ static LPDIRECT3DTEXTURE9 m_pTexture; // テクスチャへのポインタ int m_nCntAnim; // アニメーションカウント int m_nAnimX; // アニメーションX軸 int m_nAnimY; // アニメーションY軸 int m_nPlayerNum; }; #endif

4c7b44adcf40f19ccb71e8eaf214bbe24970cb75

58b3d4d6376d0828411f4fc5fe2c17454004296b

/glutils.hh

49b1aa74f908f798d1c7efafec6e150d3fc4984e

[]

no_license

thaapasa/gpu-fractal

8a858f0e41a6fca96df5003a7bf0871343ba03f4

bc6f3cd776fb1e2a71df0efb6f5bf90d114312c9

refs/heads/master

2022-11-13T00:43:47.221243

2020-06-23T12:06:16

274,395,188

0

null

UTF-8

C++

false

194

hh

glutils.hh

#ifndef GL_UTILS #define GL_UTILS class GLUtils { public: static void setup2D(int width, int height); static void drawRectangle(int x1, int y1, int x2, int y2); }; #endif // GL_UTILS

3bf4ac6b6e29471f94194333630226017fb015a0

5ca6dcf33a2ba44223c608bd3db519a8e37c93e7

/MSNServerListener.h

1b7d50df9c82930ab1130fdeb455d012e27f568b

[]

no_license

tomatoKiller/MSNServer

4b52b961c579352fabaea99d9cda1716eaa98d4d

79d6daf152303440c8405eb8fabcce16aa08192a

refs/heads/master

2021-03-12T20:10:16.304822

2014-09-09T14:06:35

null

0

null

UTF-8

C++

false

159

h

MSNServerListener.h

#ifndef MSNSERVERLISTENER_H #define MSNSERVERLISTENER_H class MSNServerListener{ virtual void serverStarted()=0; virtual void serverStopping()=0; }; #endif

8093380dac3fc8846745148200cf4a737fda388a

54bcc6bba394e61e1163bac50fab8fb7f4672271

/sandbox/textgen/textgen.cc

ee919bf2ad96bfcfe67ed5e9d3102f8f4331d737

[ "MIT" ]

permissive

NeuralNetworkingTechnologies/jik

4ff548b85d652374d4bcbac2f8c1c223096a10bd

1d211533e66de96859956aef6c1000db0a2fab22

refs/heads/master

2021-04-29T03:48:08.630085

2017-06-24T16:31:45

null

0

null

UTF-8

C++

false

18,555

cc

textgen.cc

/*! The MIT License (MIT) Copyright (c)2016 Olivier Soares 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 <core/arg_parse.h> #include <core/log.h> #include <core/dataset.h> #include <core/layer_eltwise_scale.h> #include <core/layer_softmax_loss.h> #include <core/solver_sgd.h> #include <core/solver_rmsprop.h> #include <recurrent/rnn.h> #include <recurrent/lstm.h> #include <vector> #include <set> #include <map> #include <string> #include <fstream> #include <random> namespace jik { /*! * \class TextgenDataset * \brief Textgen dataset */ class TextgenDataset: public Dataset { // Public types public: typedef Dataset Parent; // Protected attributes protected: std::vector<std::string> sentence_; // List of sentences std::set<char> vocab_; // Vocabulary std::map<char, uint32_t> letter_to_index_; // Mapping letters to indices std::map<uint32_t, char> index_to_letter_; // Mapping indices to letters // Protected methods protected: /*! * Cleaning a string. * Removing leading and trailing spaces and tabs. * * \param[in] str: string */ static void CleanString(std::string* str) { // Trim leading spaces and tabs size_t startpos = str->find_first_not_of(" \t"); if (std::string::npos != startpos) { *str = str->substr(startpos); } // Trim trailing spaces and tabs size_t endpos = str->find_last_not_of(" \t"); if (std::string::npos != endpos) { *str = str->substr(0, endpos + 1); } } // Public methods public: /*! * Default constructor. */ TextgenDataset() {} /*! * Destructor. */ virtual ~TextgenDataset() {} /*! * Load the dataset. * * \param[in] dataset_path: path to the dataset root directory * * \return Error? */ virtual bool Load(const char* dataset_path) { Report(kInfo, "Loading dataset '%s'", dataset_path); std::string line; std::ifstream fp(dataset_path); if (fp.fail()) { Report(kError, "Can't open file '%s'", dataset_path); return false; } while (std::getline(fp, line)) { CleanString(&line); if (line.empty()) { continue; } for (uint32_t i = 0; i < line.length(); ++i) { vocab_.insert(line[i]); } sentence_.push_back(line); } // Reserve index 0 uint32_t i = 1; for (auto it = vocab_.begin(); it != vocab_.end(); ++it, ++i) { letter_to_index_[*it] = i; index_to_letter_[i] = *it; } return true; } /*! * Get the number of sentences. * * \return Number of sentences */ uint32_t SentenceSize() const { return uint32_t(sentence_.size()); } /*! * Get the number of letters. * * \return Number of letters */ uint32_t VocabSize() const { return uint32_t(vocab_.size()); } /*! * Get a given sentence. * * \param[in] index: sentence index * * \return Sentence */ const std::string& Sentence(uint32_t index) const { return sentence_[index]; } /*! * Convert a character to an index. * * \param[in] ch: character * * \return Index */ uint32_t LetterToIndex(char ch) const { auto it = letter_to_index_.find(ch); if (it == letter_to_index_.end()) { return 0; } return it->second; } /*! * Convert an index to a letter. * * \param[in] index: index * * \return Letter */ char IndexToLetter(uint32_t index) const { auto it = index_to_letter_.find(index); if (it == index_to_letter_.end()) { return '\0'; } return it->second; } }; /*! * \class TextgenDataLayer * \brief Textgen data layer */ template <typename Dtype> class TextgenDataLayer: public LayerData<Dtype> { // Public types public: typedef Dtype Type; typedef LayerData<Dtype> Parent; // Protected attributes protected: TextgenDataset dataset_; // Textgen dataset uint32_t dataset_train_index_; // Index in the dataset (training) uint32_t dataset_test_index_; // Index in the dataset (testing) uint32_t num_predict_; // Number of predictions std::string sentence_; // Currently loaded sentence // Public methods public: /*! * Constructor. * * \param[in] name : layer name * \param[in] param: parameters */ TextgenDataLayer(const char* name, const Param& param): Parent(name) { // Parameters std::string dataset_path; uint32_t batch_size; param.Get("dataset_path", &dataset_path); param.Get("num_predict" , &num_predict_); param.Get("batch_size" , &batch_size); if (!dataset_.Load(dataset_path.c_str())) { return; } Report(kInfo, "Sentence size: %ld", dataset_.SentenceSize()); Report(kInfo, "Vocabulary size: %ld", dataset_.VocabSize()); // Set index at the beginning of the dataset dataset_train_index_ = dataset_test_index_ = 0; // Create 1 output for the labels // There's no derivative as we don't backpropagate them Parent::out_.resize(1); Parent::out_[0] = std::make_shared<Mat<Dtype>>(1, 1, 1, batch_size, false); } /*! * Destructor. */ virtual ~TextgenDataLayer() {} /*! * Get the dataset. * * \return Dataset */ const TextgenDataset& Dataset() const { return dataset_; } /*! * Get the prediction index (aka testing index). * * \return Prediction index */ uint32_t PredictionIndex() const { return dataset_test_index_; } /*! * Check if testing is done * (i.e. if we are at the end of the testing dataset). * * \return Testing done? */ bool TestingDone() { if (!num_predict_) { // No prediction: we are done return true; } // We are done if we did all the predictions bool testing_done = dataset_test_index_ == num_predict_; if (testing_done) { // If we are done, we rewind dataset_test_index_ = 0; } return testing_done; } /*! * Get the currently loaded sentence. * * \return Currently loaded sentence */ const std::string& Sentence() const { return sentence_; } /*! * Forward pass. * * \param[in] state: state */ virtual void Forward(const State& state) { if (state.phase == State::PHASE_TEST) { if (dataset_test_index_ >= num_predict_) { Report(kError, "Invalid dataset index"); return; } // During testing, just increase a counter ++dataset_test_index_; return; } uint32_t sentence_size = dataset_.SentenceSize(); if (!sentence_size) { Report(kError, "Empty dataset"); sentence_.clear(); return; } if (dataset_train_index_ >= sentence_size) { Report(kError, "Invalid dataset index"); sentence_.clear(); return; } // Load the current sentence sentence_ = dataset_.Sentence(dataset_train_index_); // Go to the next sentence if (++dataset_train_index_ >= sentence_size) { dataset_train_index_ = 0; } } }; /*! * \class TextgenModel * \brief Textgen recurrent model */ template <class R> class TextgenModel: public R { // Protected types protected: // Public types public: typedef typename R::Type Dtype; typedef Dtype Type; typedef R Parent; // Protected attributes protected: std::shared_ptr<TextgenDataLayer<Dtype>> data_layer_; // Data layer Dtype temperature_; // Temperature std::shared_ptr<Mat<Dtype>> prob_; // Probabilities // Public methods public: /*! * Constructor. * * \param[in] name : model name * \param[in] data_layer : data layer * \param[in] size_in : input size * \param[in] hidden_size: hidden state size * \param[in] range : value range ([-range/2, range/2]) * \param[in] batch_size : batch size */ TextgenModel(const char* name, const std::shared_ptr<TextgenDataLayer<Dtype>>& data_layer, Dtype temperature, uint32_t size_in, const std::vector<uint32_t>& hidden_size, Dtype range, uint32_t batch_size): R(name, size_in, hidden_size, data_layer->Dataset().VocabSize() + 1, range, batch_size) { data_layer_ = data_layer; temperature_ = temperature; } /*! * Destructor. */ virtual ~TextgenModel() {} /*! * Create a data layer. * * \param[in] dataset_path: path to the dataset * \param[in] num_predict : number of predictions * \param[in] batch_size : batch size * * \return Data layer */ static std::shared_ptr<TextgenDataLayer<Dtype>> CreateDataLayer( const char* dataset_path, uint32_t num_predict, uint32_t batch_size) { Param param; param.Add("dataset_path", dataset_path); param.Add("num_predict" , num_predict); param.Add("batch_size" , batch_size); return std::make_shared<TextgenDataLayer<Dtype>>("data1", param); } /*! * Create at a specific index. * * \param[in] index: data index */ virtual void Create(uint32_t index) { Parent::Create(index); // Add a scale (temperature) layer if (temperature_ > std::numeric_limits<Dtype>::epsilon() && temperature_ < Dtype(1) - std::numeric_limits<Dtype>::epsilon()) { Param param; param.Add("scale", temperature_); Parent::out_ = Parent::Add(std::make_shared<EltwiseScaleLayer<Dtype>>( "", std::initializer_list<std::shared_ptr<Mat<Dtype>>>{Parent::out_}, param))[0]; } // Add a softmax layer std::shared_ptr<Mat<Dtype>> label = data_layer_->Output()[0]; const std::vector<std::shared_ptr<Mat<Dtype>>>& out = Parent::Add(std::make_shared<LayerSoftMaxLoss<Dtype>>( "", std::initializer_list<std::shared_ptr<Mat<Dtype>>>{ Parent::out_, label})); Parent::out_ = out[0]; prob_ = out[1]; } /*! * Graph training (forward + backward pass). * * \return Loss */ virtual Dtype Train() { // Clear the previous iteration state Parent::ClearPrevState(); State state(State::PHASE_TRAIN); // Load the data data_layer_->Forward(state); // Get the label, sentence dataset and currently loaded sentence std::shared_ptr<Mat<Dtype>> label = data_layer_->Output()[0]; const TextgenDataset& dataset = data_layer_->Dataset(); const std::string& sentence = data_layer_->Sentence(); uint32_t len = sentence.length(); if (!len) { return Dtype(0); } Dtype loss = Dtype(0); for (uint32_t i = 0; i <= len; ++i) { uint32_t index_src = 0; uint32_t index_dst = 0; if (i) { index_src = dataset.LetterToIndex(sentence[i - 1]); } if (i != len) { index_dst = dataset.LetterToIndex(sentence[i]); } *label->Data() = index_dst; Create(index_src); loss += Parent::Train(); } return loss / len; } /*! * Graph testing (inference). * * \return Accuracy */ virtual Dtype Test() { // Clear the previous iteration state Parent::ClearPrevState(); State state(State::PHASE_TEST); // Get the sentence dataset const TextgenDataset& dataset = data_layer_->Dataset(); // Max length of a predicted sentence const uint32_t kMaxSentenceLen = 80; std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution<Dtype> dist(Dtype(0), Dtype(1)); while (!data_layer_->TestingDone()) { // Load the data data_layer_->Forward(state); std::string sentence; while (true) { uint32_t index; if (sentence.empty()) { index = 0; } else { index = dataset.LetterToIndex(sentence[sentence.length() - 1]); } // Inference Create(index); Parent::Forward(state); // Pseudo-randomly choose an index index = 0; Dtype r = dist(gen); Dtype x = Dtype(0); Dtype* out = prob_->Data(); for (uint32_t i = 0; i < prob_->Size(); ++i) { x += out[i]; if (x > r) { break; } ++index; } // End of the sentence predicted if (!index) { break; } // Add the character to the sentence sentence += dataset.IndexToLetter(index); // Too many characters, we stop if (sentence.length() > kMaxSentenceLen) { break; } } Report(kInfo, "Predicted sentence %ld: '%s'", data_layer_->PredictionIndex(), sentence.c_str()); } return Dtype(1); } }; } // namespace jik int main(int argc, char* argv[]) { using namespace jik; // NOLINT(build/namespaces) // 32-bit float quantization typedef float Dtype; // Hyperparameters ArgParse arg(argc, argv); const char* dataset_path = arg.Arg("-dataset"); const char* model_type = arg.Arg("-model"); const char* model_name = arg.Arg("-name"); const char* solver_type = arg.Arg("-solver"); Dtype learning_rate, decay_rate, momentum, reg, clip, lr_scale, temperature, range; uint32_t batch_size, num_step, print_each, test_each, save_each, lr_scale_each, num_predict, embed_size, hs; arg.Arg<uint32_t>("-batchsize" , 128 , &batch_size); arg.Arg<Dtype> ("-lr" , Dtype(0.001), &learning_rate); arg.Arg<Dtype> ("-decayrate" , Dtype(0.999), &decay_rate); arg.Arg<Dtype> ("-momentum" , Dtype(0.9) , &momentum); arg.Arg<Dtype> ("-reg" , Dtype(0.001), &reg); arg.Arg<Dtype> ("-clip" , Dtype(5) , &clip); arg.Arg<uint32_t>("-numstep" , 50000 , &num_step); arg.Arg<uint32_t>("-printeach" , 100 , &print_each); arg.Arg<uint32_t>("-testeach" , 1000 , &test_each); arg.Arg<uint32_t>("-saveeach" , 1000 , &save_each); arg.Arg<uint32_t>("-lrscaleeach", 10000 , &lr_scale_each); arg.Arg<Dtype> ("-lrscale" , Dtype(0.1) , &lr_scale); arg.Arg<Dtype> ("-temperature", Dtype(1) , &temperature); arg.Arg<uint32_t>("-numpredict" , 10 , &num_predict); arg.Arg<uint32_t>("-embedsize" , 5 , &embed_size); arg.Arg<uint32_t>("-hs" , 20 , &hs); arg.Arg<Dtype> ("-range" , Dtype(0.2) , &range); if (!dataset_path || arg.ArgExists("-h")) { Report(kInfo, "Usage: %s -dataset <path/to/text/file> " "[-model <rnn/lstm>]", argv[0]); return -1; } // Default model type and model and solver names if (!model_type) { model_type = "rnn"; } if (!model_name) { model_name = "textgen"; } if (!solver_type) { solver_type = "rmsprop"; } // Printing hyperparameters Report(kInfo, "Batch size : %d", batch_size); Report(kInfo, "Learning rate : %f", learning_rate); Report(kInfo, "Decay rate : %f", decay_rate); Report(kInfo, "Momentum : %f", momentum); Report(kInfo, "L2 regularization : %f", reg); Report(kInfo, "Gradient clipping : %f", clip); Report(kInfo, "Number of steps : %d", num_step); Report(kInfo, "Print each : %d", print_each); Report(kInfo, "Test each : %d", test_each); Report(kInfo, "Save each : %d", save_each); Report(kInfo, "Scale learning rate each: %d", lr_scale_each); Report(kInfo, "Learning rate scale : %f", lr_scale); Report(kInfo, "Temperature : %f", temperature); Report(kInfo, "Number of predictions : %d", num_predict); Report(kInfo, "Embedded size : %d", embed_size); Report(kInfo, "Hidden size : %d", hs); Report(kInfo, "Value range : %f", range); // Create either a RNN or LSTM based recurrent model Model<Dtype>* model; if (!std::strcmp(model_type, "rnn")) { Report(kInfo, "Creating RNN model '%s'", model_name); model = new TextgenModel<Rnn<Dtype>>(model_name, TextgenModel<Rnn<Dtype>>::CreateDataLayer(dataset_path, num_predict, batch_size), temperature, embed_size, {hs, hs}, range, batch_size); } else if (!std::strcmp(model_type, "lstm")) { Report(kInfo, "Creating LSTM model '%s'", model_name); model = new TextgenModel<Lstm<Dtype>>(model_name, TextgenModel<Lstm<Dtype>>::CreateDataLayer(dataset_path, num_predict, batch_size), temperature, embed_size, {hs, hs}, range, batch_size); } else { Report(kError, "Unknown model type '%s'", model_type); return -1; } Solver<Dtype>* solver; if (!std::strcmp(solver_type, "sgd")) { Report(kInfo, "Creating SGD solver"); solver = new SolverSGD<Dtype>(print_each, test_each, save_each, lr_scale_each, lr_scale, momentum, reg, clip); } else if (!std::strcmp(solver_type, "rmsprop")) { Report(kInfo, "Creating RMSprop solver"); solver = new SolverRMSprop<Dtype>(print_each, test_each, save_each, lr_scale_each, lr_scale, decay_rate, reg, clip); } else { Report(kError, "Unknown solver type '%s'", solver_type); return -1; } // Train the model if (!solver->Train(model, num_step, learning_rate)) { return -1; } // Clean delete model; delete solver; return 0; }

4c550bce5ae703317d48519bb1b3f5145638d218

5b1a8c419efa4c2ec73e1fcc8645b9e99cd49234

/C++/atomic.cpp

3422c0ad166451bf9e04ead846926c94cecf3c6b

[]

no_license

Clcanny/Notes

90b59523800d7d59b87ecb5e0448fb2c87130ee0

b0490d9d796ccff075a975eef370ff6dd41f50cb

refs/heads/master

2021-01-25T09:37:30.520162

2018-08-07T06:49:52

2018-12-22T09:12:17

93,859,097

3

0

null

UTF-8

C++

false

105

cpp

atomic.cpp

#include <atomic> void atomicFunction() { std::atomic<int> a; a = 0; a++; } int main() { }

9647034e58ed3e6b28a697b2ffa2343411de9985

a7d95bf500c71c051b761be24b2f1430601b320a

/main.cpp

6677bd6409f9b64f693d8e8f3fc1aae0e467ae83

[]

no_license

fdc227/aero-wing

eb1d23274daf3dba0d7518fa49007e994ab4cea2

49d6f862efc2c3f3531bcb16d553747b12bb040b

refs/heads/master

2022-11-17T23:20:26.342480

2020-07-10T09:25:14

277,240,481

0

null

UTF-8

C++

false

3,812

cpp

main.cpp

#include "main.hpp" #include <fstream> #include "mkl_lapacke.h" #include <vector> #include <boost/array.hpp> #include <boost/numeric/odeint.hpp> #define N 63 #define NRHS 1 #define LDA N #define LDB NRHS #define STORAGE_SIZE 64*10000 #define VEC_LEN 64 using namespace std; using namespace boost::numeric::odeint; vector<double> A(LDA * N); vector<double> rhs(N); vector<double> var_list(2*N); double storage[STORAGE_SIZE]; int location = 0; int total_array_num = 0; int vector_length = VEC_LEN; void init_condition(vector<double>& var_list) { for (int i = 0; i < 21; i++) { if (i < 10) { var_list[3 * i] = 1.0 - 0.1 * i; var_list[3 * i + 1] = -0.1; var_list[3 * i + 2] = 1.0 - 0.1 * i; } else if (i == 10) { var_list[30] = 0; var_list[31] = 0; var_list[32] = 0; } else { var_list[3 * i] = 0.1 * (i - 10); var_list[3 * i + 1] = 0.1; var_list[3 * i + 2] = 0.1 * (i - 10); } } } void print_array(vector<double>& array, int length) { for(int i=0;i<length;i++) { if(i!=length-1) cout<<array[i]<<' '; else { cout<<array[i]<<endl; } } } void array_from_vector(double* array_ptr, const vector<double>& V, const double t) { array_ptr[0] = t; for (int i = 0; i < V.size(); i++) { array_ptr[i+1] = V[i]; } } void ptr_array_to_console(const vector<double>& x, const double t) { cout << t<< ' '; for (int i = 0; i < 63; i++) { cout << x[i] << ' '; } cout << endl; } void write_array_to_file(double* array, int total_array_num, int array_size, ofstream& file) { for(int i=0;i<total_array_num;i++) { for (int j = 0; j < array_size; j++) { if (j != array_size - 1) { file<<array[array_size*i+ j]<<' '; } else { file<<array[array_size * i + j]<<endl; } } } for (int i = 0; i < total_array_num * array_size; i++) { array[i] = 0; } location = 0; total_array_num = 0; } void output_process(const vector<double>& x, const double t) { total_array_num += 1; array_from_vector(&storage[location], x, t); if (location + vector_length >= STORAGE_SIZE) { ofstream outfile; outfile.open("ODE_RESULTS.dat", ios_base::app); write_array_to_file(storage, total_array_num, vector_length, outfile); } else { location += vector_length; } } void ODE_dydt(const vector<double>& var_list, vector<double>& rhs, double t) { MKL_INT n = N, nrhs = NRHS, lda = LDA, ldb = LDB, info; MKL_INT ipiv[N]; A_func(var_list, A); rhs_func(var_list, rhs); info = LAPACKE_dgesv(LAPACK_ROW_MAJOR, n, nrhs, &*A.begin(), lda, ipiv, &*rhs.begin(), ldb); } int main(void) { init_condition(var_list); integrate(ODE_dydt, var_list, 0.0, 10.0, 0.1, ptr_array_to_console); /* ofstream outfile; outfile.open("ODE_RESULTS.dat", ios_base::app); write_array_to_file(storage, total_array_num, vector_length, outfile);*/ //A_func(var_list, A); //rhs_func(var_list, rhs); //info = LAPACKE_dgesv(LAPACK_ROW_MAJOR, n, nrhs, & *A.begin(), lda, ipiv, & *rhs.begin(), ldb); //print_array(rhs, 63); //ofstream outfile; //outfile.open("data.dat");*/ //rhs_func(var_list, rhs); //print_array(rhs, 63); //save_array(rhs, 63, outfile); //outfile.close(); return 0; }

831030bf53c4f923e67aba0c9d9bb904aa03d57b

3584c950559d06fd08d7aacfdbfd98a42900fef4

/artdaq/proto/fhicl_test.cc

9ab38f1bd5e950fda17f8dc6373234c9a603f2bf

[]

no_license

diegoa314/artdaq_lme

50278f8e93249ce17aa9727fda43efa42cf304c9

59ae2822bfed43fa71932511d3048add4c2dec61

refs/heads/master

2020-07-02T13:15:09.409266

2019-09-18T16:41:29

201,527,427

1

0

null

UTF-8

C++

false

771

cc

fhicl_test.cc

// Show that the string representation of numbers in fhicl is not what you'd expect. #include "fhiclcpp/ParameterSet.h" #include <iostream> #include <iomanip> #include "artdaq/Application/LoadParameterSet.hh" namespace bpo = boost::program_options; int main(int argc, char * argv[]) { struct Config {}; auto pset = LoadParameterSet<Config>(argc, argv, "test_fhicl", "A test application to ensure that FHiCL numeric values are converted properly to/from hexadecimal values"); for(auto& p : pset.get_all_keys()) { std::cout << "Key " <(p) << " and uint64_t value " << pset.get<uint64_t>(p) << " ( hex 0x" << std::hex << pset.get<uint64_t>(p) << " )." << std::endl; } }

a7f1ae5928556bcbe03236e9f426915c4ce10a33

53b695844f2978a031ce8c5d435f532cd8c62c80

/temperature_sensor.ino

6cb1a3da705998568dda35b00b0dfbf718da751b

[]

no_license

dvreijen/CarElectricalRadiatorFanController

1ee6116a0f56bcc9627e08d035ecc8876239c99e

949a5f05c04d90eaf6f7d84ecce218fdad550d98

refs/heads/master

2022-01-23T21:06:41.321140

2018-08-26T06:38:52

null

0

null

UTF-8

C++

false

15,225

ino

temperature_sensor.ino

//Include libraries // https://github.com/espressif/arduino-esp32/issues/755 // Public global paramters related to this module bool TempSensorFound = false; //#define MotorTemp_IDX 0 //#define RadiatorTemp_IDX 1 void setup_dallas(void) { // sensors sensors.begin();// IC Default 9 bit. If you have troubles consider upping it 12. Ups the delay giving the IC more time to process the temperature measurement //delay(500); // locate devices on the bus Serial.print(F("Found ")); Serial.print(sensors.getDeviceCount(), DEC); // Strange, this always seems to return zero.. why is that? Serial.println(F(" oneWire devices.")); // search for devices on the bus and assign based on an index. // change order if g_Dallas_Default_Ordering == false if (!sensors.getAddress(DallasDevices[MotorTemp_IDX], g_Dallas_Default_Ordering ? MotorTemp_IDX : RadiatorTemp_IDX)) Serial.println(F("Unable to find address for Device 0")); // Serial.print(F("Found ")); // Serial.print(sensors.getDeviceCount(), DEC); // Strange, this always seems to return zero.. why is that? // Serial.println(F(" oneWire devices.")); if (!sensors.getAddress(DallasDevices[RadiatorTemp_IDX], g_Dallas_Default_Ordering ? RadiatorTemp_IDX : MotorTemp_IDX)) Serial.println(F("Unable to find address for Device 1")); // Serial.print(F("Found ")); // Serial.print(sensors.getDeviceCount(), DEC); // Strange, this always seems to return zero.. why is that? // Serial.println(F(" oneWire devices.")); if (g_Dallas_Default_Ordering == false) { Serial.println(F("Reversed default order of dallas Device")); } // Libary CRC check of adress if ( !sensors.validAddress(DallasDevices[MotorTemp_IDX]) ) { Serial.println(F("Invalid adress (CRC check failed)")); } else { Serial.println(F("CRC OK")); } if ( !sensors.validAddress(DallasDevices[RadiatorTemp_IDX]) ) { Serial.println(F("Invalid adress (CRC check failed)")); } else { Serial.println(F("CRC OK")); } if ( sensors.readPowerSupply(DallasDevices[MotorTemp_IDX])) { Serial.println(F("Device runs has no power (undesired parasitic mode)!")); } else { Serial.println(F("Power OK")); } if ( sensors.readPowerSupply(DallasDevices[RadiatorTemp_IDX]) ) { Serial.println(F("Device runs has no power (undesired parasitic mode)!")); } else { Serial.println(F("Power OK")); } //sensors.setResolution(DallasDevices[MotorTemp_IDX],g_Dallas_Resolution); //sensors.setResolution(DallasDevices[RadiatorTemp_IDX],g_Dallas_Resolution); set_dallas_resolution(g_Dallas_Resolution); // Set (a)sync mode sensors.setWaitForConversion(g_Dallas_Synchronous); // how long we should "wait" (just not requesting the value, after starting conversion. // 750 is from datasheet for 12 bits //g_dallas_conversion_time = 750 / ( 1 << ( 12 - g_Dallas_Resolution ) ); // res in 9,10,11,12 #define SHOW_DALLAS_ERROR 1 { DeviceAddress temp_device; int i; for (i = 0; i < 2; i++) { sensors.getAddress(temp_device, i); switch ( temp_device[0] ) { case DS18S20MODEL: Serial.println(F("Device[i] Chip = DS18(S)20")); // or old DS1820 //type_s = 1; break; case DS18B20MODEL: Serial.println(F("Device[i] Chip = DS18B20")); //type_s = 0; TempSensorFound = true; // only accept this type break; case DS1822MODEL : Serial.println(F("Device[i] Chip = DS1822")); //type_s = 0; break; case DS1825MODEL : Serial.println(F("Device[i] Chip = DS1825")); //type_s = 0; break; case DS28EA00MODEL : Serial.println(F("Device[i] Chip = DS28EA00")); //type_s = 0; break; default: #ifdef SHOW_DALLAS_ERROR Serial.println(F("Device is not a DS18x20 family device.")); #endif return; } } } // show the addresses we found on the bus Serial.print(F("Device 0[DallasDevices[MotorTemp_IDX]] Address: ")); printAddress(DallasDevices[MotorTemp_IDX]); Serial.println(); Serial.print(F("Device 0[DallasDevices[MotorTemp_IDX]] Alarms: ")); printAlarms(DallasDevices[MotorTemp_IDX]); Serial.println(); Serial.print(F("Device 1[DallasDevices[RadiatorTemp_IDX]] Address: ")); printAddress(DallasDevices[RadiatorTemp_IDX]); Serial.println(); Serial.print(F("Device 1[DallasDevices[RadiatorTemp_IDX]] Alarms: ")); printAlarms(DallasDevices[RadiatorTemp_IDX]); Serial.println(); /* Serial.println(F("Setting alarm temps...")); // alarm when temp is higher than 30C sensors.setHighAlarmTemp(DallasDevices[MotorTemp_IDX], 30); // alarm when temp is lower than -10C sensors.setLowAlarmTemp(DallasDevices[MotorTemp_IDX], -10); // alarm when temp is higher than 31C sensors.setHighAlarmTemp(DallasDevices[RadiatorTemp_IDX], 31); // alarn when temp is lower than 27C sensors.setLowAlarmTemp(DallasDevices[RadiatorTemp_IDX], -10); Serial.print(F("New Device 0 Alarms: ")); printAlarms(DallasDevices[MotorTemp_IDX]); Serial.println(); Serial.print(F("New Device 1 Alarms: ")); printAlarms(DallasDevices[RadiatorTemp_IDX]); Serial.println(); */ } // function to print a device address void printAddress(DeviceAddress deviceAddress) { for (uint8_t i = 0; i < 8; i++) { if (deviceAddress[i] < 16) Serial.print(F("0")); Serial.print(deviceAddress[i], HEX); } } // function to print the temperature for a device void printTemperature(DeviceAddress deviceAddress) { float tempC = sensors.getTempC(deviceAddress); Serial.print(F("Temp C: ")); Serial.print(tempC); Serial.print(F(" Temp F: ")); Serial.print(DallasTemperature::toFahrenheit(tempC)); } void printAlarms(uint8_t deviceAddress[]) { char temp; temp = sensors.getHighAlarmTemp(deviceAddress); Serial.print(F("High Alarm: ")); Serial.print(temp, DEC); Serial.print(F("C/")); Serial.print(DallasTemperature::toFahrenheit(temp)); Serial.print(F("F | Low Alarm: ")); temp = sensors.getLowAlarmTemp(deviceAddress); Serial.print(temp, DEC); Serial.print(F("C/")); Serial.print(DallasTemperature::toFahrenheit(temp)); Serial.print(F("F")); } // main function to print information about a device void printData(DeviceAddress deviceAddress) { Serial.print(F("Device Address: ")); printAddress(deviceAddress); Serial.print(F(" ")); printTemperature(deviceAddress); Serial.println(); } void checkAlarm(DeviceAddress deviceAddress) { if (sensors.hasAlarm(deviceAddress)) { Serial.print(F("ALARM: ")); printData(deviceAddress); } } // old version , serialized, spend huge time, just on waiting (blocking) void get_Dallas_Temperatures_sync(void) { uint32_t t_start, t_stop; if (TempSensorFound == false) return; // refuse to do anything when sensor not found if (g_debug) Serial.print("Requesting temperatures...(synch)"); t_start = millis(); // measuring time function call sensors.requestTemperatures(); // request to all devices on the bus t_stop = millis(); // measuring time function call t_dallas_sensors = t_stop - t_start; if (g_debug) Serial.print(F("requestTemperature Time:")); if (g_debug) Serial.println(t_dallas_sensors); if ( g_operating_mode == C_OPERATING_MODE_SIMULATED ) { // Why "byIndex"? You can have more than one IC on the same bus. 0 refers to the first IC on the wire //sensors.getTempCByIndex(0); // request value, and do not assign it. //sensors.getTempCByIndex(1); // request value, and do not assign it. sensors.getTempC(DallasDevices[MotorTemp_IDX]); // request value, and do not assign it. sensors.getTempC(DallasDevices[RadiatorTemp_IDX]);// request value, and do not assign it. g_CoolingWaterTemp_Motor_OUT_InC = g_simulate_values[MotorTemp_IDX]; // Inject Simulated values g_CoolingWaterTemp_Motor_IN_InC = g_simulate_values[RadiatorTemp_IDX]; // Inject Simulated value } else { // Why "byIndex"? You can have more than one IC on the same bus. 0 refers to the first IC on the wire //g_CoolingWaterTemp_Motor_OUT_InC = sensors.getTempCByIndex(0); //g_CoolingWaterTemp_Motor_IN_InC = sensors.getTempCByIndex(1); g_CoolingWaterTemp_Motor_OUT_InC = sensors.getTempC(DallasDevices[MotorTemp_IDX]); g_CoolingWaterTemp_Motor_IN_InC = sensors.getTempC(DallasDevices[RadiatorTemp_IDX]); } if (g_CoolingWaterTemp_Motor_OUT_InC == DEVICE_DISCONNECTED_C ) { Serial.println(F("ERROR: Device[DallasDevices[MotorTemp_IDX]] returns disconnected (getTempC())")); DallasMissedCounters[MotorTemp_IDX]++; } if (g_CoolingWaterTemp_Motor_IN_InC == DEVICE_DISCONNECTED_C ) { Serial.println(F("ERROR: Device[DallasDevices[RadiatorTemp_IDX]] returns disconnected (getTempC())")); DallasMissedCounters[RadiatorTemp_IDX]++; } } //------------------------------------------------------- // updated version, asynchronous version, starts conversion, and reads next time, when conversion time has been expired. void get_Dallas_Temperatures_async(void) { uint32_t t_start, t_stop; static uint32_t lastTempRequest; // keep value over multiple funciton call's static bool running = false; // initialize for not in action, true=> waiting for an answer if (TempSensorFound == false) return; // refuse to do anything when sensor not found if (running == true) { // running (no else, because running is changing inside loop) if ( (millis() - lastTempRequest) >= g_dallas_conversion_time) { if (g_debug) { Serial.print(F("Reading temperatures... after (ms): ")); Serial.print(millis() - lastTempRequest); Serial.print(F(" g_dallas_conversion_time (ms): ")); Serial.println(g_dallas_conversion_time); } if ( sensors.isConversionComplete() ) { running = false; if ( g_operating_mode == C_OPERATING_MODE_SIMULATED) { // Why "byIndex"? You can have more than one IC on the same bus. 0 refers to the first IC on the wire //sensors.getTempCByIndex(0); // request value, and do not assign it. //sensors.getTempCByIndex(1); // request value, and do not assign it. sensors.getTempC(DallasDevices[MotorTemp_IDX]); // request value, and do not assign it. sensors.getTempC(DallasDevices[RadiatorTemp_IDX]);// request value, and do not assign it. g_CoolingWaterTemp_Motor_OUT_InC = g_simulate_values[MotorTemp_IDX]; // Simulated values g_CoolingWaterTemp_Motor_IN_InC = g_simulate_values[RadiatorTemp_IDX]; // Simulated value } else { // Why "byIndex"? You can have more than one IC on the same bus. 0 refers to the first IC on the wire //g_CoolingWaterTemp_Motor_OUT_InC = sensors.getTempCByIndex(0); //g_CoolingWaterTemp_Motor_IN_InC = sensors.getTempCByIndex(1); g_CoolingWaterTemp_Motor_OUT_InC = sensors.getTempC(DallasDevices[MotorTemp_IDX]); g_CoolingWaterTemp_Motor_IN_InC = sensors.getTempC(DallasDevices[RadiatorTemp_IDX]); } // ERROR handling if (g_CoolingWaterTemp_Motor_OUT_InC == DEVICE_DISCONNECTED_C ) { Serial.println(F("ERROR: Device[DallasDevices[MotorTemp_IDX]] returns disconnected (getTempC())")); DallasMissedCounters[MotorTemp_IDX]++; } if (g_CoolingWaterTemp_Motor_IN_InC == DEVICE_DISCONNECTED_C ) { Serial.println(F("ERROR: Device[DallasDevices[RadiatorTemp_IDX]] returns disconnected (getTempC())")); DallasMissedCounters[RadiatorTemp_IDX]++; } } else { Serial.println(F("ERROR: Sensor conversion time expired, but converson was not complete!!!!")); // Keep testing next time, perhaps a max retry/escalation/error recovery???? if ( (millis() - lastTempRequest) >= (g_dallas_conversion_time * 4)) { // Escalation when expired time is over 4 times expected time Serial.println(F("ERROR: Sensor 4*g_dallas_conversion_time expired, restarting ")); //sensors.reset??(); // does this work as expected? running = false; // Up the errors DallasMissedCounters[MotorTemp_IDX]++; DallasMissedCounters[RadiatorTemp_IDX]++; } } // Immediate restart requesting a new temperature requst, like first time. } else { if (g_debug > DEBUGLEVEL2) { Serial.print(F("dallas_conversion time not yet exceeded, time since last request (ms) : ")); Serial.print(millis() - lastTempRequest); Serial.print(F(" g_dallas_conversion_time (ms): ")); Serial.println(g_dallas_conversion_time); } } } if (running == false) { // Initial AND new measurements running = true; if (g_debug) Serial.println(F("Requesting temperatures... (async)")); t_start = millis(); // measuring time function call sensors.requestTemperatures(); // request to all devices on the bus lastTempRequest = t_stop = millis(); // measuring time function call if (g_debug) { t_dallas_sensors = t_stop - t_start; //if (g_debug) Serial.print(F("requestTemperature Request Time:")); //if (g_debug) Serial.println(t_dallas_sensors); } } } // Changes resultions and related conversion time to wait // This function does not handle current started measurements // So you may wait too long, or too short in transition measurement. void set_dallas_resolution(int _resolution) { sensors.setResolution(DallasDevices[MotorTemp_IDX], _resolution); sensors.setResolution(DallasDevices[RadiatorTemp_IDX], _resolution); Serial.print(F("Set dallas sensor resolution[9,10,11,12] to :")); Serial.println(_resolution); g_Dallas_Resolution = _resolution; // update global value //g_dallas_conversion_time = 750 / ( 1 << ( 12 - g_Dallas_Resolution ) ); // res in 9,10,11,12 g_dallas_conversion_time = sensors.millisToWaitForConversion(g_Dallas_Resolution); // same as above, but then using buildin library } // float getChipTemperatureInC(void) { #ifdef __AVR__ // https://playground.arduino.cc/Main/InternalTemperatureSensor #endif #ifdef ESP32 return getESP32ChipTemperatureInC(); #endif } #ifdef ESP32 #ifdef __cplusplus extern "C" { #endif uint8_t temprature_sens_read(); #ifdef __cplusplus } #endif uint8_t temprature_sens_read(); float getESP32ChipTemperatureInC(void) { #define MAGIC_CORRETIONFACTOR 46 // the thread at blynk forum // Convert raw temperature in F to Celsius degrees // Note: this results are WAY off, reading about 70 degrees celsius just at start.. // https://community.blynk.cc/t/esp32-internal-sensors/23041/37 on "Isn’t 61.7 ºC a bit high" // and another thread mentions 32 as correction on raw value: // uint8_t raw_temp_f= temprature_sens_read(); /* Serial.print("Raw temp in F: "); Serial.println(raw_temp_f); Serial.print("Raw temp in F: "); Serial.println(raw_temp_f,BIN); */ //uint8_t bugCorrection = 83; // magical 46*1.8...=82,8 uint8_t bugCorrection = 42; // manual adjusted to some reasonable value raw_temp_f -= bugCorrection; return (( raw_temp_f - 32) / 1.8 - 0) ; } #endif

f5dec2aa6f57eba6661f8c7078c6a404ea69b898

5c50acd60fb29fc852a2ecf549a49996eca44a21

/TextBasedConsole4UPC/Monsters.h

863fd31f4cc17ccfc682fa7773a44a3b69efcdbc

[ "MIT" ]

permissive

Misarte/Zork

e5d540481a79c00e78b45d6923e4b23ca31dcdc7

bc16352670d9c56d793c15db2cae942500c02553

refs/heads/master

2020-05-31T12:31:04.575681

2019-06-04T22:27:42

190,282,493

1

null

UTF-8

C++

false

656

h

Monsters.h

#pragma once #ifndef __MONSTERS_H__ #define __MONSTERS_H__ #define uint unsigned int #include "Entity.h" class Monster : public Entity { public: String name; String description; String current_place; int position_num;//integer used for accessing the rooms int damage; int life; Monster(const char* item_name, const char* item_description, String location, int damage, int life) { this->name = item_name; this->description = item_description; this->current_place = location; this->damage = damage; this->life = life; } public: bool Move_Monster(const String& destination); bool monster_randmove(); ~Monster(); }; #endif

bda922e638ab845ad6b1d7d484d7aeb45be24ce2

503c589ec087e21e83918440e2c2eebb9537026a

/Source/HoudiniEngineRuntime/Private/HoudiniAttributeObject.cpp

531608a502ad491eee0f2b2700710aaf06f22e2a

[]

no_license

richmondx/HoudiniEngineForUnreal

d704e59e9da7a3ae5ccad641ecdb4375c47fe1b3

d8bf704c0f115d92f6d4949b6c73e8fcea905350

refs/heads/Houdini15.5-Unreal4.12

2021-01-15T22:24:00.753466

2016-06-29T22:00:46

62,433,065

1

0

null

2016-07-02T03:58:50

null

UTF-8

C++

false

17,842

cpp

HoudiniAttributeObject.cpp

/* * PROPRIETARY INFORMATION. This software is proprietary to * Side Effects Software Inc., and is not to be reproduced, * transmitted, or disclosed in any way without written permission. * * Produced by: * Mykola Konyk * Side Effects Software Inc * 123 Front Street West, Suite 1401 * Toronto, Ontario * Canada M5J 2M2 * 416-504-9876 * */ #include "HoudiniEngineRuntimePrivatePCH.h" #include "HoudiniAttributeObject.h" #include "HoudiniAttributeObjectVersion.h" #include "HoudiniGeoPartObject.h" FHoudiniAttributeObject::FHoudiniAttributeObject() : ValueCount(0), ValueSize(0), AttributeName(TEXT("")), AttributeOwner(HAPI_ATTROWNER_INVALID), StorageType(HAPI_STORAGETYPE_INVALID), AssetId(-1), ObjectId(-1), GeoId(-1), PartId(-1), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_BASE) { } FHoudiniAttributeObject::FHoudiniAttributeObject(const FHoudiniGeoPartObject& HoudiniGeoPartObject, const char* InAttributeName, const HAPI_AttributeInfo& AttributeInfo) : ValueCount(0), ValueSize(0), AttributeName(FString(InAttributeName)), AttributeOwner(AttributeInfo.owner), StorageType(AttributeInfo.storage), AssetId(HoudiniGeoPartObject.AssetId), ObjectId(HoudiniGeoPartObject.ObjectId), GeoId(HoudiniGeoPartObject.GeoId), PartId(HoudiniGeoPartObject.PartId), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_BASE) { } FHoudiniAttributeObject::FHoudiniAttributeObject(const FHoudiniGeoPartObject& HoudiniGeoPartObject, const FString& InAttributeName, const HAPI_AttributeInfo& AttributeInfo) : ValueCount(0), ValueSize(0), AttributeName(InAttributeName), AttributeOwner(AttributeInfo.owner), StorageType(AttributeInfo.storage), AssetId(HoudiniGeoPartObject.AssetId), ObjectId(HoudiniGeoPartObject.ObjectId), GeoId(HoudiniGeoPartObject.GeoId), PartId(HoudiniGeoPartObject.PartId), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_BASE) { } FHoudiniAttributeObject::FHoudiniAttributeObject(HAPI_AssetId InAssetId, HAPI_ObjectId InObjectId, HAPI_GeoId InGeoId, HAPI_PartId InPartId, const char* InAttributeName, const HAPI_AttributeInfo& AttributeInfo) : ValueCount(0), ValueSize(0), AttributeName(FString(InAttributeName)), AttributeOwner(AttributeInfo.owner), StorageType(AttributeInfo.storage), AssetId(InAssetId), ObjectId(InObjectId), GeoId(InGeoId), PartId(InPartId), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_BASE) { } FHoudiniAttributeObject::FHoudiniAttributeObject(HAPI_AssetId InAssetId, HAPI_ObjectId InObjectId, HAPI_GeoId InGeoId, HAPI_PartId InPartId, const FString& InAttributeName, const HAPI_AttributeInfo& AttributeInfo) : ValueCount(0), ValueSize(0), AttributeName(InAttributeName), AttributeOwner(AttributeInfo.owner), StorageType(AttributeInfo.storage), AssetId(InAssetId), ObjectId(InObjectId), GeoId(InGeoId), PartId(InPartId), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_BASE) { } FHoudiniAttributeObject::FHoudiniAttributeObject(const FHoudiniAttributeObject& HoudiniAttributeObject) : Value(HoudiniAttributeObject.Value), ValueCount(HoudiniAttributeObject.ValueCount), ValueSize(HoudiniAttributeObject.ValueSize), AttributeName(HoudiniAttributeObject.AttributeName), AttributeOwner(HoudiniAttributeObject.AttributeOwner), StorageType(HoudiniAttributeObject.StorageType), AssetId(HoudiniAttributeObject.AssetId), ObjectId(HoudiniAttributeObject.ObjectId), GeoId(HoudiniAttributeObject.GeoId), PartId(HoudiniAttributeObject.PartId), HoudiniAttributeObjectFlagsPacked(0u), HoudiniAttributeObjectVersion(HoudiniAttributeObject.HoudiniAttributeObjectVersion) { } bool FHoudiniAttributeObject::HapiGetValues(TArray<int32>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!ValueCount || !ValueSize) { return false; } Values.SetNumUninitialized(ValueCount * ValueSize); FMemory::Memcpy(Values.GetData(), Value.GetData(), ValueCount * ValueSize * sizeof(int32)); return true; } bool FHoudiniAttributeObject::HapiGetValues(TArray<float>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!ValueCount || !ValueSize) { return false; } Values.SetNumUninitialized(ValueCount * ValueSize); FMemory::Memcpy(Values.GetData(), Value.GetData(), ValueCount * ValueSize * sizeof(float)); return true; } bool FHoudiniAttributeObject::HapiGetValues(TArray<FHoudiniEngineString>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!ValueCount || !ValueSize) { return false; } TArray<HAPI_StringHandle> StringHandles; StringHandles.Init(-1, ValueCount * ValueSize); FMemory::Memcpy(StringHandles.GetData(), Value.GetData(), ValueCount * ValueSize * sizeof(int32)); for(int32 Idx = 0, Num = StringHandles.Num(); Idx < Num; ++Idx) { Values.Add(FHoudiniEngineString(StringHandles[Idx])); } return true; } bool FHoudiniAttributeObject::HapiGetValues(TArray<FString>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!ValueCount || !ValueSize) { return false; } TArray<HAPI_StringHandle> StringHandles; StringHandles.Init(-1, ValueCount * ValueSize); FMemory::Memcpy(StringHandles.GetData(), Value.GetData(), ValueCount * ValueSize * sizeof(int32)); for(int32 Idx = 0, Num = StringHandles.Num(); Idx < Num; ++Idx) { FString HapiString = TEXT(""); FHoudiniEngineString HoudiniEngineString(StringHandles[Idx]); HoudiniEngineString.ToFString(HapiString); Values.Add(HapiString); } return true; } bool FHoudiniAttributeObject::HapiGetValuesAsVertex(const TArray<int32>& Vertices, TArray<int32>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!Vertices.Num()) { return false; } if(HAPI_ATTROWNER_VERTEX == AttributeOwner) { // Data is on vertices already, we can do direct transfer. return HapiGetValues(Values, TupleSize); } else { TArray<int32> UnprocessedValues; if(!HapiGetValues(UnprocessedValues, TupleSize)) { return false; } Values.SetNumUninitialized(Vertices.Num() * TupleSize); for(int32 IdxWedge = 0, NumWedges = Vertices.Num(); IdxWedge < NumWedges; ++IdxWedge) { int32 VertexId = Vertices[IdxWedge]; int32 PrimIdx = IdxWedge / 3; int32 EntryValue = 0; for(int32 IdxTuple = 0; IdxTuple < TupleSize; ++IdxTuple) { switch(AttributeOwner) { case HAPI_ATTROWNER_POINT: { EntryValue = UnprocessedValues[VertexId * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_PRIM: { EntryValue = UnprocessedValues[PrimIdx * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_DETAIL: { EntryValue = UnprocessedValues[IdxTuple]; break; } default: { Values.Empty(); return false; } } Values[IdxWedge * TupleSize + IdxTuple] = EntryValue; } } } return true; } bool FHoudiniAttributeObject::HapiGetValuesAsVertex(const TArray<int32>& Vertices, TArray<float>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!Vertices.Num()) { return false; } if(HAPI_ATTROWNER_VERTEX == AttributeOwner) { // Data is on vertices already, we can do direct transfer. return HapiGetValues(Values, TupleSize); } else { TArray<float> UnprocessedValues; if(!HapiGetValues(UnprocessedValues, TupleSize)) { return false; } Values.SetNumUninitialized(Vertices.Num() * TupleSize); for(int32 IdxWedge = 0, NumWedges = Vertices.Num(); IdxWedge < NumWedges; ++IdxWedge) { int32 VertexId = Vertices[IdxWedge]; int32 PrimIdx = IdxWedge / 3; float EntryValue = 1.0f; for(int32 IdxTuple = 0; IdxTuple < TupleSize; ++IdxTuple) { switch(AttributeOwner) { case HAPI_ATTROWNER_POINT: { EntryValue = UnprocessedValues[VertexId * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_PRIM: { EntryValue = UnprocessedValues[PrimIdx * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_DETAIL: { EntryValue = UnprocessedValues[IdxTuple]; break; } default: { Values.Empty(); return false; } } Values[IdxWedge * TupleSize + IdxTuple] = EntryValue; } } } return true; } bool FHoudiniAttributeObject::HapiGetValuesAsVertex(const TArray<int32>& Vertices, TArray<FHoudiniEngineString>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!Vertices.Num()) { return false; } if(HAPI_ATTROWNER_VERTEX == AttributeOwner) { // Data is on vertices already, we can do direct transfer. return HapiGetValues(Values, TupleSize); } else { TArray<FHoudiniEngineString> UnprocessedValues; if(!HapiGetValues(UnprocessedValues, TupleSize)) { return false; } Values.SetNumUninitialized(Vertices.Num() * TupleSize); for(int32 IdxWedge = 0, NumWedges = Vertices.Num(); IdxWedge < NumWedges; ++IdxWedge) { int32 VertexId = Vertices[IdxWedge]; int32 PrimIdx = IdxWedge / 3; FHoudiniEngineString EntryValue; for(int32 IdxTuple = 0; IdxTuple < TupleSize; ++IdxTuple) { switch(AttributeOwner) { case HAPI_ATTROWNER_POINT: { EntryValue = UnprocessedValues[VertexId * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_PRIM: { EntryValue = UnprocessedValues[PrimIdx * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_DETAIL: { EntryValue = UnprocessedValues[IdxTuple]; break; } default: { Values.Empty(); return false; } } Values[IdxWedge * TupleSize + IdxTuple] = EntryValue; } } } return true; } bool FHoudiniAttributeObject::HapiGetValuesAsVertex(const TArray<int32>& Vertices, TArray<FString>& Values, int32& TupleSize) const { Values.Empty(); TupleSize = ValueSize; if(!Vertices.Num()) { return false; } if(HAPI_ATTROWNER_VERTEX == AttributeOwner) { // Data is on vertices already, we can do direct transfer. return HapiGetValues(Values, TupleSize); } else { TArray<FString> UnprocessedValues; if(!HapiGetValues(UnprocessedValues, TupleSize)) { return false; } Values.SetNumUninitialized(Vertices.Num() * TupleSize); for(int32 IdxWedge = 0, NumWedges = Vertices.Num(); IdxWedge < NumWedges; ++IdxWedge) { int32 VertexId = Vertices[IdxWedge]; int32 PrimIdx = IdxWedge / 3; FString EntryValue = TEXT(""); for(int32 IdxTuple = 0; IdxTuple < TupleSize; ++IdxTuple) { switch(AttributeOwner) { case HAPI_ATTROWNER_POINT: { EntryValue = UnprocessedValues[VertexId * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_PRIM: { EntryValue = UnprocessedValues[PrimIdx * TupleSize + IdxTuple]; break; } case HAPI_ATTROWNER_DETAIL: { EntryValue = UnprocessedValues[IdxTuple]; break; } default: { Values.Empty(); return false; } } Values[IdxWedge * TupleSize + IdxTuple] = EntryValue; } } } return true; } bool FHoudiniAttributeObject::HapiIsArray() const { HAPI_AttributeInfo AttributeInfo; if(!HapiGetAttributeInfo(AttributeInfo)) { return false; } return AttributeInfo.count > 1; } bool FHoudiniAttributeObject::HapiRefetch() { Value.Empty(); ValueCount = 0; ValueSize = 0; HAPI_AttributeInfo AttributeInfo; if(!HapiGetAttributeInfo(AttributeInfo)) { return false; } ValueCount = AttributeInfo.count; ValueSize = AttributeInfo.tupleSize; if(!ValueCount || !ValueSize) { return false; } bool bResult = true; std::string AttributeNameRaw = TCHAR_TO_UTF8(*AttributeName); Value.SetNumUninitialized(ValueCount * ValueSize * sizeof(int32)); HAPI_AttributeInfo ResultAttributeInfo; FMemory::Memset<HAPI_AttributeInfo>(ResultAttributeInfo, 0); switch(StorageType) { case HAPI_STORAGETYPE_INT: { if(HAPI_RESULT_SUCCESS != FHoudiniApi::GetAttributeIntData(FHoudiniEngine::Get().GetSession(), AssetId, ObjectId, GeoId, PartId, AttributeNameRaw.c_str(), &ResultAttributeInfo, (int*) &Value[0], 0, ValueCount)) { bResult = false; } break; } case HAPI_STORAGETYPE_FLOAT: { if(HAPI_RESULT_SUCCESS != FHoudiniApi::GetAttributeFloatData(FHoudiniEngine::Get().GetSession(), AssetId, ObjectId, GeoId, PartId, AttributeNameRaw.c_str(), &ResultAttributeInfo, (float*) &Value[0], 0, ValueCount)) { bResult = false; } break; } case HAPI_STORAGETYPE_STRING: { if(HAPI_RESULT_SUCCESS != FHoudiniApi::GetAttributeStringData(FHoudiniEngine::Get().GetSession(), AssetId, ObjectId, GeoId, PartId, AttributeNameRaw.c_str(), &ResultAttributeInfo, (int*) &Value[0], 0, ValueCount)) { bResult = false; } break; } default: { return false; } } if(!bResult) { Value.Empty(); ValueCount = 0; ValueSize = 0; return false; } return true; } bool FHoudiniAttributeObject::HapiGetAttributeInfo(HAPI_AttributeInfo& AttributeInfo) const { std::string AttributeNameRaw = TCHAR_TO_UTF8(*AttributeName); FMemory::Memset<HAPI_AttributeInfo>(AttributeInfo, 0); if(HAPI_RESULT_SUCCESS == FHoudiniApi::GetAttributeInfo(FHoudiniEngine::Get().GetSession(), AssetId, ObjectId, GeoId, PartId, AttributeNameRaw.c_str(), AttributeOwner, &AttributeInfo)) { return true; } return false; } bool FHoudiniAttributeObject::HapiExists() const { HAPI_AttributeInfo AttributeInfo; if(!HapiGetAttributeInfo(AttributeInfo)) { return false; } return AttributeInfo.exists; } int32 FHoudiniAttributeObject::HapiGetTupleSize() const { HAPI_AttributeInfo AttributeInfo; if(!HapiGetAttributeInfo(AttributeInfo)) { return 0; } return AttributeInfo.tupleSize; } bool FHoudiniAttributeObject::Serialize(FArchive& Ar) { HoudiniAttributeObjectVersion = VER_HOUDINI_ENGINE_ATTRIBUTEOBJECT_AUTOMATIC_VERSION; Ar << HoudiniAttributeObjectVersion; Ar << HoudiniAttributeObjectFlagsPacked; Ar << Value; Ar << ValueCount; Ar << ValueSize; Ar << AttributeName; return true; } uint32 FHoudiniAttributeObject::GetTypeHash() const { // We hash attribute name. return FCrc::Strihash_DEPRECATED(*AttributeName); } FArchive& operator<<(FArchive& Ar, FHoudiniAttributeObject& HoudiniAttributeObject) { HoudiniAttributeObject.Serialize(Ar); return Ar; } uint32 GetTypeHash(const FHoudiniAttributeObject& HoudiniAttributeObject) { return HoudiniAttributeObject.GetTypeHash(); }

1923d09246eb842dc0985ce8d4af69f367f3e6b9

b46d4f0a7e806b175de55214dfd3909e5bcb6687

/gui/gui/TEvdCrystal.hh

49db26d7d82595f561c586ad35299cf96a6f14e7

[ "Apache-2.0" ]

permissive

Mu2e/Stntuple

23fa5550288586b0e0909aa3be7439fd41cf9511

766b735ae2fabf391e6f935c67f7245995378e87

refs/heads/main

2023-08-23T17:52:41.537174

2023-08-16T15:01:21

218,061,235

0

9

Apache-2.0

2023-09-14T01:44:36

2019-10-28T14:07:19

C++

UTF-8

C++

false

3,755

hh

TEvdCrystal.hh

/////////////////////////////////////////////////////////////////////////////// // vis node displays one wedge /////////////////////////////////////////////////////////////////////////////// #ifndef TEvdCrystal_hh #define TEvdCrystal_hh #include "Gtypes.h" #include "TClonesArray.h" #include "TH1.h" #include "TPad.h" #include "TArc.h" #include "Stntuple/base/TVisNode.hh" #include "Stntuple/base/TStnShape.hh" #ifndef __CINT__ #include "Offline/CalorimeterGeom/inc/Crystal.hh" #include "Offline/RecoDataProducts/inc/CaloCluster.hh" #include "Offline/RecoDataProducts/inc/CaloHit.hh" // #include "Offline/RecoDataProducts/inc/CaloCrystalHit.hh" #include "Offline/CalorimeterGeom/inc/Disk.hh" #else namespace mu2e { class CaloCluster; class CaloCrystalHit; class CaloHit; class Crystal; class Disk; }; #endif class TDisk; class TEvdCrystal: public TObject { public: protected: const mu2e::Crystal* fCrystal; mu2e::CaloHit* fCrystalHit; TClonesArray* fListOfHits; // display in XY view TStnShape* fShape; int fNEdges; // 4:square 6:hex int fFillStyle; int fFillColor; int fLineColor; int fNHits; // number of (resolved) crystal hits float fEnergy; // total deposited energy const mu2e::Disk* fDisk; public: //----------------------------------------------------------------------------- // constructors and destructor //----------------------------------------------------------------------------- TEvdCrystal() {} TEvdCrystal(const mu2e::Crystal* Cr, int NEdges, double Size, const mu2e::Disk* Disk); virtual ~TEvdCrystal(); //----------------------------------------------------------------------------- // accessors //----------------------------------------------------------------------------- TClonesArray* ListOfHits () { return fListOfHits; } int NHits () const { return fNHits; } float Energy () const { return fEnergy; } double Radius () const { return fShape->Radius(); } const mu2e::Disk* Disk () const { return fDisk; } double X0 () const { return fShape->X0(); } double Y0 () const { return fShape->Y0(); } const TStnShape* Shape () const { return fShape; } const mu2e::Crystal* Crystal() const { return fCrystal; } //----------------------------------------------------------------------------- // modifiers //----------------------------------------------------------------------------- void SetFillStyle(int Style) { fShape->fFillStyle = Style; } void SetFillColor(int Color) { fShape->fFillColor = Color; } void SetLineColor(int Color) { fShape->fLineColor = Color; } void SetLineWidth(int Width) { fShape->fLineWidth = Width; } void AddHit(const mu2e::CaloHit* CrystalHit); // virtual void Draw (Option_t* option = ""); virtual void Paint (Option_t* option = ""); virtual void PaintXY (Option_t* option = ""); virtual void PaintCal(Option_t* option = ""); // virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py); virtual Int_t DistancetoPrimitive (Int_t px, Int_t py); virtual Int_t DistancetoPrimitiveXY(Int_t px, Int_t py); virtual Int_t DistancetoPrimitiveRZ(Int_t px, Int_t py); //----------------------------------------------------------------------------- // overloaded methods of TObject //----------------------------------------------------------------------------- virtual void Clear(const char* Opt = "") ; virtual void Print(const char* Opt = "") const ; // **MENU** ClassDef(TEvdCrystal,0) }; #endif

7245c64e07e6aefa5372b7c4505360bcc7168bfe

0a8d05154d373e55691ab946cf5211853911de60

/tests/adapter-tests/current_thread_name.cpp

93b1d70492ffcc5e5ce32a8b277c41b7d095d87f

[]

no_license

ubports/repowerd

52284838c6dd5a40d10b00e4dc3e46f1bf4df567

1375dd39d39e2d9de543ff04f61e6b8c3594f109

refs/heads/xenial

2023-05-08T06:27:29.458064

2021-03-25T00:04:46

113,965,269

1

7

null

2021-06-07T09:07:42

2017-12-12T08:42:18

C++

UTF-8

C++

false

1,012

cpp

current_thread_name.cpp

/* * Copyright © 2016 Canonical Ltd. * * This program is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License version 3, * as published by the Free Software Foundation. * * 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, see <http://www.gnu.org/licenses/>. * * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com> */ #include "current_thread_name.h" #include <pthread.h> std::string repowerd::test::current_thread_name() { static size_t constexpr max_thread_name_size = 16; char thread_name[max_thread_name_size]; pthread_getname_np(pthread_self(), thread_name, sizeof thread_name); return {thread_name}; }

b91496929e30c372c00ce8b0c4e5010e0f9dd825

ccfa879f695f6685801b3ff282c681cdbcb3799d

/Kattis/yoda.cpp

3c82b9e15e2c58837823677f613dde6e0374a6e0

[]

no_license

septa97/competitive-programming

ecf9974e6b75e461394e58b5a9a3ee4fdb8880e0

605cc2d548fde35a600235999ff7a4b57c4b7976

refs/heads/master

2021-04-29T13:11:07.524540

2019-05-01T00:50:58

121,744,278

1

0

null

UTF-8

C++

false

1,269

cpp

yoda.cpp

#include <iostream> #include <vector> #include <map> #include <set> #include <utility> #include <string> #include <algorithm> #include <iterator> #include <cstdio> #include <cstring> #include <cmath> #define MOD 1000000009 #define debug(x) cout << x << " "; #define debug_newline(x) cout << x << endl; #define scan(x) do{while((x=getchar())<'0'); for(x-='0'; '0'<=(_=getchar()); x=(x<<3)+(x<<1)+_-'0');}while(0) // for unsigned integral data types using namespace std; typedef long long ll; typedef unsigned long long ull; typedef pair<int, int> p_ii; int main() { int a, b; string a_str, b_str; a_str = ""; b_str = ""; cin >> a; cin >> b; while (a > 0 || b > 0) { int a_rem = a % 10; int b_rem = b % 10; if (a_rem > b_rem) { a_str = to_string(a_rem) + a_str; } else if (a_rem < b_rem) { b_str = to_string(b_rem) + b_str; } else { a_str = to_string(a_rem) + a_str; b_str = to_string(b_rem) + b_str; } a /= 10; b /= 10; } if (a_str == "") cout << "YODA" << "\n"; else cout << (stoi(a_str)) << "\n"; if (b_str == "") cout << "YODA" << "\n"; else cout << (stoi(b_str)) << "\n"; return 0; }

010c34e2b3a551da1b46848b70c5b4e93eb80f13

a0b346b88c3c481a829016773e0a6f2b0004d659

/keyvi/3rdparty/msgpack-c/example/boost/asio_send_recv_zlib.cpp

885e8807bc142dc92c32fa451610f0a2e432ecff

[ "BSD-3-Clause", "Zlib", "Python-2.0", "Apache-2.0", "MIT", "BSD-2-Clause", "LicenseRef-scancode-unknown-license-reference", "BSL-1.0" ]

permissive

KeyviDev/keyvi

4c5f512e2e13f5f8e21e82b91c1443c271b70b91

3a816037a74da049b01b522f42a6fdfb61f00a4a

refs/heads/master

2023-01-11T03:44:18.571671

2022-12-14T20:20:56

109,309,657

235

42

Apache-2.0

2022-12-29T19:16:08

2017-11-02T19:28:41

C++

UTF-8

C++

false

6,618

cpp

asio_send_recv_zlib.cpp

// MessagePack for C++ example // // Copyright (C) 2017 KONDO Takatoshi // // 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) // #include <string> #include <sstream> #include <iostream> #include <boost/asio.hpp> #include <boost/lexical_cast.hpp> #include <msgpack.hpp> #include <msgpack/zbuffer.hpp> #include <zlib.h> void print(std::string const& buf) { for (std::string::const_iterator it = buf.begin(), end = buf.end(); it != end; ++it) { std::cout << std::setw(2) << std::hex << std::setfill('0') << (static_cast<int>(*it) & 0xff) << ' '; } std::cout << std::dec << std::endl; } int main() { boost::asio::io_service ios; std::uint16_t const port = 12345; int num_of_zlib_data = 2; int idx_zlib_data = 0; // Server std::size_t const window_size = 11; boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)); boost::asio::ip::tcp::socket ss(ios); std::function<void()> do_accept; std::function<void()> do_async_read_some; // zlib for decompress z_stream strm; auto zlib_init = [&] { strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.next_in = Z_NULL; { int zret = inflateInit(&strm); if (zret != Z_OK) { std::cout << "Zlib inflateInit() error = " << zret << std::endl; } } }; zlib_init(); std::vector<char> buf(4); // buf size msgpack::unpacker unp; do_accept = [&] { ac.async_accept( ss, [&] (boost::system::error_code const& e) { if (e) { std::cout << __LINE__ << ":" << e.message() << std::endl; return; } do_async_read_some = [&] { ss.async_read_some( boost::asio::buffer(buf), [&](boost::system::error_code const& e, std::size_t bytes_transferred) { if (e) { std::cout << __LINE__ << ":" << e.message() << std::endl; return; } std::cout << bytes_transferred << " bytes read." << std::endl; print(std::string(std::string(&buf[0], buf.size()))); strm.avail_in = bytes_transferred; do { strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in); int zret; unp.reserve_buffer(window_size); strm.avail_out = window_size; strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer()); do { zret = inflate(&strm, Z_NO_FLUSH); assert(zret != Z_STREAM_ERROR); switch (zret) { case Z_NEED_DICT: zret = Z_DATA_ERROR; // fall through case Z_DATA_ERROR: case Z_MEM_ERROR: inflateEnd(&strm); std::cout << "Zlib inflate() error = " << zret << std::endl; std::exit(-1); } std::size_t decompressed_size = window_size - strm.avail_out; std::cout << decompressed_size << " bytes decompressed." << std::endl; unp.buffer_consumed(decompressed_size); msgpack::object_handle oh; while (unp.next(oh)) { std::cout << oh.get() << std::endl; } } while (strm.avail_out == 0); if (zret == Z_STREAM_END) { inflateEnd(&strm); std::cout << "Zlib decompress finished." << std::endl; ++idx_zlib_data; if (idx_zlib_data == num_of_zlib_data) { std::cout << "All zlib decompress finished." << std::endl; return; } zlib_init(); } } while (strm.avail_in != 0); do_async_read_some(); } ); }; do_async_read_some(); } ); }; do_accept(); // Client auto host = "localhost"; boost::asio::ip::tcp::resolver r(ios); #if BOOST_VERSION < 106600 boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port)); auto it = r.resolve(q); boost::asio::ip::tcp::resolver::iterator end; #else // BOOST_VERSION < 106600 auto eps = r.resolve(host, boost::lexical_cast<std::string>(port)); auto it = eps.begin(); auto end = eps.end(); #endif // BOOST_VERSION < 106600 boost::asio::ip::tcp::socket cs(ios); boost::asio::async_connect( cs, it, end, [&] (boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) { if (e) { std::cout << __LINE__ << ":" << e.message() << std::endl; return; } std::cout << __LINE__ << ":client connected" << std::endl; for (int i = 0; i != num_of_zlib_data; ++i) { msgpack::zbuffer zb; msgpack::pack(zb, std::make_tuple(i, false, "hello world", 12.3456)); zb.flush(); // finalize zbuffer (don't forget it) print(std::string(zb.data(), zb.size())); write(cs, boost::asio::buffer(zb.data(), zb.size())); } } ); // Start ios.run(); }

37db9f87f62b76818cbe72a7091f6d38a1be2b61

20e58a78041a5959d7d892dcc2b984bd82710e88

/compare/hugefile/test_ntuple.cc

3e7d96bbdeb0ffc8ad0d755d22c3a9027b98ae18

[]

no_license

jblomer/iotools

812c63d90cce173307eda3e8c7a63dc2466f8edf

817bf4e89d323cb6a137041f8a6978499f4fee48

refs/heads/master

2023-08-08T07:50:20.882150

2023-06-15T11:13:41

85,220,481

7

null

2023-06-15T11:13:43

2017-03-16T16:53:46

C++

UTF-8

C++

false

1,978

cc

test_ntuple.cc

#include <ROOT/RNTuple.hxx> #include <ROOT/RNTupleModel.hxx> #include <ROOT/RNTupleOptions.hxx> #include <TROOT.h> #include <cstdio> #include <memory> #include <string> #include <type_traits> using RNTupleModel = ROOT::Experimental::RNTupleModel; using RNTupleReader = ROOT::Experimental::RNTupleReader; using RNTupleWriter = ROOT::Experimental::RNTupleWriter; using RNTupleWriteOptions = ROOT::Experimental::RNTupleWriteOptions; static constexpr const char *kNtupleName = "hugefile"; void Hugefile_Read(const std::string &filename) { ROOT::EnableImplicitMT(); auto model = RNTupleModel::Create(); auto ntuple = RNTupleReader::Open(std::move(model), kNtupleName, filename); auto viewField0 = ntuple->GetView<float>("field_0"); auto viewField1 = ntuple->GetView<float>("field_1"); auto viewField2 = ntuple->GetView<float>("field_2"); for (auto i : ntuple->GetEntryRange()) { (void)viewField0(i); (void)viewField1(i); (void)viewField2(i); if (i % 10000 == 0) printf("Read %lu entries\r", (unsigned long)i); } printf("Read %lu entries\n", (unsigned long)ntuple->GetNEntries()); } void Hugefile_Write(const std::string &filename, size_t nEntries) { ROOT::EnableImplicitMT(); auto model = RNTupleModel::Create(); std::shared_ptr<float> field[3]; for (size_t i = 0; i < std::extent<decltype(field)>::value; ++i) { field[i] = model->MakeField<float>("field_" + std::to_string(i), 0.0f); } RNTupleWriteOptions options; options.SetCompression(0); auto ntuple = RNTupleWriter::Recreate(std::move(model), kNtupleName, filename, options); for (size_t i = 0; i < nEntries; ++i) { *field[0] = static_cast<float>(i); *field[1] = static_cast<float>(i) + 0.1f; *field[2] = static_cast<float>(i) + 1.1f; ntuple->Fill(); if (i % 10000 == 0) printf("Wrote %lu entries\r", (unsigned long)i); } printf("Wrote %lu entries\n", (unsigned long)nEntries); }

6b1c03b71ecf1f9d78a65a3966e5daf2b6cd9b14

bf0e9de1d26eabe066b405f480b2425fb704b524

/app/AnalogSensor.cpp

f859b5a3d70b77faaa01fe36b0cdbf9fa89a0a3a

[]

no_license

SamPusegaonkar/Valgrind

ebd739b0ff6cb79e4b39b6c10239113691732405

f0144d3e69a4b40bc9562c961915ed812b82ab15

refs/heads/main

2023-08-27T16:05:43.652117

2021-10-09T21:50:05

415,170,441

0

null

UTF-8

C++

false

570

cpp

AnalogSensor.cpp

/** * @file AnalogSensor.cpp * @author Sameer Pusegaonkar (sameer@umd.edu) * @brief AnalogSensor to get the average reading * @version 0.1 * @date 2021-10-09 * @copyright Copyright (c) 2021 * */ #include <AnalogSensor.hpp> #include <numeric> #include <vector> AnalogSensor::AnalogSensor(unsigned int samples): mSamples(samples) {} AnalogSensor::~AnalogSensor() {} int AnalogSensor::Read() { std::vector<int> readings(mSamples, 10); double result = std::accumulate(readings.begin(), readings.end(), 0.0) / readings.size(); return result; }

934c0998ab06a11582c2c97ae770a76cccaeb82f

e0bf00dc8ce16e81530d46442cf364668e23bb38

/CesiumGltfReader/generated/PropertyStatisticsJsonHandler.cpp

b5656db8805797f39779710f534f24b29535ee27

[ "Apache-2.0", "LicenseRef-scancode-free-unknown" ]

permissive

Lucas1188/cesium-native

d81ef0915cbd0cffba6f37e5e473b9623a9564b3

54cd13b95b8b61d4ad1d1dfd418014a031c0164e

refs/heads/main

2023-07-08T02:13:46.807782

2021-08-05T05:51:52

391,251,346

0

Apache-2.0

2021-07-31T04:09:59

null

UTF-8

C++

false

2,018

cpp

PropertyStatisticsJsonHandler.cpp

// This file was generated by generate-gltf-classes. // DO NOT EDIT THIS FILE! #include "PropertyStatisticsJsonHandler.h" #include "CesiumGltf/PropertyStatistics.h" #include <cassert> #include <string> using namespace CesiumGltf; PropertyStatisticsJsonHandler::PropertyStatisticsJsonHandler( const ReaderContext& context) noexcept : ExtensibleObjectJsonHandler(context), _min(), _max(), _mean(), _median(), _standardDeviation(), _variance(), _sum(), _occurrences() {} void PropertyStatisticsJsonHandler::reset( CesiumJsonReader::IJsonHandler* pParentHandler, PropertyStatistics* pObject) { ExtensibleObjectJsonHandler::reset(pParentHandler, pObject); this->_pObject = pObject; } CesiumJsonReader::IJsonHandler* PropertyStatisticsJsonHandler::readObjectKey(const std::string_view& str) { assert(this->_pObject); return this->readObjectKeyPropertyStatistics( PropertyStatistics::TypeName, str, *this->_pObject); } CesiumJsonReader::IJsonHandler* PropertyStatisticsJsonHandler::readObjectKeyPropertyStatistics( const std::string& objectType, const std::string_view& str, PropertyStatistics& o) { using namespace std::string_literals; if ("min"s == str) return property("min", this->_min, o.min); if ("max"s == str) return property("max", this->_max, o.max); if ("mean"s == str) return property("mean", this->_mean, o.mean); if ("median"s == str) return property("median", this->_median, o.median); if ("standardDeviation"s == str) return property( "standardDeviation", this->_standardDeviation, o.standardDeviation); if ("variance"s == str) return property("variance", this->_variance, o.variance); if ("sum"s == str) return property("sum", this->_sum, o.sum); if ("occurrences"s == str) return property("occurrences", this->_occurrences, o.occurrences); return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject); }

c9cc9aa5e1d45b671ac831daf9ab94b27725c07a

7ed9ddde7aa126433fccaaf724415d08d59caec2

/TalkingScene/WalaberEngine/Walaber/src/IO/ZipArchive.cpp

55b470a2d6d09fed0816371333bb8ea6ca1f9ea3

[]

no_license

DannyTking/TalkingScene

7b01c92d273d15f0b9c72b2170fdb5a7b95b5e22

b73828e69b4324ccb8f26648dbb3b5b8cbddeb8f

refs/heads/master

2020-12-30T10:36:40.516557

2013-12-23T01:34:45

13,242,667

0

2

null

UTF-8

C++

false

7,836

cpp

ZipArchive.cpp

#include "ZipArchive.h" #include "Logger.h" #include <fstream> namespace Walaber { // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== ZipArchiveReader::ZipArchiveReader( const std::string& zipFile ) { // try to open up the file mUnzFile = wUnzOpen( zipFile.c_str() ); // pre-cache all file locations so we don't need to look them up later. if (mUnzFile != NULL) { if (wUnzGoToFirstFile( mUnzFile ) == UNZ_OK) { do { char filename[ 256 ]; FileLocation loc; wUnzGetCurrentFileInfo64(mUnzFile, &loc.file_info, &loc.file_info_internal, filename, 256, NULL, 0, NULL, 0, &loc.num_file, &loc.pos_in_central_dir); //Logger::printf("Walaber", Logger::SV_INFO, "ZipArchive found file: {%s}\n", filename); // insert into map! mFileLocations[ std::string(filename) ] = loc; } while (wUnzGoToNextFile(mUnzFile) == UNZ_OK); } } } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== ZipArchiveReader::~ZipArchiveReader() { if (mUnzFile != NULL) { // close the zip file. wUnzCloseCurrentFile( mUnzFile ); wUnzClose( mUnzFile ); } } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== std::vector< std::string > ZipArchiveReader::getFilenames() { std::vector< std::string > ret; for (FileLocationMap::iterator it = mFileLocations.begin(); it != mFileLocations.end(); ++it) { ret.push_back( it->first ); } return ret; } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== bool ZipArchiveReader::openFile( const std::string& filename ) { if (mUnzFile == NULL) return false; FileLocationMap::iterator it = mFileLocations.find( filename ); if (it != mFileLocations.end()) { wUnzLocateFileImmediate( mUnzFile, it->second.file_info, it->second.file_info_internal, it->second.num_file, it->second.pos_in_central_dir ); wUnzOpenCurrentFile( mUnzFile ); mCurrentFileInfo = it->second.file_info; //Logger::printf("Walaber", Logger::SV_INFO, "openFile(%s) found file in archive, size is %ld uncompressed.\n", filename.c_str(), it->second.file_info.uncompressed_size); } else { Logger::printf("Walaber", Logger::SV_ERROR, "openFile(%s) ERROR! File not found in archive!\n", filename.c_str()); } return true; } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== unsigned long ZipArchiveReader::getCurrentFileSize() { return mCurrentFileInfo.uncompressed_size; } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== void ZipArchiveReader::readCurrentFile( void* buffer ) { int read = wUnzReadCurrentFile(mUnzFile, buffer, mCurrentFileInfo.uncompressed_size); Logger::printf("Walaber", Logger::SV_INFO, "ZipArchiveReader::readCurrentFile() read %d bytes", read); } /*! Extracts a file to the target destination @param sourceFilname the name of the file in the zip to be extracted @param destinationFilename the name of the destination (path and filename) to be extracted to @return if the file was extracted */ bool ZipArchiveReader::extractFile(const std::string& sourceFilename, const std::string& destinationFilename) { bool extracted(true); if (mUnzFile == NULL) return false; if (openFile(sourceFilename)) { // read the database from app bundle int size = getCurrentFileSize(); char *buffer = new char[size]; readCurrentFile( buffer ); Logger::printf("Walaber", Logger::SV_INFO, "ZipArchiveReader::readCurrentFile() read %d bytes", read); if (FILE *destFile = std::fopen( destinationFilename.c_str(), "w" )) { fwrite((void*)buffer, 1, size, destFile); if (fclose(destFile) == EOF) { Walaber::Logger::printf("Init", Walaber::Logger::SV_INFO, "ZipArchivEreader::extractFile() - \ fclose of open file failed"); extracted = false; } } else { Walaber::Logger::printf("Init", Walaber::Logger::SV_INFO, "ZipArchivEreader::extractFile() - couldn't \ open %s for writing ", destinationFilename.c_str()); extracted = false; } delete [] buffer; } else { extracted = false; } return extracted; } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== ZipArchiveCreator::ZipArchiveCreator( const std::string& destZipFile ) { // try to create the new file mZipFile = wZipOpen( destZipFile.c_str(), APPEND_STATUS_CREATE ); } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== ZipArchiveCreator::~ZipArchiveCreator() { if (mZipFile != NULL) { // close the zip file. wZipClose( mZipFile, "created by ZipArchiveCreator" ); } } // ----====----====----====----====----====----====----====----====----==== // ----====----====----====----====----====----====----====----====----==== bool ZipArchiveCreator::addFileToZip( const std::string& filePath, const std::string& nameOfFileInZip ) { if (mZipFile == NULL) return false; std::fstream fileStream( filePath.c_str(), std::ios_base::in | std::ios_base::binary ); if (fileStream.is_open()) { // the source file is open, now add this as a new file into the ZIP archive. zip_fileinfo zip_info; int ret = wZipOpenNewFileInZip(mZipFile, nameOfFileInZip.c_str(), &zip_info, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION); printf("openNewFileInZip... ret[%d]\n", ret); if (ret != ZIP_OK) { return false; } // write this entire file into the ZIP... unsigned int length = 0; fileStream.seekg(0, std::ios::end); length = fileStream.tellg(); fileStream.seekg(0, std::ios::beg); char* buffer = new char[length]; fileStream.read( buffer, length ); fileStream.close(); ret = wZipWriteInFileInZip(mZipFile, buffer, length); printf("WriteInFileInZip... ret[%d]\n", ret); if (ret != ZIP_OK) { delete[] buffer; return false; } ret = wZipCloseFileInZip(mZipFile); printf("CloseFileInZip... ret[%d]\n", ret); delete[] buffer; if (ret != ZIP_OK) { return false; } return true; } return false; } }

675ed435945c0359ead0a9b3b684ba75addd47a2

23251b94518a55709e3d1c0e685aba44c240dfa5

/CppModule08/ex01/main.cpp

6403359c1f28da5f0df8807198a2f63d2d2b13b6

[]

no_license

soukainahikma/Piscine-cpp-42-

a8febd8d221ce4cf025891a45428f8af05f35b8e

5b01426ba1257bb7a3ccc50eb1ce96e297b8bcde

refs/heads/main

2023-09-05T17:22:47.148176

2021-09-28T11:49:17

376,921,846

0

null

UTF-8

C++

false

1,882

cpp

main.cpp

#include "span.hpp" int main () { Span sp(6); Span sp2(5); Span sp3(1000); int x; std::cout << "---------------- testing sp ---------------" << std::endl; for (size_t i = 0; i < 6; i++) { try { sp.addNumber(i); } catch(std::exception &e) { std::cout << "you have achieved the limit" << std::endl; } } try { std::cout << "shortestSpan : "<< sp.shortestSpan() << std::endl; std::cout << "longestSpan : "<< sp.longestSpan() << std::endl; } catch(std::exception &e) { std::cout << "Too short" << std::endl; } std::cout << "---------------- testing sp2 ---------------" << std::endl; try { sp2.addNumber(-9); sp2.addNumber(0); } catch(std::exception &e) { std::cout << "you have achieved the limit" << std::endl; } try { std::cout << "shortestSpan : "<< sp2.shortestSpan() << std::endl; std::cout << "longestSpan : "<< sp2.longestSpan() << std::endl; } catch(std::exception &e) { std::cout << "Too short" << std::endl; } std::cout << "---------------- testing sp3 ---------------" << std::endl; srand(time(NULL)); for (size_t i = 0; i < 1000; i++) { try { x = rand() %1000; sp3.addNumber(x); } catch(std::exception &e) { std::cout << "you have achieved the limit" << std::endl; } } std::cout << "shortestSpan : " << sp3.shortestSpan() << std::endl; std::cout << "longestSpan : " << sp3.longestSpan() << std::endl; std::cout << "----------- testing the overload add -------------" << std::endl; std::vector<int> vec; vec.push_back(-9); vec.push_back(0); vec.push_back(0); vec.push_back(0); try{ sp2.addNumber(vec.begin(), vec.end());} catch(std::exception &e) { std::cout << "you have reached the limit" << std::endl; } std::cout << "shortestSpan : " << sp2.shortestSpan() << std::endl; std::cout << "longestSpan : " << sp2.longestSpan() << std::endl; sp2.spanPrinter(); }

f389c40ed236f71c050f39b575c93d8575876a00

190ab627f77ad18fe63a70a408fc3480c0ccf1a3

/quick_sort.cpp

408de9584746f8cf6010b7f178e232db4703ebfb

[]

no_license

sudeepdino008/competitive-programming-solutions

f14d4557405e1165df26c48a54a51c93633c03de

63d5a928a8bc66250c383da2848a889c6722f162

refs/heads/master

2021-12-22T01:42:51.678160

2021-12-16T16:04:51

25,127,301

0

null

UTF-8

C++

false

1,221

cpp

quick_sort.cpp

#include <iostream> #include <cstring> #include <sstream> #include <cstdlib> #include <cstdio> #include <cmath> #include <vector> #include <set> #include <map> #include <climits> #include <ctime> //#define NDEBUG //when all assert statements have to be disabled #include <cassert> #define tr(c,i) for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++) #define present(c,x) ((c).find(x) != (c).end()) #define lld long long int #define MOD 1000000007 #define SIZE 10 using namespace std; int array[SIZE]; void quick_sort(int start, int end) { if(start<end) { int pivot=SIZE%(end-start)+start; int p=end+1,i; swap(array[start], array[pivot]); for(i=start+1;i<=end;i++) { if(array[i]<=array[start] && p!=end+1) swap(array[i], array[p++]); else if(array[i]>array[start] && p==end+1) p=i; } swap(array[p-1],array[start]); quick_sort(start, p-1); quick_sort(p, end); } } int main() { srand((unsigned int)(time(NULL))); int i; for(i=0;i<SIZE;i++) array[i]=rand()%100; cout<<"initial array:\n"; for(i=0;i<SIZE;i++) cout<<array[i]<<" "; cout<<endl; quick_sort(0,SIZE-1); cout<<"\n\nsorted array:\n"; for(i=0;i<SIZE;i++) cout<<array[i]<<" "; cout<<endl; }

6ebe1b8321e1db13aa7082e6aec306529cc85a33

8d8441aae38d587fc753832e48235980d7180f25

/jogo-21-VERSAO-ATUAL.cpp

f6221699c2cc0d0f182ad57ed32c6b60ef6f646a

[]

no_license

williamkoller/jogo21-C

2fd77da526be28235d58e8da3ae27e8a0faf14bc

1dbbcc09774994222d8c7b2e69fd4b68d6f03e10

refs/heads/master

2020-04-25T19:47:09.826849

2019-02-28T03:17:16

null

0

null

WINDOWS-1252

C++

false

15,947

cpp

jogo-21-VERSAO-ATUAL.cpp

/* projeto: Jogando 21 desenvolvedores: Jeferson Jacinto, Nilton, Vinicius e William Koller */ #include <time.h> #include <ctype.h> #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int pts1, pts2, pt1, pt2, partida, jogandoi; // sistema int smc_player2, i2, sorteadas2, player2, player2_2, player2_2_bkp; // jogador 2 int smc_player1, i1, sorteadas1, player1, continua1, continua1_1; // jogador 1 char cartas1[100], carta1[2]; // jogador 1 char jogador2[40], cartas2[100], carta2[2], result2[80], continuar, outracarta; // jogador 2 int x; char naipe[1]; int chooseNaipe; int cartassorteadas[52]; int sorteio(); main() { setlocale(LC_ALL, "Portuguese"); system("cls"); system("title JOGANDO 21"); system("color 22"); pts1 = (0); pts2 = (0); partida = (0); jogandoi = (2); continuar = 'S'; printf(" ---------------------------------------------------------------------- \n"); printf(" | BLACK JACK | \n"); printf("----------------------------------------------------------------------\n"); printf(" \n Bem vindo ao: BLACK JACK! \n\n\n "); printf(" ************* INSTRUCOES ********************* \n\n"); printf(" 1 - O Ganhador é quem conseguir somar o numero de cartas em 21. \n"); printf(" 2 - podera comprar a quantidade de cartas conforme seu jogo ateh que o numero 21 seja ultrapassado. \n"); printf(" 3 - Voce pode tambem optar por nao comprar mais cartas mesmo que o numero nao tenha fechado em 21. \n\n"); printf(" Esta pronto ? \n\n"); printf(" Vamos la digite abaixo o nome do seu jogador: \n"); // inicia o vetor de cartas sorteadas com o valor -1 for(int k=0;k<52;k++){ cartassorteadas[k] = -1; } printf("\n Nome do jogador 1 : Windows"); printf("\n Nome do jogador 2 : "); fflush(stdin); gets(jogador2); do { // while controlador. system("cls"); partida++; pt1 = (0); pt2 = (0); sorteadas2 = (2); sorteadas1 = (2); smc_player1 = (0); smc_player2 = (0); strcpy(cartas1, ""); strcpy(cartas2, ""); strcpy(carta1, ""); strcpy(carta2, ""); printf(" ------------------------------------------------------------------------------ \n"); printf(" | Rodada: %i | Placar: Windows %i x %i %s | 21 contra o Windows \n", partida, pts1, pts2, jogador2); printf(" ------------------------------------------------------------------------------ \n"); if (jogandoi == 2) // inicio da jogada, jogador 2 { /* Player two */ for (i2=1 ; i2<=2 ; i2++) { srand(time(NULL)); player2 = sorteio(); //rand()%12; if (player2 >=1 && player2 <=13){ player2 = player2; naipe [0] = 'P'; } else if (player2 >=14 && player2 <=26){ player2 = player2 - 13; naipe [0] = 'C'; } else if (player2 >=27 && player2 <=39){ player2 = player2 - 26; naipe [0] = 'E'; } else if (player2 >=40 && player2 <=52){ player2 = player2 - 39; naipe [0] = 'O'; } smc_player2 = (smc_player2+player2); // soma cartas itoa(player2,carta2,10); // converte numero inteiro em string strcat(cartas2, "["); // concatena strings strcat(cartas2, carta2); // concatena strings strcat(cartas2, naipe); strcat(cartas2, "]"); // concatena strings if (i2 == 1) { printf("\n Dando as cartas! - "); system("pause"); printf("\n"); } } printf("\n Foram dadas 2 cartas %s \n A soma das suas cartas corresponde a {%i}", cartas2, smc_player2); printf("\n Quer outra carta? (S/N) "); do { fflush(stdin); outracarta = toupper(getch()); } while (outracarta!='s' && outracarta!='S' && outracarta!='n' && outracarta!='N'); if (outracarta == 'S') { do { sorteadas2++; srand(time(NULL)); player2_2 = sorteio(); //rand()%12; if (player2_2 >=1 && player2_2 <=13){ player2_2 = player2_2; naipe [0] = 'P'; } else if (player2_2 >=14 && player2_2 <=26){ player2_2 = player2_2 - 13; naipe [0] = 'C'; } else if (player2_2 >=27 && player2_2 <=39){ player2_2 = player2_2 - 26; naipe [0] = 'E'; } else if (player2_2 >=40 && player2_2 <=52){ player2_2 = player2_2 - 39; naipe [0] = 'O'; } player2_2_bkp = (player2_2); smc_player2 = (smc_player2+player2_2); // soma cartas aceitas alem das sorteados itoa(player2_2,carta2,11); // converte numero inteiro em string strcat(cartas2, "["); // concatena strings strcat(cartas2, carta2); // concatena strings strcat(cartas2, naipe); strcat(cartas2, "]"); // concatena strings if (smc_player2 > 21) { printf("\n \n Estourou, voce pegou a carta [%i%s] \n Voce obteve um total de {%i}", player2_2_bkp,naipe, smc_player2); printf("\n Suas cartas foram %s", cartas2); printf("\n Windows ganhou um ponto no placar! \n \n"); outracarta = 'N'; jogandoi = (2); pt1 = (1); pts1++; } else if (smc_player2 == 21) { printf("\n \n OPA que sorte! [21] \n"); printf("\n Suas cartas foram %s", cartas2, naipe); printf("\n Voce ganhou um ponto no placar! \n \n"); outracarta = 'N'; jogandoi = (2); pt2 = (1); pts2++; } else { printf("\n \n Voce pegou a carta [%i%s]", player2_2_bkp, naipe); printf("\n Voce ja tem [%i] cartas, a soma corresponde a {%i}", sorteadas2, smc_player2); printf("\n Quer outra carta? (S/N) "); do { fflush(stdin); outracarta = toupper(getch()); } while (outracarta!='s' && outracarta!='S' && outracarta!='n' && outracarta!='N'); } } while (outracarta=='S'); } if (smc_player2 < 21 && jogandoi == 2) { if (smc_player2 == 20) { strcpy(result2, "\n Otimo. voce tem grandes chances! \n"); } else if (smc_player2 >= 18 && smc_player2 <= 19) { strcpy(result2, "\n Bom. tomara que o windows estoure! \n"); } else if (smc_player2 >= 15 && smc_player2 <= 17) { strcpy(result2, "\n Eita. voce podia ter tentado mais uma! \n"); } else if (smc_player2 >= 12 && smc_player2 <= 14) { strcpy(result2, "\n Aff. ta feio pro seu lado! \n"); } else if (smc_player2 <= 13) { strcpy(result2, "\n SO POR UM MILAGRE VOCE LEVA A RODADA! \n"); } printf("\n \n A soma de suas cartas corresponde a {%i} %s", smc_player2, result2); printf("\n Suas cartas foram %s \n \n", cartas2); } if (outracarta == 'N' && smc_player2 < 21) { jogandoi = (1); } system("pause"); } if (jogandoi == 1) //inicio da jogada, jogador 1 { /* Windows */ system("cls"); printf(" ------------------------------------------------------------------------------ \n"); printf(" | Rodada: %i | Placar: Windows %i x %i %s | 21 contra o Windows \n", partida, pts1, pts2, jogador2); printf(" ------------------------------------------------------------------------------ \n"); for (i1=1 ; i1<=2 ; i1++) { srand(time(NULL)); player1 = sorteio(); //rand()%12; if (player1 >=1 && player1 <=13){ player1 = player1; naipe [0] = 'P'; } else if (player1>=14 && player1<=26){ player1 = player1 - 13; naipe [0] = 'C'; } else if (player1 >=27 && player1 <=39){ player1 = player1 - 26; naipe [0] = 'E'; } else if (player1 >=40 && player1 <=52){ player1 = player1 - 39; naipe [0] = 'O'; } smc_player1 = (smc_player1+player1); // soma cartas itoa(player1,carta1,10); // converte numero inteiro em string strcat(cartas1, "["); // concatena strings strcat(cartas1, carta1); // concatena strings strcat(cartas1, naipe); strcat(cartas1, "]"); // concatena strings if (i1 == 1) { printf("\n Windows jogando! \n"); printf("\n Recebendo as cartas! - "); system("pause"); printf("\n"); } } printf("\n Windows fala: Nao tenho nada a esconder! \n Vou mostrar minhas cartas e jogadas \n"); printf("\n Peguei 2 cartas %s \n A soma das cartas corresponde a {%i} \n ", cartas1, smc_player1); system("pause"); do { continua1 = (1); if (smc_player1 <= 17) { sorteadas1++; srand(time(NULL)); player1 = sorteio(); //rand()%12; if (player1 >=1 && player1 <=13){ player1 = player1; naipe [0] = 'P'; } else if (player1>=14 && player1<=26){ player1 = player1 - 13; naipe [0] = 'C'; } else if (player1 >=27 && player1 <=39){ player1 = player1 - 26; naipe [0] = 'E'; } else if (player1 >=40 && player1 <=52){ player1 = player1 - 39; naipe [0] = 'O'; } smc_player1 = (smc_player1+player1); // soma cartas itoa(player1,carta1,10); // converte numero inteiro em string strcat(cartas1, "["); // concatena strings strcat(cartas1, carta1); // concatena strings strcat(cartas1, naipe); strcat(cartas1, "]"); // concatena strings if (smc_player1 < 21) { printf("\n Estou com %i cartas, somando {%i} \n ", sorteadas1, smc_player1); system("pause"); } } else if (smc_player1 >= 18 && smc_player1 <= 19) { srand(time(NULL)); continua1_1 = sorteio(); //rand()%12; if (continua1_1 >=1 && continua1_1 <=13){ continua1_1 = continua1_1 ; naipe [0] = 'P'; } else if (continua1_1 >=14 && continua1_1 <=26){ continua1_1 = continua1_1 - 13; naipe [0] = 'C'; } else if (continua1_1 >=27 && continua1_1 <=39){ continua1_1 = continua1_1 - 26; naipe [0] = 'E'; } else if (continua1_1 >=40 && continua1_1 <=52){ continua1_1 = continua1_1 - 39; naipe [0] = 'O'; } } if (continua1_1 == 1) { sorteadas1++; srand(time(NULL)); player1 = sorteio(); //rand()%12; if (player1 >=1 && player1 <=13){ player1 = player1; naipe [0] = 'P'; } else if (player1>=14 && player1<=26){ player1 = player1 - 13; naipe [0] = 'C'; } else if (player1 >=27 && player1 <=39){ player1 = player1 - 26; naipe [0] = 'E'; } else if (player1 >=40 && player1 <=52){ player1 = player1 - 39; naipe [0] = 'O'; } smc_player1 = (smc_player1+player1); // soma cartas itoa(player1,carta1,10); // converte numero inteiro em string strcat(cartas1, "["); // concatena strings strcat(cartas1, carta1); // concatena strings strcat(cartas1, naipe); strcat(cartas1, "]"); // concatena strings } else { printf("\n Windows fala: Vou parar por Aqui! \n Vamos ver quem chegou mais perto do 21 \n "); continua1 = (1); system("pause"); } if (smc_player1 == 20) { srand(time(NULL)); continua1_1 = sorteio(); //rand()%12; if (continua1_1 >=1 && continua1_1 <=13){ continua1_1 = continua1_1 ; naipe [0] = 'P'; } else if (continua1_1 >=14 && continua1_1 <=26){ continua1_1 = continua1_1 - 13; naipe [0] = 'C'; } else if (continua1_1 >=27 && continua1_1 <=39){ continua1_1 = continua1_1- 26; naipe [0] = 'E'; } else if (continua1_1 >=40 && continua1_1 <=52){ continua1_1 = continua1_1 - 39; naipe [0] = 'O'; } } if (continua1_1 == 1) { sorteadas1++; srand(time(NULL)); player1 = sorteio(); //rand()%12; if (player1 >=1 && player1 <=13){ player1 = player1; naipe [0] = 'P'; } else if (player1>=14 && player1<=26){ player1 = player1 - 13; naipe [0] = 'C'; } else if (player1 >=27 && player1 <=39){ player1 = player1 - 26; naipe [0] = 'E'; } else if (player1 >=40 && player1 <=52){ player1 = player1 - 39; naipe [0] = 'O'; } smc_player1 = (smc_player1+player1); // soma cartas itoa(player1,carta1,10); // converte numero inteiro em string strcat(cartas1, "["); // concatena strings strcat(cartas1, carta1); // concatena strings strcat(cartas1, naipe); strcat(cartas1, "]"); // concatena strings } else { printf("\n Windows fala: Vou parar por Aqui! \n Vamos ver quem chegou mais perto do 21 \n "); //continua1 = (0); jogandoi = (2); pt1 = (0); pts1++; system("pause"); } if (smc_player1 == 21) { printf("\n Ganhei! HAHAHAHA fiz 21 \n Minhas cartas foram %s \n ", cartas1); continua1 = (0); jogandoi = (2); pt1 = (1); pts1++; system("pause"); } else if (smc_player1 > 21) { printf("\n Ow nao! Estourei. \n Peguei as cartas %s \n Fiz um total de {%i}", cartas1, smc_player1); printf("\n \n %s, ganhou um ponto no placar! \n \n ", jogador2); continua1 = (0); jogandoi = (2); pt2 = (1); pts2++; system("pause"); } } while (continua1==1); if (pt1 == 0 && pt2 == 0) { if (smc_player1 > smc_player2) { printf("\n HEHE, quase ganhou em. Mas eu sou Melhor."); printf("\n Windows venceu! por aproximacao do 21"); printf("\n Soma do windows {%i} - Soma do(a) %s {%i} \n \n", smc_player1, jogador2, smc_player2); pts1++; jogandoi = (2); system("pause"); } else if (smc_player2 > smc_player1) { printf("\n %s venceu! por aproximacao do 21", jogador2); printf("\n Soma do(a) %s {%i} - Soma do Windows {%i} \n \n", jogador2, smc_player2, smc_player1); pts2++; jogandoi = (2); system("pause"); } else if (smc_player2 == smc_player1) { printf("\n OW nossa. houve empate ^^ \n Um ponto pra cada! \n "); pts1++; pts2++; jogandoi = (2); system("pause"); } } system("cls"); printf("\n \n Outra rodada? (S/N) "); do { fflush(stdin); continuar = toupper(getch()); } while (continuar!='s' && continuar!='S' && continuar!='n' && continuar!='N'); } }while (continuar == 'S'); printf("\n \n PLACAR FINAL | Windows: %i x %i %s", pts1, pts2, jogador2); if (pts1 > pts2) { printf("\n \n Windows fala: HAHAHA, Ja vai sair? esta tao divertido! kkkk \n Eu sou bom nisso! \n \n \n \n"); } else if (pts2 > pts1) { printf("\n \n Windows fala: Tude bem. Vai ter revanche! \n E alias, meu negocio é pokker! \n \n \n \n"); } else if (pts1 == pts2) { printf("\n \n Windows fala: empatou! \n Vamos jogar de novo, isso nao ficou bem decidido. \n \n \n \n"); } } int sorteio(){ int carta, naipe, x = 1; int i; do{ carta = rand() % 52; carta++; // 1-13 ->paus 14-26 ->copas 27-39 ->espadas 40-52 ->ouro for(i=0; i<52 && cartassorteadas[i] != -1; i++){ if (cartassorteadas[i] == carta){ x = 0; } } if (x == 1){ cartassorteadas[i] = carta; return carta; } }while (x == 0); }

e0085c07b2ea385209817b3aac3b30ef41564d32

b4c1fba2f585796346492cd56d7c1eb02e821d8a

/greedy/COINCHANGE/solve.cpp

ba949f69c43333bd90ed104ad947e925e6f1e379

[]

no_license

nqhung291/algorithm

03161073018a56015c600def0b0889f729cd1ce1

f64b7083d53dcdd34ab5ca5d9c6b552d3a6e1e75

refs/heads/master

2023-02-24T06:28:41.524792

2021-02-04T00:57:30

304,799,153

0

null

UTF-8

C++

false

695

cpp

solve.cpp

#include <bits/stdc++.h> using namespace std; typedef unsigned long long ull; typedef long long ll; typedef long double ld; typedef vector<int> vi; typedef vector<vi> vvi; typedef pair<int, int> ii; typedef vector<ii> vii; // vector of integer pairs typedef set<int> si; typedef map<string, int> msi; int n; int coins[] = {1,5,10,50,100,500}; int ans; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n; int pay = 1000 - n; for (int i = 5; i >= 0; i--) { int num = pay / coins[i]; pay -= num * coins[i]; ans += num; } cout << ans << endl; return 0; }

5589c57d325fa6f8720c0046d6282a801827a57e

c4f81131f3209f2d3415201c2d41b51ed9ff88c5

/querys_quest/Space.cpp

0163459b70c8caa23faa9447f2779cfa74a515ed

[]

no_license

sgilbo618/Querys_Quest

e9e32aec9ca1f4490e4961b8f3641c6a37312d6e

3839706a5660485cf64516dae613fa1ec7cd40dc

refs/heads/master

2022-11-10T14:48:06.748518

2020-06-19T19:24:08

174,137,607

0

null

UTF-8

C++

false

2,963

cpp

Space.cpp

/********************************************************************* ** Program name: Query's Quest ** File: ** Author: Samantha Guilbeault ** Date: 2-26-2019 ** Description: Contains the implementation of the class Space which ** is an abstract base case that represents the basic ** tile of the game board for Query's Quest. Each Space ** has a character to signify it's type and four pointers ** to other Spaces in the directions of up, down, left, ** and right. *********************************************************************/ #include "Space.hpp" /********************************************************************* ** Function: Space() ** Description: Default constructor for Space object. *********************************************************************/ Space::Space() { elementType = NON; itemType = NONE; up = nullptr; down = nullptr; left = nullptr; right = nullptr; } /********************************************************************* ** Function: ~Space() ** Description: Destructor for Space object. *********************************************************************/ Space::~Space() { } /********************************************************************* ** Description: Getters for types. *********************************************************************/ SpaceType Space::getType() { return type; } ElementType Space::getElementType() { return elementType; } ItemType Space::getItemType() { return itemType; } /********************************************************************* ** Description: Getter and Setter for symbol. *********************************************************************/ std::string Space::getSpaceSymbol() { return symbol; } void Space::setSpaceSymbol(std::string symbol) { this->symbol = symbol; } /********************************************************************* ** Description: Getter and Setter for up. *********************************************************************/ Space * Space::getUp() { return up; } void Space::setUp(Space * up) { this->up = up; } /********************************************************************* ** Description: Getter and Setter for down. *********************************************************************/ Space * Space::getDown() { return down; } void Space::setDown(Space * down) { this->down = down; } /********************************************************************* ** Description: Getter and Setter for left. *********************************************************************/ Space * Space::getLeft() { return left; } void Space::setLeft(Space * left) { this->left = left; } /********************************************************************* ** Description: Getter and Setter for right. *********************************************************************/ Space * Space::getRight() { return right; } void Space::setRight(Space * right) { this->right = right; }

b5ef2c382c859dc4237839d53e5f7803122a690d

ecb9e52e2e9fed4304e0c6e5ffc0b06ae06766e4

/src/REXOS/ROS/libraries/rexos_delta_robot/include/rexos_delta_robot/Measures.h

d10cdce044c8073085351a04a32dbaecd1386dd1

[]

no_license

tommasbakker/HUniversal-Production-Utrecht

1f6b0f269d3d9088418ee06dce84b77142a248cc

edbd9443adb97d076ee21bf4ceb72de9f7a1a8f7

refs/heads/master

2021-01-16T21:25:06.036294

2013-10-10T11:31:25

2013-10-10T11:32:09

null

0

null

UTF-8

C++

false

4,676

h

Measures.h

/** * @file Measures.h * @brief Miscellaneous measures. * * @author 1.0 Lukas Vermond * @author 1.0 Kasper van Nieuwland * @author 1.1 Daan Veltman * @author 1.1 Koen Braham * * @section LICENSE * License: newBSD * * Copyright © 2012, HU University of Applied Sciences Utrecht. * 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 HU University of Applied Sciences Utrecht 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 HU UNIVERSITY OF APPLIED SCIENCES UTRECHT * 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. **/ #pragma once #include <rexos_utilities/Utilities.h> #include <rexos_motor/CRD514KD.h> namespace rexos_delta_robot{ namespace Measures{ /** * @var double BASE * Radius of the base in millimeters. **/ const double BASE = 101.3; /** * @var double HIP * Length of the hip in millimeters. **/ const double HIP = 100; /** * @var double EFFECTOR * Radius of the effector in millimeters. **/ const double EFFECTOR = 46.19; /** * @var double ANKLE * Length of the ankle in millimeters. **/ const double ANKLE = 250; /** * @var double HIP_ANKLE_ANGLE_MAX * Maximum angle between hip and ankle when moving the ankle sideways in radians. **/ const double HIP_ANKLE_ANGLE_MAX = rexos_utilities::degreesToRadians(22); /** * @var double MOTOR_ROT_MIN * Mathematical minimum angle the motor is allowed to move to in radians. **/ const double MOTOR_ROT_MIN = rexos_utilities::degreesToRadians(-42); /** * @var double MOTOR_ROT_MAX * Mathematical maximum angle the motor is allowed to move to in radians. **/ const double MOTOR_ROT_MAX = rexos_utilities::degreesToRadians(55); /** * @var double MOTORS_FROM_ZERO_TO_TOP_POSITION * The angle from zero (horizontal) to the top position in radians. **/ const double MOTORS_FROM_ZERO_TO_TOP_POSITION = rexos_utilities::degreesToRadians(42.5); /** * @var double BOUNDARY_BOX_MAX_X * The max x-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MAX_X = 500; /** * @var double BOUNDARY_BOX_MAX_Y * The max y-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MAX_Y = BOUNDARY_BOX_MAX_X; /** * @var double BOUNDARY_BOX_MIN_X * The min x-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MIN_X = -BOUNDARY_BOX_MAX_X; /** * @var double BOUNDARY_BOX_MIN_Y * The min y-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MIN_Y = -BOUNDARY_BOX_MAX_Y; /** * @var double BOUNDARY_BOX_MIN_Z * The min z-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MIN_Z = -275; /** * @var double BOUNDARY_BOX_MAX_Z * The max z-coordinate of the effector boundary box in millimeters. **/ const double BOUNDARY_BOX_MAX_Z = -180; /** * @var double CALIBRATION_STEP_SMALL * The size of the small steps in the calibration in radians. **/ const double CALIBRATION_STEP_SMALL = rexos_motor::CRD514KD::MOTOR_STEP_ANGLE; /** * @var double CALIBRATION_STEP_BIG * The size of the big calibration steps in radians. Currently equal to 20 small calibration steps. **/ const double CALIBRATION_STEP_BIG = CALIBRATION_STEP_SMALL * 20; } }

1f28ff08d8d5f3286a4a7d5af7a6cb693eec940a

2c2d1fa4f0f8949ff4371eb01a7628355984a369

/D1L2/FlowerGarden.cpp

02098422ede935a95dbc801061828bdc95beae00

[]

no_license

kokizzu/topcoder

85b439d369e8ff342fed27681e84de148a7ff09a

9e9b85dc7ceb9872daa3571203ad3d4b1c932187

refs/heads/master

2020-06-12T15:35:13.440655

2015-05-15T09:58:59

null

0

null

UTF-8

C++

false

1,200

cpp

FlowerGarden.cpp

#include <vector> #include <algorithm> #include <functional> #include <cstring> using namespace std; vector<int> a; int beg[1001], end[1001]; bool block(int x, int y) { if (beg[x] > end[y] || beg[y] > end[x]) { return false; } return true; } vector<int> getOrdering(vector<int> const &height, vector<int> const &bloom, vector<int> const &wilt) { a = height; int n = a.size(); for (int i = 0; i != n; ++i) { beg[a[i]] = bloom[i]; end[a[i]] = wilt[i]; } sort(a.begin(), a.end(), greater<int>()); vector<int> ret(n); bool used[n]; memset(used, false, sizeof(used)); for (int i = 0; i != n; ++i) { for (int j = 0; j != n; ++j) { if (used[j]) { continue; } int ok = true; for (int k = j + 1; k != n; ++k) { if (!used[k] && block(a[j], a[k])) { ok = false; break; } } if (ok) { ret[i] = a[j]; used[j] = true; break; } } } return ret; }

0943387849ac4fe1d7c06ad0b6efe54f6438b9a9

cd470ad61c4dbbd37ff004785fd6d75980987fe9

/Codeforces/1201E2 Knightmare (hard)/交互,BFS/std.cpp

70f83ef5c57fd8717c276d78db959c5835230185

[]

no_license

AutumnKite/Codes

d67c3770687f3d68f17a06775c79285edc59a96d

31b7fc457bf8858424172bc3580389badab62269

refs/heads/master

2023-02-17T21:33:04.604104

2023-02-17T05:38:57

202,944,952

3

1

null

UTF-8

C++

false

2,538

cpp

std.cpp

#include <cstdio> #include <cctype> #include <cstdlib> #include <algorithm> #include <cstring> int read(){ register int x = 0; register char ch = getchar(), f = 1; for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = !f; for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0'); return f ? x : -x; } #define N 1005 #define INF 0x3f3f3f3f const int d[8][2] = {{-1, -2}, {-1, 2}, {-2, -1}, {-2, 1}, {1, 2}, {1, -2}, {2, -1}, {2, 1}}; struct node{ int x, y; void get(){ x = read(), y = read(); } }w, b; int n, m, dis[2][N][N], h, t; node pre[2][N][N]; node Q[N * N]; void bfs(int k, int x, int y){ memset(dis[k], 0x3f, sizeof dis[k]); h = 0, t = 1, Q[t] = (node){x, y}, dis[k][x][y] = 0; while (h < t){ node u = Q[++h]; for (register int i = 0; i < 8; ++i){ node v = u; v.x += d[i][0], v.y += d[i][1]; if (v.x >= 1 && v.x <= n && v.y >= 1 && v.y <= m && dis[k][v.x][v.y] == INF) dis[k][v.x][v.y] = dis[k][u.x][u.y] + 1, pre[k][v.x][v.y] = u, Q[++t] = v; } } } node A, B; void check(){ for (register int i = 0; i < 8; ++i) if (A.x + d[i][0] == B.x && A.y + d[i][1] == B.y) printf("%d %d\n", B.x, B.y), fflush(stdout), exit(0); } void move(){ printf("%d %d\n", A.x, A.y), fflush(stdout), B.get(), check(); } void solve1(int k){ if (!k) printf("WHITE\n"), fflush(stdout), A = w, B = b, check(); else printf("BLACK\n"), fflush(stdout), A = b, B.get(), check(); if (!dis[k][A.x][A.y]) exit(0); while (1){ A = pre[k][A.x][A.y]; if (!dis[k][A.x][A.y]) printf("%d %d\n", A.x, A.y), fflush(stdout), exit(0); move(); } } void solve2(int k){ if (!k) printf("WHITE\n"), fflush(stdout), A = w, B = b, check(); else printf("BLACK\n"), fflush(stdout), A = b, B.get(), check(); while (1){ if (dis[k ^ 1][A.x][A.y] == 0) break; A = pre[k ^ 1][A.x][A.y], move(); } if (!k) --A.x, ++A.y, ++A.y, move(), --A.x, --A.x, --A.y, move(), ++A.x, ++A.x, --A.y; else ++A.x, ++A.y, ++A.y, move(), ++A.x, ++A.x, --A.y, move(), --A.x, --A.x, --A.y; printf("%d %d\n", A.x, A.y), fflush(stdout), exit(0); } int main(){ n = read(), m = read(), w.get(), b.get(); bfs(0, n >> 1, m >> 1), bfs(1, (n >> 1) + 1, m >> 1); int colw = (w.x & 1) == (w.y & 1), colb = (b.x & 1) == (b.y & 1); if (colw != colb){ if (dis[0][w.x][w.y] <= dis[1][b.x][b.y]) solve1(0); else if (dis[1][w.x][w.y] >= dis[1][b.x][b.y] + 2) solve1(1); else solve2(0); } else{ if (dis[1][b.x][b.y] <= dis[0][w.x][w.y] - 1) solve1(1); else if (dis[0][b.x][b.y] >= dis[0][w.x][w.y] + 1) solve1(0); else solve2(1); } }

4124c5345e8a6ec926ab833d98f8751950197b2f

87f50d20d4780dcede0b9ac13109ab104bc75449

/Ch 3 Paradigms/uva-11057.cpp

3c7c2f55adcb09afd0f71f41e438055d75b72587

[ "MIT" ]

permissive

sladewinter/CompetitveProgramming

7721da680a1826ae04c69747abef04b95aacef68

3e8003e8ae5452eed1468be44ae5d7bbcc763dd1

refs/heads/master

2022-11-08T12:52:27.628385

2020-06-19T05:28:59

255,092,073

0

null

UTF-8

C++

false

706

cpp

uva-11057.cpp

//UVa - 11057 - Exact Sum #include <iostream> #include <algorithm> using namespace std; int main() { int book[10000]; int N, M; while( scanf( "%d", &N ) != EOF ) { for( int i{0}; i < N; ++i ) scanf( "%d", &book[i] ); scanf( "%d", &M ); sort( book, book + N ); int beg{ 0 }; int end{ N - 1 }; pair<int ,int> books; while( beg < end ) { if( book[beg] + book[end] == M ) { books.first = book[beg]; books.second = book[end]; ++beg; --end; } else if( book[beg] + book[end] < M ) ++beg; else --end; } printf("Peter should buy books whose prices are %d and %d.\n\n", books.first, books.second); } return 0; }

b055d6e055f682615e3c3c93b0c0b6f1007736fc

95a43c10c75b16595c30bdf6db4a1c2af2e4765d

/codecrawler/_code/hdu2066/8646006.cpp

d802c26ef9f6a4b0abaa1709e2dd422e0552d2b6

[]

no_license

kunhuicho/crawl-tools

945e8c40261dfa51fb13088163f0a7bece85fc9d

8eb8c4192d39919c64b84e0a817c65da0effad2d

refs/heads/master

2021-01-21T01:05:54.638395

2016-08-28T17:01:37

null

0

null

UTF-8

C++

false

1,487

cpp

8646006.cpp

#include <queue> #include <cstdio> #include <cstring> #define N 1005 #define INF 0x7f7f7f7f using namespace std; int map[N][N]; int start[N]; int end[N]; int d[N]; int used[N]; int MAX; int T,S,D; int SPEA() { int i, u, min; for(i=0; i<=MAX; i++) d[i] = INF; queue<int> q; for(i=0; i<S; i++) { d[start[i]] = 0; q.push(start[i]); used[start[i] ] =1; } while(!q.empty()) { u = q.front(); q.pop(); used[u] = 0; for(i=0; i<=MAX; i++) { if(d[i] > d[u] + map[u][i]) { d[i] = d[u] + map[u][i]; if(!used[i]) { q.push(i); used[i] = 1; } } } } min = INF; for(i=0; i<D; i++) if(min>d[end[i]]) min = d[end[i]]; return min; } int main() { int i, j, a, b, len; while(~scanf("%d%d%d",&T,&S,&D)) { memset(map,INF,sizeof(map)); MAX = 0; for(i=0; i<T; i++) { scanf("%d%d%d",&a,&b,&len); if(len<map[a][b]) { map[a][b] = map[b][a] = len; } if(MAX<a) MAX = a; if(MAX<b) MAX = b; } for(i=0; i<S; i++) { scanf("%d",&start[i]); } for(i=0; i<D; i++) { scanf("%d",&end[i]); } printf("%d\n", SPEA()); } return 0; }

fc76e310795a0da9ac7bef25437c774828cc6aa6

819c996d03a7db4de3507e05b326988b19befe28

/Apocalypse 2.0.0/Apocalypse/ItemsArray.h

0e7c0620503b300fa67d5b033cda0800b7b67144

[]

no_license

GenoMainiero/Apocalypse

efaf0e19be324407218ac2d64249611e2f2bb6bd

8745fcf602f528fc53b4b3ef52483e1950a4af06

refs/heads/master

2022-03-08T15:47:43.722037

2019-10-30T15:13:08

217,333,001

0

null

UTF-8

C++

false

594

h

ItemsArray.h

#pragma once #ifndef ITEMS_ARRAY #define ITEMS_ARRAY #include <string> using namespace std; class Item { private: string name; bool possess; bool possessRoom; int count; public: Item() { name = "dummy item"; possess = 0; count = 0; } Item(string na, bool po, int c) { name = na; possess = po; count = c; } void setName(string na) { name = na; } string getName() { return name; } void setPossess(bool po) { possess = po; } bool getPossess() { return possess; } void setCount(int co) { count = co; } int getCount() { return count; } }; #endif

bf6d46441027643a2296045fb58d08763f297767

8812cddcaa19671817e2b9cc179d3f41f6c620b2

/Trunk/Client/src/Engine/Include/Engine/NavPathFinder.h

01e850fee132e18554b8041164a3512e8218127e

[]

no_license

Hengle/airengine

7e6956a8a649ef0ca07fcf892c55ae2451ce993c

2f5fbfbfe83eb3f2d1d44af4401b3a48ae75cb24

refs/heads/master

2023-03-17T00:17:33.284538

2020-02-04T03:25:48

null

0

null

GB18030

C++

false

3,810

h

NavPathFinder.h

// *************************************************************** // 文件: NavPathFinder.h // 日期: 2010-7-6 // 作者: huangjunjie // 说明: // *************************************************************** #pragma once #ifndef __NavPathFinder_H__ #define __NavPathFinder_H__ #include "Navigater.h" #include "MemoryAlloter.h" #include "MemoryAllocatorConfig.h" #define CHILD_COUNT 3 // 导航网格三角形 class NavTriangle { public: NavTriangle( void ) : m_byAttrib(0), m_dwID(-1) {} NavTriangle( const Triangle3Df& tri, u8 attrib, u32 id ) : m_Triangle(tri), m_byAttrib(attrib), m_dwID(id) {} NavTriangle( const NavTriangle& other ) : m_Triangle(other.m_Triangle), m_byAttrib(other.m_byAttrib), m_dwID(other.m_dwID) {} void operator = (const NavTriangle& other) { m_Triangle = other.m_Triangle; m_byAttrib = other.m_byAttrib; m_dwID = other.m_dwID; } bool operator == (const NavTriangle& other) { return (m_Triangle == other.m_Triangle && m_byAttrib == other.m_byAttrib && m_dwID == other.m_dwID); } //bool operator < (const NavTriangle& other) //{ // CCamera* pCamera = ENGINE_INST->GetSceneMgr()->GetCamera(); // return (m_Triangle.GetCenterOfTriangle() - pCamera->GetPosition()).GetLength() < (other.m_Triangle.GetCenterOfTriangle() - pCamera->GetPosition()).GetLength(); //} public: u32 m_dwID; // id Triangle3Df m_Triangle; // 三角形信息 u8 m_byAttrib; // 0(高度以地面为准), 1(高度以导航面为准) }; // 导航面链表 class CTriangleLink { public: CTriangleLink(void) { m_TriLink[0] = -1; m_TriLink[1] = -1; m_TriLink[2] = -1; } public: int m_TriLink[3]; }; // 路径三角面链表 class CTrianglePath { public: int x; int side; }; // 路径节点 class CNode// : public EngineAllocator(CNode) { EngineAllocator(CNode) public: CNode(void) { idx = side = -1; f = g = h = 0; for (int i = 0 ; i < CHILD_COUNT; i++) { chil[i]=NULL; } parent = next = prev = NULL; } public: int idx; //该节点的标志 double f,g,h; //评估价值f = g + h int side; //边ID CNode* chil[CHILD_COUNT]; //子节点 CNode* parent; //父节点 CNode* next; //下一个节点 CNode* prev; //上一个节点 }; // 导航网格寻路器 class NavPathFinder { public: NavPathFinder( void ); NavPathFinder( const AIRVector<NavTriangle>& triangleList ); virtual ~NavPathFinder( void ); // 寻找三角面路径 const AIRVector<CTrianglePath>& FindPathOfTriangle( Vector3Df& vStart, Vector3Df& vEnd ); // 寻找顶点路径 const AIRVector<Vector3Df>& FindPathOfLine( Vector3Df& vStart, Vector3Df& vEnd ); // 清空寻路信息 bool Clear(); // 重置寻路器信息 void ResetNavPathFinder( const AIRVector<NavTriangle>& triangleList ); protected: // 获得最佳的路径节点 CNode* GetBestNode(); // 插入一个路径节点 CNode* Insert(CNode* head, CNode* node); // 移除路径节点 CNode* Remove(CNode* list, CNode* node); // 检查某个节点是否在开表 CNode* CheckInOpen(int idx); // 检查某个节点是否在闭表 CNode* CheckInClose(int idx); // A星寻路 bool AStar(int nCurr, int tar, Vector3Df& target); // 检查某个点是否在导航网格里三角形 int GetPointIn(Vector3Df& pt); // 成功找到 void Successor(int cr, int end, int side, Vector3Df& targ); // 获得H值 double GetH(int nT , Vector3Df& pt); // 获得G值 double GetG(int s, int e); // 排列 void Sort(CNode* list, CNode* node); protected: CNode * m_pOpen; CNode * m_pClose; CNode * m_pBestNode; AIRVector<NavTriangle> m_vTriangle; AIRVector<CTrianglePath> m_vTPath; AIRVector<CTriangleLink> m_nLink; AIRVector<Vector3Df> m_vtVPath; };//! end class NavPathFinder #endif //! __NavPathFinder_H__

73f3ef52d995dc89d015eac2e12521b8c10fdcd5

6fe68ff36a23f729896941d5b09f22c5760c0165

/FtcRobotController/src/main/jni/p_Block.h

fab229775f36e2194c05936037be8b385a749668

[ "BSD-3-Clause" ]

permissive

pszczeszynski/ftc_app

ba4bbde0f0a2f1bbd5c301ad861bb38c7a41db29

da2c6b29a83d141666d52da34b0aa6e52c75a0b2

refs/heads/master

2021-06-21T10:33:05.764157

2017-07-27T14:25:53

null

0

null

UTF-8

C++

false

1,586

h

p_Block.h

// // Created by Administrator on 7/20/2017. // #include <jni.h> #include <stdio.h> #include <opencv2/opencv.hpp> #ifndef FTC_2017_2018_P_BLOCK_H #define FTC_2017_2018_P_BLOCK_H //#ifdef __cplusplus //extern "C" { //#endif class p_Block { public: int x; int y; bool open = false; bool closed = false; bool invalid = false; bool horizontalOnly=false; bool verticalOnly=false; //the h_score represents a score given to each block that increases based on how //many steps away it is from the target. It is the sum of the difference in x values //and the difference in y. This way of calculating distance is known as the Manhattan method. //All values in this variable are positive. int h_score = 0; //the g_score represents a score given to parented blocks that represents how //much it will cost to move there. For example, blocks that are diagonal from //a parent block cost more than ones that are straight up or down. double g_score = 0.0; //this is a predefined movement penalty set by the field map. double pre_g_score = 0; //the sum of our g and h score double f_score = 0; //initialize ourselves by setting our x and y pos p_Block* m_parent = NULL; p_Block(int x, int y); void setTarget(int target_x, int target_y); void setParent(p_Block* parent); static double calc_g_score(p_Block* parent, p_Block* block2); bool isHorizontal(p_Block* otherBlock); bool isVertical(p_Block* otherBlock); void setObstical(bool o); }; //#ifdef __cplusplus //} //#endif #endif

ab0b506482340f35f971f1a862cc7fd382fcfc77

de40db8b5524c464a47ebfac6fceb738ad5f7ba8

/fluidSImularion/fsInd3d11/common/D3DApp.h

4c8ceffa6a456ec4f93a002a5f8d821c12792931

[]

no_license

nlsysis/fluidSimulation

400bb24701b933f8eb1742b495d38df8277f0363

f14b4e7c3865d10b486f8b92162cb5c160400129

refs/heads/master

2020-12-28T12:03:50.944679

2020-04-04T12:30:18

238,325,670

3

0

null

UTF-8

C++

false

2,666

h

D3DApp.h

#pragma once #include "d3dUtil.h" #include "GameTimer.h" #include <string> #include "Mouse.h" #include "Keyboard.h" #include "ImguiManager.h" #pragma comment(lib,"d3d11.lib") #pragma comment(lib,"d3dx11d.lib") #pragma comment(lib,"D3DCompiler.lib") class D3DApp { public: D3DApp(HINSTANCE hInstance); virtual ~D3DApp(); HINSTANCE GetAppInst()const; HWND GetMainWnd()const; float GetAspectRatio()const; //the ratio of back buffer int Run(); virtual bool Init(); virtual void OnResize(); virtual void UpdateScene(float dt) = 0; virtual void DrawScene() = 0; virtual void DrawScene(float dt) = 0; virtual LRESULT MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); /// deal with mouse input virtual void OnMouseDown(WPARAM btnState, int x, int y) { } virtual void OnMouseUp(WPARAM btnState, int x, int y) { } virtual void OnMouseMove(WPARAM btnState, int x, int y) { } enum class CameraMode { FirstPerson, ThirdPerson, Free }; protected: bool InitMainWindow(); bool InitDirect3D(); void CalculateFrameStats(); protected: HINSTANCE mhAppInst; // application instance HWND mhMainWnd; // main window handle bool mAppPaused; // whether the application stop bool mMinimized; // whether set the application minized bool mMaximized; // whether set the application max bool mResizing; // whether the application is changing the size UINT m4xMsaaQuality;// 4X MSAA quality GameTimer mTimer; //calculate the gameTime ID3D11Device* md3dDevice; ID3D11DeviceContext* md3dDeviceContext; IDXGISwapChain* mSwapChain; ID3D11Texture2D* mDepthStencilBuffer; ID3D11RenderTargetView* mRenderTargetView; ID3D11DepthStencilView* mDepthStencilView; ID3D11DepthStencilState* m_depthStencilState; ID3D11ShaderResourceView* mDepthStencilSRView; D3D11_VIEWPORT mScreenViewport; ID3D11RasterizerState* m_rasterState; XMMATRIX m_orthoMatrix; std::unique_ptr<DirectX::Mouse> m_pMouse; // mouse DirectX::Mouse::ButtonStateTracker m_MouseTracker; // mouse state tracker std::unique_ptr<DirectX::Keyboard> m_pKeyboard; // keyboard DirectX::Keyboard::KeyboardStateTracker m_KeyboardTracker; // keyboard state tracker ///The parameters can be reset or overwrited std::wstring mMainWndCaption; D3D_DRIVER_TYPE md3dDriverType; // Hardware device in D3DApp default setting is D3D_DRIVER_TYPE_HARDWARE。 /// The initial size of window. /// D3DApp the default size is `800x600`. int mClientWidth; int mClientHeight; float mScreenNear; float mScreenDepth; ///if use 4XMSAA，define false. bool mEnable4xMsaa; ImguiManager imgui; };

efe74c061403e8ef6e40c5df36a02bba3246a4d7

ac93858e79b7486c0c346a55610c2a1df07ece89

/AnoDet2012/ANOMALY_DETECTION/RBF/KMeans.cpp

29653530b289688c9fc677b445257f812e19a3db

[]

no_license

AnomalyDetection2012/AnomalyDetection2012PWR

4dea822b40c4cd39d9a4ce83a17b89839cb7a8ad

a76217401475baa5ecdf8372b35a18bd44052142

refs/heads/master

2016-09-05T17:34:29.432193

2012-12-17T23:35:41

null

0

null

UTF-8

C++

false

5,081

cpp

KMeans.cpp

#include "KMeans.h" #include "time.h" #include <vector> #include <iostream> #include <stdlib.h> #include <limits> #include <QDebug> using namespace std; KMeans::KMeans(int clustersNumber, double minSigmaSquare, double maxSigmaSquare, int pointSize, int iterations, int quantizationError, std::vector<std::vector<double> >& neighbours) : clustersNumber(clustersNumber),minSigmaSquare(minSigmaSquare),maxSigmaSquare(maxSigmaSquare),pointSize(pointSize),iterations(iterations),stepImprovement(stepImprovement), neighbours(neighbours) { } KMeans::~KMeans(void) { } void KMeans::initAlgorithm() { vector<vector<double> >::iterator neighboursIt = this->neighbours.begin(); for(int a=0; a<clustersNumber; ++a){ Cluster* newCluster = new Cluster(this->pointSize, this->minSigmaSquare, this->maxSigmaSquare); if(neighboursIt!=this->neighbours.end()) { newCluster->neighbours.push_back(&(*neighboursIt)); ++neighboursIt; } this->clusters.push_back(newCluster); } srand((unsigned)time(NULL)); for(;neighboursIt!=this->neighbours.end(); ++neighboursIt){ this->clusters.at(rand()%this->clustersNumber)->neighbours.push_back(&(*neighboursIt)); } QList<Cluster*>::iterator clustersIt; for(clustersIt=this->clusters.begin();clustersIt!=this->clusters.end();++clustersIt){ (*clustersIt)->calculateCenter(); } } void KMeans::runAlgorithm(){ double previousQuantizationError = numeric_limits<double>().max(); double currentQuantizationError=0.0; double shortestDistance=0.0; double possibleClusterDistance=0.0; Cluster* chosenCluster; QList<Cluster*>::iterator currentClusterIt; QList<Cluster*>::iterator possibleClusterIt; QList<vector<double>*>::iterator neighboursIt; for(int iteration=0; iteration<this->iterations;++iteration){ //cout<<iteration<<endl; for(currentClusterIt=this->clusters.begin();currentClusterIt!=this->clusters.end();++currentClusterIt){ for(neighboursIt=(*currentClusterIt)->neighbours.begin(); neighboursIt!=(*currentClusterIt)->neighbours.end();){ shortestDistance = (*currentClusterIt)->toCenter((*neighboursIt)); chosenCluster = (*currentClusterIt); for(possibleClusterIt=this->clusters.begin();possibleClusterIt!=this->clusters.end();++possibleClusterIt){ if(*currentClusterIt!=*possibleClusterIt){ if((possibleClusterDistance = (*possibleClusterIt)->toCenter(*neighboursIt))<shortestDistance){ shortestDistance = possibleClusterDistance; chosenCluster = (*possibleClusterIt); } } } if(chosenCluster!=(*currentClusterIt)){ //cout<<"Przeniesiono!"<<endl; chosenCluster->neighbours.push_back((*neighboursIt)); neighboursIt = (*currentClusterIt)->neighbours.erase(neighboursIt); }else{ ++neighboursIt; } } } for(currentClusterIt=this->clusters.begin();currentClusterIt!=this->clusters.end();++currentClusterIt){ (*currentClusterIt)->calculateCenter(); } currentQuantizationError = this->calculateQuantizationError(); if((previousQuantizationError-currentQuantizationError)/currentQuantizationError<stepImprovement){ break; }else{ previousQuantizationError = currentQuantizationError; } } for(currentClusterIt=this->clusters.begin();currentClusterIt!=this->clusters.end();++currentClusterIt){ (*currentClusterIt)->calculateSigmaSquare(); //cout<<(*currentClusterIt)->sigmaSquare<<endl; } } double KMeans::calculateQuantizationError(){ QList<Cluster*>::iterator clustersIt; QList<vector<double>*>::iterator neighboursIt; double qError=0.0; for(clustersIt=this->clusters.begin();clustersIt!=this->clusters.end();++clustersIt){ Cluster* curCluster = (*clustersIt); for(neighboursIt=curCluster->neighbours.begin(); neighboursIt!=curCluster->neighbours.end(); ++neighboursIt){ qError+=curCluster->toCenter(*neighboursIt); } } return qError; } void KMeans::drawClusters(){ QList<Cluster*>::iterator clIt; QList<vector<double>*>::iterator ngbrIt; int tab[100][100]; for(int a=0;a<100;++a){ for(int b=0;b<100;++b){ tab[a][b]=0; } } for(clIt = this->clusters.begin();clIt!=this->clusters.end();++clIt){ Cluster* cluster = *clIt; tab[(int)(cluster->center[0]*100)][(int)(cluster->center[1]*100)] = 1; for(ngbrIt=cluster->neighbours.begin();ngbrIt!=cluster->neighbours.end();++ngbrIt){ vector<double>* ngbr = *ngbrIt; tab[(int)(ngbr->at(0)*100)][(int)(ngbr->at(1)*100)] = 2; } } for(int a=0;a<100;++a){ for(int b=0;b<100;++b){ if(tab[a][b]==0){ cout<<"-"; }else if(tab[a][b]==1){ cout<<"C"; }else if(tab[a][b]==2){ cout<<"s"; } } cout<<endl; } } void KMeans::printClustersParams(){ QList<Cluster*>::iterator clustersIt; vector<double>::iterator it; for(clustersIt = this->clusters.begin(); clustersIt!=this->clusters.end(); ++clustersIt){ cout<<"sigmaSquare: "<<(*clustersIt)->sigmaSquare<<", center:"; for(it=(*clustersIt)->center.begin(); it!=(*clustersIt)->center.end();++it){ cout<<*it<<", "; } cout<<"neighbours: "<<(*clustersIt)->neighbours.size()<<endl; } }

27ef8b2bfc35e9ef6fb05e7d7454b803a941241b

7ed3b54477d480ee96fbb17894ef43a067459c03

/TestIO_Siemens/TestIO_Siemens.ino

2b2853b1976996a95ff58d7accd64078d4a978bb

[]

no_license

alismont/TestIO_Siemens

d93d3312360f164d096f1b25309912221249f357

57c5a2d0eca2098a16405f0e0c6ec27966664e27

refs/heads/master

2021-04-29T21:16:36.641589

2018-03-06T20:49:41

121,611,370

0

null

UTF-8

C++

false

8,012

ino

TestIO_Siemens.ino

/* 15-02-18 Projet Test I/O * Auteurs: Brahim Boujamaoui */ /*========= Virtuino General methods ============================================================================================================================== * void vDigitalMemoryWrite(int digitalMemoryIndex, int value) write a value to a Virtuino digital memory (digitalMemoryIndex=0..31, value range = 0 or 1) * int vDigitalMemoryRead(int digitalMemoryIndex) read the value of a Virtuino digital memory (digitalMemoryIndex=0..31, returned value range = 0 or 1) * void vMemoryWrite(int memoryIndex, float value); write a value to Virtuino memory (memoryIndex=0..31, value range as float value) * float vMemoryRead(int memoryIndex); read a value of Virtuino memory (memoryIndex=0..31, returned a float value * run(); neccesary command to communicate with Virtuino android app (on start of void loop) * int getPinValue(int pin); read the value of a Pin. Usefull to read the value of a PWM pin * long lastCommunicationTime; Stores the last communication with Virtuino time * void vDelay(long milliseconds); ================================================================================================================================================================*/ #include <WiFi.h> #include "Virtuino_ESP_WifiServer.h" //========== SETTING SI UTILISATION DU RESEAU BBOX ================== const char* ssid = "bbox2-5de4"; // WIFI network SSID const char* password = "ARLARLARL"; // WIFI network PASSWORD WiFiServer server(8000); // Server port //==================================================================== Virtuino_ESP_WifiServer virtuino(&server); //================= VARIABLE ========================================= int Index_Panel=0,Memo_Index_Panel=0; // 0=Menu 1=Panel_IO1....etc int Input[3]; // contient l'index de chaque cartes entrées ici 2 boolean IN1[7]; // Etat des bits 0-7 de la 1er carte d'entrée boolean IN2[7]; // Etat des bits 0-7 de la 2er carte d'entrée int Input1Valid[7],Input2Valid[7]; //==================================================================== void connectToWiFiNetwork(){ Serial.println("Connecting to "+String(ssid)); // If you don't want to config IP manually disable the next four lines IPAddress ip(192, 168, 1, 50); // where 150 is the desired IP Address IPAddress gateway(192, 168, 1, 1); // set gateway to match your network IPAddress subnet(255, 255, 255, 0); // set subnet mask to match your network WiFi.config(ip, gateway, subnet); // If you don't want to config IP manually disable this line WiFi.mode(WIFI_STA); // Config module as station only. WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); Serial.println(WiFi.localIP()); } //================================================================= void initAccessPoint(){ Serial.print("Setting soft-AP ... "); // Default IP: 192.168.4.1 WiFi.mode(WIFI_AP); // Config module as Access point only. Set WiFi.mode(WIFI_AP_STA); to config module as Acces point and station boolean result = WiFi.softAP("Virtuino Network", "12345678"); // SSID: Virtuino Network Password:12345678 if(result == true) { Serial.println("Server Ready"); Serial.println(WiFi.softAPIP()); } else Serial.println("Failed!"); } //+++++++++++++++++++ SEUP ++++++++++++++++++++++++++++++++++++++++++ void setup() { //----- Virtuino settings virtuino.DEBUG=false; // set this value TRUE to enable the serial monitor status virtuino.password=""; // Set a password or prefix to your web server for more protection // avoid special characters like ! $ = @ # % & * on your password. Use only numbers or text characters Serial.begin(9600); // connectToWiFiNetwork(); initAccessPoint(); server.begin(); } //++++++++++++++++++ LOOP ++++++++++++++++++++++++++++++++++++++++++ void loop() { virtuino.run(); //----------------------- // Lecture fichier Index INPUT OUPUT // A Faire -> Tableau Input[i]; Input[1]=0; Input[2]=6; //----------------------- // Lecture Index Panel //0=Menu Index_Panel=virtuino.vMemoryRead(0); //Menu if(Index_Panel==0){ virtuino.vMemoryWrite(1, Input[1]); // 1er carte INPUT 0-7 bits V1= index 1ere carte ENTREE virtuino.vMemoryWrite(2, Input[2]); // 1er carte INPUT 0-7 bits V2= index 2ere carte ENTREE } //2em Panel traitement 1er carte d'entrée if(Index_Panel==1){ virtuino.vMemoryWrite(1, Input[1]); // 1er carte INPUT 0-7 bits V1= index 1ere carte ENTREE //Ecriture de l ETAT des tests pour cet Index, précédent if (Memo_Index_Panel!=Index_Panel){ virtuino.vMemoryWrite(10,Input1Valid[0]); virtuino.vMemoryWrite(11,Input1Valid[1]); virtuino.vMemoryWrite(12,Input1Valid[2]); virtuino.vMemoryWrite(13,Input1Valid[3]); virtuino.vMemoryWrite(14,Input1Valid[4]); virtuino.vMemoryWrite(15,Input1Valid[5]); virtuino.vMemoryWrite(16,Input1Valid[6]); virtuino.vMemoryWrite(17,Input1Valid[7]); Memo_Index_Panel=Index_Panel; } // visualisation état bits 0-7 I index DV0 à DV7 virtuino.vDigitalMemoryWrite(0,IN1[0]); virtuino.vDigitalMemoryWrite(1,IN1[1]); virtuino.vDigitalMemoryWrite(2,IN1[2]); virtuino.vDigitalMemoryWrite(3,IN1[3]); virtuino.vDigitalMemoryWrite(4,IN1[4]); virtuino.vDigitalMemoryWrite(5,IN1[5]); virtuino.vDigitalMemoryWrite(6,IN1[6]); virtuino.vDigitalMemoryWrite(7,IN1[7]); //Validation if (virtuino.vDigitalMemoryRead(8)){ Input1Valid[0] = virtuino.vMemoryRead(10); Input1Valid[1] = virtuino.vMemoryRead(11); Input1Valid[2] = virtuino.vMemoryRead(12); Input1Valid[3] = virtuino.vMemoryRead(13); Input1Valid[4] = virtuino.vMemoryRead(14); Input1Valid[5] = virtuino.vMemoryRead(15); Input1Valid[6] = virtuino.vMemoryRead(16); Input1Valid[7] = virtuino.vMemoryRead(17); virtuino.vDigitalMemoryWrite(8,0); } } //3em Panel traitement 1er carte d'entrée // visualisation état bits 0-7 I index DV0 à DV7 if(Index_Panel==2){ virtuino.vMemoryWrite(2, Input[2]); // 1er carte INPUT 0-7 bits V2= index 2ere carte ENTREE //Ecriture de l ETAT des tests pour cet Index, précédent if (Memo_Index_Panel!=Index_Panel){ virtuino.vMemoryWrite(10,Input2Valid[0]); virtuino.vMemoryWrite(11,Input2Valid[1]); virtuino.vMemoryWrite(12,Input2Valid[2]); virtuino.vMemoryWrite(13,Input2Valid[3]); virtuino.vMemoryWrite(14,Input2Valid[4]); virtuino.vMemoryWrite(15,Input2Valid[5]); virtuino.vMemoryWrite(16,Input2Valid[6]); virtuino.vMemoryWrite(17,Input2Valid[7]); Memo_Index_Panel=Index_Panel; } virtuino.vDigitalMemoryWrite(0,IN2[0]); virtuino.vDigitalMemoryWrite(1,IN2[1]); virtuino.vDigitalMemoryWrite(2,IN2[2]); virtuino.vDigitalMemoryWrite(3,IN2[3]); virtuino.vDigitalMemoryWrite(4,IN2[4]); virtuino.vDigitalMemoryWrite(5,IN2[5]); virtuino.vDigitalMemoryWrite(6,IN2[6]); virtuino.vDigitalMemoryWrite(7,IN2[7]); if (virtuino.vDigitalMemoryRead(8)){ Input2Valid[0] = virtuino.vMemoryRead(10); Input2Valid[0] = virtuino.vMemoryRead(11); Input2Valid[0] = virtuino.vMemoryRead(12); Input2Valid[0] = virtuino.vMemoryRead(13); Input2Valid[0] = virtuino.vMemoryRead(14); Input2Valid[0] = virtuino.vMemoryRead(15); Input2Valid[0] = virtuino.vMemoryRead(16); Input2Valid[0] = virtuino.vMemoryRead(17); virtuino.vDigitalMemoryWrite(8,0); } } //------ avoid to use delay() function in your code virtuino.vDelay(1000); // wait 5 seconds delay(100); }

651dc097b96e687a2c0696c02f547aa1725b6843

806410cc83acebed719e5804232821bc83a87f01

/source/library/render/public/potato/render/shader.h

4724a184c56649fb018303425b4eb99aef86cb41

[ "MIT" ]

permissive

blockspacer/potato

e4d37969b791f434826114721455d8dbb642d361

a52f9712e5251412e14406c54927ab9984ec6f0e

refs/heads/master

2020-07-05T19:02:41.665477

2019-07-19T03:15:09

null

0

null

UTF-8

C++

false

530

h

shader.h

// Copyright (C) 2019 Sean Middleditch, all rights reserverd. #pragma once #include "potato/foundation/rc.h" #include "potato/foundation/vector.h" #include "potato/foundation/int_types.h" namespace up { class RenderContext; class Shader : public shared<Shader> { public: explicit Shader(vector<byte> shader) : _content(std::move(shader)) {} ~Shader() = default; view<byte> content() const noexcept { return _content; } private: vector<byte> _content; }; } // namespace up

cc977aa4994f5f71c2b9ffe4f025efa049bda82e

06ae40ff7b1de99c2d84d1f22d34d03c1d7c9079

/src/transforms/rdft.cc

febe6c82acaa4be255cf3238c28be47e0f6939ca

[ "Apache-2.0" ]

permissive

zyh329/veles.sound_feature_extraction

4270696885613b582e896bf652e1fe0a46704f2c

56b7c5d3816d092c72a874ca236e889fe843e6cd

refs/heads/master

2021-01-18T10:23:00.173800

2015-08-10T08:27:49

null

0

null

UTF-8

C++

false

3,485

cc

rdft.cc

/*! @file rdft.cc * @brief Discrete Fourier Transform using FFT. * @author Markovtsev Vadim <v.markovtsev@samsung.com> * @version 1.0 * * @section Notes * This code partially conforms to <a href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google C++ Style Guide</a>. * * @section Copyright * Copyright © 2013 Samsung R&D Institute Russia * * @section License * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 "src/transforms/rdft.h" #include <vector> #include <fftf/api.h> #include <simd/arithmetic-inl.h> namespace sound_feature_extraction { namespace transforms { size_t RDFT::OnFormatChanged(size_t buffersCount) { output_format_->SetSize(input_format_->Size() + 2); return buffersCount; } size_t RDFTInverse::OnFormatChanged(size_t buffersCount) { output_format_->SetSize(input_format_->Size() - 2); return buffersCount; } void RDFT::Do(const BuffersBase<float*>& in, BuffersBase<float*>* out) const noexcept { int length = input_format_->Size(); std::vector<const float*> inputs(in.Count()); std::vector<float*> outputs(in.Count()); for (size_t i = 0; i < in.Count(); i++) { inputs[i] = in[i]; outputs[i] = (*out)[i]; } fftf_set_backend(FFTF_BACKEND_NONE); fftf_ensure_is_supported(FFTF_TYPE_REAL, input_format_->Size()); auto fft_plan = std::unique_ptr<FFTFInstance, void (*)(FFTFInstance *)>( fftf_init_batch( FFTF_TYPE_REAL, FFTF_DIRECTION_FORWARD, FFTF_DIMENSION_1D, &length, FFTF_NO_OPTIONS, in.Count(), &inputs[0], &outputs[0]), fftf_destroy); fftf_calc(fft_plan.get()); } void RDFTInverse::Do(const BuffersBase<float*>& in, BuffersBase<float*>* out) const noexcept { int length = output_format_->Size(); std::vector<const float*> inputs(in.Count()); std::vector<float*> outputs(in.Count()); for (size_t i = 0; i < in.Count(); i++) { inputs[i] = in[i]; outputs[i] = (*out)[i]; } fftf_set_backend(FFTF_BACKEND_NONE); fftf_ensure_is_supported(FFTF_TYPE_REAL, output_format_->Size()); auto fft_plan = std::unique_ptr<FFTFInstance, void (*)(FFTFInstance *)>( fftf_init_batch( FFTF_TYPE_REAL, FFTF_DIRECTION_BACKWARD, FFTF_DIMENSION_1D, &length, FFTF_NO_OPTIONS, in.Count(), &inputs[0], &outputs[0]), fftf_destroy); fftf_calc(fft_plan.get()); for (size_t i = 0; i < in.Count(); i++) { real_multiply_scalar(outputs[i], length, 1.0f / length, outputs[i]); } } REGISTER_TRANSFORM(RDFT); REGISTER_TRANSFORM(RDFTInverse); } // namespace transforms } // namespace sound_feature_extraction

0ff81be4244ecbf119a9a05a9d0037293c662dd8

0141a8f26284dbfd824d9b054a899f6b6d7510eb

/abc/abc/100-150/abc112/a.cpp

018fa0f8ce0fd698e49c1556e67d73b36ec5e557

[]

no_license

yunotama/atcoder

2da758f479da6aaaa17c88f13995e42554cb0701

ddb16580416d04abaa6c4d543dc82a62706d283a

refs/heads/master

2021-03-15T06:20:52.038947

2020-03-12T13:19:34

246,830,843

0

null

2020-03-12T13:19:36

2020-03-12T12:39:16

null

UTF-8

C++

false

627

cpp

a.cpp

#include <bits/stdc++.h> #define rep(i, n) for (int i = 0; i < n; i++) #define ll long long using namespace std; int main() { int n; cin >> n; vector<int> a(3); rep(i,n){ string str; cin >> setw(3) >> str; if(str =="SET"){ int x, y; cin >> x >> y; a[x] = y; }else if (str == "ADD"){ int x; cin >> x; a[2] = a[1] + x; }else if (str == "SUB"){ int x; cin >> x; a[2] = a[1] - x; } } cout << a[1] << ' ' << a[2] << endl; }

3d158531e7db27c774440b2a829d0dc16a4b3fc0

74ba533508217abba7de9c7094d6f987f20536c1

/pcl_try/src/pcl_test/src/pcl_test_core.h

4d28fe7aea8ba97b0e8bac979b1f9e9efefdfdbc

[]

no_license

Wingooo/piontcloud

3a63c3ab0e2dfa8e6da75292d795835e84bd5bfe

8b923646e5cee052e70809bb9417020d87d7aec5

refs/heads/master

2022-11-29T19:09:58.257012

2020-07-31T02:32:32

283,922,996

0

null

UTF-8

C++

false

1,378

h

pcl_test_core.h

#pragma once #include <pcl/ModelCoefficients.h> #include <ros/ros.h> #include <pcl_conversions/pcl_conversions.h> #include <pcl/point_types.h> #include <pcl/conversions.h> #include <pcl_ros/transforms.h> #include <std_msgs/Float64MultiArray.h> //点云下采样 #include <pcl/filters/voxel_grid.h> #include <pcl/filters/extract_indices.h> #include <sensor_msgs/PointCloud2.h> #include <pcl/kdtree/kdtree.h> #include <pcl/segmentation/extract_clusters.h> #include <pcl/surface/convex_hull.h> #include <Eigen/Core> #include <boost/thread/thread.hpp> #include <pcl/features/moment_of_inertia_estimation.h> #include <message_filters/subscriber.h> #include <message_filters/synchronizer.h> #include <message_filters/sync_policies/approximate_time.h> #include <sensor_msgs/NavSatFix.h> class PclTestCore { private: ros::Subscriber sub_point_cloud_; ros::Publisher pub_filtered_points_; ros::Publisher pub_filtered_vis_; void point_cb(const sensor_msgs::PointCloud2ConstPtr& in_cloud); void callback(const sensor_msgs::PointCloud2ConstPtr& in_cloud,const sensor_msgs::NavSatFixConstPtr& ori_imu); void point_cluster(const pcl::PointCloud<pcl::PointXYZ>::Ptr in,const pcl::PointCloud<pcl::PointXYZ>::Ptr out); public: PclTestCore(ros::NodeHandle &nh); //构造函数 ~PclTestCore(); //析构函数 void Spin(); };

548b3243f0f07ec3df4cd2a1552d5fd78f5479d1

e8275bb8ab22eb928c9b15b55bde86e301134cca

/과제전/과제전/Ghost.cpp

f1247db09fafcf468661fd7a14c3c28c4806a348

[]

no_license

sohyunie/StyudyByMyself

6699033912c43400334e2ef55f989cd43722abce

f6aeb0b5f4d5469f6cdeae0b777fba0fc4b6894c

refs/heads/main

2023-04-27T02:49:57.105025

2021-05-15T19:34:21

329,078,479

0

null

UHC

C++

false

3,856

cpp

Ghost.cpp

#include "Standard.h" #include "Ghost.h" #include "InGameManager.h" default_random_engine dreColor((size_t)time(NULL)); normal_distribution <float>uidColor{ 0.0,1.0 }; uniform_int_distribution <int>uidDirection{ 0,3 }; // 생성자 // 헤더랑 따로 한 이유: 헤더에서는 이 클래스가 어떤 역할 하는지 보기 쉽게 만드는 거고 잡다한게 써있으면 복잡하니까 정의들은 cpp에다가 풀어놓는다. Ghost::Ghost() { this->type = ObjectType::GHOST; } Ghost::Ghost(int i, int j, Vector3 pos, int id) { this->id; this->type = ObjectType::GHOST; this->position = pos; this->board_i = i; this->board_j = j; this->scale = Vector3(0.5,0.5,0.5); this->rotate = Vector3(0.0, 1.0, 0.0); this->color = glm::vec3(uidColor(dreColor), uidColor(dreColor), uidColor(dreColor)); this->newDirection = (DIRECTION)uidDirection(dreColor); this->boundingOffset = 1.5; } void Ghost::SetRandomDirection() { this->newDirection = (DIRECTION)uidDirection(dreColor); } void Ghost::DrawObject(GLuint s_program) { if (this->isActive == false) return; glm::mat4 STR = glm::mat4(1.0f); //--- transformation matrix glm::mat4 R = glm::mat4(1.0f); //--- rotation matrix glm::mat4 T = glm::mat4(1.0f); //--- transformation matrix glm::mat4 S = glm::mat4(1.0f); //--- rotation matrix T = glm::translate(T, this->position.GetGlmVec3(-2)); //--- x축으로 translation R = glm::rotate(R, glm::radians(rotateAngle+=10), this->rotate.GetGlmVec3()); //--- z축에대하여 회전 S = glm::scale(glm::mat4(1.0f), this->scale.GetGlmVec3()); STR = T * S * R; //--- 합성 변환 행렬: translate -> rotate Vector3 lightColor = InGameManager::GetInstance().GetLightColor(); glm::vec3 cameraPos = InGameManager::GetInstance().GetCameraPos(); glm::vec3 cameraDirection = InGameManager::GetInstance().GetCameraDirection(); glm::vec3 cameraUp = InGameManager::GetInstance().GetCameraUp(); glm::mat4 view = glm::lookAt(glm::vec3(cameraPos), cameraDirection, cameraUp); glm::mat4 proj = glm::perspective(glm::radians(60.0f), WINDOW_WITDH / (float)WINDOW_HEIGHT, 0.001f, 1000.f); unsigned int modelLocation = glGetUniformLocation(s_program, "g_modelTransform"); //--- 버텍스 세이더에서모델 변환 위치 가져오기 glUniformMatrix4fv(modelLocation, 1, GL_FALSE, glm::value_ptr(STR)); //--- modelTransform 변수에 변환 값 적용하기 unsigned int viewLocation = glGetUniformLocation(s_program, "g_view"); // 버텍스 사이에서 viewTransform 변수위치 glUniformMatrix4fv(viewLocation, 1, GL_FALSE, glm::value_ptr(view)); // viewTransform 변수에 변환값 적용하기 unsigned int projectionLocation = glGetUniformLocation(s_program, "g_projection"); glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, glm::value_ptr(proj)); int lightPosLocation = glGetUniformLocation(s_program, "g_lightPos"); //--- lightPos 값 전달: (0.0, 0.0, 5.0); glUniform3f(lightPosLocation, lightPos.x, lightPos.y, lightPos.z); int lightColorLocation = glGetUniformLocation(s_program, "g_lightColor"); //--- lightColor 값 전달: (1.0, 1.0, 1.0) 백색 glUniform3f(lightColorLocation, lightColor.x, lightColor.y, lightColor.z); int objColorLocation = glGetUniformLocation(s_program, "g_objectColor"); //--- object Color값 전달: (1.0, 0.5, 0.3)의 색 glUniform3f(objColorLocation, this->color.x, this->color.y, this->color.z); int ViewLocation = glGetUniformLocation(s_program, "g_cameraPos"); glUniform3f(ViewLocation, cameraPos.x, cameraPos.y, cameraPos.z); unsigned int flaglocation = glGetUniformLocation(s_program, "flag"); glUniform1i(flaglocation, 0); // 사용할 VAO 불러오기 glBindVertexArray(InGameManager::GetInstance().GetVAO(this->type)); // 삼각형 그리기 glDrawElements(GL_TRIANGLES, InGameManager::GetInstance().GetObjData(this->type)->indexCount, GL_UNSIGNED_INT, 0); }

74dfd853c72cb57cd5996425eb926c88587cf2c3

e8973643f21585593ef487e52420d221c5ebfa01

/src/test.cc

a8cc0d57515a8d3cc9b091e6add39cae68e4afbc

[]

no_license

AShocke/TicTacToeNM

1cbfd3c8d1900bdd41a5a808fde2d63bcd0e37b8

28ffdcd40670a2e6755cf461de4b274c9bc605de

refs/heads/master

2021-09-13T18:19:38.965151

2018-05-02T21:50:07

null

0

null

UTF-8

C++

false

348

cc

test.cc

#include <iostream> #include "logic.h" #include "minimax.h" int main() { Logic l(3, 3, 3); l.play(1, 1, 2); l.play(0, 2, 1); l.play(2, 0, 1); l.play(0, 1, 1); l.play(1, 2, 1); l.play(0, 0, 1); l.print(); //Minimax m(l, 2, 5); //m.play(l); //m.print_tree(); l.print(); std::cout << l.is_game_over() << " " << l.n_in_a_row(1) << "\n"; }

4a70a8a52cf19716d8f2232c3f362b98e3f63bf0

f81083f27b792a6936c11a2ee74282290200b316

/lib/pdm/Matrices.cpp

8c7f6bbe60c4263808df57ce2c34e0b97ad0c0e1

[]

no_license

chhuang66/csPDM

056ab2b636ada4823712ba5dcf57e2c4bd76920f

3449502b420d28bab3c909d26a4a7bed60f205da

refs/heads/master

2020-04-08T10:18:27.394103

2018-11-29T07:05:25

159,263,334

0

null

UTF-8

C++

false

1,985

cpp

Matrices.cpp

/////////////////////////////////////////////////////////////////////////////// // Matrice.cpp // =========== // NxN Matrix Math classes // // The elements of the matrix are stored as column major order. // | 0 2 | | 0 3 6 | | 0 4 8 12 | // | 1 3 | | 1 4 7 | | 1 5 9 13 | // | 2 5 8 | | 2 6 10 14 | // | 3 7 11 15 | // // AUTHOR: Song Ho Ahn (song.ahn@gmail.com) // CREATED: 2005-06-24 // UPDATED: 2014-09-21 // // Copyright (C) 2005 Song Ho Ahn /////////////////////////////////////////////////////////////////////////////// #include <cmath> #include <algorithm> #include "Matrices.h" const double DEG2RAD = 3.141593f / 180; const double EPSILON = 0.00001f; /////////////////////////////////////////////////////////////////////////////// // transpose 2x2 matrix /////////////////////////////////////////////////////////////////////////////// Matrix2& Matrix2::transpose() { std::swap(m[1], m[2]); return *this; } /////////////////////////////////////////////////////////////////////////////// // return the determinant of 2x2 matrix /////////////////////////////////////////////////////////////////////////////// double Matrix2::getDeterminant() { return m[0] * m[3] - m[1] * m[2]; } /////////////////////////////////////////////////////////////////////////////// // inverse of 2x2 matrix // If cannot find inverse, set identity matrix /////////////////////////////////////////////////////////////////////////////// Matrix2& Matrix2::invert() { double determinant = getDeterminant(); if(fabs(determinant) <= EPSILON) { return identity(); } double tmp = m[0]; // copy the first element double invDeterminant = 1.0f / determinant; m[0] = invDeterminant * m[3]; m[1] = -invDeterminant * m[1]; m[2] = -invDeterminant * m[2]; m[3] = invDeterminant * tmp; return *this; }

d50698601cb6ce913abb0dbd48f22c4285d0533e

786de89be635eb21295070a6a3452f3a7fe6712c

/pypdsdata/tags/V01-01-03/pyext/types/usdusb/DataV1.cpp

3a3d92adc46d8f6bbdee8ecf31a85ef8c655d7ee

[]

no_license

connectthefuture/psdmrepo

85267cfe8d54564f99e17035efe931077c8f7a37

f32870a987a7493e7bf0f0a5c1712a5a030ef199

refs/heads/master

2021-01-13T03:26:35.494026

2015-09-03T22:22:11

null

0

null

UTF-8

C++

false

3,063

cpp

DataV1.cpp

//-------------------------------------------------------------------------- // File and Version Information: // $Id$ // // Description: // Class UsdUsb_DataV1... // // Author List: // Andrei Salnikov // //------------------------------------------------------------------------ //----------------------- // This Class's Header -- //----------------------- #include "DataV1.h" //----------------- // C/C++ Headers -- //----------------- #include <sstream> //------------------------------- // Collaborating Class Headers -- //------------------------------- #include "../../EnumType.h" #include "../../Exception.h" #include "../TypeLib.h" //----------------------------------------------------------------------- // Local Macros, Typedefs, Structures, Unions and Forward Declarations -- //----------------------------------------------------------------------- namespace { // list of enums pypdsdata::TypeLib::EnumEntry enums[] = { { "Encoder_Inputs", Pds::UsdUsb::DataV1::Encoder_Inputs }, { "Analog_Inputs", Pds::UsdUsb::DataV1::Analog_Inputs }, { "Digital_Inputs", Pds::UsdUsb::DataV1::Digital_Inputs }, { 0, 0 } }; // methods FUN0_WRAPPER(pypdsdata::UsdUsb::DataV1, digital_in) FUN0_WRAPPER(pypdsdata::UsdUsb::DataV1, timestamp) FUN0_WRAPPER(pypdsdata::UsdUsb::DataV1, status) FUN0_WRAPPER(pypdsdata::UsdUsb::DataV1, encoder_count) FUN0_WRAPPER(pypdsdata::UsdUsb::DataV1, analog_in) PyMethodDef methods[] = { {"digital_in", digital_in, METH_NOARGS, "self.digital_in() -> int\n\nReturns integer number" }, {"timestamp", timestamp, METH_NOARGS, "self.timestamp() -> int\n\nReturns integer number" }, {"status", status, METH_NOARGS, "self.status() -> list of ints\n\nReturns list of integers" }, {"encoder_count", encoder_count, METH_NOARGS, "self.encoder_count() -> list of ints\n\nReturns list of Encoder_Inputs numbers" }, {"analog_in", analog_in, METH_NOARGS, "self.analog_in() -> list of ints\n\nReturns list of Analog_Inputs numbers" }, {0, 0, 0, 0} }; char typedoc[] = "Python class wrapping C++ Pds::UsdUsb::DataV1 class."; } // ---------------------------------------- // -- Public Function Member Definitions -- // ---------------------------------------- void pypdsdata::UsdUsb::DataV1::initType( PyObject* module ) { PyTypeObject* type = BaseType::typeObject() ; type->tp_doc = ::typedoc; type->tp_methods = ::methods; // define class attributes for enums PyObject* tp_dict = PyDict_New(); pypdsdata::TypeLib::DefineEnums( tp_dict, ::enums ); type->tp_dict = tp_dict; BaseType::initType( "DataV1", module ); } void pypdsdata::UsdUsb::DataV1::print(std::ostream& str) const { str << "usdusb.DataV1(encoder_count=" << m_obj->encoder_count() << ", analog_in=" << m_obj->analog_in() << ", digital_in=" << m_obj->digital_in() << ", timestamp=" << m_obj->timestamp() << ", status=" << m_obj->status() << ")" ; }

af077856d5681bba536db0b1675b76bf93fef1da

71d566418edc633bae8136443ba1a288607d83a2

/TicTacToeAcceptor.h

7d163277b26be756ce33c3aa8582518ca941e8a2

[]

no_license

JusticeShurup/TicTacToe_server

a8881993ffca55d024ae1738292deb1d11d6d85c

b0e608dcc4e4d3f525efbde82ccaeba0281bab24

refs/heads/master

2023-08-27T13:56:40.300980

2021-09-23T13:55:58

399,817,358

0

null

UTF-8

C++

false

525

h

TicTacToeAcceptor.h

#pragma once #include "ClientHandler.h" #include <Poco/Net/StreamSocket.h> #include <Poco/Net/ServerSocket.h> #include <Poco/Net/SocketReactor.h> #include <Poco/Net/SocketAcceptor.h> class Server; class TicTacToeAcceptor : public Poco::Net::SocketAcceptor<ClientHandler> { public: TicTacToeAcceptor(Poco::Net::ServerSocket &server_socket, Poco::Net::SocketReactor &reactor, Server* server); protected: virtual ClientHandler* createServiceHandler(Poco::Net::StreamSocket& socket) override; private: Server* server; };

9c1d883fe073ba8df21258944cd638be4ef4349c

7c9f0adf1d3f34b6843c435b249fd4281bce29f4

/lab3/generator.cpp

3adaac885949a9a907a2874d669acd41be8c426f

[]

no_license

volkserg/PDPlabs

d1c019c0cd4514090157d7659de8e1ca31b9b6a2

53dbcf7f9109cd11bf5fd80c8afcc3bee8614fec

refs/heads/master

2022-03-21T18:51:42.751623

2019-12-12T10:05:01

206,797,996

0

null

UTF-8

C++

false

1,369

cpp

generator.cpp

#include <iostream> #include <fstream> #include <string> #include <thread> #include <vector> #include <unistd.h> using namespace std; void generator_shift(int n, unsigned long long int seed){ // unsigned long long int * res = new unsigned long long int[n]; unsigned long long int a = 2685821657736338717; unsigned long long int x = seed; // res[0] = x; for(int i=1;i<n+1;i++){ x = x ^ x >> 12; x = x ^ x << 25; x = x ^ x >> 27; cout <<seed <<" : "<< x * a << endl; } } unsigned long long int * get_seeds(int n){ ifstream devrand; devrand.open("/dev/random", ios::in | ios::binary); unsigned long long int * seed = new unsigned long long int[n]; const auto bytes_num = sizeof seed; for (int i=0;i<n;++i){ devrand.read((char *) &seed[i], bytes_num); } devrand.close(); return seed; } int main(int argc, char *argv[]) { int num = atoi(argv[1]); int th_num = atoi(argv[2]); unsigned long long int *seeds = get_seeds(th_num); cout<<"seeds:"<<endl; for(int i=0;i<th_num;++i){ cout<<seeds[i]<<endl; } vector<thread> threads; cout<<"Starting generators:"<<endl; for(int i = 0; i < th_num; ++i) { threads.push_back(thread(generator_shift, num, seeds[i])); } for (auto& th: threads){ th.join(); } }

d145689f050c0e65d0df54e8e04170c680e116ad

30bdd8ab897e056f0fb2f9937dcf2f608c1fd06a

/Codes/AC/1555.cpp

ed5af444ee4d7eafb98e28a7e8cecd887c0c0bbe

[]

no_license

thegamer1907/Code_Analysis

0a2bb97a9fb5faf01d983c223d9715eb419b7519

48079e399321b585efc8a2c6a84c25e2e7a22a61

refs/heads/master

2020-05-27T01:20:55.921937

2019-11-20T11:15:11

188,403,594

2

1

null

UTF-8

C++

false

1,257

cpp

1555.cpp

#include <algorithm> #include <cassert> #include <cmath> #include <complex> #include <cstdio> #include <cstdlib> #include <cstring> #include <ctime> #include <deque> #include <iostream> #include <map> #include <memory> #include <queue> #include <set> #include <sstream> #include <stack> #include <string> #include <unordered_map> #include <unordered_set> #include <utility> #include <vector> using namespace std; typedef long long ll; typedef pair<int, int> pii; int l[100005]; int actual[100005]; int n, maxAmt; int solve(int num) { for(int i = 0; i < n; i++) { actual[i] = min((ll)1.05e9, l[i] + (i+1LL) * num); } sort(actual, actual+n); int ret = 0; for(int i = 0; i < num; i++) { ret = min(maxAmt+1, ret + actual[i]); } return ret; } int main() { scanf("%d%d", &n, &maxAmt); for(int i = 0; i < n; i++) { scanf("%d", &l[i]); } int lhs = 0; int rhs = n; int ret = 0; while(lhs != rhs) { int mid = (lhs+rhs+1)/2; int amt = solve(mid); if(amt <= maxAmt) { lhs = mid; ret = amt; } else { rhs = mid-1; } } printf("%d %d\n", lhs, ret); }

9c49fab65f91ee6032e5b033e0a64cb4f89b9345

e34b29bf766e5458d1426ebe49aa5c7307aeb495

/src/cpp/test/integration/ClassCast.cpp

0be8018bd58d88f663a86f4a19dd32edcdee58e2

[ "MIT" ]

permissive

MichaelRFairhurst/wake-compiler

3720f02976f4ee23065a90ad34ab47bbbf393347

88239594fc8857acfc5635455d3bbc73ad062d13

refs/heads/master

2016-09-06T02:01:14.724274

2015-08-01T19:17:46

13,249,947

62

5

null

2015-05-21T19:08:52

2013-10-01T17:00:16

C++

UTF-8

C++

false

1,002

cpp

ClassCast.cpp

/************************************************** * Source Code for the Original Compiler for the * Programming Language Wake * * ClassCast.cpp * * Licensed under the MIT license * See LICENSE.TXT for details * * Author: Michael Fairhurst * Revised By: * **************************************************/ PTT_TEST_CASE( TestCastDownToInvalidClass, "every MyClass is: method() { (cast NonExist) this; }", PTT_EXPECT(CLASSNAME_NOT_FOUND) ) PTT_TEST_CASE( TestCastDownToNonSubType, "every MyClass is: method() { (cast MyClass) 5; }", PTT_EXPECT(TYPE_ERROR) ) PTT_TEST_CASE( TestCastDownValid, "every ParentClass is: \n\ every MyClass (a ParentClass) is: \n\ method(ParentClass) { \n\ method((cast ParentClass) this); \n\ }", PTT_VALID ) PTT_TEST_CASE( TestUnsafeCastInvalidAccepted, "every UnrelatedClass is: \n\ every MyClass is: \n\ method(UnrelatedClass) { \n\ method((unsafe cast UnrelatedClass) this); \n\ }", PTT_VALID )

f4a01c4d66d9e98a18a9951bae19fbcaa2af901e

a3d6556180e74af7b555f8d47d3fea55b94bcbda

/base/fuchsia/process_context.h

9e21d532240189ae7e72590c8ca0d173cb9103fc

[ "BSD-3-Clause" ]

permissive

chromium/chromium

aaa9eda10115b50b0616d2f1aed5ef35d1d779d6

a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c

refs/heads/main

2023-08-24T00:35:12.585945

2023-08-23T22:01:11

120,360,765

17,408

7,102

BSD-3-Clause

2023-09-10T23:44:27

2018-02-05T20:55:32

null

UTF-8

C++

false

1,268

h

process_context.h

// Copyright 2020 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef BASE_FUCHSIA_PROCESS_CONTEXT_H_ #define BASE_FUCHSIA_PROCESS_CONTEXT_H_ #include <fidl/fuchsia.io/cpp/fidl.h> #include <memory> #include "base/base_export.h" namespace sys { class ComponentContext; } // namespace sys namespace base { // Returns default sys::ComponentContext for the current process. BASE_EXPORT sys::ComponentContext* ComponentContextForProcess(); // Returns the ClientEnd for the default service directory in this process // `ComponentContextForProcess()->svc()`. This can be passed to // `component::ConnectAt` in order to connect a client to a service in this // directory. BASE_EXPORT fidl::UnownedClientEnd<fuchsia_io::Directory> BorrowIncomingServiceDirectoryForProcess(); // Replaces the default sys::ComponentContext for the current process, and // returns the previously-active one. // Use the base::TestComponentContextForProcess rather than calling this // directly. BASE_EXPORT std::unique_ptr<sys::ComponentContext> ReplaceComponentContextForProcessForTest( std::unique_ptr<sys::ComponentContext> context); } // namespace base #endif // BASE_FUCHSIA_PROCESS_CONTEXT_H_

3315c8af161f04fc77d60c2bf96a46b10b47fd89

fd9f5186fa5d19db077dbf302fe9c940cb42e82f

/src/common/expression/RelationalExpression.cpp

703426581308b507f3526d4a6ea9e84c66511588

[ "Apache-2.0" ]

permissive

vesoft-inc/nebula

a0b9af548e124e59ecbfb0c5152098a1020b621c

7c32088dec1891870a24aaa37ee5818e69f5ad6d

refs/heads/master

2023-08-17T00:00:29.022525

2023-08-16T04:02:03

146,459,443

11,007

1,220

Apache-2.0

2023-09-05T05:48:16

2018-08-28T14:25:09

C++

UTF-8

C++

false

8,784

cpp

RelationalExpression.cpp

/* Copyright (c) 2020 vesoft inc. All rights reserved. * * This source code is licensed under Apache 2.0 License. */ #include "common/expression/RelationalExpression.h" #include "common/datatypes/List.h" #include "common/datatypes/Map.h" #include "common/datatypes/Set.h" #include "common/expression/ExprVisitor.h" namespace nebula { const Value& RelationalExpression::eval(ExpressionContext& ctx) { auto& lhs = lhs_->eval(ctx); auto& rhs = rhs_->eval(ctx); switch (kind_) { case Kind::kRelEQ: result_ = lhs.equal(rhs); break; case Kind::kRelNE: result_ = !lhs.equal(rhs); break; case Kind::kRelLT: result_ = lhs.lessThan(rhs); break; case Kind::kRelLE: result_ = lhs.lessThan(rhs) || lhs.equal(rhs); break; case Kind::kRelGT: result_ = rhs.lessThan(lhs); break; case Kind::kRelGE: result_ = rhs.lessThan(lhs) || lhs.equal(rhs); break; case Kind::kRelREG: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { try { const auto& r = ctx.getRegex(rhs.getStr()); result_ = std::regex_match(lhs.getStr(), r); } catch (const std::exception& ex) { LOG(ERROR) << "Regex match error: " << ex.what(); result_ = Value::kNullBadType; } } else { result_ = Value::kNullValue; } break; } case Kind::kRelIn: { if (rhs.isNull() && !rhs.isBadNull()) { result_ = Value::kNullValue; } else if (rhs.isList()) { auto& list = rhs.getList(); result_ = list.contains(lhs); if (UNLIKELY(result_.isBool() && !result_.getBool() && list.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else if (rhs.isSet()) { auto& set = rhs.getSet(); result_ = set.contains(lhs); if (UNLIKELY(result_.isBool() && !result_.getBool() && set.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else if (rhs.isMap()) { auto& map = rhs.getMap(); result_ = map.contains(lhs); if (UNLIKELY(result_.isBool() && !result_.getBool() && map.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else { result_ = Value(NullType::BAD_TYPE); } if (UNLIKELY(!result_.isBadNull() && lhs.isNull())) { result_ = Value::kNullValue; } break; } case Kind::kRelNotIn: { if (rhs.isNull() && !rhs.isBadNull()) { result_ = Value::kNullValue; } else if (rhs.isList()) { auto& list = rhs.getList(); result_ = !list.contains(lhs); if (UNLIKELY(result_.isBool() && result_.getBool() && list.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else if (rhs.isSet()) { auto& set = rhs.getSet(); result_ = !set.contains(lhs); if (UNLIKELY(result_.isBool() && result_.getBool() && set.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else if (rhs.isMap()) { auto& map = rhs.getMap(); result_ = !map.contains(lhs); if (UNLIKELY(result_.isBool() && result_.getBool() && map.contains(Value::kNullValue))) { result_ = Value::kNullValue; } } else { result_ = Value(NullType::BAD_TYPE); } if (UNLIKELY(!result_.isBadNull() && lhs.isNull())) { result_ = Value::kNullValue; } break; } case Kind::kContains: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().find(rhs.getStr()) != std::string::npos; } else { result_ = Value::kNullValue; } break; } case Kind::kNotContains: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = !(lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().find(rhs.getStr()) != std::string::npos); } else { result_ = Value::kNullValue; } break; } case Kind::kStartsWith: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().find(rhs.getStr()) == 0; } else { result_ = Value::kNullValue; } break; } case Kind::kNotStartsWith: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = !(lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().find(rhs.getStr()) == 0); } else { result_ = Value::kNullValue; } break; } case Kind::kEndsWith: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().compare( lhs.getStr().size() - rhs.getStr().size(), rhs.getStr().size(), rhs.getStr()) == 0; } else { result_ = Value::kNullValue; } break; } case Kind::kNotEndsWith: { if (lhs.isBadNull() || rhs.isBadNull()) { result_ = Value::kNullBadType; } else if ((!lhs.isNull() && !lhs.empty() && !lhs.isStr()) || (!rhs.isNull() && !rhs.empty() && !rhs.isStr())) { result_ = Value::kNullBadType; } else if (lhs.isStr() && rhs.isStr()) { result_ = !(lhs.getStr().size() >= rhs.getStr().size() && lhs.getStr().compare(lhs.getStr().size() - rhs.getStr().size(), rhs.getStr().size(), rhs.getStr()) == 0); } else { result_ = Value::kNullValue; } break; } default: DLOG(FATAL) << "Unknown type: " << kind_; result_ = Value::kNullBadType; } return result_; } std::string RelationalExpression::toString() const { std::string op; switch (kind_) { case Kind::kRelLT: op = "<"; break; case Kind::kRelLE: op = "<="; break; case Kind::kRelGT: op = ">"; break; case Kind::kRelGE: op = ">="; break; case Kind::kRelEQ: op = "=="; break; case Kind::kRelNE: op = "!="; break; case Kind::kRelREG: op = "=~"; break; case Kind::kRelIn: op = " IN "; break; case Kind::kRelNotIn: op = " NOT IN "; break; case Kind::kContains: op = " CONTAINS "; break; case Kind::kNotContains: op = " NOT CONTAINS "; break; case Kind::kStartsWith: op = " STARTS WITH "; break; case Kind::kNotStartsWith: op = " NOT STARTS WITH "; break; case Kind::kEndsWith: op = " ENDS WITH "; break; case Kind::kNotEndsWith: op = " NOT ENDS WITH "; break; default: DLOG(FATAL) << "Illegal kind for relational expression: " << static_cast<int>(kind()); op = " Invalid relational expression "; } std::stringstream out; out << "(" << (lhs_ ? lhs_->toString() : "") << op << (rhs_ ? rhs_->toString() : "") << ")"; return out.str(); } void RelationalExpression::accept(ExprVisitor* visitor) { visitor->visit(this); } } // namespace nebula

890c81cee28ced3f0717437df0032b019aa34d65

283a455f88b5dd9e92472d400669965706522bd2

/nRF24/Simple Example/nRF24_recieve.ino

a61bb0dc18d5bda08edd4ed56f8a21c590300bb8

[]

no_license

mrsoltys/GEEN1400

d86855a106e208c4fddae7e291d556baffb365f6

46d2e39521b1b061d24b850a79a6796218fa3071

refs/heads/master

2021-12-01T22:45:44.724110

2021-11-17T20:07:46

123,316,295

1

null

UTF-8

C++

false

562

ino

nRF24_recieve.ino

// Include Libraries #include <nRF24L01.h> #include <printf.h> #include <RF24.h> #include <RF24_config.h> // Define LED pin #define ledPin 2 // Set Up Radios RF24 radio(9,10); const byte address[6]="01100"; void setup() { pinMode(ledPin,OUTPUT); Serial.begin(9600); radio.begin(); radio.setPALevel(RF24_PA_MAX); radio.openReadingPipe(0,address); radio.startListening(); } void loop() { if(radio.available()){ bool dataIn=0; radio.read(&dataIn,sizeof(dataIn)); Serial.println(dataIn); digitalWrite(ledPin,dataIn); } }

812d7ce6197092879bd4d69c2e1b3ec806bfa42f

96df51d812ad28f4c5816102ad450864aa57e608

/src/NodeAnimation.h

054a065b2fdbe91c51b950ef6795999faa19431d

[ "MIT" ]

permissive

infinitedescent/Maya2glTF

26ebf29816d1552e248830adc1eea21ba1cc2f7c

3da15de118e98a10d2edc49b77ad9e61daee5ff1

refs/heads/master

2021-10-20T23:42:41.833140

2021-10-16T19:55:13

147,889,150

0

MIT

2021-09-06T21:23:50

2018-09-08T01:07:55

Mathematica

UTF-8

C++

false

2,139

h

NodeAnimation.h

#pragma once #include "ExportableNode.h" #include "PropAnimation.h" #include "Arguments.h" class ExportableNode; class ExportableMesh; class NodeTransformCache; class NodeAnimation { public: NodeAnimation(const ExportableNode &node, const ExportableFrames &frames, double scaleFactor, const Arguments &args); /** Consider a blend shape weight animation path as constant if all values are below this threshold */ double constantWeightsThreshold = 1e-9; virtual ~NodeAnimation() = default; // Samples values at the current time void sampleAt(const MTime &absoluteTime, int relativeFrameIndex, int superSampleIndex, NodeTransformCache &transformCache); void exportTo(GLTF::Animation &glAnimation); const ExportableNode &node; const ExportableMesh *mesh; private: const double m_scaleFactor; const size_t m_blendShapeCount; const Arguments &m_arguments; double m_maxNonOrthogonality = 0; std::vector<MTime> m_invalidLocalTransformTimes; std::unique_ptr<PropAnimation> m_positions; std::unique_ptr<PropAnimation> m_rotations; std::unique_ptr<PropAnimation> m_scales; // Either the inverse parent scales, or pivot offsets. std::unique_ptr<PropAnimation> m_correctors; // Dummy constant channels for when animation channels are forced. std::unique_ptr<PropAnimation> m_dummyProps1; std::unique_ptr<PropAnimation> m_dummyProps2; std::unique_ptr<PropAnimation> m_weights; void finish(GLTF::Animation &glAnimation, const char *propName, std::unique_ptr<PropAnimation> &animatedProp, double constantThreshold, const gsl::span<const float> &baseValues) const; template <int N> void finish(GLTF::Animation &glAnimation, const char *propName, std::unique_ptr<PropAnimation> &animatedProp, double constantThreshold, int detectStepSampleCount, const float (&baseValues)[N]) { finish(glAnimation, propName, animatedProp, constantThreshold, detectStepSampleCount, gsl::make_span(&baseValues[0], N)); } DISALLOW_COPY_MOVE_ASSIGN(NodeAnimation); };

6b8333fa75461bd6ab808350de70124201d17f68

60b4b95f8c69541f2948e761ad95f989632c2e7c

/C++/nasleduvanje_2/datum.cpp

c7a1c444324825d7daff114b75e02e5cdba51748

[]

no_license

VlatkoT994/Vlatko_Tasevski_qtwinsoft

3d995e55540100544afd8147549a8aa456797e3c

c069e826de872bb11e038832185d396010142b68

refs/heads/master

2021-02-17T23:06:37.124828

2020-03-22T13:35:46

245,134,203

0

null

UTF-8

C++

false

1,057

cpp

datum.cpp

#include "datum.h" #include<iostream> using namespace std; Datum::Datum() { den = 1; mesec = 1; godina = 1; } Datum::Datum(int day,int month,int year){ godina = year; mesec = (month>=1&&month<=12)?month:1; den = (day>=1 && day<=denVoMesec[month-1])?day:1; } void Datum::setDay(int day){ if(day>=1 && day<=denVoMesec[mesec-1]) den = day; } void Datum::setMonth(int month){ if (month>=1&&month<=12){ mesec = month; if (den<denVoMesec[mesec-1]) den = 1; } } void Datum::setYear(int year){ godina = year; } int Datum::operator-(Datum desno){ int days = (godina - desno.getYear())*365; if (mesec>desno.getMonth()) for (int i = desno.getMonth();i<mesec;i++) days+=denVoMesec[i-1]; else if(mesec<desno.getMonth()) for (int i = mesec;i<desno.getMonth();i++) days-=denVoMesec[i-1]; days+=(den-desno.getDay()); return days; } void Datum::print(){ cout<<(den<10?"0":"")<<den<<'/'<<(mesec<10?"0":"")<<mesec<<'/'<<godina<<endl; }

0253a615de18a4518ebd8f72f7c678135cf3e17d

7696821b698f0b7c515175ad330c182c8d83087e

/LeetCode/Convert Sorted Array to Binary Search Tree.cpp

ac14782a25e3b260b97f8e8c1239f44461d7bcbd

[]

no_license

leopeng1995/acplusplus

6ff140e5fa0556d07386f721e215f6e43df34336

3ab7fc51803300486f499c7ff087028717dfb6f3

refs/heads/master

2021-06-16T01:00:14.995261

2017-05-02T05:49:18

68,093,570

24

9

null

2016-11-22T05:16:20

2016-09-13T09:18:44

C++

UTF-8

C++

false

1,242

cpp

Convert Sorted Array to Binary Search Tree.cpp

#include <iostream> #include <vector> #include <queue> #include <cmath> using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { public: TreeNode* sortedArrayToBST(vector<int>& nums) { if (nums.empty()) return NULL; return divide(nums, 0, nums.size() - 1); } private: TreeNode* divide(vector<int>& nums, int l, int r) { if (l > r) return NULL; // 这里是重点！为什么不能 l == r ? int mid = l + ceil((r-l)/2.0); TreeNode *root = new TreeNode(nums[mid]); root->left = divide(nums, l, mid-1); root->right = divide(nums, mid+1, r); return root; } }; std::ostream& operator<<(std::ostream &stream, TreeNode *root) { if (NULL == root) return stream; queue<TreeNode*> q; q.push(root); while (!q.empty()) { TreeNode *p = q.front(); q.pop(); if (p->left != NULL) q.push(p->left); if (p->right != NULL) q.push(p->right); stream << p->val << " "; } stream << endl; return stream; } int main() { vector<int> nums({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); Solution solution; TreeNode *root = solution.sortedArrayToBST(nums); cout << root << endl; return 0; }

eb121f2eda63e750b008bc3a2c6143a4e9f6c08b

0fa3f8ff23770e761561307f2b6a438514af87e0

/shader/Shader.h

3d574abc62e00f53dd0be65da4a87693fbf281b8

[]

no_license

ardazishvili/fig

2cfff7f5314eead3e6a758e93cff1d7420882f16

e9961bdc5a1c1561f86cd7944474223df21b3f34

refs/heads/master

2022-03-12T12:30:10.648896

2022-03-11T16:54:31

2022-03-11T17:03:20

236,101,022

1

0

null

2022-03-10T20:08:43

2020-01-24T23:30:42

C++

UTF-8

C++

false

1,627

h

Shader.h

#pragma once #include <GL/glew.h> #include <fstream> #include <glm/gtc/matrix_transform.hpp> #include <sstream> #include <string> #include "Camera.h" namespace fig { class Light; class Shader { public: static const unsigned int MAX_BONES = 100; Shader(Light* light, Camera& camera, glm::mat4& view, glm::mat4& projection, const std::string& vertexPath, const std::string& fragmentPath); virtual ~Shader() = default; Shader(const Shader&) = delete; Shader(Shader&&) = delete; Shader& operator=(const Shader&) = delete; Shader& operator=(Shader&&) = delete; void init(); void use(); void setBool(const std::string& name, bool value) const; void setInt(const std::string& name, int value) const; void setFloat(const std::string& name, float value) const; void setColor(const std::string& name, float value) const; void setVec3(const std::string& name, float f1, float f2, float f3) const; void setVec3(const std::string& name, glm::vec3& value) const; void setVec4(const std::string& name, glm::vec4& value) const; void setVec2(const std::string& name, glm::vec2& value) const; void setTransformation(const std::string& name, const GLfloat* matrix) const; void setMat4(const std::string& name, const glm::mat4& mat) const; Camera& camera(); GLint getUniformLocation(const char* name); void setBoneTransform(unsigned int index, const glm::mat4& matrix); virtual void configure() = 0; protected: unsigned int _id; Light* _light; Camera& _camera; glm::mat4& _view; glm::mat4& _projection; private: GLuint m_boneLocation[MAX_BONES]; }; } // namespace fig

5dca6370d24ca7a7428976a5d88441f7149d89f3

592b3b99c881023b83f7f08ff4624db5c20b4dc4

/hw2/src/hw2.cpp

b13543a1d049872daab160d60e3dff30aa29d8c6

[]

no_license

CastleOnTheHill/CG_HW

edf56a103f52203845b2fb337ee50ca568fc4f6e

4a2b3af974319359a0c92745cbbd0734144d3d19

refs/heads/master

2020-05-19T19:41:48.889305

2019-05-28T12:54:16

185,186,437

0

null

UTF-8

C++

false

5,864

cpp

hw2.cpp

#include <glad/glad.h> #include <GLFW/glfw3.h> #include "shader.h" #include "imgui.h" #include "imgui_impl_opengl3.h" #include "imgui_impl_glfw.h" #include <iostream> using std::cout; using std::endl; void framebuffer__size_callback(GLFWwindow* window, int width, int height); int main() { int assignment_num = 4; glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); GLFWwindow* window = glfwCreateWindow(800, 600, "hw2", NULL, NULL); if (window == NULL) { cout << "Failed to create GLF window" << endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { cout << "Failed to initialize GLAD" << endl; return -1; } const char* glsl_version = "#version 330"; ImGui::CreateContext(); ImGuiIO& io = ImGui::GetIO(); (void)io; ImGui_ImplGlfw_InitForOpenGL(window, true); ImGui_ImplOpenGL3_Init(glsl_version); ImGui::StyleColorsClassic(); glViewport(0, 0, 800, 600); glfwSetFramebufferSizeCallback(window, framebuffer__size_callback); float vertices1[] = { -1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; float vertices2[] = { -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f }; float vertices3[] = { -1.0f, -1.0f, 0.0f, -0.5f, -0.5f, 0.0f, 1.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.0f }; unsigned int index[] = { 1, 3, 5, 3, 0, 2, 4, 0, 5 }; ImVec4 color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f); Shader shader1("vertexShaderSrc2.txt", "fragmentShaderSrc2.txt"); Shader shader2("vertexShaderSrc3.txt", "fragmentShaderSrc3.txt"); Shader shader3("vertexShaderSrc3.txt", "fragmentShaderSrc3.txt"); unsigned int VBO1, VAO1, VBO2, VAO2, VBO3, EBO3, VAO3; // assignment 1&2 glGenVertexArrays(1, &VAO1); glBindVertexArray(VAO1); glGenBuffers(1, &VBO1); glBindBuffer(GL_ARRAY_BUFFER, VBO1); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); glEnableVertexAttribArray(1); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); // assignment3 glGenVertexArrays(1, &VAO2); glBindVertexArray(VAO2); glGenBuffers(1, &VBO2); glBindBuffer(GL_ARRAY_BUFFER, VBO2); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); // assignment5 glGenVertexArrays(1, &VAO3); glBindVertexArray(VAO3); glGenBuffers(1, &VBO3); glBindBuffer(GL_ARRAY_BUFFER, VBO3); glGenBuffers(1, &EBO3); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO3); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(index), index, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices3), vertices3, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glEnableVertexAttribArray(0); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); glfwMakeContextCurrent(window); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT); if (assignment_num < 3) { shader1.use(); glBindVertexArray(VAO1); glDrawArrays(GL_TRIANGLES, 0, 3); } else if (assignment_num == 3) { std::string name = "our_color"; int location = shader2.getLocation(name); if (location == -1) { std::cout << "Failed to find " << name << endl; } else { shader2.use(); glUniform4f(location, color.x, color.y, color.z, color.w); } glBindVertexArray(VAO2); glDrawArrays(GL_TRIANGLES, 0, 3); } else if (assignment_num == 4) { std::string name = "our_color"; int location = shader3.getLocation(name); if (location == -1) { std::cout << "Failed to find " << name << endl; } else { shader3.use(); glUniform4f(location, color.x, color.y, color.z, color.w); } glBindVertexArray(VAO3); glPointSize(10.0f); glDrawElements(GL_POINTS, 9, GL_UNSIGNED_INT, 0); glDrawElements(GL_LINES, 8, GL_UNSIGNED_INT, 0); } else { std::string name = "our_color"; int location = shader3.getLocation(name); if (location == -1) { std::cout << "Failed to find " << name << endl; } else { shader3.use(); glUniform4f(location, color.x, color.y, color.z, color.w); } glBindVertexArray(VAO3); glDrawElements(GL_TRIANGLES, 9, GL_UNSIGNED_INT, 0); } ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame(); ImGui::Begin("color changer"); ImGui::ColorEdit3("Editer ", (float*)&color); if (ImGui::CollapsingHeader("Select assignment")) { for (int i = 1; i <= 5; i++) { char msg[32]; sprintf(msg, "assignment %d", i); if (ImGui::Selectable(msg, i == assignment_num)) { assignment_num = i; } } } ImGui::End(); ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); glfwMakeContextCurrent(window); glfwSwapBuffers(window); } ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); glDeleteVertexArrays(1, &VAO1); glDeleteVertexArrays(1, &VAO2); glDeleteVertexArrays(1, &VAO3); glDeleteBuffers(1, &VBO1); glDeleteBuffers(1, &VBO2); glDeleteBuffers(1, &VBO3); glDeleteBuffers(1, &EBO3); glfwTerminate(); return 0; } void framebuffer__size_callback(GLFWwindow * window, int width, int height) { glViewport(0, 0, width, height); }

b21e6588a693346dbbfbe42398505ce9d0b7ec0e

96d00dc95c65c6e4d0e7a54507a8aaad7cf18d47

/sources/FG/classes/src/ATriangle.cpp

24505782c445425e252ab0e83b8a42c7b23294a4

[]

no_license

eryeden/R8C_FG

4ff141e9408cabfb5136e05e513024904db6d04b

585cff8c808d49fc49b6a1e5e34cecb37bfcd55d

refs/heads/master

2021-01-10T11:50:41.309419

2015-09-28T08:08:09

43,061,792

0

null

UTF-8

C++

false

887

cpp

ATriangle.cpp

// // // Generated by StarUML(tm) C++ Add-In // // Project : Function Generator // @ File Name : ATriangle.cpp // @ Date : 2015/05/25 // @ Author : Kazuki Kikuchi // // #include "ATriangle.hpp" #include "Settings.hpp" #define SCL_TR 10 ATriangle::ATriangle(unsigned int freq, float phase, unsigned int gain) :AWave(0xA2) { SetGain(gain); m_clk.Set(freq, 64, phase); unsigned int tmp = 1; for (int i = 0; i < SCL_TR; i++){ tmp *= 2; } m_dv_fp = (unsigned long) ((double) 0xFFF / ((double) m_clk.GetNop() / 2.0) * (double) tmp); ID = Settings::WAVE_ID_ATRIANGLE; } unsigned int ATriangle::GetValueNow() { unsigned int out = (unsigned int) ((((unsigned long) (m_clk.Update())) * m_dv_fp) >> SCL_TR); if (out < 0xFFF){ return out; } else{ return (unsigned int) (0x1FFF - out); } } unsigned char ATriangle::GetId() { return Settings::WAVE_ID_ATRIANGLE; }

db285d2e52b089a3445ade3fbbff809ac0c63c11

2f6c2872118a7b6df295174c2338fcd2afa6a1bc

/src/TriggeredEvent.cpp

7c10e75fc5bd582488cb3216c9eae27fd9f311f5

[ "MIT" ]

permissive

matteobarbieri/titan

2ff020367eb6a000c09de6087b0e8233d42050a4

e440f921ce165a7b1004a971b55d3ae63b145514

refs/heads/master

2021-07-11T19:23:12.792053

2020-08-27T15:34:32

192,607,869

1

0

MIT

2020-08-20T09:02:52

2019-06-18T20:25:40

C

UTF-8

C++

false

1,251

cpp

TriggeredEvent.cpp

#include "TriggeredEvent.hpp" #include "GameState.hpp" #include "Entity.hpp" #include "map/GameMap.hpp" #include "components/Interactive.hpp" #include "GameMessages.hpp" #include "prefabs/funcs/misc.hpp" TriggeredEvent::TriggeredEvent(EventTrigger * et): trigger(et) { } bool TriggeredEvent::does_trigger(Entity * player, GameMap * game_map, GameState * game_state) { return trigger->does_trigger(player, game_map, game_state); } void TriggeredEvent::resolve(Entity * player, GameMap * game_map, GameState * game_state) { for (int i=0; i<(int)effects.size(); i++) { effects[i]->apply(player, game_map, game_state); } } json TriggeredEvent::to_json() { json j; // The trigger j["trigger"] = trigger->to_json(); // All effects json j_effects; for (int i=0; i<(int)effects.size(); i++) { j_effects.push_back(effects[i]->to_json()); } j["effects"] = j_effects; return j; } TriggeredEvent * TriggeredEvent::from_json(json j) { TriggeredEvent * te = new TriggeredEvent( EventTrigger::from_json(j["trigger"])); for (int i=0; i<(int)j["effects"].size(); i++) { te->effects.push_back(Effect::from_json(j["effects"][i])); } return te; }

96fe81d8d6abb6d9086502a66aad509a82d4761d

db5e6ed5267950fd745110b301263f23ff88df0d

/ProductInventory/ProductInventory/Account.h

7b50847586cecfcbbf4ade464b4d79609c0f4ec2

[]

no_license

abidahmedgwu/C-Practice

fc1d4be6329136393736814b808d84b416ae1a19

464e809e98b56d996815d398c91ab3da6f0d9d7d

refs/heads/master

2021-05-13T18:43:43.377269

2018-01-09T22:15:06

116,875,822

0

null

UTF-8

C++

false

278

h

Account.h

#pragma once #include <string> class Account { private: std::string username; std::string password; public: Account(); Account(std::string username, std::string password); ~Account(); std::string getUsername() const; std::string getPassword() const; };

9f65b1ff334af7af49d66012e78bd42347a217e7

9a37e0dd62a14c3700e65646eee4c2f64b087fdc

/UCT-project/build-project-Desktop_Qt_5_5_0_GCC_64bit-Debug/ui_mainwindow.h

ade60839a4e87c9e29540a991c2435db9a1f2a12

[]

no_license

merveyildiz/UCT-project

c01a835a96f0d65fa5d0ed8e08847ab99d813768

4e03ce3ad70bc30f0d970202eb5a0e7c60b8b14e

refs/heads/master

2021-01-10T06:29:51.067695

2016-01-25T21:22:35

50,379,590

1

null

UTF-8

C++

false

171,116

h

ui_mainwindow.h

/******************************************************************************** ** Form generated from reading UI file 'mainwindow.ui' ** ** Created by: Qt User Interface Compiler version 5.5.0 ** ** WARNING! All changes made in this file will be lost when recompiling UI file! ********************************************************************************/ #ifndef UI_MAINWINDOW_H #define UI_MAINWINDOW_H #include <QtCore/QVariant> #include <QtWidgets/QAction> #include <QtWidgets/QApplication> #include <QtWidgets/QButtonGroup> #include <QtWidgets/QComboBox> #include <QtWidgets/QGridLayout> #include <QtWidgets/QHBoxLayout> #include <QtWidgets/QHeaderView> #include <QtWidgets/QLabel> #include <QtWidgets/QMainWindow> #include <QtWidgets/QMenuBar> #include <QtWidgets/QPushButton> #include <QtWidgets/QStatusBar> #include <QtWidgets/QTabWidget> #include <QtWidgets/QTableWidget> #include <QtWidgets/QToolBar> #include <QtWidgets/QVBoxLayout> #include <QtWidgets/QWidget> QT_BEGIN_NAMESPACE class Ui_MainWindow { public: QWidget *centralWidget; QHBoxLayout *horizontalLayout_3; QHBoxLayout *horizontalLayout_6; QVBoxLayout *verticalLayout_2; QHBoxLayout *horizontalLayout; QLabel *label; QPushButton *pushButton; QLabel *label_2; QComboBox *comboBox; QPushButton *pushButton_3; QPushButton *pushButton_4; QPushButton *pushButton_9; QVBoxLayout *verticalLayout_3; QTabWidget *tabWidget; QWidget *tab; QGridLayout *gridLayout_4; QTableWidget *tableWidget_1; QWidget *tab_2; QGridLayout *gridLayout_5; QTableWidget *tableWidget_2; QWidget *tab_3; QGridLayout *gridLayout_3; QTableWidget *tableWidget_3; QWidget *tab_4; QGridLayout *gridLayout_6; QTableWidget *tableWidget_4; QWidget *tab_5; QGridLayout *gridLayout_7; QTableWidget *tableWidget_5; QWidget *tab_6; QGridLayout *gridLayout_8; QTableWidget *tableWidget_6; QWidget *tab_7; QGridLayout *gridLayout_9; QTableWidget *tableWidget_7; QWidget *tab_8; QGridLayout *gridLayout_10; QTableWidget *tableWidget_8; QWidget *tab_9; QGridLayout *gridLayout; QTableWidget *tableWidget_9; QTableWidget *tableWidget_10; QTableWidget *tableWidget_11; QTableWidget *tableWidget_12; QWidget *tab_10; QGridLayout *gridLayout_2; QTableWidget *tableWidget_13; QTableWidget *tableWidget_14; QTableWidget *tableWidget_15; QTableWidget *tableWidget_16; QWidget *tab_11; QGridLayout *gridLayout_11; QTableWidget *tableWidget_17; QTableWidget *tableWidget_18; QTableWidget *tableWidget_19; QTableWidget *tableWidget_20; QWidget *tab_12; QGridLayout *gridLayout_12; QTableWidget *tableWidget_21; QTableWidget *tableWidget_22; QTableWidget *tableWidget_23; QTableWidget *tableWidget_24; QTableWidget *tableWidget_25; QTableWidget *tableWidget_26; QTableWidget *tableWidget_27; QTableWidget *tableWidget_28; QWidget *tab_13; QGridLayout *gridLayout_13; QTableWidget *tableWidget; QPushButton *pushButton_7; QPushButton *pushButton_6; QVBoxLayout *verticalLayout; QPushButton *pushButton_2; QPushButton *pushButton_5; QPushButton *pushButton_8; QMenuBar *menuBar; QToolBar *mainToolBar; QStatusBar *statusBar; void setupUi(QMainWindow *MainWindow) { if (MainWindow->objectName().isEmpty()) MainWindow->setObjectName(QStringLiteral("MainWindow")); MainWindow->setWindowModality(Qt::NonModal); MainWindow->resize(1451, 610); centralWidget = new QWidget(MainWindow); centralWidget->setObjectName(QStringLiteral("centralWidget")); horizontalLayout_3 = new QHBoxLayout(centralWidget); horizontalLayout_3->setSpacing(6); horizontalLayout_3->setContentsMargins(11, 11, 11, 11); horizontalLayout_3->setObjectName(QStringLiteral("horizontalLayout_3")); horizontalLayout_6 = new QHBoxLayout(); horizontalLayout_6->setSpacing(6); horizontalLayout_6->setObjectName(QStringLiteral("horizontalLayout_6")); horizontalLayout_6->setSizeConstraint(QLayout::SetMaximumSize); verticalLayout_2 = new QVBoxLayout(); verticalLayout_2->setSpacing(6); verticalLayout_2->setObjectName(QStringLiteral("verticalLayout_2")); horizontalLayout = new QHBoxLayout(); horizontalLayout->setSpacing(6); horizontalLayout->setObjectName(QStringLiteral("horizontalLayout")); label = new QLabel(centralWidget); label->setObjectName(QStringLiteral("label")); horizontalLayout->addWidget(label); verticalLayout_2->addLayout(horizontalLayout); pushButton = new QPushButton(centralWidget); pushButton->setObjectName(QStringLiteral("pushButton")); verticalLayout_2->addWidget(pushButton); label_2 = new QLabel(centralWidget); label_2->setObjectName(QStringLiteral("label_2")); verticalLayout_2->addWidget(label_2); comboBox = new QComboBox(centralWidget); comboBox->setObjectName(QStringLiteral("comboBox")); verticalLayout_2->addWidget(comboBox); pushButton_3 = new QPushButton(centralWidget); pushButton_3->setObjectName(QStringLiteral("pushButton_3")); verticalLayout_2->addWidget(pushButton_3); pushButton_4 = new QPushButton(centralWidget); pushButton_4->setObjectName(QStringLiteral("pushButton_4")); verticalLayout_2->addWidget(pushButton_4); pushButton_9 = new QPushButton(centralWidget); pushButton_9->setObjectName(QStringLiteral("pushButton_9")); verticalLayout_2->addWidget(pushButton_9); horizontalLayout_6->addLayout(verticalLayout_2); verticalLayout_3 = new QVBoxLayout(); verticalLayout_3->setSpacing(6); verticalLayout_3->setObjectName(QStringLiteral("verticalLayout_3")); tabWidget = new QTabWidget(centralWidget); tabWidget->setObjectName(QStringLiteral("tabWidget")); tab = new QWidget(); tab->setObjectName(QStringLiteral("tab")); gridLayout_4 = new QGridLayout(tab); gridLayout_4->setSpacing(6); gridLayout_4->setContentsMargins(11, 11, 11, 11); gridLayout_4->setObjectName(QStringLiteral("gridLayout_4")); tableWidget_1 = new QTableWidget(tab); if (tableWidget_1->columnCount() < 5) tableWidget_1->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem = new QTableWidgetItem(); tableWidget_1->setHorizontalHeaderItem(0, __qtablewidgetitem); QTableWidgetItem *__qtablewidgetitem1 = new QTableWidgetItem(); tableWidget_1->setHorizontalHeaderItem(1, __qtablewidgetitem1); QTableWidgetItem *__qtablewidgetitem2 = new QTableWidgetItem(); tableWidget_1->setHorizontalHeaderItem(2, __qtablewidgetitem2); QTableWidgetItem *__qtablewidgetitem3 = new QTableWidgetItem(); tableWidget_1->setHorizontalHeaderItem(3, __qtablewidgetitem3); QTableWidgetItem *__qtablewidgetitem4 = new QTableWidgetItem(); tableWidget_1->setHorizontalHeaderItem(4, __qtablewidgetitem4); if (tableWidget_1->rowCount() < 10) tableWidget_1->setRowCount(10); QTableWidgetItem *__qtablewidgetitem5 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(0, __qtablewidgetitem5); QTableWidgetItem *__qtablewidgetitem6 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(1, __qtablewidgetitem6); QTableWidgetItem *__qtablewidgetitem7 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(2, __qtablewidgetitem7); QTableWidgetItem *__qtablewidgetitem8 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(3, __qtablewidgetitem8); QTableWidgetItem *__qtablewidgetitem9 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(4, __qtablewidgetitem9); QTableWidgetItem *__qtablewidgetitem10 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(5, __qtablewidgetitem10); QTableWidgetItem *__qtablewidgetitem11 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(6, __qtablewidgetitem11); QTableWidgetItem *__qtablewidgetitem12 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(7, __qtablewidgetitem12); QTableWidgetItem *__qtablewidgetitem13 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(8, __qtablewidgetitem13); QTableWidgetItem *__qtablewidgetitem14 = new QTableWidgetItem(); tableWidget_1->setVerticalHeaderItem(9, __qtablewidgetitem14); tableWidget_1->setObjectName(QStringLiteral("tableWidget_1")); gridLayout_4->addWidget(tableWidget_1, 0, 0, 1, 1); tabWidget->addTab(tab, QString()); tab_2 = new QWidget(); tab_2->setObjectName(QStringLiteral("tab_2")); gridLayout_5 = new QGridLayout(tab_2); gridLayout_5->setSpacing(6); gridLayout_5->setContentsMargins(11, 11, 11, 11); gridLayout_5->setObjectName(QStringLiteral("gridLayout_5")); tableWidget_2 = new QTableWidget(tab_2); if (tableWidget_2->columnCount() < 5) tableWidget_2->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem15 = new QTableWidgetItem(); tableWidget_2->setHorizontalHeaderItem(0, __qtablewidgetitem15); QTableWidgetItem *__qtablewidgetitem16 = new QTableWidgetItem(); tableWidget_2->setHorizontalHeaderItem(1, __qtablewidgetitem16); QTableWidgetItem *__qtablewidgetitem17 = new QTableWidgetItem(); tableWidget_2->setHorizontalHeaderItem(2, __qtablewidgetitem17); QTableWidgetItem *__qtablewidgetitem18 = new QTableWidgetItem(); tableWidget_2->setHorizontalHeaderItem(3, __qtablewidgetitem18); QTableWidgetItem *__qtablewidgetitem19 = new QTableWidgetItem(); tableWidget_2->setHorizontalHeaderItem(4, __qtablewidgetitem19); if (tableWidget_2->rowCount() < 10) tableWidget_2->setRowCount(10); QTableWidgetItem *__qtablewidgetitem20 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(0, __qtablewidgetitem20); QTableWidgetItem *__qtablewidgetitem21 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(1, __qtablewidgetitem21); QTableWidgetItem *__qtablewidgetitem22 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(2, __qtablewidgetitem22); QTableWidgetItem *__qtablewidgetitem23 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(3, __qtablewidgetitem23); QTableWidgetItem *__qtablewidgetitem24 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(4, __qtablewidgetitem24); QTableWidgetItem *__qtablewidgetitem25 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(5, __qtablewidgetitem25); QTableWidgetItem *__qtablewidgetitem26 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(6, __qtablewidgetitem26); QTableWidgetItem *__qtablewidgetitem27 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(7, __qtablewidgetitem27); QTableWidgetItem *__qtablewidgetitem28 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(8, __qtablewidgetitem28); QTableWidgetItem *__qtablewidgetitem29 = new QTableWidgetItem(); tableWidget_2->setVerticalHeaderItem(9, __qtablewidgetitem29); tableWidget_2->setObjectName(QStringLiteral("tableWidget_2")); gridLayout_5->addWidget(tableWidget_2, 0, 0, 1, 1); tabWidget->addTab(tab_2, QString()); tab_3 = new QWidget(); tab_3->setObjectName(QStringLiteral("tab_3")); gridLayout_3 = new QGridLayout(tab_3); gridLayout_3->setSpacing(6); gridLayout_3->setContentsMargins(11, 11, 11, 11); gridLayout_3->setObjectName(QStringLiteral("gridLayout_3")); tableWidget_3 = new QTableWidget(tab_3); if (tableWidget_3->columnCount() < 5) tableWidget_3->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem30 = new QTableWidgetItem(); tableWidget_3->setHorizontalHeaderItem(0, __qtablewidgetitem30); QTableWidgetItem *__qtablewidgetitem31 = new QTableWidgetItem(); tableWidget_3->setHorizontalHeaderItem(1, __qtablewidgetitem31); QTableWidgetItem *__qtablewidgetitem32 = new QTableWidgetItem(); tableWidget_3->setHorizontalHeaderItem(2, __qtablewidgetitem32); QTableWidgetItem *__qtablewidgetitem33 = new QTableWidgetItem(); tableWidget_3->setHorizontalHeaderItem(3, __qtablewidgetitem33); QTableWidgetItem *__qtablewidgetitem34 = new QTableWidgetItem(); tableWidget_3->setHorizontalHeaderItem(4, __qtablewidgetitem34); if (tableWidget_3->rowCount() < 10) tableWidget_3->setRowCount(10); QTableWidgetItem *__qtablewidgetitem35 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(0, __qtablewidgetitem35); QTableWidgetItem *__qtablewidgetitem36 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(1, __qtablewidgetitem36); QTableWidgetItem *__qtablewidgetitem37 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(2, __qtablewidgetitem37); QTableWidgetItem *__qtablewidgetitem38 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(3, __qtablewidgetitem38); QTableWidgetItem *__qtablewidgetitem39 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(4, __qtablewidgetitem39); QTableWidgetItem *__qtablewidgetitem40 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(5, __qtablewidgetitem40); QTableWidgetItem *__qtablewidgetitem41 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(6, __qtablewidgetitem41); QTableWidgetItem *__qtablewidgetitem42 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(7, __qtablewidgetitem42); QTableWidgetItem *__qtablewidgetitem43 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(8, __qtablewidgetitem43); QTableWidgetItem *__qtablewidgetitem44 = new QTableWidgetItem(); tableWidget_3->setVerticalHeaderItem(9, __qtablewidgetitem44); tableWidget_3->setObjectName(QStringLiteral("tableWidget_3")); gridLayout_3->addWidget(tableWidget_3, 0, 0, 1, 1); tabWidget->addTab(tab_3, QString()); tab_4 = new QWidget(); tab_4->setObjectName(QStringLiteral("tab_4")); gridLayout_6 = new QGridLayout(tab_4); gridLayout_6->setSpacing(6); gridLayout_6->setContentsMargins(11, 11, 11, 11); gridLayout_6->setObjectName(QStringLiteral("gridLayout_6")); tableWidget_4 = new QTableWidget(tab_4); if (tableWidget_4->columnCount() < 5) tableWidget_4->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem45 = new QTableWidgetItem(); tableWidget_4->setHorizontalHeaderItem(0, __qtablewidgetitem45); QTableWidgetItem *__qtablewidgetitem46 = new QTableWidgetItem(); tableWidget_4->setHorizontalHeaderItem(1, __qtablewidgetitem46); QTableWidgetItem *__qtablewidgetitem47 = new QTableWidgetItem(); tableWidget_4->setHorizontalHeaderItem(2, __qtablewidgetitem47); QTableWidgetItem *__qtablewidgetitem48 = new QTableWidgetItem(); tableWidget_4->setHorizontalHeaderItem(3, __qtablewidgetitem48); QTableWidgetItem *__qtablewidgetitem49 = new QTableWidgetItem(); tableWidget_4->setHorizontalHeaderItem(4, __qtablewidgetitem49); if (tableWidget_4->rowCount() < 10) tableWidget_4->setRowCount(10); QTableWidgetItem *__qtablewidgetitem50 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(0, __qtablewidgetitem50); QTableWidgetItem *__qtablewidgetitem51 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(1, __qtablewidgetitem51); QTableWidgetItem *__qtablewidgetitem52 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(2, __qtablewidgetitem52); QTableWidgetItem *__qtablewidgetitem53 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(3, __qtablewidgetitem53); QTableWidgetItem *__qtablewidgetitem54 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(4, __qtablewidgetitem54); QTableWidgetItem *__qtablewidgetitem55 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(5, __qtablewidgetitem55); QTableWidgetItem *__qtablewidgetitem56 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(6, __qtablewidgetitem56); QTableWidgetItem *__qtablewidgetitem57 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(7, __qtablewidgetitem57); QTableWidgetItem *__qtablewidgetitem58 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(8, __qtablewidgetitem58); QTableWidgetItem *__qtablewidgetitem59 = new QTableWidgetItem(); tableWidget_4->setVerticalHeaderItem(9, __qtablewidgetitem59); tableWidget_4->setObjectName(QStringLiteral("tableWidget_4")); gridLayout_6->addWidget(tableWidget_4, 0, 0, 1, 1); tabWidget->addTab(tab_4, QString()); tab_5 = new QWidget(); tab_5->setObjectName(QStringLiteral("tab_5")); gridLayout_7 = new QGridLayout(tab_5); gridLayout_7->setSpacing(6); gridLayout_7->setContentsMargins(11, 11, 11, 11); gridLayout_7->setObjectName(QStringLiteral("gridLayout_7")); tableWidget_5 = new QTableWidget(tab_5); if (tableWidget_5->columnCount() < 5) tableWidget_5->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem60 = new QTableWidgetItem(); tableWidget_5->setHorizontalHeaderItem(0, __qtablewidgetitem60); QTableWidgetItem *__qtablewidgetitem61 = new QTableWidgetItem(); tableWidget_5->setHorizontalHeaderItem(1, __qtablewidgetitem61); QTableWidgetItem *__qtablewidgetitem62 = new QTableWidgetItem(); tableWidget_5->setHorizontalHeaderItem(2, __qtablewidgetitem62); QTableWidgetItem *__qtablewidgetitem63 = new QTableWidgetItem(); tableWidget_5->setHorizontalHeaderItem(3, __qtablewidgetitem63); QTableWidgetItem *__qtablewidgetitem64 = new QTableWidgetItem(); tableWidget_5->setHorizontalHeaderItem(4, __qtablewidgetitem64); if (tableWidget_5->rowCount() < 10) tableWidget_5->setRowCount(10); QTableWidgetItem *__qtablewidgetitem65 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(0, __qtablewidgetitem65); QTableWidgetItem *__qtablewidgetitem66 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(1, __qtablewidgetitem66); QTableWidgetItem *__qtablewidgetitem67 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(2, __qtablewidgetitem67); QTableWidgetItem *__qtablewidgetitem68 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(3, __qtablewidgetitem68); QTableWidgetItem *__qtablewidgetitem69 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(4, __qtablewidgetitem69); QTableWidgetItem *__qtablewidgetitem70 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(5, __qtablewidgetitem70); QTableWidgetItem *__qtablewidgetitem71 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(6, __qtablewidgetitem71); QTableWidgetItem *__qtablewidgetitem72 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(7, __qtablewidgetitem72); QTableWidgetItem *__qtablewidgetitem73 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(8, __qtablewidgetitem73); QTableWidgetItem *__qtablewidgetitem74 = new QTableWidgetItem(); tableWidget_5->setVerticalHeaderItem(9, __qtablewidgetitem74); tableWidget_5->setObjectName(QStringLiteral("tableWidget_5")); gridLayout_7->addWidget(tableWidget_5, 0, 0, 1, 1); tabWidget->addTab(tab_5, QString()); tab_6 = new QWidget(); tab_6->setObjectName(QStringLiteral("tab_6")); gridLayout_8 = new QGridLayout(tab_6); gridLayout_8->setSpacing(6); gridLayout_8->setContentsMargins(11, 11, 11, 11); gridLayout_8->setObjectName(QStringLiteral("gridLayout_8")); tableWidget_6 = new QTableWidget(tab_6); if (tableWidget_6->columnCount() < 5) tableWidget_6->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem75 = new QTableWidgetItem(); tableWidget_6->setHorizontalHeaderItem(0, __qtablewidgetitem75); QTableWidgetItem *__qtablewidgetitem76 = new QTableWidgetItem(); tableWidget_6->setHorizontalHeaderItem(1, __qtablewidgetitem76); QTableWidgetItem *__qtablewidgetitem77 = new QTableWidgetItem(); tableWidget_6->setHorizontalHeaderItem(2, __qtablewidgetitem77); QTableWidgetItem *__qtablewidgetitem78 = new QTableWidgetItem(); tableWidget_6->setHorizontalHeaderItem(3, __qtablewidgetitem78); QTableWidgetItem *__qtablewidgetitem79 = new QTableWidgetItem(); tableWidget_6->setHorizontalHeaderItem(4, __qtablewidgetitem79); if (tableWidget_6->rowCount() < 10) tableWidget_6->setRowCount(10); QTableWidgetItem *__qtablewidgetitem80 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(0, __qtablewidgetitem80); QTableWidgetItem *__qtablewidgetitem81 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(1, __qtablewidgetitem81); QTableWidgetItem *__qtablewidgetitem82 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(2, __qtablewidgetitem82); QTableWidgetItem *__qtablewidgetitem83 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(3, __qtablewidgetitem83); QTableWidgetItem *__qtablewidgetitem84 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(4, __qtablewidgetitem84); QTableWidgetItem *__qtablewidgetitem85 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(5, __qtablewidgetitem85); QTableWidgetItem *__qtablewidgetitem86 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(6, __qtablewidgetitem86); QTableWidgetItem *__qtablewidgetitem87 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(7, __qtablewidgetitem87); QTableWidgetItem *__qtablewidgetitem88 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(8, __qtablewidgetitem88); QTableWidgetItem *__qtablewidgetitem89 = new QTableWidgetItem(); tableWidget_6->setVerticalHeaderItem(9, __qtablewidgetitem89); tableWidget_6->setObjectName(QStringLiteral("tableWidget_6")); gridLayout_8->addWidget(tableWidget_6, 0, 0, 1, 1); tabWidget->addTab(tab_6, QString()); tab_7 = new QWidget(); tab_7->setObjectName(QStringLiteral("tab_7")); gridLayout_9 = new QGridLayout(tab_7); gridLayout_9->setSpacing(6); gridLayout_9->setContentsMargins(11, 11, 11, 11); gridLayout_9->setObjectName(QStringLiteral("gridLayout_9")); tableWidget_7 = new QTableWidget(tab_7); if (tableWidget_7->columnCount() < 5) tableWidget_7->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem90 = new QTableWidgetItem(); tableWidget_7->setHorizontalHeaderItem(0, __qtablewidgetitem90); QTableWidgetItem *__qtablewidgetitem91 = new QTableWidgetItem(); tableWidget_7->setHorizontalHeaderItem(1, __qtablewidgetitem91); QTableWidgetItem *__qtablewidgetitem92 = new QTableWidgetItem(); tableWidget_7->setHorizontalHeaderItem(2, __qtablewidgetitem92); QTableWidgetItem *__qtablewidgetitem93 = new QTableWidgetItem(); tableWidget_7->setHorizontalHeaderItem(3, __qtablewidgetitem93); QTableWidgetItem *__qtablewidgetitem94 = new QTableWidgetItem(); tableWidget_7->setHorizontalHeaderItem(4, __qtablewidgetitem94); if (tableWidget_7->rowCount() < 10) tableWidget_7->setRowCount(10); QTableWidgetItem *__qtablewidgetitem95 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(0, __qtablewidgetitem95); QTableWidgetItem *__qtablewidgetitem96 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(1, __qtablewidgetitem96); QTableWidgetItem *__qtablewidgetitem97 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(2, __qtablewidgetitem97); QTableWidgetItem *__qtablewidgetitem98 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(3, __qtablewidgetitem98); QTableWidgetItem *__qtablewidgetitem99 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(4, __qtablewidgetitem99); QTableWidgetItem *__qtablewidgetitem100 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(5, __qtablewidgetitem100); QTableWidgetItem *__qtablewidgetitem101 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(6, __qtablewidgetitem101); QTableWidgetItem *__qtablewidgetitem102 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(7, __qtablewidgetitem102); QTableWidgetItem *__qtablewidgetitem103 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(8, __qtablewidgetitem103); QTableWidgetItem *__qtablewidgetitem104 = new QTableWidgetItem(); tableWidget_7->setVerticalHeaderItem(9, __qtablewidgetitem104); tableWidget_7->setObjectName(QStringLiteral("tableWidget_7")); gridLayout_9->addWidget(tableWidget_7, 0, 0, 1, 1); tabWidget->addTab(tab_7, QString()); tab_8 = new QWidget(); tab_8->setObjectName(QStringLiteral("tab_8")); gridLayout_10 = new QGridLayout(tab_8); gridLayout_10->setSpacing(6); gridLayout_10->setContentsMargins(11, 11, 11, 11); gridLayout_10->setObjectName(QStringLiteral("gridLayout_10")); tableWidget_8 = new QTableWidget(tab_8); if (tableWidget_8->columnCount() < 5) tableWidget_8->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem105 = new QTableWidgetItem(); tableWidget_8->setHorizontalHeaderItem(0, __qtablewidgetitem105); QTableWidgetItem *__qtablewidgetitem106 = new QTableWidgetItem(); tableWidget_8->setHorizontalHeaderItem(1, __qtablewidgetitem106); QTableWidgetItem *__qtablewidgetitem107 = new QTableWidgetItem(); tableWidget_8->setHorizontalHeaderItem(2, __qtablewidgetitem107); QTableWidgetItem *__qtablewidgetitem108 = new QTableWidgetItem(); tableWidget_8->setHorizontalHeaderItem(3, __qtablewidgetitem108); QTableWidgetItem *__qtablewidgetitem109 = new QTableWidgetItem(); tableWidget_8->setHorizontalHeaderItem(4, __qtablewidgetitem109); if (tableWidget_8->rowCount() < 10) tableWidget_8->setRowCount(10); QTableWidgetItem *__qtablewidgetitem110 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(0, __qtablewidgetitem110); QTableWidgetItem *__qtablewidgetitem111 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(1, __qtablewidgetitem111); QTableWidgetItem *__qtablewidgetitem112 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(2, __qtablewidgetitem112); QTableWidgetItem *__qtablewidgetitem113 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(3, __qtablewidgetitem113); QTableWidgetItem *__qtablewidgetitem114 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(4, __qtablewidgetitem114); QTableWidgetItem *__qtablewidgetitem115 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(5, __qtablewidgetitem115); QTableWidgetItem *__qtablewidgetitem116 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(6, __qtablewidgetitem116); QTableWidgetItem *__qtablewidgetitem117 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(7, __qtablewidgetitem117); QTableWidgetItem *__qtablewidgetitem118 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(8, __qtablewidgetitem118); QTableWidgetItem *__qtablewidgetitem119 = new QTableWidgetItem(); tableWidget_8->setVerticalHeaderItem(9, __qtablewidgetitem119); tableWidget_8->setObjectName(QStringLiteral("tableWidget_8")); gridLayout_10->addWidget(tableWidget_8, 0, 0, 1, 1); tabWidget->addTab(tab_8, QString()); tab_9 = new QWidget(); tab_9->setObjectName(QStringLiteral("tab_9")); gridLayout = new QGridLayout(tab_9); gridLayout->setSpacing(6); gridLayout->setContentsMargins(11, 11, 11, 11); gridLayout->setObjectName(QStringLiteral("gridLayout")); tableWidget_9 = new QTableWidget(tab_9); if (tableWidget_9->columnCount() < 5) tableWidget_9->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem120 = new QTableWidgetItem(); tableWidget_9->setHorizontalHeaderItem(0, __qtablewidgetitem120); QTableWidgetItem *__qtablewidgetitem121 = new QTableWidgetItem(); tableWidget_9->setHorizontalHeaderItem(1, __qtablewidgetitem121); QTableWidgetItem *__qtablewidgetitem122 = new QTableWidgetItem(); tableWidget_9->setHorizontalHeaderItem(2, __qtablewidgetitem122); QTableWidgetItem *__qtablewidgetitem123 = new QTableWidgetItem(); tableWidget_9->setHorizontalHeaderItem(3, __qtablewidgetitem123); QTableWidgetItem *__qtablewidgetitem124 = new QTableWidgetItem(); tableWidget_9->setHorizontalHeaderItem(4, __qtablewidgetitem124); if (tableWidget_9->rowCount() < 10) tableWidget_9->setRowCount(10); QTableWidgetItem *__qtablewidgetitem125 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(0, __qtablewidgetitem125); QTableWidgetItem *__qtablewidgetitem126 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(1, __qtablewidgetitem126); QTableWidgetItem *__qtablewidgetitem127 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(2, __qtablewidgetitem127); QTableWidgetItem *__qtablewidgetitem128 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(3, __qtablewidgetitem128); QTableWidgetItem *__qtablewidgetitem129 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(4, __qtablewidgetitem129); QTableWidgetItem *__qtablewidgetitem130 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(5, __qtablewidgetitem130); QTableWidgetItem *__qtablewidgetitem131 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(6, __qtablewidgetitem131); QTableWidgetItem *__qtablewidgetitem132 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(7, __qtablewidgetitem132); QTableWidgetItem *__qtablewidgetitem133 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(8, __qtablewidgetitem133); QTableWidgetItem *__qtablewidgetitem134 = new QTableWidgetItem(); tableWidget_9->setVerticalHeaderItem(9, __qtablewidgetitem134); tableWidget_9->setObjectName(QStringLiteral("tableWidget_9")); gridLayout->addWidget(tableWidget_9, 0, 0, 1, 1); tableWidget_10 = new QTableWidget(tab_9); if (tableWidget_10->columnCount() < 5) tableWidget_10->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem135 = new QTableWidgetItem(); tableWidget_10->setHorizontalHeaderItem(0, __qtablewidgetitem135); QTableWidgetItem *__qtablewidgetitem136 = new QTableWidgetItem(); tableWidget_10->setHorizontalHeaderItem(1, __qtablewidgetitem136); QTableWidgetItem *__qtablewidgetitem137 = new QTableWidgetItem(); tableWidget_10->setHorizontalHeaderItem(2, __qtablewidgetitem137); QTableWidgetItem *__qtablewidgetitem138 = new QTableWidgetItem(); tableWidget_10->setHorizontalHeaderItem(3, __qtablewidgetitem138); QTableWidgetItem *__qtablewidgetitem139 = new QTableWidgetItem(); tableWidget_10->setHorizontalHeaderItem(4, __qtablewidgetitem139); if (tableWidget_10->rowCount() < 10) tableWidget_10->setRowCount(10); QTableWidgetItem *__qtablewidgetitem140 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(0, __qtablewidgetitem140); QTableWidgetItem *__qtablewidgetitem141 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(1, __qtablewidgetitem141); QTableWidgetItem *__qtablewidgetitem142 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(2, __qtablewidgetitem142); QTableWidgetItem *__qtablewidgetitem143 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(3, __qtablewidgetitem143); QTableWidgetItem *__qtablewidgetitem144 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(4, __qtablewidgetitem144); QTableWidgetItem *__qtablewidgetitem145 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(5, __qtablewidgetitem145); QTableWidgetItem *__qtablewidgetitem146 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(6, __qtablewidgetitem146); QTableWidgetItem *__qtablewidgetitem147 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(7, __qtablewidgetitem147); QTableWidgetItem *__qtablewidgetitem148 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(8, __qtablewidgetitem148); QTableWidgetItem *__qtablewidgetitem149 = new QTableWidgetItem(); tableWidget_10->setVerticalHeaderItem(9, __qtablewidgetitem149); tableWidget_10->setObjectName(QStringLiteral("tableWidget_10")); gridLayout->addWidget(tableWidget_10, 0, 1, 1, 1); tableWidget_11 = new QTableWidget(tab_9); if (tableWidget_11->columnCount() < 5) tableWidget_11->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem150 = new QTableWidgetItem(); tableWidget_11->setHorizontalHeaderItem(0, __qtablewidgetitem150); QTableWidgetItem *__qtablewidgetitem151 = new QTableWidgetItem(); tableWidget_11->setHorizontalHeaderItem(1, __qtablewidgetitem151); QTableWidgetItem *__qtablewidgetitem152 = new QTableWidgetItem(); tableWidget_11->setHorizontalHeaderItem(2, __qtablewidgetitem152); QTableWidgetItem *__qtablewidgetitem153 = new QTableWidgetItem(); tableWidget_11->setHorizontalHeaderItem(3, __qtablewidgetitem153); QTableWidgetItem *__qtablewidgetitem154 = new QTableWidgetItem(); tableWidget_11->setHorizontalHeaderItem(4, __qtablewidgetitem154); if (tableWidget_11->rowCount() < 10) tableWidget_11->setRowCount(10); QTableWidgetItem *__qtablewidgetitem155 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(0, __qtablewidgetitem155); QTableWidgetItem *__qtablewidgetitem156 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(1, __qtablewidgetitem156); QTableWidgetItem *__qtablewidgetitem157 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(2, __qtablewidgetitem157); QTableWidgetItem *__qtablewidgetitem158 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(3, __qtablewidgetitem158); QTableWidgetItem *__qtablewidgetitem159 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(4, __qtablewidgetitem159); QTableWidgetItem *__qtablewidgetitem160 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(5, __qtablewidgetitem160); QTableWidgetItem *__qtablewidgetitem161 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(6, __qtablewidgetitem161); QTableWidgetItem *__qtablewidgetitem162 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(7, __qtablewidgetitem162); QTableWidgetItem *__qtablewidgetitem163 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(8, __qtablewidgetitem163); QTableWidgetItem *__qtablewidgetitem164 = new QTableWidgetItem(); tableWidget_11->setVerticalHeaderItem(9, __qtablewidgetitem164); tableWidget_11->setObjectName(QStringLiteral("tableWidget_11")); gridLayout->addWidget(tableWidget_11, 1, 0, 1, 1); tableWidget_12 = new QTableWidget(tab_9); if (tableWidget_12->columnCount() < 5) tableWidget_12->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem165 = new QTableWidgetItem(); tableWidget_12->setHorizontalHeaderItem(0, __qtablewidgetitem165); QTableWidgetItem *__qtablewidgetitem166 = new QTableWidgetItem(); tableWidget_12->setHorizontalHeaderItem(1, __qtablewidgetitem166); QTableWidgetItem *__qtablewidgetitem167 = new QTableWidgetItem(); tableWidget_12->setHorizontalHeaderItem(2, __qtablewidgetitem167); QTableWidgetItem *__qtablewidgetitem168 = new QTableWidgetItem(); tableWidget_12->setHorizontalHeaderItem(3, __qtablewidgetitem168); QTableWidgetItem *__qtablewidgetitem169 = new QTableWidgetItem(); tableWidget_12->setHorizontalHeaderItem(4, __qtablewidgetitem169); if (tableWidget_12->rowCount() < 10) tableWidget_12->setRowCount(10); QTableWidgetItem *__qtablewidgetitem170 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(0, __qtablewidgetitem170); QTableWidgetItem *__qtablewidgetitem171 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(1, __qtablewidgetitem171); QTableWidgetItem *__qtablewidgetitem172 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(2, __qtablewidgetitem172); QTableWidgetItem *__qtablewidgetitem173 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(3, __qtablewidgetitem173); QTableWidgetItem *__qtablewidgetitem174 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(4, __qtablewidgetitem174); QTableWidgetItem *__qtablewidgetitem175 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(5, __qtablewidgetitem175); QTableWidgetItem *__qtablewidgetitem176 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(6, __qtablewidgetitem176); QTableWidgetItem *__qtablewidgetitem177 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(7, __qtablewidgetitem177); QTableWidgetItem *__qtablewidgetitem178 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(8, __qtablewidgetitem178); QTableWidgetItem *__qtablewidgetitem179 = new QTableWidgetItem(); tableWidget_12->setVerticalHeaderItem(9, __qtablewidgetitem179); tableWidget_12->setObjectName(QStringLiteral("tableWidget_12")); gridLayout->addWidget(tableWidget_12, 1, 1, 1, 1); tabWidget->addTab(tab_9, QString()); tab_10 = new QWidget(); tab_10->setObjectName(QStringLiteral("tab_10")); gridLayout_2 = new QGridLayout(tab_10); gridLayout_2->setSpacing(6); gridLayout_2->setContentsMargins(11, 11, 11, 11); gridLayout_2->setObjectName(QStringLiteral("gridLayout_2")); tableWidget_13 = new QTableWidget(tab_10); if (tableWidget_13->columnCount() < 5) tableWidget_13->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem180 = new QTableWidgetItem(); tableWidget_13->setHorizontalHeaderItem(0, __qtablewidgetitem180); QTableWidgetItem *__qtablewidgetitem181 = new QTableWidgetItem(); tableWidget_13->setHorizontalHeaderItem(1, __qtablewidgetitem181); QTableWidgetItem *__qtablewidgetitem182 = new QTableWidgetItem(); tableWidget_13->setHorizontalHeaderItem(2, __qtablewidgetitem182); QTableWidgetItem *__qtablewidgetitem183 = new QTableWidgetItem(); tableWidget_13->setHorizontalHeaderItem(3, __qtablewidgetitem183); QTableWidgetItem *__qtablewidgetitem184 = new QTableWidgetItem(); tableWidget_13->setHorizontalHeaderItem(4, __qtablewidgetitem184); if (tableWidget_13->rowCount() < 10) tableWidget_13->setRowCount(10); QTableWidgetItem *__qtablewidgetitem185 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(0, __qtablewidgetitem185); QTableWidgetItem *__qtablewidgetitem186 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(1, __qtablewidgetitem186); QTableWidgetItem *__qtablewidgetitem187 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(2, __qtablewidgetitem187); QTableWidgetItem *__qtablewidgetitem188 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(3, __qtablewidgetitem188); QTableWidgetItem *__qtablewidgetitem189 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(4, __qtablewidgetitem189); QTableWidgetItem *__qtablewidgetitem190 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(5, __qtablewidgetitem190); QTableWidgetItem *__qtablewidgetitem191 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(6, __qtablewidgetitem191); QTableWidgetItem *__qtablewidgetitem192 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(7, __qtablewidgetitem192); QTableWidgetItem *__qtablewidgetitem193 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(8, __qtablewidgetitem193); QTableWidgetItem *__qtablewidgetitem194 = new QTableWidgetItem(); tableWidget_13->setVerticalHeaderItem(9, __qtablewidgetitem194); tableWidget_13->setObjectName(QStringLiteral("tableWidget_13")); gridLayout_2->addWidget(tableWidget_13, 0, 0, 1, 1); tableWidget_14 = new QTableWidget(tab_10); if (tableWidget_14->columnCount() < 5) tableWidget_14->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem195 = new QTableWidgetItem(); tableWidget_14->setHorizontalHeaderItem(0, __qtablewidgetitem195); QTableWidgetItem *__qtablewidgetitem196 = new QTableWidgetItem(); tableWidget_14->setHorizontalHeaderItem(1, __qtablewidgetitem196); QTableWidgetItem *__qtablewidgetitem197 = new QTableWidgetItem(); tableWidget_14->setHorizontalHeaderItem(2, __qtablewidgetitem197); QTableWidgetItem *__qtablewidgetitem198 = new QTableWidgetItem(); tableWidget_14->setHorizontalHeaderItem(3, __qtablewidgetitem198); QTableWidgetItem *__qtablewidgetitem199 = new QTableWidgetItem(); tableWidget_14->setHorizontalHeaderItem(4, __qtablewidgetitem199); if (tableWidget_14->rowCount() < 10) tableWidget_14->setRowCount(10); QTableWidgetItem *__qtablewidgetitem200 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(0, __qtablewidgetitem200); QTableWidgetItem *__qtablewidgetitem201 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(1, __qtablewidgetitem201); QTableWidgetItem *__qtablewidgetitem202 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(2, __qtablewidgetitem202); QTableWidgetItem *__qtablewidgetitem203 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(3, __qtablewidgetitem203); QTableWidgetItem *__qtablewidgetitem204 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(4, __qtablewidgetitem204); QTableWidgetItem *__qtablewidgetitem205 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(5, __qtablewidgetitem205); QTableWidgetItem *__qtablewidgetitem206 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(6, __qtablewidgetitem206); QTableWidgetItem *__qtablewidgetitem207 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(7, __qtablewidgetitem207); QTableWidgetItem *__qtablewidgetitem208 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(8, __qtablewidgetitem208); QTableWidgetItem *__qtablewidgetitem209 = new QTableWidgetItem(); tableWidget_14->setVerticalHeaderItem(9, __qtablewidgetitem209); tableWidget_14->setObjectName(QStringLiteral("tableWidget_14")); gridLayout_2->addWidget(tableWidget_14, 0, 1, 1, 1); tableWidget_15 = new QTableWidget(tab_10); if (tableWidget_15->columnCount() < 5) tableWidget_15->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem210 = new QTableWidgetItem(); tableWidget_15->setHorizontalHeaderItem(0, __qtablewidgetitem210); QTableWidgetItem *__qtablewidgetitem211 = new QTableWidgetItem(); tableWidget_15->setHorizontalHeaderItem(1, __qtablewidgetitem211); QTableWidgetItem *__qtablewidgetitem212 = new QTableWidgetItem(); tableWidget_15->setHorizontalHeaderItem(2, __qtablewidgetitem212); QTableWidgetItem *__qtablewidgetitem213 = new QTableWidgetItem(); tableWidget_15->setHorizontalHeaderItem(3, __qtablewidgetitem213); QTableWidgetItem *__qtablewidgetitem214 = new QTableWidgetItem(); tableWidget_15->setHorizontalHeaderItem(4, __qtablewidgetitem214); if (tableWidget_15->rowCount() < 10) tableWidget_15->setRowCount(10); QTableWidgetItem *__qtablewidgetitem215 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(0, __qtablewidgetitem215); QTableWidgetItem *__qtablewidgetitem216 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(1, __qtablewidgetitem216); QTableWidgetItem *__qtablewidgetitem217 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(2, __qtablewidgetitem217); QTableWidgetItem *__qtablewidgetitem218 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(3, __qtablewidgetitem218); QTableWidgetItem *__qtablewidgetitem219 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(4, __qtablewidgetitem219); QTableWidgetItem *__qtablewidgetitem220 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(5, __qtablewidgetitem220); QTableWidgetItem *__qtablewidgetitem221 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(6, __qtablewidgetitem221); QTableWidgetItem *__qtablewidgetitem222 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(7, __qtablewidgetitem222); QTableWidgetItem *__qtablewidgetitem223 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(8, __qtablewidgetitem223); QTableWidgetItem *__qtablewidgetitem224 = new QTableWidgetItem(); tableWidget_15->setVerticalHeaderItem(9, __qtablewidgetitem224); tableWidget_15->setObjectName(QStringLiteral("tableWidget_15")); gridLayout_2->addWidget(tableWidget_15, 1, 0, 1, 1); tableWidget_16 = new QTableWidget(tab_10); if (tableWidget_16->columnCount() < 5) tableWidget_16->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem225 = new QTableWidgetItem(); tableWidget_16->setHorizontalHeaderItem(0, __qtablewidgetitem225); QTableWidgetItem *__qtablewidgetitem226 = new QTableWidgetItem(); tableWidget_16->setHorizontalHeaderItem(1, __qtablewidgetitem226); QTableWidgetItem *__qtablewidgetitem227 = new QTableWidgetItem(); tableWidget_16->setHorizontalHeaderItem(2, __qtablewidgetitem227); QTableWidgetItem *__qtablewidgetitem228 = new QTableWidgetItem(); tableWidget_16->setHorizontalHeaderItem(3, __qtablewidgetitem228); QTableWidgetItem *__qtablewidgetitem229 = new QTableWidgetItem(); tableWidget_16->setHorizontalHeaderItem(4, __qtablewidgetitem229); if (tableWidget_16->rowCount() < 10) tableWidget_16->setRowCount(10); QTableWidgetItem *__qtablewidgetitem230 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(0, __qtablewidgetitem230); QTableWidgetItem *__qtablewidgetitem231 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(1, __qtablewidgetitem231); QTableWidgetItem *__qtablewidgetitem232 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(2, __qtablewidgetitem232); QTableWidgetItem *__qtablewidgetitem233 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(3, __qtablewidgetitem233); QTableWidgetItem *__qtablewidgetitem234 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(4, __qtablewidgetitem234); QTableWidgetItem *__qtablewidgetitem235 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(5, __qtablewidgetitem235); QTableWidgetItem *__qtablewidgetitem236 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(6, __qtablewidgetitem236); QTableWidgetItem *__qtablewidgetitem237 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(7, __qtablewidgetitem237); QTableWidgetItem *__qtablewidgetitem238 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(8, __qtablewidgetitem238); QTableWidgetItem *__qtablewidgetitem239 = new QTableWidgetItem(); tableWidget_16->setVerticalHeaderItem(9, __qtablewidgetitem239); tableWidget_16->setObjectName(QStringLiteral("tableWidget_16")); gridLayout_2->addWidget(tableWidget_16, 1, 1, 1, 1); tabWidget->addTab(tab_10, QString()); tab_11 = new QWidget(); tab_11->setObjectName(QStringLiteral("tab_11")); gridLayout_11 = new QGridLayout(tab_11); gridLayout_11->setSpacing(6); gridLayout_11->setContentsMargins(11, 11, 11, 11); gridLayout_11->setObjectName(QStringLiteral("gridLayout_11")); tableWidget_17 = new QTableWidget(tab_11); if (tableWidget_17->columnCount() < 5) tableWidget_17->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem240 = new QTableWidgetItem(); tableWidget_17->setHorizontalHeaderItem(0, __qtablewidgetitem240); QTableWidgetItem *__qtablewidgetitem241 = new QTableWidgetItem(); tableWidget_17->setHorizontalHeaderItem(1, __qtablewidgetitem241); QTableWidgetItem *__qtablewidgetitem242 = new QTableWidgetItem(); tableWidget_17->setHorizontalHeaderItem(2, __qtablewidgetitem242); QTableWidgetItem *__qtablewidgetitem243 = new QTableWidgetItem(); tableWidget_17->setHorizontalHeaderItem(3, __qtablewidgetitem243); QTableWidgetItem *__qtablewidgetitem244 = new QTableWidgetItem(); tableWidget_17->setHorizontalHeaderItem(4, __qtablewidgetitem244); if (tableWidget_17->rowCount() < 10) tableWidget_17->setRowCount(10); QTableWidgetItem *__qtablewidgetitem245 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(0, __qtablewidgetitem245); QTableWidgetItem *__qtablewidgetitem246 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(1, __qtablewidgetitem246); QTableWidgetItem *__qtablewidgetitem247 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(2, __qtablewidgetitem247); QTableWidgetItem *__qtablewidgetitem248 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(3, __qtablewidgetitem248); QTableWidgetItem *__qtablewidgetitem249 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(4, __qtablewidgetitem249); QTableWidgetItem *__qtablewidgetitem250 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(5, __qtablewidgetitem250); QTableWidgetItem *__qtablewidgetitem251 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(6, __qtablewidgetitem251); QTableWidgetItem *__qtablewidgetitem252 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(7, __qtablewidgetitem252); QTableWidgetItem *__qtablewidgetitem253 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(8, __qtablewidgetitem253); QTableWidgetItem *__qtablewidgetitem254 = new QTableWidgetItem(); tableWidget_17->setVerticalHeaderItem(9, __qtablewidgetitem254); tableWidget_17->setObjectName(QStringLiteral("tableWidget_17")); gridLayout_11->addWidget(tableWidget_17, 0, 0, 1, 1); tableWidget_18 = new QTableWidget(tab_11); if (tableWidget_18->columnCount() < 5) tableWidget_18->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem255 = new QTableWidgetItem(); tableWidget_18->setHorizontalHeaderItem(0, __qtablewidgetitem255); QTableWidgetItem *__qtablewidgetitem256 = new QTableWidgetItem(); tableWidget_18->setHorizontalHeaderItem(1, __qtablewidgetitem256); QTableWidgetItem *__qtablewidgetitem257 = new QTableWidgetItem(); tableWidget_18->setHorizontalHeaderItem(2, __qtablewidgetitem257); QTableWidgetItem *__qtablewidgetitem258 = new QTableWidgetItem(); tableWidget_18->setHorizontalHeaderItem(3, __qtablewidgetitem258); QTableWidgetItem *__qtablewidgetitem259 = new QTableWidgetItem(); tableWidget_18->setHorizontalHeaderItem(4, __qtablewidgetitem259); if (tableWidget_18->rowCount() < 10) tableWidget_18->setRowCount(10); QTableWidgetItem *__qtablewidgetitem260 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(0, __qtablewidgetitem260); QTableWidgetItem *__qtablewidgetitem261 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(1, __qtablewidgetitem261); QTableWidgetItem *__qtablewidgetitem262 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(2, __qtablewidgetitem262); QTableWidgetItem *__qtablewidgetitem263 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(3, __qtablewidgetitem263); QTableWidgetItem *__qtablewidgetitem264 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(4, __qtablewidgetitem264); QTableWidgetItem *__qtablewidgetitem265 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(5, __qtablewidgetitem265); QTableWidgetItem *__qtablewidgetitem266 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(6, __qtablewidgetitem266); QTableWidgetItem *__qtablewidgetitem267 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(7, __qtablewidgetitem267); QTableWidgetItem *__qtablewidgetitem268 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(8, __qtablewidgetitem268); QTableWidgetItem *__qtablewidgetitem269 = new QTableWidgetItem(); tableWidget_18->setVerticalHeaderItem(9, __qtablewidgetitem269); tableWidget_18->setObjectName(QStringLiteral("tableWidget_18")); gridLayout_11->addWidget(tableWidget_18, 0, 1, 1, 1); tableWidget_19 = new QTableWidget(tab_11); if (tableWidget_19->columnCount() < 5) tableWidget_19->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem270 = new QTableWidgetItem(); tableWidget_19->setHorizontalHeaderItem(0, __qtablewidgetitem270); QTableWidgetItem *__qtablewidgetitem271 = new QTableWidgetItem(); tableWidget_19->setHorizontalHeaderItem(1, __qtablewidgetitem271); QTableWidgetItem *__qtablewidgetitem272 = new QTableWidgetItem(); tableWidget_19->setHorizontalHeaderItem(2, __qtablewidgetitem272); QTableWidgetItem *__qtablewidgetitem273 = new QTableWidgetItem(); tableWidget_19->setHorizontalHeaderItem(3, __qtablewidgetitem273); QTableWidgetItem *__qtablewidgetitem274 = new QTableWidgetItem(); tableWidget_19->setHorizontalHeaderItem(4, __qtablewidgetitem274); if (tableWidget_19->rowCount() < 10) tableWidget_19->setRowCount(10); QTableWidgetItem *__qtablewidgetitem275 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(0, __qtablewidgetitem275); QTableWidgetItem *__qtablewidgetitem276 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(1, __qtablewidgetitem276); QTableWidgetItem *__qtablewidgetitem277 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(2, __qtablewidgetitem277); QTableWidgetItem *__qtablewidgetitem278 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(3, __qtablewidgetitem278); QTableWidgetItem *__qtablewidgetitem279 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(4, __qtablewidgetitem279); QTableWidgetItem *__qtablewidgetitem280 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(5, __qtablewidgetitem280); QTableWidgetItem *__qtablewidgetitem281 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(6, __qtablewidgetitem281); QTableWidgetItem *__qtablewidgetitem282 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(7, __qtablewidgetitem282); QTableWidgetItem *__qtablewidgetitem283 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(8, __qtablewidgetitem283); QTableWidgetItem *__qtablewidgetitem284 = new QTableWidgetItem(); tableWidget_19->setVerticalHeaderItem(9, __qtablewidgetitem284); tableWidget_19->setObjectName(QStringLiteral("tableWidget_19")); gridLayout_11->addWidget(tableWidget_19, 1, 0, 1, 1); tableWidget_20 = new QTableWidget(tab_11); if (tableWidget_20->columnCount() < 5) tableWidget_20->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem285 = new QTableWidgetItem(); tableWidget_20->setHorizontalHeaderItem(0, __qtablewidgetitem285); QTableWidgetItem *__qtablewidgetitem286 = new QTableWidgetItem(); tableWidget_20->setHorizontalHeaderItem(1, __qtablewidgetitem286); QTableWidgetItem *__qtablewidgetitem287 = new QTableWidgetItem(); tableWidget_20->setHorizontalHeaderItem(2, __qtablewidgetitem287); QTableWidgetItem *__qtablewidgetitem288 = new QTableWidgetItem(); tableWidget_20->setHorizontalHeaderItem(3, __qtablewidgetitem288); QTableWidgetItem *__qtablewidgetitem289 = new QTableWidgetItem(); tableWidget_20->setHorizontalHeaderItem(4, __qtablewidgetitem289); if (tableWidget_20->rowCount() < 10) tableWidget_20->setRowCount(10); QTableWidgetItem *__qtablewidgetitem290 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(0, __qtablewidgetitem290); QTableWidgetItem *__qtablewidgetitem291 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(1, __qtablewidgetitem291); QTableWidgetItem *__qtablewidgetitem292 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(2, __qtablewidgetitem292); QTableWidgetItem *__qtablewidgetitem293 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(3, __qtablewidgetitem293); QTableWidgetItem *__qtablewidgetitem294 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(4, __qtablewidgetitem294); QTableWidgetItem *__qtablewidgetitem295 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(5, __qtablewidgetitem295); QTableWidgetItem *__qtablewidgetitem296 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(6, __qtablewidgetitem296); QTableWidgetItem *__qtablewidgetitem297 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(7, __qtablewidgetitem297); QTableWidgetItem *__qtablewidgetitem298 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(8, __qtablewidgetitem298); QTableWidgetItem *__qtablewidgetitem299 = new QTableWidgetItem(); tableWidget_20->setVerticalHeaderItem(9, __qtablewidgetitem299); tableWidget_20->setObjectName(QStringLiteral("tableWidget_20")); gridLayout_11->addWidget(tableWidget_20, 1, 1, 1, 1); tabWidget->addTab(tab_11, QString()); tab_12 = new QWidget(); tab_12->setObjectName(QStringLiteral("tab_12")); gridLayout_12 = new QGridLayout(tab_12); gridLayout_12->setSpacing(6); gridLayout_12->setContentsMargins(11, 11, 11, 11); gridLayout_12->setObjectName(QStringLiteral("gridLayout_12")); tableWidget_21 = new QTableWidget(tab_12); if (tableWidget_21->columnCount() < 5) tableWidget_21->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem300 = new QTableWidgetItem(); tableWidget_21->setHorizontalHeaderItem(0, __qtablewidgetitem300); QTableWidgetItem *__qtablewidgetitem301 = new QTableWidgetItem(); tableWidget_21->setHorizontalHeaderItem(1, __qtablewidgetitem301); QTableWidgetItem *__qtablewidgetitem302 = new QTableWidgetItem(); tableWidget_21->setHorizontalHeaderItem(2, __qtablewidgetitem302); QTableWidgetItem *__qtablewidgetitem303 = new QTableWidgetItem(); tableWidget_21->setHorizontalHeaderItem(3, __qtablewidgetitem303); QTableWidgetItem *__qtablewidgetitem304 = new QTableWidgetItem(); tableWidget_21->setHorizontalHeaderItem(4, __qtablewidgetitem304); if (tableWidget_21->rowCount() < 10) tableWidget_21->setRowCount(10); QTableWidgetItem *__qtablewidgetitem305 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(0, __qtablewidgetitem305); QTableWidgetItem *__qtablewidgetitem306 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(1, __qtablewidgetitem306); QTableWidgetItem *__qtablewidgetitem307 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(2, __qtablewidgetitem307); QTableWidgetItem *__qtablewidgetitem308 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(3, __qtablewidgetitem308); QTableWidgetItem *__qtablewidgetitem309 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(4, __qtablewidgetitem309); QTableWidgetItem *__qtablewidgetitem310 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(5, __qtablewidgetitem310); QTableWidgetItem *__qtablewidgetitem311 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(6, __qtablewidgetitem311); QTableWidgetItem *__qtablewidgetitem312 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(7, __qtablewidgetitem312); QTableWidgetItem *__qtablewidgetitem313 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(8, __qtablewidgetitem313); QTableWidgetItem *__qtablewidgetitem314 = new QTableWidgetItem(); tableWidget_21->setVerticalHeaderItem(9, __qtablewidgetitem314); tableWidget_21->setObjectName(QStringLiteral("tableWidget_21")); gridLayout_12->addWidget(tableWidget_21, 0, 0, 1, 1); tableWidget_22 = new QTableWidget(tab_12); if (tableWidget_22->columnCount() < 5) tableWidget_22->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem315 = new QTableWidgetItem(); tableWidget_22->setHorizontalHeaderItem(0, __qtablewidgetitem315); QTableWidgetItem *__qtablewidgetitem316 = new QTableWidgetItem(); tableWidget_22->setHorizontalHeaderItem(1, __qtablewidgetitem316); QTableWidgetItem *__qtablewidgetitem317 = new QTableWidgetItem(); tableWidget_22->setHorizontalHeaderItem(2, __qtablewidgetitem317); QTableWidgetItem *__qtablewidgetitem318 = new QTableWidgetItem(); tableWidget_22->setHorizontalHeaderItem(3, __qtablewidgetitem318); QTableWidgetItem *__qtablewidgetitem319 = new QTableWidgetItem(); tableWidget_22->setHorizontalHeaderItem(4, __qtablewidgetitem319); if (tableWidget_22->rowCount() < 10) tableWidget_22->setRowCount(10); QTableWidgetItem *__qtablewidgetitem320 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(0, __qtablewidgetitem320); QTableWidgetItem *__qtablewidgetitem321 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(1, __qtablewidgetitem321); QTableWidgetItem *__qtablewidgetitem322 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(2, __qtablewidgetitem322); QTableWidgetItem *__qtablewidgetitem323 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(3, __qtablewidgetitem323); QTableWidgetItem *__qtablewidgetitem324 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(4, __qtablewidgetitem324); QTableWidgetItem *__qtablewidgetitem325 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(5, __qtablewidgetitem325); QTableWidgetItem *__qtablewidgetitem326 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(6, __qtablewidgetitem326); QTableWidgetItem *__qtablewidgetitem327 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(7, __qtablewidgetitem327); QTableWidgetItem *__qtablewidgetitem328 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(8, __qtablewidgetitem328); QTableWidgetItem *__qtablewidgetitem329 = new QTableWidgetItem(); tableWidget_22->setVerticalHeaderItem(9, __qtablewidgetitem329); tableWidget_22->setObjectName(QStringLiteral("tableWidget_22")); gridLayout_12->addWidget(tableWidget_22, 0, 1, 1, 1); tableWidget_23 = new QTableWidget(tab_12); if (tableWidget_23->columnCount() < 5) tableWidget_23->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem330 = new QTableWidgetItem(); tableWidget_23->setHorizontalHeaderItem(0, __qtablewidgetitem330); QTableWidgetItem *__qtablewidgetitem331 = new QTableWidgetItem(); tableWidget_23->setHorizontalHeaderItem(1, __qtablewidgetitem331); QTableWidgetItem *__qtablewidgetitem332 = new QTableWidgetItem(); tableWidget_23->setHorizontalHeaderItem(2, __qtablewidgetitem332); QTableWidgetItem *__qtablewidgetitem333 = new QTableWidgetItem(); tableWidget_23->setHorizontalHeaderItem(3, __qtablewidgetitem333); QTableWidgetItem *__qtablewidgetitem334 = new QTableWidgetItem(); tableWidget_23->setHorizontalHeaderItem(4, __qtablewidgetitem334); if (tableWidget_23->rowCount() < 10) tableWidget_23->setRowCount(10); QTableWidgetItem *__qtablewidgetitem335 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(0, __qtablewidgetitem335); QTableWidgetItem *__qtablewidgetitem336 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(1, __qtablewidgetitem336); QTableWidgetItem *__qtablewidgetitem337 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(2, __qtablewidgetitem337); QTableWidgetItem *__qtablewidgetitem338 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(3, __qtablewidgetitem338); QTableWidgetItem *__qtablewidgetitem339 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(4, __qtablewidgetitem339); QTableWidgetItem *__qtablewidgetitem340 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(5, __qtablewidgetitem340); QTableWidgetItem *__qtablewidgetitem341 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(6, __qtablewidgetitem341); QTableWidgetItem *__qtablewidgetitem342 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(7, __qtablewidgetitem342); QTableWidgetItem *__qtablewidgetitem343 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(8, __qtablewidgetitem343); QTableWidgetItem *__qtablewidgetitem344 = new QTableWidgetItem(); tableWidget_23->setVerticalHeaderItem(9, __qtablewidgetitem344); tableWidget_23->setObjectName(QStringLiteral("tableWidget_23")); gridLayout_12->addWidget(tableWidget_23, 0, 2, 1, 1); tableWidget_24 = new QTableWidget(tab_12); if (tableWidget_24->columnCount() < 5) tableWidget_24->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem345 = new QTableWidgetItem(); tableWidget_24->setHorizontalHeaderItem(0, __qtablewidgetitem345); QTableWidgetItem *__qtablewidgetitem346 = new QTableWidgetItem(); tableWidget_24->setHorizontalHeaderItem(1, __qtablewidgetitem346); QTableWidgetItem *__qtablewidgetitem347 = new QTableWidgetItem(); tableWidget_24->setHorizontalHeaderItem(2, __qtablewidgetitem347); QTableWidgetItem *__qtablewidgetitem348 = new QTableWidgetItem(); tableWidget_24->setHorizontalHeaderItem(3, __qtablewidgetitem348); QTableWidgetItem *__qtablewidgetitem349 = new QTableWidgetItem(); tableWidget_24->setHorizontalHeaderItem(4, __qtablewidgetitem349); if (tableWidget_24->rowCount() < 10) tableWidget_24->setRowCount(10); QTableWidgetItem *__qtablewidgetitem350 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(0, __qtablewidgetitem350); QTableWidgetItem *__qtablewidgetitem351 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(1, __qtablewidgetitem351); QTableWidgetItem *__qtablewidgetitem352 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(2, __qtablewidgetitem352); QTableWidgetItem *__qtablewidgetitem353 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(3, __qtablewidgetitem353); QTableWidgetItem *__qtablewidgetitem354 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(4, __qtablewidgetitem354); QTableWidgetItem *__qtablewidgetitem355 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(5, __qtablewidgetitem355); QTableWidgetItem *__qtablewidgetitem356 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(6, __qtablewidgetitem356); QTableWidgetItem *__qtablewidgetitem357 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(7, __qtablewidgetitem357); QTableWidgetItem *__qtablewidgetitem358 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(8, __qtablewidgetitem358); QTableWidgetItem *__qtablewidgetitem359 = new QTableWidgetItem(); tableWidget_24->setVerticalHeaderItem(9, __qtablewidgetitem359); tableWidget_24->setObjectName(QStringLiteral("tableWidget_24")); gridLayout_12->addWidget(tableWidget_24, 0, 3, 1, 1); tableWidget_25 = new QTableWidget(tab_12); if (tableWidget_25->columnCount() < 5) tableWidget_25->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem360 = new QTableWidgetItem(); tableWidget_25->setHorizontalHeaderItem(0, __qtablewidgetitem360); QTableWidgetItem *__qtablewidgetitem361 = new QTableWidgetItem(); tableWidget_25->setHorizontalHeaderItem(1, __qtablewidgetitem361); QTableWidgetItem *__qtablewidgetitem362 = new QTableWidgetItem(); tableWidget_25->setHorizontalHeaderItem(2, __qtablewidgetitem362); QTableWidgetItem *__qtablewidgetitem363 = new QTableWidgetItem(); tableWidget_25->setHorizontalHeaderItem(3, __qtablewidgetitem363); QTableWidgetItem *__qtablewidgetitem364 = new QTableWidgetItem(); tableWidget_25->setHorizontalHeaderItem(4, __qtablewidgetitem364); if (tableWidget_25->rowCount() < 10) tableWidget_25->setRowCount(10); QTableWidgetItem *__qtablewidgetitem365 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(0, __qtablewidgetitem365); QTableWidgetItem *__qtablewidgetitem366 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(1, __qtablewidgetitem366); QTableWidgetItem *__qtablewidgetitem367 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(2, __qtablewidgetitem367); QTableWidgetItem *__qtablewidgetitem368 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(3, __qtablewidgetitem368); QTableWidgetItem *__qtablewidgetitem369 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(4, __qtablewidgetitem369); QTableWidgetItem *__qtablewidgetitem370 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(5, __qtablewidgetitem370); QTableWidgetItem *__qtablewidgetitem371 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(6, __qtablewidgetitem371); QTableWidgetItem *__qtablewidgetitem372 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(7, __qtablewidgetitem372); QTableWidgetItem *__qtablewidgetitem373 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(8, __qtablewidgetitem373); QTableWidgetItem *__qtablewidgetitem374 = new QTableWidgetItem(); tableWidget_25->setVerticalHeaderItem(9, __qtablewidgetitem374); tableWidget_25->setObjectName(QStringLiteral("tableWidget_25")); gridLayout_12->addWidget(tableWidget_25, 1, 0, 1, 1); tableWidget_26 = new QTableWidget(tab_12); if (tableWidget_26->columnCount() < 5) tableWidget_26->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem375 = new QTableWidgetItem(); tableWidget_26->setHorizontalHeaderItem(0, __qtablewidgetitem375); QTableWidgetItem *__qtablewidgetitem376 = new QTableWidgetItem(); tableWidget_26->setHorizontalHeaderItem(1, __qtablewidgetitem376); QTableWidgetItem *__qtablewidgetitem377 = new QTableWidgetItem(); tableWidget_26->setHorizontalHeaderItem(2, __qtablewidgetitem377); QTableWidgetItem *__qtablewidgetitem378 = new QTableWidgetItem(); tableWidget_26->setHorizontalHeaderItem(3, __qtablewidgetitem378); QTableWidgetItem *__qtablewidgetitem379 = new QTableWidgetItem(); tableWidget_26->setHorizontalHeaderItem(4, __qtablewidgetitem379); if (tableWidget_26->rowCount() < 9) tableWidget_26->setRowCount(9); QTableWidgetItem *__qtablewidgetitem380 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(0, __qtablewidgetitem380); QTableWidgetItem *__qtablewidgetitem381 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(1, __qtablewidgetitem381); QTableWidgetItem *__qtablewidgetitem382 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(2, __qtablewidgetitem382); QTableWidgetItem *__qtablewidgetitem383 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(3, __qtablewidgetitem383); QTableWidgetItem *__qtablewidgetitem384 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(4, __qtablewidgetitem384); QTableWidgetItem *__qtablewidgetitem385 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(5, __qtablewidgetitem385); QTableWidgetItem *__qtablewidgetitem386 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(6, __qtablewidgetitem386); QTableWidgetItem *__qtablewidgetitem387 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(7, __qtablewidgetitem387); QTableWidgetItem *__qtablewidgetitem388 = new QTableWidgetItem(); tableWidget_26->setVerticalHeaderItem(8, __qtablewidgetitem388); tableWidget_26->setObjectName(QStringLiteral("tableWidget_26")); gridLayout_12->addWidget(tableWidget_26, 1, 1, 1, 1); tableWidget_27 = new QTableWidget(tab_12); if (tableWidget_27->columnCount() < 5) tableWidget_27->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem389 = new QTableWidgetItem(); tableWidget_27->setHorizontalHeaderItem(0, __qtablewidgetitem389); QTableWidgetItem *__qtablewidgetitem390 = new QTableWidgetItem(); tableWidget_27->setHorizontalHeaderItem(1, __qtablewidgetitem390); QTableWidgetItem *__qtablewidgetitem391 = new QTableWidgetItem(); tableWidget_27->setHorizontalHeaderItem(2, __qtablewidgetitem391); QTableWidgetItem *__qtablewidgetitem392 = new QTableWidgetItem(); tableWidget_27->setHorizontalHeaderItem(3, __qtablewidgetitem392); QTableWidgetItem *__qtablewidgetitem393 = new QTableWidgetItem(); tableWidget_27->setHorizontalHeaderItem(4, __qtablewidgetitem393); if (tableWidget_27->rowCount() < 10) tableWidget_27->setRowCount(10); QTableWidgetItem *__qtablewidgetitem394 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(0, __qtablewidgetitem394); QTableWidgetItem *__qtablewidgetitem395 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(1, __qtablewidgetitem395); QTableWidgetItem *__qtablewidgetitem396 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(2, __qtablewidgetitem396); QTableWidgetItem *__qtablewidgetitem397 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(3, __qtablewidgetitem397); QTableWidgetItem *__qtablewidgetitem398 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(4, __qtablewidgetitem398); QTableWidgetItem *__qtablewidgetitem399 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(5, __qtablewidgetitem399); QTableWidgetItem *__qtablewidgetitem400 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(6, __qtablewidgetitem400); QTableWidgetItem *__qtablewidgetitem401 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(7, __qtablewidgetitem401); QTableWidgetItem *__qtablewidgetitem402 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(8, __qtablewidgetitem402); QTableWidgetItem *__qtablewidgetitem403 = new QTableWidgetItem(); tableWidget_27->setVerticalHeaderItem(9, __qtablewidgetitem403); tableWidget_27->setObjectName(QStringLiteral("tableWidget_27")); gridLayout_12->addWidget(tableWidget_27, 1, 2, 1, 1); tableWidget_28 = new QTableWidget(tab_12); if (tableWidget_28->columnCount() < 5) tableWidget_28->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem404 = new QTableWidgetItem(); tableWidget_28->setHorizontalHeaderItem(0, __qtablewidgetitem404); QTableWidgetItem *__qtablewidgetitem405 = new QTableWidgetItem(); tableWidget_28->setHorizontalHeaderItem(1, __qtablewidgetitem405); QTableWidgetItem *__qtablewidgetitem406 = new QTableWidgetItem(); tableWidget_28->setHorizontalHeaderItem(2, __qtablewidgetitem406); QTableWidgetItem *__qtablewidgetitem407 = new QTableWidgetItem(); tableWidget_28->setHorizontalHeaderItem(3, __qtablewidgetitem407); QTableWidgetItem *__qtablewidgetitem408 = new QTableWidgetItem(); tableWidget_28->setHorizontalHeaderItem(4, __qtablewidgetitem408); if (tableWidget_28->rowCount() < 10) tableWidget_28->setRowCount(10); QTableWidgetItem *__qtablewidgetitem409 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(0, __qtablewidgetitem409); QTableWidgetItem *__qtablewidgetitem410 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(1, __qtablewidgetitem410); QTableWidgetItem *__qtablewidgetitem411 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(2, __qtablewidgetitem411); QTableWidgetItem *__qtablewidgetitem412 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(3, __qtablewidgetitem412); QTableWidgetItem *__qtablewidgetitem413 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(4, __qtablewidgetitem413); QTableWidgetItem *__qtablewidgetitem414 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(5, __qtablewidgetitem414); QTableWidgetItem *__qtablewidgetitem415 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(6, __qtablewidgetitem415); QTableWidgetItem *__qtablewidgetitem416 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(7, __qtablewidgetitem416); QTableWidgetItem *__qtablewidgetitem417 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(8, __qtablewidgetitem417); QTableWidgetItem *__qtablewidgetitem418 = new QTableWidgetItem(); tableWidget_28->setVerticalHeaderItem(9, __qtablewidgetitem418); tableWidget_28->setObjectName(QStringLiteral("tableWidget_28")); gridLayout_12->addWidget(tableWidget_28, 1, 3, 1, 1); tabWidget->addTab(tab_12, QString()); tab_13 = new QWidget(); tab_13->setObjectName(QStringLiteral("tab_13")); gridLayout_13 = new QGridLayout(tab_13); gridLayout_13->setSpacing(6); gridLayout_13->setContentsMargins(11, 11, 11, 11); gridLayout_13->setObjectName(QStringLiteral("gridLayout_13")); tableWidget = new QTableWidget(tab_13); if (tableWidget->columnCount() < 5) tableWidget->setColumnCount(5); QTableWidgetItem *__qtablewidgetitem419 = new QTableWidgetItem(); tableWidget->setHorizontalHeaderItem(0, __qtablewidgetitem419); QTableWidgetItem *__qtablewidgetitem420 = new QTableWidgetItem(); tableWidget->setHorizontalHeaderItem(1, __qtablewidgetitem420); QTableWidgetItem *__qtablewidgetitem421 = new QTableWidgetItem(); tableWidget->setHorizontalHeaderItem(2, __qtablewidgetitem421); QTableWidgetItem *__qtablewidgetitem422 = new QTableWidgetItem(); tableWidget->setHorizontalHeaderItem(3, __qtablewidgetitem422); QTableWidgetItem *__qtablewidgetitem423 = new QTableWidgetItem(); tableWidget->setHorizontalHeaderItem(4, __qtablewidgetitem423); if (tableWidget->rowCount() < 10) tableWidget->setRowCount(10); QTableWidgetItem *__qtablewidgetitem424 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(0, __qtablewidgetitem424); QTableWidgetItem *__qtablewidgetitem425 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(1, __qtablewidgetitem425); QTableWidgetItem *__qtablewidgetitem426 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(2, __qtablewidgetitem426); QTableWidgetItem *__qtablewidgetitem427 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(3, __qtablewidgetitem427); QTableWidgetItem *__qtablewidgetitem428 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(4, __qtablewidgetitem428); QTableWidgetItem *__qtablewidgetitem429 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(5, __qtablewidgetitem429); QTableWidgetItem *__qtablewidgetitem430 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(6, __qtablewidgetitem430); QTableWidgetItem *__qtablewidgetitem431 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(7, __qtablewidgetitem431); QTableWidgetItem *__qtablewidgetitem432 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(8, __qtablewidgetitem432); QTableWidgetItem *__qtablewidgetitem433 = new QTableWidgetItem(); tableWidget->setVerticalHeaderItem(9, __qtablewidgetitem433); tableWidget->setObjectName(QStringLiteral("tableWidget")); gridLayout_13->addWidget(tableWidget, 0, 0, 1, 1); pushButton_7 = new QPushButton(tab_13); pushButton_7->setObjectName(QStringLiteral("pushButton_7")); gridLayout_13->addWidget(pushButton_7, 0, 2, 1, 1); pushButton_6 = new QPushButton(tab_13); pushButton_6->setObjectName(QStringLiteral("pushButton_6")); gridLayout_13->addWidget(pushButton_6, 0, 1, 1, 1); tabWidget->addTab(tab_13, QString()); verticalLayout_3->addWidget(tabWidget); horizontalLayout_6->addLayout(verticalLayout_3); verticalLayout = new QVBoxLayout(); verticalLayout->setSpacing(6); verticalLayout->setObjectName(QStringLiteral("verticalLayout")); pushButton_2 = new QPushButton(centralWidget); pushButton_2->setObjectName(QStringLiteral("pushButton_2")); verticalLayout->addWidget(pushButton_2); pushButton_5 = new QPushButton(centralWidget); pushButton_5->setObjectName(QStringLiteral("pushButton_5")); verticalLayout->addWidget(pushButton_5); pushButton_8 = new QPushButton(centralWidget); pushButton_8->setObjectName(QStringLiteral("pushButton_8")); verticalLayout->addWidget(pushButton_8); horizontalLayout_6->addLayout(verticalLayout); horizontalLayout_3->addLayout(horizontalLayout_6); MainWindow->setCentralWidget(centralWidget); menuBar = new QMenuBar(MainWindow); menuBar->setObjectName(QStringLiteral("menuBar")); menuBar->setGeometry(QRect(0, 0, 1451, 25)); MainWindow->setMenuBar(menuBar); mainToolBar = new QToolBar(MainWindow); mainToolBar->setObjectName(QStringLiteral("mainToolBar")); MainWindow->addToolBar(Qt::TopToolBarArea, mainToolBar); statusBar = new QStatusBar(MainWindow); statusBar->setObjectName(QStringLiteral("statusBar")); MainWindow->setStatusBar(statusBar); retranslateUi(MainWindow); tabWidget->setCurrentIndex(11); QMetaObject::connectSlotsByName(MainWindow); } // setupUi void retranslateUi(QMainWindow *MainWindow) { MainWindow->setWindowTitle(QApplication::translate("MainWindow", "MainWindow", 0)); label->setText(QApplication::translate("MainWindow", "Press NSGA-II Button", 0)); pushButton->setText(QApplication::translate("MainWindow", "NSGA-ii", 0)); label_2->setText(QApplication::translate("MainWindow", "Choose any individual\n" "through Bespop.out\n" "to see on\n" "semester tables", 0)); pushButton_3->setText(QApplication::translate("MainWindow", "Print Chosen Individual", 0)); pushButton_4->setText(QApplication::translate("MainWindow", "Reset Tables", 0)); pushButton_9->setText(QApplication::translate("MainWindow", "Report Constraints", 0)); QTableWidgetItem *___qtablewidgetitem = tableWidget_1->horizontalHeaderItem(0); ___qtablewidgetitem->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem1 = tableWidget_1->horizontalHeaderItem(1); ___qtablewidgetitem1->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem2 = tableWidget_1->horizontalHeaderItem(2); ___qtablewidgetitem2->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem3 = tableWidget_1->horizontalHeaderItem(3); ___qtablewidgetitem3->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem4 = tableWidget_1->horizontalHeaderItem(4); ___qtablewidgetitem4->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem5 = tableWidget_1->verticalHeaderItem(0); ___qtablewidgetitem5->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem6 = tableWidget_1->verticalHeaderItem(1); ___qtablewidgetitem6->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem7 = tableWidget_1->verticalHeaderItem(2); ___qtablewidgetitem7->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem8 = tableWidget_1->verticalHeaderItem(3); ___qtablewidgetitem8->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem9 = tableWidget_1->verticalHeaderItem(4); ___qtablewidgetitem9->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem10 = tableWidget_1->verticalHeaderItem(5); ___qtablewidgetitem10->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem11 = tableWidget_1->verticalHeaderItem(6); ___qtablewidgetitem11->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem12 = tableWidget_1->verticalHeaderItem(7); ___qtablewidgetitem12->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem13 = tableWidget_1->verticalHeaderItem(8); ___qtablewidgetitem13->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem14 = tableWidget_1->verticalHeaderItem(9); ___qtablewidgetitem14->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab), QApplication::translate("MainWindow", "Tab 1", 0)); QTableWidgetItem *___qtablewidgetitem15 = tableWidget_2->horizontalHeaderItem(0); ___qtablewidgetitem15->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem16 = tableWidget_2->horizontalHeaderItem(1); ___qtablewidgetitem16->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem17 = tableWidget_2->horizontalHeaderItem(2); ___qtablewidgetitem17->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem18 = tableWidget_2->horizontalHeaderItem(3); ___qtablewidgetitem18->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem19 = tableWidget_2->horizontalHeaderItem(4); ___qtablewidgetitem19->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem20 = tableWidget_2->verticalHeaderItem(0); ___qtablewidgetitem20->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem21 = tableWidget_2->verticalHeaderItem(1); ___qtablewidgetitem21->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem22 = tableWidget_2->verticalHeaderItem(2); ___qtablewidgetitem22->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem23 = tableWidget_2->verticalHeaderItem(3); ___qtablewidgetitem23->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem24 = tableWidget_2->verticalHeaderItem(4); ___qtablewidgetitem24->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem25 = tableWidget_2->verticalHeaderItem(5); ___qtablewidgetitem25->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem26 = tableWidget_2->verticalHeaderItem(6); ___qtablewidgetitem26->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem27 = tableWidget_2->verticalHeaderItem(7); ___qtablewidgetitem27->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem28 = tableWidget_2->verticalHeaderItem(8); ___qtablewidgetitem28->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem29 = tableWidget_2->verticalHeaderItem(9); ___qtablewidgetitem29->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_2), QApplication::translate("MainWindow", "Tab 2", 0)); QTableWidgetItem *___qtablewidgetitem30 = tableWidget_3->horizontalHeaderItem(0); ___qtablewidgetitem30->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem31 = tableWidget_3->horizontalHeaderItem(1); ___qtablewidgetitem31->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem32 = tableWidget_3->horizontalHeaderItem(2); ___qtablewidgetitem32->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem33 = tableWidget_3->horizontalHeaderItem(3); ___qtablewidgetitem33->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem34 = tableWidget_3->horizontalHeaderItem(4); ___qtablewidgetitem34->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem35 = tableWidget_3->verticalHeaderItem(0); ___qtablewidgetitem35->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem36 = tableWidget_3->verticalHeaderItem(1); ___qtablewidgetitem36->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem37 = tableWidget_3->verticalHeaderItem(2); ___qtablewidgetitem37->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem38 = tableWidget_3->verticalHeaderItem(3); ___qtablewidgetitem38->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem39 = tableWidget_3->verticalHeaderItem(4); ___qtablewidgetitem39->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem40 = tableWidget_3->verticalHeaderItem(5); ___qtablewidgetitem40->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem41 = tableWidget_3->verticalHeaderItem(6); ___qtablewidgetitem41->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem42 = tableWidget_3->verticalHeaderItem(7); ___qtablewidgetitem42->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem43 = tableWidget_3->verticalHeaderItem(8); ___qtablewidgetitem43->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem44 = tableWidget_3->verticalHeaderItem(9); ___qtablewidgetitem44->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_3), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem45 = tableWidget_4->horizontalHeaderItem(0); ___qtablewidgetitem45->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem46 = tableWidget_4->horizontalHeaderItem(1); ___qtablewidgetitem46->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem47 = tableWidget_4->horizontalHeaderItem(2); ___qtablewidgetitem47->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem48 = tableWidget_4->horizontalHeaderItem(3); ___qtablewidgetitem48->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem49 = tableWidget_4->horizontalHeaderItem(4); ___qtablewidgetitem49->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem50 = tableWidget_4->verticalHeaderItem(0); ___qtablewidgetitem50->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem51 = tableWidget_4->verticalHeaderItem(1); ___qtablewidgetitem51->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem52 = tableWidget_4->verticalHeaderItem(2); ___qtablewidgetitem52->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem53 = tableWidget_4->verticalHeaderItem(3); ___qtablewidgetitem53->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem54 = tableWidget_4->verticalHeaderItem(4); ___qtablewidgetitem54->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem55 = tableWidget_4->verticalHeaderItem(5); ___qtablewidgetitem55->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem56 = tableWidget_4->verticalHeaderItem(6); ___qtablewidgetitem56->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem57 = tableWidget_4->verticalHeaderItem(7); ___qtablewidgetitem57->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem58 = tableWidget_4->verticalHeaderItem(8); ___qtablewidgetitem58->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem59 = tableWidget_4->verticalHeaderItem(9); ___qtablewidgetitem59->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_4), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem60 = tableWidget_5->horizontalHeaderItem(0); ___qtablewidgetitem60->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem61 = tableWidget_5->horizontalHeaderItem(1); ___qtablewidgetitem61->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem62 = tableWidget_5->horizontalHeaderItem(2); ___qtablewidgetitem62->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem63 = tableWidget_5->horizontalHeaderItem(3); ___qtablewidgetitem63->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem64 = tableWidget_5->horizontalHeaderItem(4); ___qtablewidgetitem64->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem65 = tableWidget_5->verticalHeaderItem(0); ___qtablewidgetitem65->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem66 = tableWidget_5->verticalHeaderItem(1); ___qtablewidgetitem66->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem67 = tableWidget_5->verticalHeaderItem(2); ___qtablewidgetitem67->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem68 = tableWidget_5->verticalHeaderItem(3); ___qtablewidgetitem68->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem69 = tableWidget_5->verticalHeaderItem(4); ___qtablewidgetitem69->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem70 = tableWidget_5->verticalHeaderItem(5); ___qtablewidgetitem70->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem71 = tableWidget_5->verticalHeaderItem(6); ___qtablewidgetitem71->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem72 = tableWidget_5->verticalHeaderItem(7); ___qtablewidgetitem72->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem73 = tableWidget_5->verticalHeaderItem(8); ___qtablewidgetitem73->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem74 = tableWidget_5->verticalHeaderItem(9); ___qtablewidgetitem74->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_5), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem75 = tableWidget_6->horizontalHeaderItem(0); ___qtablewidgetitem75->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem76 = tableWidget_6->horizontalHeaderItem(1); ___qtablewidgetitem76->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem77 = tableWidget_6->horizontalHeaderItem(2); ___qtablewidgetitem77->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem78 = tableWidget_6->horizontalHeaderItem(3); ___qtablewidgetitem78->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem79 = tableWidget_6->horizontalHeaderItem(4); ___qtablewidgetitem79->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem80 = tableWidget_6->verticalHeaderItem(0); ___qtablewidgetitem80->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem81 = tableWidget_6->verticalHeaderItem(1); ___qtablewidgetitem81->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem82 = tableWidget_6->verticalHeaderItem(2); ___qtablewidgetitem82->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem83 = tableWidget_6->verticalHeaderItem(3); ___qtablewidgetitem83->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem84 = tableWidget_6->verticalHeaderItem(4); ___qtablewidgetitem84->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem85 = tableWidget_6->verticalHeaderItem(5); ___qtablewidgetitem85->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem86 = tableWidget_6->verticalHeaderItem(6); ___qtablewidgetitem86->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem87 = tableWidget_6->verticalHeaderItem(7); ___qtablewidgetitem87->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem88 = tableWidget_6->verticalHeaderItem(8); ___qtablewidgetitem88->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem89 = tableWidget_6->verticalHeaderItem(9); ___qtablewidgetitem89->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_6), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem90 = tableWidget_7->horizontalHeaderItem(0); ___qtablewidgetitem90->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem91 = tableWidget_7->horizontalHeaderItem(1); ___qtablewidgetitem91->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem92 = tableWidget_7->horizontalHeaderItem(2); ___qtablewidgetitem92->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem93 = tableWidget_7->horizontalHeaderItem(3); ___qtablewidgetitem93->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem94 = tableWidget_7->horizontalHeaderItem(4); ___qtablewidgetitem94->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem95 = tableWidget_7->verticalHeaderItem(0); ___qtablewidgetitem95->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem96 = tableWidget_7->verticalHeaderItem(1); ___qtablewidgetitem96->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem97 = tableWidget_7->verticalHeaderItem(2); ___qtablewidgetitem97->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem98 = tableWidget_7->verticalHeaderItem(3); ___qtablewidgetitem98->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem99 = tableWidget_7->verticalHeaderItem(4); ___qtablewidgetitem99->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem100 = tableWidget_7->verticalHeaderItem(5); ___qtablewidgetitem100->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem101 = tableWidget_7->verticalHeaderItem(6); ___qtablewidgetitem101->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem102 = tableWidget_7->verticalHeaderItem(7); ___qtablewidgetitem102->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem103 = tableWidget_7->verticalHeaderItem(8); ___qtablewidgetitem103->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem104 = tableWidget_7->verticalHeaderItem(9); ___qtablewidgetitem104->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_7), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem105 = tableWidget_8->horizontalHeaderItem(0); ___qtablewidgetitem105->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem106 = tableWidget_8->horizontalHeaderItem(1); ___qtablewidgetitem106->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem107 = tableWidget_8->horizontalHeaderItem(2); ___qtablewidgetitem107->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem108 = tableWidget_8->horizontalHeaderItem(3); ___qtablewidgetitem108->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem109 = tableWidget_8->horizontalHeaderItem(4); ___qtablewidgetitem109->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem110 = tableWidget_8->verticalHeaderItem(0); ___qtablewidgetitem110->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem111 = tableWidget_8->verticalHeaderItem(1); ___qtablewidgetitem111->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem112 = tableWidget_8->verticalHeaderItem(2); ___qtablewidgetitem112->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem113 = tableWidget_8->verticalHeaderItem(3); ___qtablewidgetitem113->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem114 = tableWidget_8->verticalHeaderItem(4); ___qtablewidgetitem114->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem115 = tableWidget_8->verticalHeaderItem(5); ___qtablewidgetitem115->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem116 = tableWidget_8->verticalHeaderItem(6); ___qtablewidgetitem116->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem117 = tableWidget_8->verticalHeaderItem(7); ___qtablewidgetitem117->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem118 = tableWidget_8->verticalHeaderItem(8); ___qtablewidgetitem118->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem119 = tableWidget_8->verticalHeaderItem(9); ___qtablewidgetitem119->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_8), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem120 = tableWidget_9->horizontalHeaderItem(0); ___qtablewidgetitem120->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem121 = tableWidget_9->horizontalHeaderItem(1); ___qtablewidgetitem121->setText(QApplication::translate("MainWindow", "Tueaday", 0)); QTableWidgetItem *___qtablewidgetitem122 = tableWidget_9->horizontalHeaderItem(2); ___qtablewidgetitem122->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem123 = tableWidget_9->horizontalHeaderItem(3); ___qtablewidgetitem123->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem124 = tableWidget_9->horizontalHeaderItem(4); ___qtablewidgetitem124->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem125 = tableWidget_9->verticalHeaderItem(0); ___qtablewidgetitem125->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem126 = tableWidget_9->verticalHeaderItem(1); ___qtablewidgetitem126->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem127 = tableWidget_9->verticalHeaderItem(2); ___qtablewidgetitem127->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem128 = tableWidget_9->verticalHeaderItem(3); ___qtablewidgetitem128->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem129 = tableWidget_9->verticalHeaderItem(4); ___qtablewidgetitem129->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem130 = tableWidget_9->verticalHeaderItem(5); ___qtablewidgetitem130->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem131 = tableWidget_9->verticalHeaderItem(6); ___qtablewidgetitem131->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem132 = tableWidget_9->verticalHeaderItem(7); ___qtablewidgetitem132->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem133 = tableWidget_9->verticalHeaderItem(8); ___qtablewidgetitem133->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem134 = tableWidget_9->verticalHeaderItem(9); ___qtablewidgetitem134->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem135 = tableWidget_10->horizontalHeaderItem(0); ___qtablewidgetitem135->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem136 = tableWidget_10->horizontalHeaderItem(1); ___qtablewidgetitem136->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem137 = tableWidget_10->horizontalHeaderItem(2); ___qtablewidgetitem137->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem138 = tableWidget_10->horizontalHeaderItem(3); ___qtablewidgetitem138->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem139 = tableWidget_10->horizontalHeaderItem(4); ___qtablewidgetitem139->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem140 = tableWidget_10->verticalHeaderItem(0); ___qtablewidgetitem140->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem141 = tableWidget_10->verticalHeaderItem(1); ___qtablewidgetitem141->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem142 = tableWidget_10->verticalHeaderItem(2); ___qtablewidgetitem142->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem143 = tableWidget_10->verticalHeaderItem(3); ___qtablewidgetitem143->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem144 = tableWidget_10->verticalHeaderItem(4); ___qtablewidgetitem144->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem145 = tableWidget_10->verticalHeaderItem(5); ___qtablewidgetitem145->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem146 = tableWidget_10->verticalHeaderItem(6); ___qtablewidgetitem146->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem147 = tableWidget_10->verticalHeaderItem(7); ___qtablewidgetitem147->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem148 = tableWidget_10->verticalHeaderItem(8); ___qtablewidgetitem148->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem149 = tableWidget_10->verticalHeaderItem(9); ___qtablewidgetitem149->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem150 = tableWidget_11->horizontalHeaderItem(0); ___qtablewidgetitem150->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem151 = tableWidget_11->horizontalHeaderItem(1); ___qtablewidgetitem151->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem152 = tableWidget_11->horizontalHeaderItem(2); ___qtablewidgetitem152->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem153 = tableWidget_11->horizontalHeaderItem(3); ___qtablewidgetitem153->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem154 = tableWidget_11->horizontalHeaderItem(4); ___qtablewidgetitem154->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem155 = tableWidget_11->verticalHeaderItem(0); ___qtablewidgetitem155->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem156 = tableWidget_11->verticalHeaderItem(1); ___qtablewidgetitem156->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem157 = tableWidget_11->verticalHeaderItem(2); ___qtablewidgetitem157->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem158 = tableWidget_11->verticalHeaderItem(3); ___qtablewidgetitem158->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem159 = tableWidget_11->verticalHeaderItem(4); ___qtablewidgetitem159->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem160 = tableWidget_11->verticalHeaderItem(5); ___qtablewidgetitem160->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem161 = tableWidget_11->verticalHeaderItem(6); ___qtablewidgetitem161->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem162 = tableWidget_11->verticalHeaderItem(7); ___qtablewidgetitem162->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem163 = tableWidget_11->verticalHeaderItem(8); ___qtablewidgetitem163->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem164 = tableWidget_11->verticalHeaderItem(9); ___qtablewidgetitem164->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem165 = tableWidget_12->horizontalHeaderItem(0); ___qtablewidgetitem165->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem166 = tableWidget_12->horizontalHeaderItem(1); ___qtablewidgetitem166->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem167 = tableWidget_12->horizontalHeaderItem(2); ___qtablewidgetitem167->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem168 = tableWidget_12->horizontalHeaderItem(3); ___qtablewidgetitem168->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem169 = tableWidget_12->horizontalHeaderItem(4); ___qtablewidgetitem169->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem170 = tableWidget_12->verticalHeaderItem(0); ___qtablewidgetitem170->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem171 = tableWidget_12->verticalHeaderItem(1); ___qtablewidgetitem171->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem172 = tableWidget_12->verticalHeaderItem(2); ___qtablewidgetitem172->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem173 = tableWidget_12->verticalHeaderItem(3); ___qtablewidgetitem173->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem174 = tableWidget_12->verticalHeaderItem(4); ___qtablewidgetitem174->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem175 = tableWidget_12->verticalHeaderItem(5); ___qtablewidgetitem175->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem176 = tableWidget_12->verticalHeaderItem(6); ___qtablewidgetitem176->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem177 = tableWidget_12->verticalHeaderItem(7); ___qtablewidgetitem177->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem178 = tableWidget_12->verticalHeaderItem(8); ___qtablewidgetitem178->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem179 = tableWidget_12->verticalHeaderItem(9); ___qtablewidgetitem179->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_9), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem180 = tableWidget_13->horizontalHeaderItem(0); ___qtablewidgetitem180->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem181 = tableWidget_13->horizontalHeaderItem(1); ___qtablewidgetitem181->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem182 = tableWidget_13->horizontalHeaderItem(2); ___qtablewidgetitem182->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem183 = tableWidget_13->horizontalHeaderItem(3); ___qtablewidgetitem183->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem184 = tableWidget_13->horizontalHeaderItem(4); ___qtablewidgetitem184->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem185 = tableWidget_13->verticalHeaderItem(0); ___qtablewidgetitem185->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem186 = tableWidget_13->verticalHeaderItem(1); ___qtablewidgetitem186->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem187 = tableWidget_13->verticalHeaderItem(2); ___qtablewidgetitem187->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem188 = tableWidget_13->verticalHeaderItem(3); ___qtablewidgetitem188->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem189 = tableWidget_13->verticalHeaderItem(4); ___qtablewidgetitem189->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem190 = tableWidget_13->verticalHeaderItem(5); ___qtablewidgetitem190->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem191 = tableWidget_13->verticalHeaderItem(6); ___qtablewidgetitem191->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem192 = tableWidget_13->verticalHeaderItem(7); ___qtablewidgetitem192->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem193 = tableWidget_13->verticalHeaderItem(8); ___qtablewidgetitem193->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem194 = tableWidget_13->verticalHeaderItem(9); ___qtablewidgetitem194->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem195 = tableWidget_14->horizontalHeaderItem(0); ___qtablewidgetitem195->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem196 = tableWidget_14->horizontalHeaderItem(1); ___qtablewidgetitem196->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem197 = tableWidget_14->horizontalHeaderItem(2); ___qtablewidgetitem197->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem198 = tableWidget_14->horizontalHeaderItem(3); ___qtablewidgetitem198->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem199 = tableWidget_14->horizontalHeaderItem(4); ___qtablewidgetitem199->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem200 = tableWidget_14->verticalHeaderItem(0); ___qtablewidgetitem200->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem201 = tableWidget_14->verticalHeaderItem(1); ___qtablewidgetitem201->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem202 = tableWidget_14->verticalHeaderItem(2); ___qtablewidgetitem202->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem203 = tableWidget_14->verticalHeaderItem(3); ___qtablewidgetitem203->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem204 = tableWidget_14->verticalHeaderItem(4); ___qtablewidgetitem204->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem205 = tableWidget_14->verticalHeaderItem(5); ___qtablewidgetitem205->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem206 = tableWidget_14->verticalHeaderItem(6); ___qtablewidgetitem206->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem207 = tableWidget_14->verticalHeaderItem(7); ___qtablewidgetitem207->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem208 = tableWidget_14->verticalHeaderItem(8); ___qtablewidgetitem208->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem209 = tableWidget_14->verticalHeaderItem(9); ___qtablewidgetitem209->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem210 = tableWidget_15->horizontalHeaderItem(0); ___qtablewidgetitem210->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem211 = tableWidget_15->horizontalHeaderItem(1); ___qtablewidgetitem211->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem212 = tableWidget_15->horizontalHeaderItem(2); ___qtablewidgetitem212->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem213 = tableWidget_15->horizontalHeaderItem(3); ___qtablewidgetitem213->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem214 = tableWidget_15->horizontalHeaderItem(4); ___qtablewidgetitem214->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem215 = tableWidget_15->verticalHeaderItem(0); ___qtablewidgetitem215->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem216 = tableWidget_15->verticalHeaderItem(1); ___qtablewidgetitem216->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem217 = tableWidget_15->verticalHeaderItem(2); ___qtablewidgetitem217->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem218 = tableWidget_15->verticalHeaderItem(3); ___qtablewidgetitem218->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem219 = tableWidget_15->verticalHeaderItem(4); ___qtablewidgetitem219->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem220 = tableWidget_15->verticalHeaderItem(5); ___qtablewidgetitem220->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem221 = tableWidget_15->verticalHeaderItem(6); ___qtablewidgetitem221->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem222 = tableWidget_15->verticalHeaderItem(7); ___qtablewidgetitem222->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem223 = tableWidget_15->verticalHeaderItem(8); ___qtablewidgetitem223->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem224 = tableWidget_15->verticalHeaderItem(9); ___qtablewidgetitem224->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem225 = tableWidget_16->horizontalHeaderItem(0); ___qtablewidgetitem225->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem226 = tableWidget_16->horizontalHeaderItem(1); ___qtablewidgetitem226->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem227 = tableWidget_16->horizontalHeaderItem(2); ___qtablewidgetitem227->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem228 = tableWidget_16->horizontalHeaderItem(3); ___qtablewidgetitem228->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem229 = tableWidget_16->horizontalHeaderItem(4); ___qtablewidgetitem229->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem230 = tableWidget_16->verticalHeaderItem(0); ___qtablewidgetitem230->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem231 = tableWidget_16->verticalHeaderItem(1); ___qtablewidgetitem231->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem232 = tableWidget_16->verticalHeaderItem(2); ___qtablewidgetitem232->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem233 = tableWidget_16->verticalHeaderItem(3); ___qtablewidgetitem233->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem234 = tableWidget_16->verticalHeaderItem(4); ___qtablewidgetitem234->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem235 = tableWidget_16->verticalHeaderItem(5); ___qtablewidgetitem235->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem236 = tableWidget_16->verticalHeaderItem(6); ___qtablewidgetitem236->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem237 = tableWidget_16->verticalHeaderItem(7); ___qtablewidgetitem237->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem238 = tableWidget_16->verticalHeaderItem(8); ___qtablewidgetitem238->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem239 = tableWidget_16->verticalHeaderItem(9); ___qtablewidgetitem239->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_10), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem240 = tableWidget_17->horizontalHeaderItem(0); ___qtablewidgetitem240->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem241 = tableWidget_17->horizontalHeaderItem(1); ___qtablewidgetitem241->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem242 = tableWidget_17->horizontalHeaderItem(2); ___qtablewidgetitem242->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem243 = tableWidget_17->horizontalHeaderItem(3); ___qtablewidgetitem243->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem244 = tableWidget_17->horizontalHeaderItem(4); ___qtablewidgetitem244->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem245 = tableWidget_17->verticalHeaderItem(0); ___qtablewidgetitem245->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem246 = tableWidget_17->verticalHeaderItem(1); ___qtablewidgetitem246->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem247 = tableWidget_17->verticalHeaderItem(2); ___qtablewidgetitem247->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem248 = tableWidget_17->verticalHeaderItem(3); ___qtablewidgetitem248->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem249 = tableWidget_17->verticalHeaderItem(4); ___qtablewidgetitem249->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem250 = tableWidget_17->verticalHeaderItem(5); ___qtablewidgetitem250->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem251 = tableWidget_17->verticalHeaderItem(6); ___qtablewidgetitem251->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem252 = tableWidget_17->verticalHeaderItem(7); ___qtablewidgetitem252->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem253 = tableWidget_17->verticalHeaderItem(8); ___qtablewidgetitem253->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem254 = tableWidget_17->verticalHeaderItem(9); ___qtablewidgetitem254->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem255 = tableWidget_18->horizontalHeaderItem(0); ___qtablewidgetitem255->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem256 = tableWidget_18->horizontalHeaderItem(1); ___qtablewidgetitem256->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem257 = tableWidget_18->horizontalHeaderItem(2); ___qtablewidgetitem257->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem258 = tableWidget_18->horizontalHeaderItem(3); ___qtablewidgetitem258->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem259 = tableWidget_18->horizontalHeaderItem(4); ___qtablewidgetitem259->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem260 = tableWidget_18->verticalHeaderItem(0); ___qtablewidgetitem260->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem261 = tableWidget_18->verticalHeaderItem(1); ___qtablewidgetitem261->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem262 = tableWidget_18->verticalHeaderItem(2); ___qtablewidgetitem262->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem263 = tableWidget_18->verticalHeaderItem(3); ___qtablewidgetitem263->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem264 = tableWidget_18->verticalHeaderItem(4); ___qtablewidgetitem264->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem265 = tableWidget_18->verticalHeaderItem(5); ___qtablewidgetitem265->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem266 = tableWidget_18->verticalHeaderItem(6); ___qtablewidgetitem266->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem267 = tableWidget_18->verticalHeaderItem(7); ___qtablewidgetitem267->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem268 = tableWidget_18->verticalHeaderItem(8); ___qtablewidgetitem268->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem269 = tableWidget_18->verticalHeaderItem(9); ___qtablewidgetitem269->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem270 = tableWidget_19->horizontalHeaderItem(0); ___qtablewidgetitem270->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem271 = tableWidget_19->horizontalHeaderItem(1); ___qtablewidgetitem271->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem272 = tableWidget_19->horizontalHeaderItem(2); ___qtablewidgetitem272->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem273 = tableWidget_19->horizontalHeaderItem(3); ___qtablewidgetitem273->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem274 = tableWidget_19->horizontalHeaderItem(4); ___qtablewidgetitem274->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem275 = tableWidget_19->verticalHeaderItem(0); ___qtablewidgetitem275->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem276 = tableWidget_19->verticalHeaderItem(1); ___qtablewidgetitem276->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem277 = tableWidget_19->verticalHeaderItem(2); ___qtablewidgetitem277->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem278 = tableWidget_19->verticalHeaderItem(3); ___qtablewidgetitem278->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem279 = tableWidget_19->verticalHeaderItem(4); ___qtablewidgetitem279->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem280 = tableWidget_19->verticalHeaderItem(5); ___qtablewidgetitem280->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem281 = tableWidget_19->verticalHeaderItem(6); ___qtablewidgetitem281->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem282 = tableWidget_19->verticalHeaderItem(7); ___qtablewidgetitem282->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem283 = tableWidget_19->verticalHeaderItem(8); ___qtablewidgetitem283->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem284 = tableWidget_19->verticalHeaderItem(9); ___qtablewidgetitem284->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); QTableWidgetItem *___qtablewidgetitem285 = tableWidget_20->horizontalHeaderItem(0); ___qtablewidgetitem285->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem286 = tableWidget_20->horizontalHeaderItem(1); ___qtablewidgetitem286->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem287 = tableWidget_20->horizontalHeaderItem(2); ___qtablewidgetitem287->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem288 = tableWidget_20->horizontalHeaderItem(3); ___qtablewidgetitem288->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem289 = tableWidget_20->horizontalHeaderItem(4); ___qtablewidgetitem289->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem290 = tableWidget_20->verticalHeaderItem(0); ___qtablewidgetitem290->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem291 = tableWidget_20->verticalHeaderItem(1); ___qtablewidgetitem291->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem292 = tableWidget_20->verticalHeaderItem(2); ___qtablewidgetitem292->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem293 = tableWidget_20->verticalHeaderItem(3); ___qtablewidgetitem293->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem294 = tableWidget_20->verticalHeaderItem(4); ___qtablewidgetitem294->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem295 = tableWidget_20->verticalHeaderItem(5); ___qtablewidgetitem295->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem296 = tableWidget_20->verticalHeaderItem(6); ___qtablewidgetitem296->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem297 = tableWidget_20->verticalHeaderItem(7); ___qtablewidgetitem297->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem298 = tableWidget_20->verticalHeaderItem(8); ___qtablewidgetitem298->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem299 = tableWidget_20->verticalHeaderItem(9); ___qtablewidgetitem299->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_11), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem300 = tableWidget_21->horizontalHeaderItem(0); ___qtablewidgetitem300->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem301 = tableWidget_21->horizontalHeaderItem(1); ___qtablewidgetitem301->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem302 = tableWidget_21->horizontalHeaderItem(2); ___qtablewidgetitem302->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem303 = tableWidget_21->horizontalHeaderItem(3); ___qtablewidgetitem303->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem304 = tableWidget_21->horizontalHeaderItem(4); ___qtablewidgetitem304->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem305 = tableWidget_21->verticalHeaderItem(0); ___qtablewidgetitem305->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem306 = tableWidget_21->verticalHeaderItem(1); ___qtablewidgetitem306->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem307 = tableWidget_21->verticalHeaderItem(2); ___qtablewidgetitem307->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem308 = tableWidget_21->verticalHeaderItem(3); ___qtablewidgetitem308->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem309 = tableWidget_21->verticalHeaderItem(4); ___qtablewidgetitem309->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem310 = tableWidget_21->verticalHeaderItem(5); ___qtablewidgetitem310->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem311 = tableWidget_21->verticalHeaderItem(6); ___qtablewidgetitem311->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem312 = tableWidget_21->verticalHeaderItem(7); ___qtablewidgetitem312->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem313 = tableWidget_21->verticalHeaderItem(8); ___qtablewidgetitem313->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem314 = tableWidget_21->verticalHeaderItem(9); ___qtablewidgetitem314->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem315 = tableWidget_22->horizontalHeaderItem(0); ___qtablewidgetitem315->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem316 = tableWidget_22->horizontalHeaderItem(1); ___qtablewidgetitem316->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem317 = tableWidget_22->horizontalHeaderItem(2); ___qtablewidgetitem317->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem318 = tableWidget_22->horizontalHeaderItem(3); ___qtablewidgetitem318->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem319 = tableWidget_22->horizontalHeaderItem(4); ___qtablewidgetitem319->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem320 = tableWidget_22->verticalHeaderItem(0); ___qtablewidgetitem320->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem321 = tableWidget_22->verticalHeaderItem(1); ___qtablewidgetitem321->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem322 = tableWidget_22->verticalHeaderItem(2); ___qtablewidgetitem322->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem323 = tableWidget_22->verticalHeaderItem(3); ___qtablewidgetitem323->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem324 = tableWidget_22->verticalHeaderItem(4); ___qtablewidgetitem324->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem325 = tableWidget_22->verticalHeaderItem(5); ___qtablewidgetitem325->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem326 = tableWidget_22->verticalHeaderItem(6); ___qtablewidgetitem326->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem327 = tableWidget_22->verticalHeaderItem(7); ___qtablewidgetitem327->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem328 = tableWidget_22->verticalHeaderItem(8); ___qtablewidgetitem328->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem329 = tableWidget_22->verticalHeaderItem(9); ___qtablewidgetitem329->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem330 = tableWidget_23->horizontalHeaderItem(0); ___qtablewidgetitem330->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem331 = tableWidget_23->horizontalHeaderItem(1); ___qtablewidgetitem331->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem332 = tableWidget_23->horizontalHeaderItem(2); ___qtablewidgetitem332->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem333 = tableWidget_23->horizontalHeaderItem(3); ___qtablewidgetitem333->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem334 = tableWidget_23->horizontalHeaderItem(4); ___qtablewidgetitem334->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem335 = tableWidget_23->verticalHeaderItem(0); ___qtablewidgetitem335->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem336 = tableWidget_23->verticalHeaderItem(1); ___qtablewidgetitem336->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem337 = tableWidget_23->verticalHeaderItem(2); ___qtablewidgetitem337->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem338 = tableWidget_23->verticalHeaderItem(3); ___qtablewidgetitem338->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem339 = tableWidget_23->verticalHeaderItem(4); ___qtablewidgetitem339->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem340 = tableWidget_23->verticalHeaderItem(5); ___qtablewidgetitem340->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem341 = tableWidget_23->verticalHeaderItem(6); ___qtablewidgetitem341->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem342 = tableWidget_23->verticalHeaderItem(7); ___qtablewidgetitem342->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem343 = tableWidget_23->verticalHeaderItem(8); ___qtablewidgetitem343->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem344 = tableWidget_23->verticalHeaderItem(9); ___qtablewidgetitem344->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem345 = tableWidget_24->horizontalHeaderItem(0); ___qtablewidgetitem345->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem346 = tableWidget_24->horizontalHeaderItem(1); ___qtablewidgetitem346->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem347 = tableWidget_24->horizontalHeaderItem(2); ___qtablewidgetitem347->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem348 = tableWidget_24->horizontalHeaderItem(3); ___qtablewidgetitem348->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem349 = tableWidget_24->horizontalHeaderItem(4); ___qtablewidgetitem349->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem350 = tableWidget_24->verticalHeaderItem(0); ___qtablewidgetitem350->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem351 = tableWidget_24->verticalHeaderItem(1); ___qtablewidgetitem351->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem352 = tableWidget_24->verticalHeaderItem(2); ___qtablewidgetitem352->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem353 = tableWidget_24->verticalHeaderItem(3); ___qtablewidgetitem353->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem354 = tableWidget_24->verticalHeaderItem(4); ___qtablewidgetitem354->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem355 = tableWidget_24->verticalHeaderItem(5); ___qtablewidgetitem355->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem356 = tableWidget_24->verticalHeaderItem(6); ___qtablewidgetitem356->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem357 = tableWidget_24->verticalHeaderItem(7); ___qtablewidgetitem357->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem358 = tableWidget_24->verticalHeaderItem(8); ___qtablewidgetitem358->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem359 = tableWidget_24->verticalHeaderItem(9); ___qtablewidgetitem359->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem360 = tableWidget_25->horizontalHeaderItem(0); ___qtablewidgetitem360->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem361 = tableWidget_25->horizontalHeaderItem(1); ___qtablewidgetitem361->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem362 = tableWidget_25->horizontalHeaderItem(2); ___qtablewidgetitem362->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem363 = tableWidget_25->horizontalHeaderItem(3); ___qtablewidgetitem363->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem364 = tableWidget_25->horizontalHeaderItem(4); ___qtablewidgetitem364->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem365 = tableWidget_25->verticalHeaderItem(0); ___qtablewidgetitem365->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem366 = tableWidget_25->verticalHeaderItem(1); ___qtablewidgetitem366->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem367 = tableWidget_25->verticalHeaderItem(2); ___qtablewidgetitem367->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem368 = tableWidget_25->verticalHeaderItem(3); ___qtablewidgetitem368->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem369 = tableWidget_25->verticalHeaderItem(4); ___qtablewidgetitem369->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem370 = tableWidget_25->verticalHeaderItem(5); ___qtablewidgetitem370->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem371 = tableWidget_25->verticalHeaderItem(6); ___qtablewidgetitem371->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem372 = tableWidget_25->verticalHeaderItem(7); ___qtablewidgetitem372->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem373 = tableWidget_25->verticalHeaderItem(8); ___qtablewidgetitem373->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem374 = tableWidget_25->verticalHeaderItem(9); ___qtablewidgetitem374->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem375 = tableWidget_26->horizontalHeaderItem(0); ___qtablewidgetitem375->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem376 = tableWidget_26->horizontalHeaderItem(1); ___qtablewidgetitem376->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem377 = tableWidget_26->horizontalHeaderItem(2); ___qtablewidgetitem377->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem378 = tableWidget_26->horizontalHeaderItem(3); ___qtablewidgetitem378->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem379 = tableWidget_26->horizontalHeaderItem(4); ___qtablewidgetitem379->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem380 = tableWidget_26->verticalHeaderItem(0); ___qtablewidgetitem380->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem381 = tableWidget_26->verticalHeaderItem(1); ___qtablewidgetitem381->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem382 = tableWidget_26->verticalHeaderItem(2); ___qtablewidgetitem382->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem383 = tableWidget_26->verticalHeaderItem(3); ___qtablewidgetitem383->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem384 = tableWidget_26->verticalHeaderItem(4); ___qtablewidgetitem384->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem385 = tableWidget_26->verticalHeaderItem(5); ___qtablewidgetitem385->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem386 = tableWidget_26->verticalHeaderItem(6); ___qtablewidgetitem386->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem387 = tableWidget_26->verticalHeaderItem(7); ___qtablewidgetitem387->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem388 = tableWidget_26->verticalHeaderItem(8); ___qtablewidgetitem388->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem389 = tableWidget_27->horizontalHeaderItem(0); ___qtablewidgetitem389->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem390 = tableWidget_27->horizontalHeaderItem(1); ___qtablewidgetitem390->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem391 = tableWidget_27->horizontalHeaderItem(2); ___qtablewidgetitem391->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem392 = tableWidget_27->horizontalHeaderItem(3); ___qtablewidgetitem392->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem393 = tableWidget_27->horizontalHeaderItem(4); ___qtablewidgetitem393->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem394 = tableWidget_27->verticalHeaderItem(0); ___qtablewidgetitem394->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem395 = tableWidget_27->verticalHeaderItem(1); ___qtablewidgetitem395->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem396 = tableWidget_27->verticalHeaderItem(2); ___qtablewidgetitem396->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem397 = tableWidget_27->verticalHeaderItem(3); ___qtablewidgetitem397->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem398 = tableWidget_27->verticalHeaderItem(4); ___qtablewidgetitem398->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem399 = tableWidget_27->verticalHeaderItem(5); ___qtablewidgetitem399->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem400 = tableWidget_27->verticalHeaderItem(6); ___qtablewidgetitem400->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem401 = tableWidget_27->verticalHeaderItem(7); ___qtablewidgetitem401->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem402 = tableWidget_27->verticalHeaderItem(8); ___qtablewidgetitem402->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem403 = tableWidget_27->verticalHeaderItem(9); ___qtablewidgetitem403->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); QTableWidgetItem *___qtablewidgetitem404 = tableWidget_28->horizontalHeaderItem(0); ___qtablewidgetitem404->setText(QApplication::translate("MainWindow", "New Column", 0)); QTableWidgetItem *___qtablewidgetitem405 = tableWidget_28->horizontalHeaderItem(1); ___qtablewidgetitem405->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem406 = tableWidget_28->horizontalHeaderItem(2); ___qtablewidgetitem406->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem407 = tableWidget_28->horizontalHeaderItem(3); ___qtablewidgetitem407->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem408 = tableWidget_28->horizontalHeaderItem(4); ___qtablewidgetitem408->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem409 = tableWidget_28->verticalHeaderItem(0); ___qtablewidgetitem409->setText(QApplication::translate("MainWindow", "9:00-10:00", 0)); QTableWidgetItem *___qtablewidgetitem410 = tableWidget_28->verticalHeaderItem(1); ___qtablewidgetitem410->setText(QApplication::translate("MainWindow", "10:00-11:00", 0)); QTableWidgetItem *___qtablewidgetitem411 = tableWidget_28->verticalHeaderItem(2); ___qtablewidgetitem411->setText(QApplication::translate("MainWindow", "11:00-12:00", 0)); QTableWidgetItem *___qtablewidgetitem412 = tableWidget_28->verticalHeaderItem(3); ___qtablewidgetitem412->setText(QApplication::translate("MainWindow", "12:00-13:00", 0)); QTableWidgetItem *___qtablewidgetitem413 = tableWidget_28->verticalHeaderItem(4); ___qtablewidgetitem413->setText(QApplication::translate("MainWindow", "13:00-14:00", 0)); QTableWidgetItem *___qtablewidgetitem414 = tableWidget_28->verticalHeaderItem(5); ___qtablewidgetitem414->setText(QApplication::translate("MainWindow", "14:00-15:00", 0)); QTableWidgetItem *___qtablewidgetitem415 = tableWidget_28->verticalHeaderItem(6); ___qtablewidgetitem415->setText(QApplication::translate("MainWindow", "15:00-16:00", 0)); QTableWidgetItem *___qtablewidgetitem416 = tableWidget_28->verticalHeaderItem(7); ___qtablewidgetitem416->setText(QApplication::translate("MainWindow", "16:00-17:00", 0)); QTableWidgetItem *___qtablewidgetitem417 = tableWidget_28->verticalHeaderItem(8); ___qtablewidgetitem417->setText(QApplication::translate("MainWindow", "17:00-18:00", 0)); QTableWidgetItem *___qtablewidgetitem418 = tableWidget_28->verticalHeaderItem(9); ___qtablewidgetitem418->setText(QApplication::translate("MainWindow", "18:00-19:00", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_12), QApplication::translate("MainWindow", "Page", 0)); QTableWidgetItem *___qtablewidgetitem419 = tableWidget->horizontalHeaderItem(0); ___qtablewidgetitem419->setText(QApplication::translate("MainWindow", "Monday", 0)); QTableWidgetItem *___qtablewidgetitem420 = tableWidget->horizontalHeaderItem(1); ___qtablewidgetitem420->setText(QApplication::translate("MainWindow", "Tuesday", 0)); QTableWidgetItem *___qtablewidgetitem421 = tableWidget->horizontalHeaderItem(2); ___qtablewidgetitem421->setText(QApplication::translate("MainWindow", "Wednesday", 0)); QTableWidgetItem *___qtablewidgetitem422 = tableWidget->horizontalHeaderItem(3); ___qtablewidgetitem422->setText(QApplication::translate("MainWindow", "Thursday", 0)); QTableWidgetItem *___qtablewidgetitem423 = tableWidget->horizontalHeaderItem(4); ___qtablewidgetitem423->setText(QApplication::translate("MainWindow", "Friday", 0)); QTableWidgetItem *___qtablewidgetitem424 = tableWidget->verticalHeaderItem(0); ___qtablewidgetitem424->setText(QApplication::translate("MainWindow", "9:00 - 10:00", 0)); QTableWidgetItem *___qtablewidgetitem425 = tableWidget->verticalHeaderItem(1); ___qtablewidgetitem425->setText(QApplication::translate("MainWindow", "10:00 - 11:00", 0)); QTableWidgetItem *___qtablewidgetitem426 = tableWidget->verticalHeaderItem(2); ___qtablewidgetitem426->setText(QApplication::translate("MainWindow", "11:00 - 12:00", 0)); QTableWidgetItem *___qtablewidgetitem427 = tableWidget->verticalHeaderItem(3); ___qtablewidgetitem427->setText(QApplication::translate("MainWindow", "12:00 - 13:00", 0)); QTableWidgetItem *___qtablewidgetitem428 = tableWidget->verticalHeaderItem(4); ___qtablewidgetitem428->setText(QApplication::translate("MainWindow", "13:00 - 14:00", 0)); QTableWidgetItem *___qtablewidgetitem429 = tableWidget->verticalHeaderItem(5); ___qtablewidgetitem429->setText(QApplication::translate("MainWindow", "14:00 - 15:00", 0)); QTableWidgetItem *___qtablewidgetitem430 = tableWidget->verticalHeaderItem(6); ___qtablewidgetitem430->setText(QApplication::translate("MainWindow", "15:00 - 16:00", 0)); QTableWidgetItem *___qtablewidgetitem431 = tableWidget->verticalHeaderItem(7); ___qtablewidgetitem431->setText(QApplication::translate("MainWindow", "16:00 - 17:00", 0)); QTableWidgetItem *___qtablewidgetitem432 = tableWidget->verticalHeaderItem(8); ___qtablewidgetitem432->setText(QApplication::translate("MainWindow", "17:00 - 18:00", 0)); QTableWidgetItem *___qtablewidgetitem433 = tableWidget->verticalHeaderItem(9); ___qtablewidgetitem433->setText(QApplication::translate("MainWindow", "18:00 - 19:00", 0)); pushButton_7->setText(QApplication::translate("MainWindow", "Print\n" "Meeting Hours\n" "for the\n" "Input of NSGA-II", 0)); pushButton_6->setText(QApplication::translate("MainWindow", "Load Meeting\n" "Hours from the\n" "Meeting.txt", 0)); tabWidget->setTabText(tabWidget->indexOf(tab_13), QApplication::translate("MainWindow", "Page", 0)); pushButton_2->setText(QApplication::translate("MainWindow", "Read\n" "Labs", 0)); pushButton_5->setText(QApplication::translate("MainWindow", "Print\n" "Semesters\n" "into files", 0)); pushButton_8->setText(QApplication::translate("MainWindow", "Print Timetable\n" "of Lecturers", 0)); } // retranslateUi }; namespace Ui { class MainWindow: public Ui_MainWindow {}; } // namespace Ui QT_END_NAMESPACE #endif // UI_MAINWINDOW_H

aa83512c2b416869fb46d6f9e32ff85fec435b69

b005e9144443e08aa7c6b78ad87cdef8e18800b8

/백준/1058_친구.cpp

8b4fc69baa48ecd6379b225a84b5f4ad0c1b16c6

[]

no_license

SiwonLim/Problem-Solving-Practice

915bee835edcef62412835af8c274fbb179b079a

b859c12d48fa49ef26a28d181097b2540adf3956

refs/heads/master

2023-08-31T07:52:34.853306

2023-08-27T22:21:22

194,262,353

0

null

UHC

C++

false

1,153

cpp

1058_친구.cpp

#include <iostream> #include <vector> #include <string> #include<algorithm> using namespace std; int f_2[51][51]; int findMostFamous(vector<string>& str, int N) { int answer = 0; for (int i = 0; i < str.size(); i++) { for (int j = 0; j < str[i].size(); j++) { if (i == j) f_2[i][j] = 0; else if (str[i][j] == 'Y') f_2[i][j] = 1;//서로친구 else f_2[i][j] = 9999; } } //다리건너 친구 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { for (int k = 0; k < N; k++) { //이조건을 생각 못하고 i==j만 비교했더니 답X if (i == j || j == k || i == k) continue; else if (f_2[j][k] > f_2[i][j] + f_2[i][k]) { f_2[j][k] = f_2[i][j] + f_2[i][k]; } } } } //가장 유명한 사람을 찾는다 for (int i = 0; i < N; i++) { int sum = 0; for (int j = 0; j < N; j++) { if (i == j) continue; else if (f_2[i][j] <= 2) sum++; } answer = max(answer, sum); } return answer; } int main() { int N; vector<string> str; cin >> N; for (int i = 0; i < N; i++) { string t; cin >> t; str.push_back(t); } cout << findMostFamous(str, N) << endl; return 0; }

4b87523ad8f4095e40eef8c63b4c438bcb7cabd1

d8fbad708fe7720e0c82394165eecdff12628486

/src/service/plugins/sqlite/StatsPlugin.h

89bf0614489af437134046d3a51291cf830da64d

[]

no_license

KDE/kactivitymanagerd

f12b6932824b6eecdb166ac3b59d1bb42b60f20c

71ca0be8585bd6846d2acd6b4b85a526e578af2b

refs/heads/master

2023-09-04T05:48:28.980215

2023-09-03T02:58:16

50,918,798

11

3

null

UTF-8

C++

false

3,906

h

StatsPlugin.h

/* * SPDX-FileCopyrightText: 2011, 2012, 2013, 2014 Ivan Cukic <ivan.cukic(at)kde.org> * * SPDX-License-Identifier: GPL-2.0-or-later */ #ifndef PLUGINS_SQLITE_STATS_PLUGIN_H #define PLUGINS_SQLITE_STATS_PLUGIN_H // Qt #include <QObject> #include <QRegExp> #include <QSqlQuery> #include <QTimer> // STL #include <memory> // Local #include <Plugin.h> class ResourceLinking; /** * Communication with the outer world. * * - Handles configuration * - Filters the events based on the user's configuration. */ class StatsPlugin : public Plugin { Q_OBJECT // Q_CLASSINFO("D-Bus Interface", "org.kde.ActivityManager.Resources.Scoring") public: explicit StatsPlugin(QObject *parent); static StatsPlugin *self(); bool init(QHash<QString, QObject *> &modules) override; QString currentActivity() const; QStringList listActivities() const; inline QObject *activitiesInterface() const { return m_activities; } bool isFeatureOperational(const QStringList &feature) const override; QStringList listFeatures(const QStringList &feature) const override; QDBusVariant featureValue(const QStringList &property) const override; void setFeatureValue(const QStringList &property, const QDBusVariant &value) override; // // D-BUS Interface methods // public Q_SLOTS: void DeleteRecentStats(const QString &activity, int count, const QString &what); void DeleteEarlierStats(const QString &activity, int months); void DeleteStatsForResource(const QString &activity, const QString &client, const QString &resource); Q_SIGNALS: void ResourceScoreUpdated(const QString &activity, const QString &client, const QString &resource, double score, uint lastUpdate, uint firstUpdate); void ResourceScoreDeleted(const QString &activity, const QString &client, const QString &resource); void RecentStatsDeleted(const QString &activity, int count, const QString &what); void EarlierStatsDeleted(const QString &activity, int months); // // End D-BUS Interface methods // private Q_SLOTS: void addEvents(const EventList &events); void loadConfiguration(); void openResourceEvent(const QString &usedActivity, const QString &initiatingAgent, const QString &targettedResource, const QDateTime &start, const QDateTime &end = QDateTime()); void closeResourceEvent(const QString &usedActivity, const QString &initiatingAgent, const QString &targettedResource, const QDateTime &end); void saveResourceTitle(const QString &uri, const QString &title, bool autoTitle = false); void saveResourceMimetype(const QString &uri, const QString &mimetype, bool autoMimetype = false); bool insertResourceInfo(const QString &uri); void detectResourceInfo(const QString &uri); void deleteOldEvents(); private: inline bool acceptedEvent(const Event &event); inline Event validateEvent(Event event); enum WhatToRemember { AllApplications = 0, SpecificApplications = 1, NoApplications = 2, }; QObject *m_activities; QObject *m_resources; QSet<QString> m_apps; QList<QRegExp> m_urlFilters; QStringList m_otrActivities; std::unique_ptr<QSqlQuery> openResourceEventQuery; std::unique_ptr<QSqlQuery> closeResourceEventQuery; std::unique_ptr<QSqlQuery> insertResourceInfoQuery; std::unique_ptr<QSqlQuery> getResourceInfoQuery; std::unique_ptr<QSqlQuery> saveResourceTitleQuery; std::unique_ptr<QSqlQuery> saveResourceMimetypeQuery; QTimer m_deleteOldEventsTimer; bool m_blockedByDefault : 1; bool m_blockAll : 1; WhatToRemember m_whatToRemember : 2; ResourceLinking *m_resourceLinking; static StatsPlugin *s_instance; }; #endif // PLUGINS_SQLITE_STATS_PLUGIN_H

a50e51765cb79f6d4bb299668f1c2b48bae1bb0a

30d166e90d51890d35d39c4ad60d0df1f4c95beb

/thread.cpp

91f9e1ac6f751dd95168e5fe58ae5ec5172e4cf9

[]

no_license

1m2r3a/CPULoadMonitor

e43eddc812d67800f12e2716b421855a55d6ec6c

aabbd23b65648a3cba00425518bcab2230f38dd6

refs/heads/master

2020-03-21T16:34:26.560033

2018-06-26T18:35:56

138,778,526

0

null

UTF-8

C++

false

1,107

cpp

thread.cpp

#include "Thread.h" Thread::Thread() : name(""), load(0), idle(0) { } unsigned char Thread::getLoad() { return load; } void Thread::setLoad(unsigned char value) { load = value; } unsigned char Thread::getIdle() const { return idle; } void Thread::setIdle(unsigned char value) { idle = value; } std::string Thread::getName() const { return name; } void Thread::setName(const std::string &value) { name = value; } std::wstring Thread::getIdleName() const { return idleName; } void Thread::setIdleName(const std::wstring &value) { idleName = value; } std::wstring Thread::getProcessorTimeName() const { return processorTimeName; } void Thread::setProcessorTimeName(const std::wstring &value) { processorTimeName = value; } void Thread::queryTheQuery() { query.Init(); query.AddCounterInfo(processorTimeName.c_str(), counterInfo); qDebug(">>>>>>>>>>>>>>>%ls",processorTimeName.c_str()); } CounterInfo Thread::getCounterInfo() const { return counterInfo; } void Thread::setCounterInfo(const CounterInfo &value) { counterInfo = value; }

3e001988f1d24bc27a2d8033081022065cdffc6d

b815a9a834b6f3489388f385a00efe23ad837477

/EcranLCD.cpp

733a2c417e4cbedfd96662de2f07f60da1b24912

[]

no_license

hcau/oled_Sloeber

db0efbf14d4c9ca4bf08cfee65855c82b089bb07

e9ab3081859a7f97761cf096bf1468e3e436d79a

refs/heads/master

2021-01-04T19:20:33.815827

2020-02-16T00:55:42

240,726,965

0

null

UTF-8

C++

false

4,773

cpp

EcranLCD.cpp

// Do not remove the include below #include "EcranLCD.h" #include <HardwareSerial.h> #include <string.h> #include <WString.h> /************************************************************************** This is an example for our Monochrome OLEDs based on SSD1306 drivers This example is for a 128x32 pixel display using I2C to communicate 3 pins are required to interface (two I2C and one reset). **************************************************************************/ char global_message[]="Hello my name's Herve Caujolle"; char global_message2[] = "coucou"; int global_x, global_minX, global_x2, global_maxX; int global_count; void setup() { //Initiate serial communication Serial.begin(9600); // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64 Serial.println(F("SSD1306 allocation failed")); for(;;); // Don't proceed, loop forever } // Show initial display buffer contents on the screen -- // the library initializes this with an Adafruit splash screen. // display.display(); // delay(2000); // Pause for 2 seconds // Clear the buffer // display.clearDisplay(); // Draw a single pixel in white // display.drawPixel(10, 10, SSD1306_WHITE); // Show the display buffer on the screen. You MUST call display() after // drawing commands to make them visible on screen! // display.display(); // delay(2000); // display.display() is NOT necessary after every single drawing command, // unless that's what you want...rather, you can batch up a bunch of // drawing operations and then update the screen all at once by calling // display.display(). These examples demonstrate both approaches... // testdrawline(); // Draw many lines // testdrawrect(); // Draw rectangles (outlines) // // testfillrect(); // Draw rectangles (filled) // // testdrawcircle(); // Draw circles (outlines) // // testfillcircle(); // Draw circles (filled) // // testdrawroundrect(); // Draw rounded rectangles (outlines) // // testfillroundrect(); // Draw rounded rectangles (filled) // // testdrawtriangle(); // Draw triangles (outlines) // // testfilltriangle(); // Draw triangles (filled) // // testdrawchar(); // Draw characters of the default font // // testdrawstyles(); // Draw 'stylized' characters // // testscrolltext(); // Draw scrolling text // // testdrawbitmap(); // Draw a small bitmap image // // // Invert and restore display, pausing in-between // display.invertDisplay(true); // delay(1000); // display.invertDisplay(false); // delay(1000); // // testanimate(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Animate bitmaps display.setTextWrap(false); global_x = display.width(); global_minX = -12*strlen(global_message); // 12 = (6 pixels par caractère) X (taille du texte (ici 2)) global_maxX = display.width(); global_x2=0; global_count = 0; } void loop() { // testdrawcircle(); // Draw circles (outlines) // testdrawchar(); // Draw characters of the default font global_count++; //////////////////////////////// ////Texte fixe. display.clearDisplay(); display.setTextColor(WHITE); display.setCursor(0,7); // Set text position (X,Y) display.setTextSize(1); // Set text size to 1 (small) display.print("TEST SCROLLING TEXT"); // Print text ////Défilement du texte. display.setTextSize(2); // Set text size to 1 (small) display.setCursor(global_x,20); // Set text position (X,Y) display.print(global_message); //Défilement de la droite vers la gauche. global_x-=4; //scroll speed if(global_x<global_minX){ global_x = display.width(); } //Ligne séparatrice display.drawLine(0,16,display.width()-1,16,WHITE); //Défilement de la gauche vers la droite. display.setTextSize(2); // Set text size to 1 (small) display.setCursor(global_x2,40); // Set text position (X,Y) display.print(global_message2); global_x2+=2; //scroll speed if(global_x2>global_maxX){ global_x2 = 0; } display.display(); //Débug Serial.print("maxX ="); Serial.print(global_maxX, DEC); Serial.println(); Serial.print("x2 ="); Serial.print(global_x2, DEC); Serial.println(); // Serial.flush(); //cf pour scroller : https://www.youtube.com/watch?v=sTYPuDMPva8 if(global_count==250){ testdrawcircle(); testdrawrect(); testfillcircle(); testfilltriangle(); testdrawbitmap(); testfillroundrect(); testscrolltext(); testfillrect(); // Draw rectangles (filled) testdrawroundrect(); // Draw rounded rectangles (outlines) testdrawtriangle(); // Draw triangles (outlines) testdrawchar(); // Draw characters of the default font testdrawstyles(); // Draw 'stylized' characters global_count = 0; } }

6af3e35fd0fa8a034df1b80a374611714416beb3

05efcf0b6b41768ff82bc03495f107361d64c87a

/practica1/2.cpp

4902a69b81465dc73b779cc2c6aa782ada3f134f

[]

no_license

Olesya11/practica-mera

390d032a24d6315ee9ce2f83cdc4bc562c6cf9c5

948a8741a72cdfc221a91d44630274e75d331944

refs/heads/master

2020-07-07T21:42:20.526630

2016-11-30T19:03:37

74,032,266

0

null

UTF-8

C++

false

711

cpp

2.cpp

// 1.2.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "stdio.h" int main() { int hr, mn, sec; printf ("Enter time, example (hr:mn:sec) \n"); scanf_s("%d:%d:%d", &hr, &mn, &sec); while ( hr > 24 || mn > 60 || sec > 60) { printf ("Wrong time! Enter time again:\n "); scanf_s("%d:%d:%d", &hr, &mn, &sec); } if( hr < 12 && hr >= 5 ) { printf("Hello! Good morning \n"); } else if ( hr > 12 && hr < 20) { printf("Hello! Good afternoon \n"); } else if (hr > 20 ) { printf("Hello! Good night \n"); } else { printf("You can enter only numbers"); } getchar(); getchar(); getchar(); getchar(); return 0; }

2982fcc12dba05af9000212da35ee853c51ffc27

b22588340d7925b614a735bbbde1b351ad657ffc

/athena/Reconstruction/RecExample/RecExTB/root/InDet_macros/sct/sct_monitor.cc

edd80ffcd2c5f14e1b0296eea82c6deb11bd09c7

[]

no_license

rushioda/PIXELVALID_athena

90befe12042c1249cbb3655dde1428bb9b9a42ce

22df23187ef85e9c3120122c8375ea0e7d8ea440

refs/heads/master

2020-12-14T22:01:15.365949

2020-01-19T03:59:35

234,836,993

1

0

null

UTF-8

C++

false

7,521

cc

sct_monitor.cc

/* Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration */ // Offline monitor for the Simulation void sct_monitor(void) { printf("\n *************************************\n"); printf(" * *\n"); printf(" * SCT Offline Monitor *\n"); printf(" * *\n"); printf(" *************************************\n\n"); MenuMain1(); } // ************************************************************************** void MenuMain1(void){ barMain = new TControlBar("vertical","SCT",600,50); barMain->SetNumberOfColumns(2); barMain->AddButton("&Hitmaps","hitmaps()","SCT Hitmaps for plane"); barMain->AddButton("&Multi","multi()","SCT Multiplicities per plane"); barMain->AddButton("Time&Bin histograms","tbin()","TimeBin information"); barMain->AddButton("&Correlations","correlations()","Phi Correlations between planes"); barMain->AddButton("Cluster: Hits vs Y","clusHits_vs_y()","Hits vs Y with Clusters"); barMain->AddButton("Cluster: Hits vs Z","clusHits_vs_z()","Hits vs Z with Clusters"); barMain->AddButton("SpacePoint: Hits vs Y","spHits_vs_y()","Hits vs Y with SpacePoints"); barMain->AddButton("SpacePoint: Hits vs Z","spHits_vs_z()","Hits vs Z with SpacePoints"); barMain->AddButton("SpacePoint: &Frontview [Y vs Z]","frontview_sp()","Frontview [Y vs Z] (Global coordinates)"); barMain->AddButton("SpacePoint: &3D Frontview [Y vs Z]","frontview_sp3D()","3D Frontview [Y vs Z] (Global coordinates)"); barMain->AddButton("Bad channels search","find()","Find the BAD channels"); barMain->AddButton("Track residuals for SCT","trk_res()","Track residuals for SCT (all modules together)"); barMain->AddButton("Track residuals for SCT (module)","trk_res_modules()","Track residuals for SCT (per module)"); barMain->AddButton("Track errors for SCT","trk_err()","Track errors for SCT (all modules together)"); barMain->AddButton("&Run all","RunAll()","Run all macros"); barMain->AddButton("&Save all","SaveAll()","Run all macros and store the results"); //barMain->AddButton("&Quit","quit()","Stop and Quit"); barMain->Show(); gROOT->SaveContext(); } // ************************************************************************** void quit() { gROOT->ProcessLine(".q"); } // ************************************************************************** void SaveAll(void){ barMain = new TControlBar("vertical","Save All",840,70); barMain->SetNumberOfColumns(2); barMain->AddButton("PS","SaveAll_PS()","Save the histograms in GIF format"); barMain->AddButton("GIF","SaveAll_GIF()","Save the histograms in GIF format"); barMain->Show(); gROOT->SaveContext(); } // ************************************************************************** void SaveAll_PS(void) { gROOT->ProcessLine(".x InDet_macros/sct/hitmaps.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/tbin.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(1,0)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(1,1)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_y.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_z.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_y.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_z.cc(1)"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp.cc(1)"); sprintf(option,"COLZ"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp3D.cc(1,option)"); // gROOT->ProcessLine(".q"); } void SaveAll_GIF(void) { gROOT->ProcessLine(".x InDet_macros/sct/hitmaps.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/tbin.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(2,0)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(2,1)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_y.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_z.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_y.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_z.cc(2)"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp.cc(2)"); sprintf(option,"COLZ"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp3D.cc(2,option)"); // gROOT->ProcessLine(".q"); } // ************************************************************************** void RunAll(void) { gROOT->ProcessLine(".x InDet_macros/sct/hitmaps.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/tbin.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(0,0)"); gROOT->ProcessLine(".x InDet_macros/sct/correlations.cc(0,1)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_y.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/clusHits_vs_z.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_y.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/spHits_vs_z.cc(0)"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp.cc(0)"); sprintf(option,"COLZ"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp3D.cc(0,option)"); // gROOT->ProcessLine(".q"); } // ************************************************************************** // SCT_Hits void hitmaps(void) { sprintf(command,".x %s/hitmaps.cc(0)",path1); gROOT->ProcessLine(command); } void multi(void) { sprintf(command,".x %s/multi.C(0)",path1); gROOT->ProcessLine(command); } void tbin() { sprintf(command,".x %s/tbin.cc(0)",path1); gROOT->ProcessLine(command); } // ************************************************************************** void correlations(void){ gROOT->ProcessLine(".L include/dialogs.cc"); int SCT_PHI = GetIntegerDialog("Select SCT phi (Options: 0, 1)", 0); if(SCT_PHI==-999) {gROOT->ProcessLine(".U include/dialogs.cc"); return;} sprintf(command,".x %s/correlations.cc(0,SCT_PHI)",path1); gROOT->ProcessLine(command); gROOT->ProcessLine(".U include/dialogs.cc"); } // ************************************************************************** // SCT_Clusters void clusHits_vs_y() { sprintf(command,".x %s/clusHits_vs_y.cc(0)",path1); gROOT->ProcessLine(command); } void clusHits_vs_z() { sprintf(command,".x %s/clusHits_vs_z.cc(0)",path1); gROOT->ProcessLine(command); } // SCT_SpacePoins void spHits_vs_y() { sprintf(command,".x %s/spHits_vs_y.cc(0)",path1); gROOT->ProcessLine(command); } void spHits_vs_z() { sprintf(command,".x %s/spHits_vs_z.cc(0)",path1); gROOT->ProcessLine(command); } void frontview_sp() { sprintf(command,".x %s/frontview_sp.cc(0)",path1); gROOT->ProcessLine(command); } // ************************************************************************** void frontview_sp3D(void){ sprintf(option,"COLZ"); gROOT->ProcessLine(".x InDet_macros/sct/frontview_sp3D.cc(0,option)"); } // ************************************************************************** // Tracking // ************************************************************************** void trk_res(void) { sprintf(command,".x %s/track_sct_res.C(0)",path1); gROOT->ProcessLine(command); } void trk_res_modules(void) { sprintf(command,".x %s/track_sct_res_modules.C(0)",path1); gROOT->ProcessLine(command); } void trk_err(void) { sprintf(command,".x %s/track_sct_err.C(0)",path1); gROOT->ProcessLine(command); } // ************************************************************************** // Extras // ************************************************************************** void find(void) { sprintf(command,".x %s/findbad.c",path1); gROOT->ProcessLine(command); }

2f495d62b64215c82bdd9fa351b0045d294a1b0d

7f34ac3803d5d7291b30c36e64bb67dd7179ac13

/p51-100/p70.cpp

cedd21ed2e4e416f8005b6e31dc1c7e604bd45f1

[]

no_license

hikean/PEcode

a8039b6998cef05a1fc77ba55ddda545940104f2

6600594cb8380788fa40c1a5b7f601e31456a1a6

refs/heads/master

2016-09-05T22:49:24.151111

2015-03-09T13:27:56

31,539,108

0

null

UTF-8

C++

false

893

cpp

p70.cpp

#include<iostream> using namespace std; const int limit=10000000; bool bprime[limit]={0}; long long prime[limit/10],nprime=0; double p=100; int ans=12; int cnt=0; void inline check(int m,int n) { if(double(m)/double(n)> p) return; int a[10]={0},b[10]={0},c=m,d=n; while(m) { a[m%10]++; m/=10; } while(n) { b[n%10]++; n/=10; } for(int i=0;i<10;i++) if(a[i]!=b[i]) return ; p=double(c)/double(d); ans=c; } int main() { for(int i=2;i<4000;i++) if(!bprime[i]) for(int j=i<<1;j<limit;j+=i) bprime[j]=true; for(int i=2;i<limit;i++) if(!bprime[i]) prime[nprime++]=i; for(int i=0;i<nprime;i++) for(int j=i;prime[i]*prime[j]<=limit;j++) check(prime[i]*prime[j],(prime[i]-1)*(prime[j]-1)); cout<<ans<<endl; return 0; }

99572f51fa660807680a92590bbd909931311c8d

3219885d00cea2e9d2c9d0871f9c63ad6ab90666

/1160 post office.cpp

cf10b6a7ccb06756c96e076cdfbbe102d2c2b9fa

[]

no_license

Tiffanylqc/Online-Judge-Solutions

f6daaf9f9a45b4ec4c3ae83e2cbdaa4cde9a4302

883da681a7c4355802a01c44d0bf447f6cce33b2

refs/heads/master

2021-03-19T07:49:16.241164

2018-05-15T04:12:52

117,328,259

0

null

UTF-8

C++

false

1,044

cpp

1160 post office.cpp

#include<iostream> #include<algorithm> #include<cstdio> #include<cstring> #include <vector> #include <cmath> #include <map> #include <stack> #include <queue> using namespace std; #define INF 0x3f3f3f3f int Village[303]; int cost[303][303]; int dp[303][303]; int main() { int NumOfVillage,NumOfOffice; cin>>NumOfVillage>>NumOfOffice; Village[0]=0; for(int i=1;i<=NumOfVillage;i++) cin>>Village[i]; //compute cost for(int i=1;i<=NumOfVillage;i++){ for(int j=i;j<=NumOfVillage;j++){ int middle=(i+j)/2; cost[i][j]=0; for(int k=i;k<=j;k++){ cost[i][j]+=abs(Village[k]-Village[middle]); } } } memset(dp,INF, sizeof(dp)); dp[0][0]=0; for (int i = 1; i <= NumOfOffice; i++) { for (int j = i; j <= NumOfVillage; j++) { for (int k = 0; k < j; k++) dp[i][j] = min(dp[i][j], dp[i-1][k] + cost[k+1][j]); } } cout<<dp[NumOfOffice][NumOfVillage]<<endl; return 0; }

384d4544d9bcdd73f91462918369bb04eea0ddd8

bab538e9cb1613a7b11b8600f3433df49ab13e89

/tlb_include/sc_tria_slicer_type_lib.h

cdb4a4426e580c923e055f9ecf4334b2c3a905b9

[]

no_license

H0RIA/KoLaser

ba1af6cd25e56db7c6fe771bdc17c9e1235959f1

71f99d25396a1f36b66cb57cbe01564eb41d471c

refs/heads/master

2018-12-23T00:37:34.076721

2018-10-12T10:27:02

115,859,389

0

null

UTF-8

C++

false

9,808

h

sc_tria_slicer_type_lib.h

/* this ALWAYS GENERATED file contains the definitions for the interfaces */ /* File created by MIDL compiler version 7.00.0500 */ /* at Mon Jul 10 13:50:38 2017 */ /* Compiler settings for d:\scaps\dll_source\triaslicer\com\include\sc_tria_slicer_type_lib.idl: Oicf, W1, Zp1, env=Win32 (32b run) protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data VC __declspec() decoration level: __declspec(uuid()), __declspec(selectany), __declspec(novtable) DECLSPEC_UUID(), MIDL_INTERFACE() */ //@@MIDL_FILE_HEADING( ) #pragma warning( disable: 4049 ) /* more than 64k source lines */ /* verify that the <rpcndr.h> version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ #define __REQUIRED_RPCNDR_H_VERSION__ 475 #endif #include "rpc.h" #include "rpcndr.h" #ifndef __RPCNDR_H_VERSION__ #error this stub requires an updated version of <rpcndr.h> #endif // __RPCNDR_H_VERSION__ #ifndef __sc_tria_slicer_type_lib_h__ #define __sc_tria_slicer_type_lib_h__ #if defined(_MSC_VER) && (_MSC_VER >= 1020) #pragma once #endif /* Forward Declarations */ #ifndef __SC_ITriaSlicer_FWD_DEFINED__ #define __SC_ITriaSlicer_FWD_DEFINED__ typedef interface SC_ITriaSlicer SC_ITriaSlicer; #endif /* __SC_ITriaSlicer_FWD_DEFINED__ */ #ifndef __ScTriaSlicer_FWD_DEFINED__ #define __ScTriaSlicer_FWD_DEFINED__ #ifdef __cplusplus typedef class ScTriaSlicer ScTriaSlicer; #else typedef struct ScTriaSlicer ScTriaSlicer; #endif /* __cplusplus */ #endif /* __ScTriaSlicer_FWD_DEFINED__ */ /* header files for imported files */ #include "oaidl.h" #include "ocidl.h" #ifdef __cplusplus extern "C"{ #endif /* interface __MIDL_itf_sc_tria_slicer_type_lib_0000_0000 */ /* [local] */ // SCAPS SAM Header File // Version 2.5 #include "sc_layer_solid_type_lib.h" #include "sc_lines2d_type_lib.h" #include "sc_tria_mesh_type_lib.h" #include "sc_entity_groups_type_lib.h" extern RPC_IF_HANDLE __MIDL_itf_sc_tria_slicer_type_lib_0000_0000_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_sc_tria_slicer_type_lib_0000_0000_v0_0_s_ifspec; #ifndef __ScapsSamTriaSlicer_LIBRARY_DEFINED__ #define __ScapsSamTriaSlicer_LIBRARY_DEFINED__ /* library ScapsSamTriaSlicer */ /* [version][helpstring][uuid] */ EXTERN_C const IID LIBID_ScapsSamTriaSlicer; #ifndef __SC_ITriaSlicer_INTERFACE_DEFINED__ #define __SC_ITriaSlicer_INTERFACE_DEFINED__ /* interface SC_ITriaSlicer */ /* [unique][dual][hidden][oleautomation][helpstring][uuid][object] */ EXTERN_C const IID IID_SC_ITriaSlicer; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("DFDC90D6-4895-11d1-96F4-008048EEE00C") SC_ITriaSlicer : public IDispatch { public: virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScInit( /* [in] */ /* external definition not present */ SC_ILayerSolid *Layersolid, /* [in] */ double CloseDist) = 0; virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScSliceAll( /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh, /* [in] */ double Step) = 0; virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScSinglePlaneModeInit( /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh) = 0; virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScSinglePlaneModeSlice( /* [in] */ /* external definition not present */ SC_ILayer *Layer, /* [in] */ double Dist, /* [in] */ double CloseDist) = 0; virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScSinglePlaneModeEnd( void) = 0; virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE ScSliceFromFile( /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh, /* [in] */ /* external definition not present */ SC_IEntities3D *Group, /* [in] */ double CloseDist, /* [in] */ BSTR FileName) = 0; }; #else /* C style interface */ typedef struct SC_ITriaSlicerVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( SC_ITriaSlicer * This, /* [in] */ REFIID riid, /* [iid_is][out] */ __RPC__deref_out void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( SC_ITriaSlicer * This); ULONG ( STDMETHODCALLTYPE *Release )( SC_ITriaSlicer * This); HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( SC_ITriaSlicer * This, /* [out] */ UINT *pctinfo); HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( SC_ITriaSlicer * This, /* [in] */ UINT iTInfo, /* [in] */ LCID lcid, /* [out] */ ITypeInfo **ppTInfo); HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( SC_ITriaSlicer * This, /* [in] */ REFIID riid, /* [size_is][in] */ LPOLESTR *rgszNames, /* [range][in] */ UINT cNames, /* [in] */ LCID lcid, /* [size_is][out] */ DISPID *rgDispId); /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( SC_ITriaSlicer * This, /* [in] */ DISPID dispIdMember, /* [in] */ REFIID riid, /* [in] */ LCID lcid, /* [in] */ WORD wFlags, /* [out][in] */ DISPPARAMS *pDispParams, /* [out] */ VARIANT *pVarResult, /* [out] */ EXCEPINFO *pExcepInfo, /* [out] */ UINT *puArgErr); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScInit )( SC_ITriaSlicer * This, /* [in] */ /* external definition not present */ SC_ILayerSolid *Layersolid, /* [in] */ double CloseDist); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScSliceAll )( SC_ITriaSlicer * This, /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh, /* [in] */ double Step); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScSinglePlaneModeInit )( SC_ITriaSlicer * This, /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScSinglePlaneModeSlice )( SC_ITriaSlicer * This, /* [in] */ /* external definition not present */ SC_ILayer *Layer, /* [in] */ double Dist, /* [in] */ double CloseDist); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScSinglePlaneModeEnd )( SC_ITriaSlicer * This); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *ScSliceFromFile )( SC_ITriaSlicer * This, /* [in] */ /* external definition not present */ SC_ITriaMesh3D *Mesh, /* [in] */ /* external definition not present */ SC_IEntities3D *Group, /* [in] */ double CloseDist, /* [in] */ BSTR FileName); END_INTERFACE } SC_ITriaSlicerVtbl; interface SC_ITriaSlicer { CONST_VTBL struct SC_ITriaSlicerVtbl *lpVtbl; }; #ifdef COBJMACROS #define SC_ITriaSlicer_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define SC_ITriaSlicer_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define SC_ITriaSlicer_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define SC_ITriaSlicer_GetTypeInfoCount(This,pctinfo) \ ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) #define SC_ITriaSlicer_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) #define SC_ITriaSlicer_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) #define SC_ITriaSlicer_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) #define SC_ITriaSlicer_ScInit(This,Layersolid,CloseDist) \ ( (This)->lpVtbl -> ScInit(This,Layersolid,CloseDist) ) #define SC_ITriaSlicer_ScSliceAll(This,Mesh,Step) \ ( (This)->lpVtbl -> ScSliceAll(This,Mesh,Step) ) #define SC_ITriaSlicer_ScSinglePlaneModeInit(This,Mesh) \ ( (This)->lpVtbl -> ScSinglePlaneModeInit(This,Mesh) ) #define SC_ITriaSlicer_ScSinglePlaneModeSlice(This,Layer,Dist,CloseDist) \ ( (This)->lpVtbl -> ScSinglePlaneModeSlice(This,Layer,Dist,CloseDist) ) #define SC_ITriaSlicer_ScSinglePlaneModeEnd(This) \ ( (This)->lpVtbl -> ScSinglePlaneModeEnd(This) ) #define SC_ITriaSlicer_ScSliceFromFile(This,Mesh,Group,CloseDist,FileName) \ ( (This)->lpVtbl -> ScSliceFromFile(This,Mesh,Group,CloseDist,FileName) ) #endif /* COBJMACROS */ #endif /* C style interface */ #endif /* __SC_ITriaSlicer_INTERFACE_DEFINED__ */ #ifndef __ScConstantsTriaSlicer_MODULE_DEFINED__ #define __ScConstantsTriaSlicer_MODULE_DEFINED__ /* module ScConstantsTriaSlicer */ /* [helpstring][uuid] */ /* [helpstring] */ const long scComObjectTriaSlicer = ( 0x2000 | ( ( 1 * 0x1000000 ) + 0x4000 ) ) ; #endif /* __ScConstantsTriaSlicer_MODULE_DEFINED__ */ EXTERN_C const CLSID CLSID_ScTriaSlicer; #ifdef __cplusplus class DECLSPEC_UUID("DFDC90DA-4895-11d1-96F4-008048EEE00C") ScTriaSlicer; #endif #endif /* __ScapsSamTriaSlicer_LIBRARY_DEFINED__ */ /* Additional Prototypes for ALL interfaces */ /* end of Additional Prototypes */ #ifdef __cplusplus } #endif #endif

3adcbe1c5d1f961e21424b24fd225464c7cfe69e

b36f34b6a24d019d624d1cc74f5b29062eef2ba4

/frameworks/cocos2d-x/cocos/platform/win32/CCDevice-win32.cpp

1a2cb3e42cf45024d9507953cf4fbfb938f0cbea

[ "MIT" ]

permissive

zhongfq/cocos-lua

f49c1639f2c9a2a7678f9ed67e58114986ac882f

c2cf0f36ac0f0c91fb3456b555cacd8e8587be46

refs/heads/main

2023-08-17T17:13:05.705639

2023-08-17T06:06:36

192,316,318

165

63

MIT

2023-08-14T23:59:30

2019-06-17T09:27:37

C

UTF-8

C++

false

17,768

cpp

CCDevice-win32.cpp

/**************************************************************************** Copyright (c) 2010-2012 cocos2d-x.org Copyright (c) 2013-2016 Chukong Technologies Inc. Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd. http://www.cocos2d-x.org 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 "platform/CCDevice.h" #include "platform/CCFileUtils.h" #include "platform/CCStdC.h" NS_CC_BEGIN int Device::getDPI() { static int dpi = -1; if (dpi == -1) { HDC hScreenDC = GetDC(nullptr); int PixelsX = GetDeviceCaps(hScreenDC, HORZRES); int MMX = GetDeviceCaps(hScreenDC, HORZSIZE); ReleaseDC(nullptr, hScreenDC); dpi = (int)(254.0f*PixelsX / MMX / 10); } return dpi; } void Device::setAccelerometerEnabled(bool isEnabled) {} void Device::setAccelerometerInterval(float interval) {} class BitmapDC { public: BitmapDC(HWND hWnd = nullptr) : _DC(nullptr) , _bmp(nullptr) , _font((HFONT)GetStockObject(DEFAULT_GUI_FONT)) , _wnd(nullptr) { _wnd = hWnd; HDC hdc = GetDC(hWnd); _DC = CreateCompatibleDC(hdc); ReleaseDC(hWnd, hdc); } ~BitmapDC() { prepareBitmap(0, 0); if (_DC) { DeleteDC(_DC); } removeCustomFont(); } wchar_t * utf8ToUtf16(const std::string& str) { wchar_t * pwszBuffer = nullptr; do { if (str.empty()) { break; } // utf-8 to utf-16 int nLen = str.size(); int nBufLen = nLen + 1; pwszBuffer = new wchar_t[nBufLen]; CC_BREAK_IF(!pwszBuffer); memset(pwszBuffer, 0, nBufLen); nLen = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), nLen, pwszBuffer, nBufLen); pwszBuffer[nLen] = '\0'; } while (0); return pwszBuffer; } bool setFont(const char * pFontName = nullptr, int nSize = 0, bool enableBold = false) { bool bRet = false; do { std::string fontName = pFontName; std::string fontPath; HFONT hDefFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT); LOGFONTA tNewFont = { 0 }; LOGFONTA tOldFont = { 0 }; GetObjectA(hDefFont, sizeof(tNewFont), &tNewFont); if (!fontName.empty()) { // create font from ttf file if (FileUtils::getInstance()->getFileExtension(fontName) == ".ttf") { fontPath = FileUtils::getInstance()->fullPathForFilename(fontName.c_str()); int nFindPos = fontName.rfind("/"); fontName = &fontName[nFindPos + 1]; nFindPos = fontName.rfind("."); fontName = fontName.substr(0, nFindPos); } else { auto nFindPos = fontName.rfind("/"); if (nFindPos != fontName.npos) { if (fontName.length() == nFindPos + 1) { fontName = ""; } else { fontName = &fontName[nFindPos + 1]; } } } tNewFont.lfCharSet = DEFAULT_CHARSET; strcpy_s(tNewFont.lfFaceName, LF_FACESIZE, fontName.c_str()); } if (nSize) { tNewFont.lfHeight = -nSize; } if (enableBold) { tNewFont.lfWeight = FW_BOLD; } else { tNewFont.lfWeight = FW_NORMAL; } GetObjectA(_font, sizeof(tOldFont), &tOldFont); if (tOldFont.lfHeight == tNewFont.lfHeight && tOldFont.lfWeight == tNewFont.lfWeight && 0 == strcmp(tOldFont.lfFaceName, tNewFont.lfFaceName)) { bRet = true; break; } // delete old font removeCustomFont(); if (fontPath.size() > 0) { _curFontPath = fontPath; wchar_t * pwszBuffer = utf8ToUtf16(_curFontPath); if (pwszBuffer) { if (AddFontResource(pwszBuffer)) { PostMessage(_wnd, WM_FONTCHANGE, 0, 0); } delete[] pwszBuffer; pwszBuffer = nullptr; } } _font = nullptr; // disable Cleartype tNewFont.lfQuality = ANTIALIASED_QUALITY; // create new font _font = CreateFontIndirectA(&tNewFont); if (!_font) { // create failed, use default font _font = hDefFont; break; } bRet = true; } while (0); return bRet; } SIZE sizeWithText(const wchar_t * pszText, int nLen, DWORD dwFmt, const char* fontName, int textSize, LONG nWidthLimit, LONG nHeightLimit, bool enableWrap, int overflow) { SIZE tRet = { 0 }; do { CC_BREAK_IF(!pszText || nLen <= 0); RECT rc = { 0, 0, 0, 0 }; DWORD dwCalcFmt = DT_CALCRECT; if (!enableWrap) { dwCalcFmt |= DT_SINGLELINE; } if (nWidthLimit > 0) { rc.right = nWidthLimit; dwCalcFmt |= DT_WORDBREAK | (dwFmt & DT_CENTER) | (dwFmt & DT_RIGHT); } if (overflow == 2) { LONG actualWidth = nWidthLimit + 1; LONG actualHeight = nHeightLimit + 1; int newFontSize = textSize + 1; while (actualWidth > nWidthLimit || actualHeight > nHeightLimit) { if (newFontSize <= 0) { break; } this->setFont(fontName, newFontSize); // use current font to measure text extent HGDIOBJ hOld = SelectObject(_DC, _font); rc.right = nWidthLimit; // measure text size DrawTextW(_DC, pszText, nLen, &rc, dwCalcFmt); SelectObject(_DC, hOld); actualWidth = rc.right; actualHeight = rc.bottom; newFontSize = newFontSize - 1; } } else { // use current font to measure text extent HGDIOBJ hOld = SelectObject(_DC, _font); // measure text size DrawTextW(_DC, pszText, nLen, &rc, dwCalcFmt); SelectObject(_DC, hOld); } tRet.cx = rc.right; tRet.cy = rc.bottom; } while (0); return tRet; } bool prepareBitmap(int nWidth, int nHeight) { // release bitmap if (_bmp) { DeleteObject(_bmp); _bmp = nullptr; } if (nWidth > 0 && nHeight > 0) { _bmp = CreateBitmap(nWidth, nHeight, 1, 32, nullptr); if (!_bmp) { return false; } } return true; } int drawText(const char * pszText, SIZE& tSize, Device::TextAlign eAlign, const char * fontName, int textSize, bool enableWrap, int overflow) { int nRet = 0; wchar_t * pwszBuffer = nullptr; wchar_t* fixedText = nullptr; do { CC_BREAK_IF(!pszText); DWORD dwFmt = DT_WORDBREAK; if (!enableWrap) { dwFmt |= DT_SINGLELINE; } DWORD dwHoriFlag = (int)eAlign & 0x0f; DWORD dwVertFlag = ((int)eAlign & 0xf0) >> 4; switch (dwHoriFlag) { case 1: // left dwFmt |= DT_LEFT; break; case 2: // right dwFmt |= DT_RIGHT; break; case 3: // center dwFmt |= DT_CENTER; break; } int nLen = strlen(pszText); // utf-8 to utf-16 int nBufLen = nLen + 1; pwszBuffer = new wchar_t[nBufLen]; CC_BREAK_IF(!pwszBuffer); memset(pwszBuffer, 0, sizeof(wchar_t)*nBufLen); nLen = MultiByteToWideChar(CP_UTF8, 0, pszText, nLen, pwszBuffer, nBufLen); if (strchr(pszText, '&')) { fixedText = new wchar_t[nLen * 2 + 1]; int fixedIndex = 0; for (int index = 0; index < nLen; ++index) { if (pwszBuffer[index] == '&') { fixedText[fixedIndex] = '&'; fixedText[fixedIndex + 1] = '&'; fixedIndex += 2; } else { fixedText[fixedIndex] = pwszBuffer[index]; fixedIndex += 1; } } fixedText[fixedIndex] = '\0'; nLen = fixedIndex; } SIZE newSize; if (fixedText) { newSize = sizeWithText(fixedText, nLen, dwFmt, fontName, textSize, tSize.cx, tSize.cy, enableWrap, overflow); } else { newSize = sizeWithText(pwszBuffer, nLen, dwFmt, fontName, textSize, tSize.cx, tSize.cy, enableWrap, overflow); } RECT rcText = { 0 }; // if content width is 0, use text size as content size if (tSize.cx <= 0) { tSize = newSize; rcText.right = newSize.cx; rcText.bottom = newSize.cy; } else { LONG offsetX = 0; LONG offsetY = 0; rcText.right = newSize.cx; // store the text width to rectangle // calculate text horizontal offset if (1 != dwHoriFlag // and text isn't align to left && newSize.cx < tSize.cx) // and text's width less then content width, { // then need adjust offset of X. offsetX = (2 == dwHoriFlag) ? tSize.cx - newSize.cx // align to right : (tSize.cx - newSize.cx) / 2; // align to center } // if content height is 0, use text height as content height // else if content height less than text height, use content height to draw text if (tSize.cy <= 0) { tSize.cy = newSize.cy; dwFmt |= DT_NOCLIP; rcText.bottom = newSize.cy; // store the text height to rectangle } else if (tSize.cy < newSize.cy) { // content height larger than text height need, clip text to rect rcText.bottom = tSize.cy; } else { rcText.bottom = newSize.cy; // store the text height to rectangle // content larger than text, need adjust vertical position dwFmt |= DT_NOCLIP; // calculate text vertical offset offsetY = (2 == dwVertFlag) ? tSize.cy - newSize.cy // align to bottom : (3 == dwVertFlag) ? (tSize.cy - newSize.cy) / 2 // align to middle : 0; // align to top } if (offsetX || offsetY) { OffsetRect(&rcText, offsetX, offsetY); } } CC_BREAK_IF(!prepareBitmap(tSize.cx, tSize.cy)); // draw text HGDIOBJ hOldFont = SelectObject(_DC, _font); HGDIOBJ hOldBmp = SelectObject(_DC, _bmp); SetBkMode(_DC, TRANSPARENT); SetTextColor(_DC, RGB(255, 255, 255)); // white color // draw text if (fixedText) { nRet = DrawTextW(_DC, fixedText, nLen, &rcText, dwFmt); } else { nRet = DrawTextW(_DC, pwszBuffer, nLen, &rcText, dwFmt); } SelectObject(_DC, hOldBmp); SelectObject(_DC, hOldFont); } while (0); CC_SAFE_DELETE_ARRAY(pwszBuffer); delete[] fixedText; return nRet; } CC_SYNTHESIZE_READONLY(HDC, _DC, DC); CC_SYNTHESIZE_READONLY(HBITMAP, _bmp, Bitmap); private: friend class Image; HFONT _font; HWND _wnd; std::string _curFontPath; void removeCustomFont() { HFONT hDefFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT); if (hDefFont != _font) { DeleteObject(_font); _font = hDefFont; } // release temp font resource if (_curFontPath.size() > 0) { wchar_t * pwszBuffer = utf8ToUtf16(_curFontPath); if (pwszBuffer) { RemoveFontResource(pwszBuffer); PostMessage(_wnd, WM_FONTCHANGE, 0, 0); delete[] pwszBuffer; pwszBuffer = nullptr; } _curFontPath.clear(); } } }; static BitmapDC& sharedBitmapDC() { static BitmapDC s_BmpDC; return s_BmpDC; } Data Device::getTextureDataForText(const char * text, const FontDefinition& textDefinition, TextAlign align, int &width, int &height, bool& hasPremultipliedAlpha) { Data ret; do { BitmapDC& dc = sharedBitmapDC(); if (!dc.setFont(textDefinition._fontName.c_str(), (int)textDefinition._fontSize,false)) { log("Can't found font(%s), use system default", textDefinition._fontName.c_str()); } // draw text // does changing to SIZE here affects the font size by rounding from float? SIZE size = { (LONG)textDefinition._dimensions.width,(LONG)textDefinition._dimensions.height }; CC_BREAK_IF(!dc.drawText(text, size, align, textDefinition._fontName.c_str(), (int)textDefinition._fontSize, textDefinition._enableWrap, textDefinition._overflow)); int dataLen = size.cx * size.cy * 4; unsigned char* dataBuf = (unsigned char*)malloc(sizeof(unsigned char) * dataLen); CC_BREAK_IF(!dataBuf); struct { BITMAPINFOHEADER bmiHeader; int mask[4]; } bi = { 0 }; bi.bmiHeader.biSize = sizeof(bi.bmiHeader); CC_BREAK_IF(!GetDIBits(dc.getDC(), dc.getBitmap(), 0, 0, nullptr, (LPBITMAPINFO)&bi, DIB_RGB_COLORS)); width = (short)size.cx; height = (short)size.cy; // copy pixel data bi.bmiHeader.biHeight = (bi.bmiHeader.biHeight > 0) ? -bi.bmiHeader.biHeight : bi.bmiHeader.biHeight; GetDIBits(dc.getDC(), dc.getBitmap(), 0, height, dataBuf, (LPBITMAPINFO)&bi, DIB_RGB_COLORS); COLORREF textColor = (textDefinition._fontFillColor.b << 16 | textDefinition._fontFillColor.g << 8 | textDefinition._fontFillColor.r) & 0x00ffffff; float alpha = textDefinition._fontAlpha / 255.0f; COLORREF * pPixel = nullptr; for (int y = 0; y < height; ++y) { pPixel = (COLORREF *)dataBuf + y * width; for (int x = 0; x < width; ++x) { COLORREF& clr = *pPixel; clr = ((BYTE)(GetRValue(clr) * alpha) << 24) | textColor; ++pPixel; } } ret.fastSet(dataBuf, dataLen); hasPremultipliedAlpha = false; } while (0); return ret; } void Device::setKeepScreenOn(bool value) { CC_UNUSED_PARAM(value); } void Device::vibrate(float duration) { CC_UNUSED_PARAM(duration); } NS_CC_END

a7fe098d302df96f44f95d0457309f35ca3dcab1

7db77c9e3bbd079e49535c526b4e47fe538c4e73

/src/Thresh/genLACHists.cxx

f65cadc3637046cf6419b99f8eb5cb6a22041f9e

[ "BSD-3-Clause" ]

permissive

fermi-lat/calibGenCAL

d451a242c793b6ddb10cb1d523205da6a0b0279b

9b207d7ba56031f5ecd7aab544e68a6dedc7d776

refs/heads/master

2022-02-25T16:05:43.694826

2019-08-27T17:29:03

103,186,940

0

null

UTF-8

C++

false

8,393

cxx

genLACHists.cxx

// $Header: /nfs/slac/g/glast/ground/cvs/calibGenCAL/src/Thresh/genLACHists.cxx,v 1.8 2008/06/04 21:15:57 fewtrell Exp $ /** @file @author Zachary Fewtrell Generate LAC threshold histograms for each crystal face from zero suppressed data. Also save pedestal histograms in case of pedestal drift. */ // LOCAL INCLUDES #include "src/lib/Util/CfgMgr.h" #include "src/lib/Util/string_util.h" #include "src/lib/Util/CGCUtil.h" #include "src/lib/Util/RootFileAnalysis.h" #include "src/lib/Util/CalSignalArray.h" #include "src/lib/Util/stl_util.h" // GLAST INCLUDES #include "CalUtil/CalDefs.h" #include "CalUtil/CalVec.h" #include "CalUtil/SimpleCalCalib/CalPed.h" #include "CalUtil/SimpleCalCalib/ADC2NRG.h" #include "digiRootData/Gem.h" #include "digiRootData/DigiEvent.h" // EXTLIB INCLUDES #include "TFile.h" #include "TTree.h" #include "TH2F.h" #include "TH1I.h" #include "TF1.h" // STD INCLUDES #include <string> #include <sstream> #include <iostream> #include <algorithm> #include <cmath> #include <fstream> using namespace std; using namespace CfgMgr; using namespace calibGenCAL; using namespace CalUtil; /// Manage application configuraiton parameters class AppCfg { public: AppCfg(const int argc, const char **argv) : cmdParser(path_remove_ext(__FILE__)), faceName("faceName", "process either \"POS_FACE\" or \"NEG_FACE\" data", ""), digiFilenames("digiFilenames", "text file w/ newline delimited list of input digi ROOT files", ""), pedFilename("pedFilename", "text file with pedestal calibration data", ""), adc2nrgFilename("muSlopeFilename", "text file with muSlope (adc2mev) calibration data", ""), outputBasename("outputBasename", "all output files will use this basename + some_ext", ""), nEvts("numEvents", "number of events to process", 0), help("help", 'h', "print usage info") { cmdParser.registerArg(faceName); cmdParser.registerArg(digiFilenames); cmdParser.registerArg(pedFilename); cmdParser.registerArg(adc2nrgFilename); cmdParser.registerArg(outputBasename); cmdParser.registerArg(nEvts); cmdParser.registerSwitch(help); try { cmdParser.parseCmdLine(argc, argv); } catch (exception &e) { // ignore invalid commandline if user asked for help. if (!help.getVal()) cout << e.what() << endl; cmdParser.printUsage(); exit(-1); } } /// construct new parser CmdLineParser cmdParser; /// current alg processes only one face @ a time CmdArg<string> faceName; CmdArg<string> digiFilenames; CmdArg<string> pedFilename; CmdArg<string> adc2nrgFilename; CmdArg<string> outputBasename; CmdArg<unsigned> nEvts; /// print usage string CmdSwitch help; }; static const unsigned MAX_DELTA_EVENT_TIME_MUS = 100; int main(const int argc, const char **argv) { // libCalibGenCAL will throw runtime_error try { AppCfg cfg(argc,argv); // get crystal face from cmdline FaceNum face; if (cfg.faceName.getVal() == "POS") face = POS_FACE; else if (cfg.faceName.getVal() == "NEG") face = NEG_FACE; else { cout << "Invalid crystal face string: " << cfg.faceName.getVal() << endl; return -1; } //-- SETUP LOG FILE --// /// multiplexing output streams /// simultaneously to cout and to logfile LogStrm::addStream(cout); // generate logfile name const string logfile(cfg.outputBasename.getVal() + ".lac_hist.log.txt"); ofstream tmpStrm(logfile.c_str()); LogStrm::addStream(tmpStrm); // generate output ROOT filename const string outputPath(cfg.outputBasename.getVal() + ".lac_hist.root"); // open input files // input file(s) vector<string> digiFileList(getLinesFromFile(cfg.digiFilenames.getVal().c_str())); if (digiFileList.size() < 1) { cout << __FILE__ << ": No input files specified" << endl; return -1; } /// load up previous calibrations CalPed calPed; LogStrm::get() << __FILE__ << ": calib file: " << cfg.pedFilename.getVal() << endl; calPed.readTXT(cfg.pedFilename.getVal()); /// load up previous calibrations ADC2NRG adc2nrg; LogStrm::get() << __FILE__ << ": calib file: " << cfg.adc2nrgFilename.getVal() << endl; adc2nrg.readTXT(cfg.adc2nrgFilename.getVal()); RootFileAnalysis rootFile(0, &digiFileList, 0); // open output files LogStrm::get() << __FILE__ << ": opening output ROOT file: " << outputPath << endl; TFile output(outputPath.c_str(),"RECREATE"); // ENABLE / REGISTER TUPLE BRANCHES rootFile.getDigiChain()->SetBranchStatus("*", 0); rootFile.getDigiChain()->SetBranchStatus("m_calDigiCloneCol"); rootFile.getDigiChain()->SetBranchStatus("m_summary"); rootFile.getDigiChain()->SetBranchStatus("m_gem"); CalVec<XtalIdx, TH1I*> hadc; CalVec<XtalIdx, TH1I*> hped; for (XtalIdx xtalIdx; xtalIdx.isValid(); xtalIdx++) { const FaceIdx faceIdx(xtalIdx, face); ostringstream hadcname; hadcname << "hadc_" << faceIdx.toStr(); hadc[xtalIdx] = new TH1I(hadcname.str().c_str(),hadcname.str().c_str(),60,0,300); ostringstream hpedname; hpedname << "hped_" << faceIdx.toStr(); hped[xtalIdx] = new TH1I(hpedname.str().c_str(),hpedname.str().c_str(),200,-100,100); } /// store cal signal levels for each channel CalSignalArray calSignalArray(calPed, adc2nrg); // EVENT LOOP const unsigned nEvents = min<unsigned>(rootFile.getEntries(), cfg.nEvts.getVal()); LogStrm::get() << __FILE__ << ": Processing: " << nEvents << " events." << endl; for (unsigned nEvt = 0; nEvt < nEvents; nEvt++) { // read new event rootFile.getEvent(nEvt); // read in cal digis calSignalArray.clear(); DigiEvent const*const digiEvent = rootFile.getDigiEvent(); if (!digiEvent) { LogStrm::get() << __FILE__ << ": Unable to read DigiEvent " << nEvt << endl; continue; } calSignalArray.fillArray(*digiEvent); //-- retrieve trigger data const Gem &gem =digiEvent->getGem(); const unsigned gemConditionsWord = gem.getConditionSummary(); const float gemDeltaEventTime = gem.getDeltaEventTime()*0.05; // status print out if (nEvt % 1000 == 0) LogStrm::get() << nEvt << endl; CalVec<FaceNum, float> ene; CalVec<FaceNum, float> adc; CalVec<FaceNum, RngNum> rng; for (XtalIdx xtalIdx; xtalIdx.isValid(); xtalIdx++) { for (FaceNum tmpFace; tmpFace.isValid(); tmpFace++) { const FaceIdx faceIdx(xtalIdx, tmpFace); ene[tmpFace] = calSignalArray.getFaceSignal(faceIdx); adc[tmpFace] = calSignalArray.getAdcPed(faceIdx); rng[tmpFace] = calSignalArray.getAdcRng(faceIdx); } /// skip any events w/ gemDeltaEventTime < 500 muS if (gemDeltaEventTime < MAX_DELTA_EVENT_TIME_MUS) continue; /// avoid periodic triggers (pedestals) if(!gem.getPeriodicSet()){ if(rng[POS_FACE] == LEX8 && rng[NEG_FACE] == LEX8 && adc[POS_FACE]>3 && adc[NEG_FACE]>3 && adc[POS_FACE]<350 && adc[NEG_FACE]<350) { /// skip direct deposit hits by comparing asymmetry between xtal faces const FaceNum oppFace(face.oppositeFace()); /// 'healthy assymmetry maxes around 2:1, so we'll cut anything above 3:1 if (ene[face] / ene[oppFace] < 3) hadc[xtalIdx]->Fill(adc[face]); } } /// select periodic (only) triggers for pedestals if(gemConditionsWord == enums::PERIODIC) hped[xtalIdx]->Fill(adc[face]); } } LogStrm::get() << __FILE__ << ": Writing output ROOT file." << endl; output.Write(); output.Close(); LogStrm::get() << __FILE__ << ": Successfully completed." << endl; } catch (exception &e) { cout << __FILE__ << ": exception thrown: " << e.what() << endl; return -1; } return 0; }