blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
listlengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
3097dabf4a6ca51d041366d731bebba599129559
|
c912675c40e232e4a12cd94410e062477ea163b4
|
/football.cpp
|
2ad71cfa1ef862c2201e87724a1541a61fac7f8a
|
[] |
no_license
|
Abhishek183/codeforces-solutions
|
9cb152f9263e8fa301dde545869c03be5287e018
|
6657247ae77bd4f1960cec112865aed658af21a8
|
refs/heads/master
| 2022-07-08T16:19:51.625271
| 2020-05-14T20:13:28
| 2020-05-14T20:13:28
| 264,010,955
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 394
|
cpp
|
#include<iostream>
using namespace std;
#include<string>
#include<algorithm>
#include<unordered_map>
#define ll long long
int main()
{
ll int n;
cin>>n;
pair<int,string>s[n];
for(ll int i=0;i<n;i++)
{
s[i].first=0;
cin>>s[i].second;
for(ll int j=0;j<i;j++)
{
if(s[j].second==s[i].second) {s[j].first++; break;}
}
}
sort(s,s+n);
cout<<s[n-1].second;
}
|
[
"mishra.mr97@gmail.com"
] |
mishra.mr97@gmail.com
|
6312bb78eb01a43c881c74f3dae2862deb96d62e
|
193cacbe89f5b2ef2208ef075dedc1871464f5f4
|
/src/objects/src/exchangeinfo.cpp
|
4d447146b49f4a80a04afca15b902e6bbb74624a
|
[
"MIT"
] |
permissive
|
sssong81/coincenter
|
6c867fc39d9b096bafb71a9cb41295ed76dd29f5
|
5f46b89af3a10c4a85a1fe6d3cbda950b7b3c949
|
refs/heads/master
| 2023-04-22T21:43:08.753950
| 2021-05-05T06:53:20
| 2021-05-06T13:40:57
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,270
|
cpp
|
#include "exchangeinfo.hpp"
#include "cct_exception.hpp"
#include "cct_log.hpp"
#include "cct_mathhelpers.hpp"
#include "monetaryamount.hpp"
namespace cct {
ExchangeInfo::ExchangeInfo(std::string_view exchangeNameStr, const json &exchangeData) {
// Load trade fees
constexpr char kTradeFeesStr[] = "tradefees";
if (!exchangeData.contains(kTradeFeesStr)) {
throw exception("Unable to load trade fees for exchange " + std::string(exchangeNameStr));
}
const json &tradeFeesData = exchangeData[kTradeFeesStr];
std::string_view makerStr = tradeFeesData["maker"].get<std::string_view>();
std::string_view takerStr = tradeFeesData["taker"].get<std::string_view>();
_generalMakerRatio = (MonetaryAmount("100") - MonetaryAmount(makerStr)) / 100;
_generalTakerRatio = (MonetaryAmount("100") - MonetaryAmount(takerStr)) / 100;
// Load asset config
constexpr char kAssets[] = "asset";
if (exchangeData.contains(kAssets)) {
const json &assetData = exchangeData[kAssets];
constexpr const char *const kSubAssetConfig[] = {"allexclude", "withdrawexclude"};
CurrencySet *const pCurrencySetPerConfig[] = {std::addressof(_excludedCurrenciesAll),
std::addressof(_excludedCurrenciesWithdrawal)};
const int kNbSub = std::end(pCurrencySetPerConfig) - std::begin(pCurrencySetPerConfig);
for (int subIdx = 0; subIdx < kNbSub; ++subIdx) {
if (assetData.contains(kSubAssetConfig[subIdx])) {
// Don't make these json fields required, do nothing if not present
const json &subData = assetData[kSubAssetConfig[subIdx]];
CurrencySet ¤cySet = *pCurrencySetPerConfig[subIdx];
std::string currenciesCSV = subData;
std::size_t first = 0;
std::size_t last = currenciesCSV.find_first_of(',');
while (last != std::string::npos) {
currencySet.emplace(std::string_view(currenciesCSV.begin() + first, currenciesCSV.begin() + last));
first = last + 1;
last = currenciesCSV.find_first_of(',', first);
}
if (first != currenciesCSV.size()) {
currencySet.emplace(std::string_view(currenciesCSV.begin() + first, currenciesCSV.end()));
}
for (CurrencyCode code : currencySet) {
log::debug("{}: Adding {} as {}", exchangeNameStr, code.str(), kSubAssetConfig[subIdx]);
}
log::info("Loaded {} currencies in config", currencySet.size());
}
}
}
// Load query config
constexpr char kQuery[] = "query";
if (!exchangeData.contains(kQuery)) {
throw exception("Unable to load query configuration for exchange " + std::string(exchangeNameStr));
}
const json &queryData = exchangeData[kQuery];
_minPublicQueryDelay = std::chrono::milliseconds(queryData["minpublicquerydelayms"].get<int>());
_minPrivateQueryDelay = std::chrono::milliseconds(queryData["minprivatequerydelayms"].get<int>());
log::info("Loaded {} & {} ms as minimum time between two queries in config (public & private exchanges respectively)",
std::chrono::duration_cast<std::chrono::milliseconds>(_minPublicQueryDelay).count(),
std::chrono::duration_cast<std::chrono::milliseconds>(_minPrivateQueryDelay).count());
}
} // namespace cct
|
[
"stephane.janel@amadeus.com"
] |
stephane.janel@amadeus.com
|
35fd9dcbd14523925a093cb46aa2575d416466b6
|
0b50d4f69e28e1b92fdcf3e6bc4c1b3c00ce54e5
|
/Engine/Source/StrafeBehavior.cpp
|
a84fa390b65dd965fabc1eb0fb2f21a66fcd8f89
|
[] |
no_license
|
lilsimp/supercoolawesomebestgameever
|
f45309c3c3930863a06bdf10aa92fd12d7adb7bc
|
f961f1cbb783ed02246d5cd9172d567982245f0e
|
refs/heads/master
| 2021-07-01T12:33:41.301715
| 2017-09-22T22:49:28
| 2017-09-22T22:49:28
| 103,086,673
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 582
|
cpp
|
#include "Components.h"
#include "Objects.h"
StrafeBehavior::StrafeBehavior(GameObject* owner, glm::vec3 start, float dist) :
StartPos(start), MaxDistance(dist) {
Owner = owner;
Owner->Components.push_back(this);
oPhys = dynamic_cast<Physics*>(Owner->GetComponent(PHYSICS));
oTrans = dynamic_cast<Transform*>(Owner->GetComponent(TRANSFORM));
}
StrafeBehavior::~StrafeBehavior(void) {
}
void StrafeBehavior::onUpdate(void) {
float curDist = glm::distance(oTrans->posVec, StartPos);
if (curDist >= MaxDistance) {
oPhys->Velocity *= -1;
StartPos = oTrans->posVec;
}
}
|
[
"srsimpson95@gmail.com"
] |
srsimpson95@gmail.com
|
1945d4d12661dbb81bc6aaf83e2bb3bb4f1cc779
|
5d1b1533f00f7ce58f7cd459cfdcaacb68069e49
|
/kattis/downtime/downtime.cpp
|
5a5705eeb355e8b251c31563b71c5dcb6673f594
|
[] |
no_license
|
ongspxm/kattis
|
b19386afbcbb3680611fca7dbe13af19879446c0
|
a8f0f8c49e28c9bcaf1bf20a669c459c035ce83a
|
refs/heads/master
| 2020-03-08T11:10:13.496997
| 2018-12-26T08:20:53
| 2018-12-26T08:20:53
| 128,090,388
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 790
|
cpp
|
#include <bits/stdc++.h>
#define let const auto
#define REP(var, i) for (int var = 0; var < i; ++var)
using namespace std;
using Int = int;
//using Int = long long;
using vi = vector<Int>;
using vvi = vector< vector<Int> >;
/**
* Solution for problem: downtime
*
* Written by: ongspxm
*
* Date: 2018-12-14 07:29:42.303473 UTC
*
* Lessons learned: TEXTTEXTTEXT
*/
void solve() {
Int N, k; cin >> N >> k;
priority_queue< Int, vector<Int>, greater<Int> > times;
REP (n, N) {
Int x; cin >> x;
if (times.size() > 0 && times.top() <= x) {
times.pop();
}
times.push(x+1000);
}
Int size = times.size();
cout << size/k + 1*(size%k > 0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
[
"ongspxm@gmail.com"
] |
ongspxm@gmail.com
|
1b4652ce09bd2c88b5d27ad38a58c0cb9df76eec
|
59166d9d1eea9b034ac331d9c5590362ab942a8f
|
/ParticlePlayer/MainNode/UpdClbkMainNode.cpp
|
2c608e342c584f67905f27aeec17af4b43872bf5
|
[] |
no_license
|
seafengl/osgtraining
|
5915f7b3a3c78334b9029ee58e6c1cb54de5c220
|
fbfb29e5ae8cab6fa13900e417b6cba3a8c559df
|
refs/heads/master
| 2020-04-09T07:32:31.981473
| 2010-09-03T15:10:30
| 2010-09-03T15:10:30
| 40,032,354
| 0
| 3
| null | null | null | null |
WINDOWS-1251
|
C++
| false
| false
| 3,004
|
cpp
|
#include "UpdClbkMainNode.h"
#include "KeyboardState.h"
#include "CameraState.h"
#include <osg/Math>
#include <iostream>
UpdClbkMainNode::UpdClbkMainNode() : m_fMoveSpeed( 0.0 )
{
}
void UpdClbkMainNode::operator()( osg::Node* node, osg::NodeVisitor* nv )
{
//обработать вращения
ProcessRotate();
//обработать перемещение
ProcessMove();
// first update subgraph to make sure objects are all moved into position
traverse(node,nv);
}
void UpdClbkMainNode::ProcessRotate()
{
//обработать вращения
//получить доступ к состоянию клавиатуры
binEvents &mEvents = KeyboardState::Instance().GetEvents();
//получить доступ к состоянию камеры
binCameraState &mCamState = CameraState::Instance().GetCameraState();
mCamState.m_dR = mCamState.m_dR + mEvents.m_dX * 0.5;
mCamState.m_dH = mCamState.m_dH + mEvents.m_dY * 0.5;
//ограничение диапазона углов
if ( mCamState.m_dH > 360.0 )
mCamState.m_dH -= 360.0;
else
if ( mCamState.m_dH < -360.0 )
mCamState.m_dH += 360.0;
if ( mCamState.m_dR > 360.0 )
mCamState.m_dR -= 360.0;
else
if ( mCamState.m_dR < -360.0 )
mCamState.m_dR += 360.0;
}
void UpdClbkMainNode::ProcessMove()
{
//обработать перемещение
//получить доступ к состоянию клавиатуры
binEvents &mEvents = KeyboardState::Instance().GetEvents();
if ( mEvents.m_bLeft )
//перемещение камеры вперед
MoveForward();
else
if ( mEvents.m_bRight )
//перемещение камеры назад
MoveBackward();
}
void UpdClbkMainNode::MoveForward()
{
//перемещение камеры вперед
//получить доступ к состоянию камеры
binCameraState &mCamState = CameraState::Instance().GetCameraState();
double dZ = cos( osg::DegreesToRadians( -mCamState.m_dH + 90.0 ) );
double nD = sqrt( 1.0 - dZ * dZ );
double dX = -nD * sin( osg::DegreesToRadians( mCamState.m_dR ) );
double dY = -nD * cos( osg::DegreesToRadians( mCamState.m_dR ) );
mCamState.m_dX += dX * 0.01;
mCamState.m_dY += dY * 0.01;
mCamState.m_dZ += dZ * 0.01;
std::cout << mCamState.m_dY << " ";
}
void UpdClbkMainNode::MoveBackward()
{
//перемещение камеры назад
//получить доступ к состоянию камеры
binCameraState &mCamState = CameraState::Instance().GetCameraState();
double dZ = -cos( osg::DegreesToRadians( -mCamState.m_dH + 90.0 ) );
double nD = sqrt( 1.0 - dZ * dZ );
double dX = nD * sin( osg::DegreesToRadians( mCamState.m_dR ) );
double dY = nD * cos( osg::DegreesToRadians( mCamState.m_dR ) );
mCamState.m_dX += dX * 0.01;
mCamState.m_dY += dY * 0.01;
mCamState.m_dZ += dZ * 0.01;
std::cout << mCamState.m_dY << " ";
}
|
[
"asmzx79@3290fc28-3049-11de-8daa-cfecb5f7ff5b"
] |
asmzx79@3290fc28-3049-11de-8daa-cfecb5f7ff5b
|
27855431a64af048c27ed15c07aa2d1dec47180a
|
84ecf1c812b7dfd121d32c923e66dbfa5a967403
|
/TestFileOperation/Star.h
|
845795efe497ae6c61e65d7104766fdc4ae2cd7f
|
[
"MIT"
] |
permissive
|
Takayoshi1125/GPG_LT07
|
ecd3b406bb9fada7e5daff1f0c97bfe9f7107574
|
c0c1005a5c3207177ca703bad61fedf8c88f2e69
|
refs/heads/main
| 2023-06-18T10:47:09.952565
| 2021-07-15T03:00:39
| 2021-07-15T03:00:39
| 385,107,322
| 0
| 0
| null | null | null | null |
SHIFT_JIS
|
C++
| false
| false
| 411
|
h
|
#pragma once
#include "Vector2.h"
class Star
{
public:
static constexpr int SPEED_SLOW_ROT = 4;
// 初期処理
void Init(void);
// 更新ステップ
void Update(void);
// 描画処理
void Draw(void);
// 解放処理
void Release(void);
Vector2 GetPos(void);
void SetPos(Vector2 pos);
void SetSizeRate(float rate);
private:
int mImage;
Vector2 mPos;
int mRot;
float mSizeRate;
};
|
[
"takayoshi176@gmail.com"
] |
takayoshi176@gmail.com
|
0b11e494487bcf12231935139c2cd258e0873b18
|
74ffb565bd87161dbb13a6a139d45122854f9142
|
/Iot Light.ino
|
5ce686fbce05cf50e1434bdf5221ab64c311e51b
|
[] |
no_license
|
omkartawade7/Iot-Light
|
63a6d984343631b51c578cd4d1ad4edc2239df3c
|
9c294a20a01c0eac2bdb5314e54f0b4cdabffb71
|
refs/heads/master
| 2020-03-23T16:36:59.075158
| 2018-07-21T14:32:55
| 2018-07-21T14:32:55
| 139,301,440
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,515
|
ino
|
/***************************************************
Adafruit MQTT Library ESP8266 Example
Must use ESP8266 Arduino from:
https://github.com/esp8266/Arduino
Works great with Adafruit's Huzzah ESP board & Feather
----> https://www.adafruit.com/product/2471
----> https://www.adafruit.com/products/2821
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Tony DiCola for Adafruit Industries.
MIT license, all text above must be included in any redistribution
visit www.techiesms.com for projects on MQTT protocols
****************************************************/
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
/************************* WiFi Access Point *********************************/
#define WLAN_SSID ""
#define WLAN_PASS ""
/************************* Adafruit.io Setup *********************************/
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 1883 // use 8883 for SSL
#define AIO_USERNAME ""
#define AIO_KEY ""
/************ Global State (you don't need to change this!) ******************/
// Create an ESP8266 WiFiClient class to connect to the MQTT server.
WiFiClient client;
// or... use WiFiFlientSecure for SSL
//WiFiClientSecure client;
// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
/****************************** Feeds ***************************************/
// Setup a feed called 'photocell' for publishing.
// Notice MQTT paths for AIO follow the form: <username>/feeds/<feedname>
//const char PHOTOCELL_FEED[] PROGMEM = AIO_USERNAME "/feeds/photocell";
//Adafruit_MQTT_Publish photocell = Adafruit_MQTT_Publish(&mqtt, PHOTOCELL_FEED);
// Setup a feed called 'onoff' for subscribing to changes.
Adafruit_MQTT_Subscribe Light = Adafruit_MQTT_Subscribe(&mqtt, AIO_USERNAME "/feeds/onoffbutton");
/*************************** Sketch Code ************************************/
// Bug workaround for Arduino 1.6.6, it seems to need a function declaration
// for some reason (only affects ESP8266, likely an arduino-builder bug).
void MQTT_connect();
void setup() {
Serial.begin(115200);
delay(10);
pinMode(16,OUTPUT);
Serial.println(F("Adafruit MQTT demo"));
// Connect to WiFi access point.
Serial.println(); Serial.println();
Serial.print("Connecting to ");
Serial.println(WLAN_SSID);
WiFi.begin(WLAN_SSID, WLAN_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WiFi connected");
Serial.println("IP address: "); Serial.println(WiFi.localIP());
// Setup MQTT subscription for onoff feed.
mqtt.subscribe(&Light);
}
uint32_t x=0;
void loop() {
// Ensure the connection to the MQTT server is alive (this will make the first
// connection and automatically reconnect when disconnected). See the MQTT_connect
// function definition further below.
MQTT_connect();
// this is our 'wait for incoming subscription packets' busy subloop
// try to spend your time here
Adafruit_MQTT_Subscribe *subscription;
while ((subscription = mqtt.readSubscription(5000))) {
if (subscription == &Light) {
Serial.print(F("Got_Light: "));
Serial.println((char *)Light.lastread);
uint16_t num = atoi((char *)Light.lastread);
digitalWrite(16,num);
}
}
// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() {
int8_t ret;
// Stop if already connected.
if (mqtt.connected()) {
return;
}
Serial.print("Connecting to MQTT... ");
uint8_t retries = 3;
while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
Serial.println(mqtt.connectErrorString(ret));
Serial.println("Retrying MQTT connection in 5 seconds...");
mqtt.disconnect();
delay(5000); // wait 5 seconds
retries--;
if (retries == 0) {
// basically die and wait for WDT to reset me
while (1);
}
}
Serial.println("MQTT Connected!");
}
|
[
"noreply@github.com"
] |
omkartawade7.noreply@github.com
|
69d427f8722232351e968acca45148199243b9ef
|
80df2b134869b1b634701ecaaffe137287945ac6
|
/bus.cpp
|
c22ce7b5ecd4305297b81ddfb49b9f297f18f7ad
|
[] |
no_license
|
andyukovegor/Laba3new2
|
89494d36cab586125a1f3e9fd2b0696c6b22b45e
|
7dab7ce530fff15c6a32121454a200e531624b60
|
refs/heads/master
| 2022-04-24T20:37:28.235317
| 2020-04-23T17:37:16
| 2020-04-23T17:37:16
| 258,282,355
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 810
|
cpp
|
#include "bus.h"
#include <iostream>
using namespace std;
Bus::Bus():Bus(0,0,"model"){};
Bus::Bus(int capacity, int speed, const char *model)
{
if (capacity>=0){this->capacity = capacity;}
if (speed>=0){this->speed = speed;}
delete[] this->model;
int len = strlen(model)+1;
this ->model = new char [len];
strcpy(this->model, model);
}
Bus::~Bus()
{
delete [] model;
}
Bus::Bus(const Bus &b):Bus(b.capacity,b.speed,b.model){}
void Bus:: print() const
{
std::cout<<"capacity - "<< capacity <<", ";
std::cout<<"speed - "<< speed <<", ";
std::cout<<"model - "<< model <<"\n";
}
Bus& Bus::operator = (const Bus &bus)
{
this->model = bus.model;
this->capacity = bus.capacity;
this->speed = bus.speed;
return *this;
}
|
[
"noreply@github.com"
] |
andyukovegor.noreply@github.com
|
fd541ed0cf2077b1022f45222278d91f1dcf31bf
|
e12f4fb063cb0d26ebc500dd48bea14d2e5e3116
|
/atcoder/abc166_c.cpp
|
1d1d06be56e878b653b1224c5044ae5dc1cbd632
|
[] |
no_license
|
komekome09/comp_prog
|
869ccf40863c9a6bc92f45e630a230669dfb64bb
|
8b168f8ced37b8399d890691774eac0d49695874
|
refs/heads/master
| 2023-04-20T23:57:42.051560
| 2021-05-15T13:40:31
| 2021-05-15T13:40:31
| 259,368,988
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,136
|
cpp
|
#include <iostream>
#include <string>
#include <stdio.h>
#include <cmath>
#include <cfloat>
#include <algorithm>
#include <numeric>
#include <vector>
#include <iterator>
#include <set>
#include <map>
using namespace std;
const double PI=acos(-1);
vector<int> h(1000000, 0);
using graph = vector<vector<int>>;
vector<bool> seen;
int mmax = 0;
void dfs(const graph &g, int v){
seen[v] = true;
if(h[v] > mmax) mmax = h[v];
for(auto next_v : g[v]){
if(seen[next_v]) continue;
dfs(g, next_v);
}
}
int main(){
int n, m;
cin >> n >> m;
for(int i = 0; i < n; i++){
cin >> h[i];
}
graph g(n);
for(int i = 0; i < m; i++){
int a, b;
cin >> a >> b;
g[a-1].push_back(b-1);
g[b-1].push_back(a-1);
}
int cnt = 0;
for(int i = 0; i < n; i++){
int k = h[i];
for(int j = 0; j < g[i].size(); j++){
if(h[i] == h[g[i][j]]){
k = -1;
break;
}
k = max(k, h[g[i][j]]);
}
if(k == h[i]) cnt++;
}
cout << cnt << endl;
return 0;
}
|
[
"fanmaskome@gmail.com"
] |
fanmaskome@gmail.com
|
7a76386f74dcfcdaf286cc6ad4e901bcc04b977a
|
bc756e3b8bd50bc0439f9df71092264eb63cb414
|
/src/ransac/ransacutility.cpp
|
a22008f9881461bfc2dde380228abe62161e8935
|
[
"LicenseRef-scancode-warranty-disclaimer"
] |
no_license
|
akhtarjunaid/fbench
|
3af9cf449b591f115b68d9ab383aab93af88f9ae
|
0e21704f9e4dd3440b03ee913e058ee3916086f2
|
refs/heads/master
| 2023-03-15T17:54:57.582839
| 2020-11-14T16:08:46
| 2020-11-14T16:08:46
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 15,456
|
cpp
|
/*
* Copyright (c) 2016 University of Cordoba and University of Illinois
* All rights reserved.
*
* Developed by: IMPACT Research Group
* University of Cordoba and University of Illinois
* http://impact.crhc.illinois.edu/
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* with 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:
*
* > Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimers.
* > Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimers in the
* documentation and/or other materials provided with the distribution.
* > Neither the names of IMPACT Research Group, University of Cordoba,
* University of Illinois nor the names of its contributors may be used
* to endorse or promote products derived from this Software without
* specific prior written permission.
*
* 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
* CONTRIBUTORS 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 WITH
* THE SOFTWARE.
*
*
* Modifiers: Jennifer Faj
* Modifications: - Adjustments in file reading and random number generation,
* - added additional model (linear function)
* Date: 2020/06/21
*
*/
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
#include "ransacutility.h"
using namespace std;
int readInputSize(string fileName) {
FILE *File = NULL;
File = fopen(fileName.c_str(), "r");
if(File == NULL) {
puts("Error opening the file");
exit(-1);
}
int n;
fscanf(File, "%d", &n);
fclose(File);
return n;
}
void readInputData(flowvector *v, string fileName) {
int ic = 0;
// Open input file
FILE *File = NULL;
File = fopen(fileName.c_str(), "r");
if(File == NULL) {
puts("Error opening file!");
exit(-1);
}
int n;
fscanf(File, "%d", &n);
while(fscanf(File, "%d,%d,%d,%d", &v[ic].x, &v[ic].y, &v[ic].vx, &v[ic].vy) == 4) {
ic++;
if(ic > n) {
puts("Error: inconsistent file data!");
exit(-1);
}
}
if(ic < n) {
puts("Error: inconsistent file data!");
exit(-1);
}
}
void readInputData(point *p, string fileName) {
int ic = 0;
// Open input file
FILE *File = NULL;
File = fopen(fileName.c_str(), "r");
if(File == NULL) {
puts("Error opening file!");
exit(-1);
}
int n;
fscanf(File, "%d", &n);
while(fscanf(File, "%f,%f", &p[ic].x, &p[ic].y) == 2) {
ic++;
if(ic > n) {
puts("Error: inconsistent file data!");
exit(-1);
}
}
if(ic < n) {
puts("Error: inconsistent file data!");
exit(-1);
}
}
void genRandNumbers(int *r, int maxIter, int n){
srand(time(NULL));
for(int i = 0; i < 2 * maxIter; i++) {
r[i] = ((int)rand()) % n;
}
}
inline int compare_output(int count1, int count2, int outliers1, int outliers2) {
if(count1 != count2) {
printf("Test failed\n");
exit(EXIT_FAILURE);
}
if(outliers1 != outliers2) {
printf("Test failed\n");
exit(EXIT_FAILURE);
}
return 0;
}
// Sequential implementation for comparison purposes
// Function to compute new set of motion vectors based on the first order flow model
inline void gen_firstOrderFlow_vectors(
float *model_param, int flow_vector_count, flowvector *flow_vector_array, flowvector *ego_vector_array) {
float temp_x, temp_y;
// Compute new set of motion vectors for each point specified in the flow_vector_array
for(int i = 0; i < flow_vector_count; i++) {
temp_x = ((float)(flow_vector_array[i].x)) - model_param[0];
temp_y = ((float)(flow_vector_array[i].y)) - model_param[1];
ego_vector_array[i].x = flow_vector_array[i].x;
ego_vector_array[i].y = flow_vector_array[i].y;
ego_vector_array[i].vx = flow_vector_array[i].x + ((temp_x * model_param[2]) - (temp_y * model_param[3]));
ego_vector_array[i].vy = flow_vector_array[i].y + ((temp_y * model_param[2]) + (temp_x * model_param[3]));
}
}
// Compare to better model
inline void choose_better_model(flowvector *flow_vector_array, flowvector *ego_vector_array, int flow_vector_count,
float *model_param, int *model_candidate, int *outliers_candidate, int *count_candidates, int error_threshold,
float convergence_threshold, int iter) {
int outlier_count = 0;
int vx1, vy1;
float vx_error, vy_error;
// This loop calculates the no of outliers
for(int i = 0; i < flow_vector_count; i++) {
vx1 = flow_vector_array[i].vx - flow_vector_array[i].x;
vy1 = flow_vector_array[i].vy - flow_vector_array[i].y;
vx_error = flow_vector_array[i].x + ((int)((flow_vector_array[i].x - model_param[0]) * model_param[2]) -
(int)((flow_vector_array[i].y - model_param[1]) * model_param[3])) -
flow_vector_array[i].vx;
vy_error = flow_vector_array[i].y + ((int)((flow_vector_array[i].y - model_param[1]) * model_param[2]) +
(int)((flow_vector_array[i].x - model_param[0]) * model_param[3])) -
flow_vector_array[i].vy;
if((fabs(vx_error) < error_threshold) && (fabs(vy_error) < error_threshold)) {
ego_vector_array[i].x = 0;
ego_vector_array[i].y = 0;
ego_vector_array[i].vx = 0;
ego_vector_array[i].vy = 0;
} else {
outlier_count++;
ego_vector_array[i].vx = ego_vector_array[i].x + vx_error;
ego_vector_array[i].vy = ego_vector_array[i].y + vy_error;
}
}
// Compare to threshold
if(outlier_count < flow_vector_count * convergence_threshold) {
int ind = count_candidates[0]++;
model_candidate[ind] = iter;
outliers_candidate[ind] = outlier_count;
}
}
// Function to generate model parameters for first order flow (xc, yc, D and R)
inline int gen_model_param(int x1, int y1, int vx1, int vy1, int x2, int y2, int vx2, int vy2, float *model_param) {
float temp;
// xc -> model_param[0], yc -> model_param[1], D -> model_param[2], R -> model_param[3]
temp = (float)((vx1 * (vx1 - (2 * vx2))) + (vx2 * vx2) + (vy1 * vy1) - (vy2 * ((2 * vy1) - vy2)));
if(temp == 0) { // Check to prevent division by zero
return (0);
}
model_param[0] = (((vx1 * ((-vx2 * x1) + (vx1 * x2) - (vx2 * x2) + (vy2 * y1) - (vy2 * y2))) +
(vy1 * ((-vy2 * x1) + (vy1 * x2) - (vy2 * x2) - (vx2 * y1) + (vx2 * y2))) +
(x1 * ((vy2 * vy2) + (vx2 * vx2)))) /
temp);
model_param[1] = (((vx2 * ((vy1 * x1) - (vy1 * x2) - (vx1 * y1) + (vx2 * y1) - (vx1 * y2))) +
(vy2 * ((-vx1 * x1) + (vx1 * x2) - (vy1 * y1) + (vy2 * y1) - (vy1 * y2))) +
(y2 * ((vx1 * vx1) + (vy1 * vy1)))) /
temp);
temp = (float)((x1 * (x1 - (2 * x2))) + (x2 * x2) + (y1 * (y1 - (2 * y2))) + (y2 * y2));
if(temp == 0) { // Check to prevent division by zero
return (0);
}
model_param[2] = ((((x1 - x2) * (vx1 - vx2)) + ((y1 - y2) * (vy1 - vy2))) / temp);
model_param[3] = ((((x1 - x2) * (vy1 - vy2)) + ((y2 - y1) * (vx1 - vx2))) / temp);
return (1);
}
// Generate F-o-F model
inline int gen_firstOrderFlow_model(
int flow_vector_count, flowvector *flow_vector_array, float *model_param, int *random_numbers, int iter) {
int rand_num;
int x1, x2, y1, y2, vx1, vx2, vy1, vy2;
int ret;
float highest_val = 0;
// Select two motion vectors at random
rand_num = random_numbers[iter * 2];
x1 = flow_vector_array[rand_num].x;
y1 = flow_vector_array[rand_num].y;
vx1 = flow_vector_array[rand_num].vx - flow_vector_array[rand_num].x;
vy1 = flow_vector_array[rand_num].vy - flow_vector_array[rand_num].y;
rand_num = random_numbers[iter * 2 + 1];
x2 = flow_vector_array[rand_num].x;
y2 = flow_vector_array[rand_num].y;
vx2 = flow_vector_array[rand_num].vx - flow_vector_array[rand_num].x;
vy2 = flow_vector_array[rand_num].vy - flow_vector_array[rand_num].y;
// Function to generate model parameters according to first order flow (xc, yc, D and R)
ret = gen_model_param(x1, y1, vx1, vy1, x2, y2, vx2, vy2, model_param);
return (ret);
}
// Estimate egomotion using RANSAC
inline int estimate_ego_motion_first_order_flow(flowvector *flow_vector_array, int size_flow_vector_array,
int *model_candidate, int *outliers_candidate, int *count_candidates, int *random_numbers, int max_iter,
int error_threshold, float convergence_threshold) {
int iter = 0;
int ret;
if(size_flow_vector_array == 0) {
return (0);
}
// Allocate memory to store newly generated vectors
flowvector ego_vector_array[size_flow_vector_array];
*count_candidates = 0;
for(iter = 0; iter < max_iter; iter++) {
float model_param_seq[4];
// Obtain model parameters for First Order Flow
ret =
gen_firstOrderFlow_model(size_flow_vector_array, flow_vector_array, model_param_seq, random_numbers, iter);
if(ret == 0) {
continue;
}
// Compute motion vectors at every point of optical flow using First Order Flow equations
gen_firstOrderFlow_vectors(model_param_seq, size_flow_vector_array, flow_vector_array, ego_vector_array);
// Decide if the new model is better than the previous model
choose_better_model(flow_vector_array, ego_vector_array, size_flow_vector_array, model_param_seq,
model_candidate, outliers_candidate, count_candidates, error_threshold, convergence_threshold, iter);
}
return (1);
}
void verify(flowvector *flow_vector_array, int size_flow_vector_array, int *random_numbers, int max_iter,
int error_threshold, float convergence_threshold, int candidates, int b_outliers) {
int *model_candidate = (int *)malloc(max_iter * sizeof(int));
int *outliers_candidate = (int *)malloc(max_iter * sizeof(int));
int count_candidates = 0;
estimate_ego_motion_first_order_flow(flow_vector_array, size_flow_vector_array, model_candidate, outliers_candidate,
&count_candidates, random_numbers, max_iter, error_threshold, convergence_threshold);
// Post-processing (chooses the best model among the candidates)
int best_model = -1;
int best_outliers = size_flow_vector_array;
for(int i = 0; i < count_candidates; i++) {
if(outliers_candidate[i] < best_outliers) {
best_outliers = outliers_candidate[i];
best_model = model_candidate[i];
}
}
compare_output(candidates, count_candidates, best_outliers, b_outliers);
free(model_candidate);
free(outliers_candidate);
}
inline void linear_function_oultier_count(point *point_array, int point_count,
float *model_param, int *model_candidate, int *outliers_candidate, int *count_candidates, int error_threshold,
float convergence_threshold, int iter){
int outlier_count = 0;
float px, py;
float m1, m2, b1, b2, qy, qx, dist_error;
m1 = model_param[0];
b1 = model_param[1];
for(int i = 0; i < point_count; i++) {
px = point_array[i].x;
py = point_array[i].y;
m2 = (-1)/m1;
b2 = py - (m2*px);
qx = (b1-b2)/(m2-m1);
qy = (m1*qx) + b1;
dist_error = sqrt(((qy-py) * (qy-py)) + ((qx-px) * (qx-px)));
if(fabs(dist_error) >= error_threshold){
outlier_count++;
}
}
// Compare to threshold
if(outlier_count < point_count * convergence_threshold) {
int ind = count_candidates[0]++;
model_candidate[ind] = iter;
outliers_candidate[ind] = outlier_count;
}
}
inline int gen_linear_function_params(point *point_array, float *model_param, int *random_numbers, int iter){
int rand_num;
float x1, x2, y1, y2;
int ret;
float m, b;
rand_num = random_numbers[iter * 2];
x1 = point_array[rand_num].x;
y1 = point_array[rand_num].y;
rand_num = random_numbers[iter * 2 + 1];
x2 = point_array[rand_num].x;
y2 = point_array[rand_num].y;
if((x2-x1) == 0){
return (0);
}
m = (y2-y1)/(x2-x1);
b = y1 - (x1*m);
model_param[0] = m;
model_param[1] = b;
return (1);
}
inline int estimate_linear_function(point *point_array, int size_point_array, int *model_candidate, int *outliers_candidate,
int *count_candidates, int *random_numbers, int max_iter, int error_threshold, float convergence_threshold){
int iter = 0;
int ret;
if(size_point_array == 0) {
return (0);
}
*count_candidates = 0;
for(iter = 0; iter < max_iter; iter++) {
float model_param[2];
// Obtain model parameters
ret = gen_linear_function_params(point_array, model_param, random_numbers, iter);
if(ret == 0) {
continue;
}
linear_function_oultier_count(point_array, size_point_array, model_param, model_candidate, outliers_candidate, count_candidates, error_threshold, convergence_threshold, iter);
}
return (1);
}
void verify(point *point_array, int size_point_array, int *random_numbers, int max_iter,
int error_threshold, float convergence_threshold, int candidates, int b_outliers) {
int *model_candidate = (int *)malloc(max_iter * sizeof(int));
int *outliers_candidate = (int *)malloc(max_iter * sizeof(int));
int count_candidates = 0;
estimate_linear_function(point_array, size_point_array, model_candidate, outliers_candidate,
&count_candidates, random_numbers, max_iter, error_threshold, convergence_threshold);
// Post-processing (chooses the best model among the candidates)
int best_model = -1;
int best_outliers = size_point_array;
for(int i = 0; i < count_candidates; i++) {
if(outliers_candidate[i] < best_outliers) {
best_outliers = outliers_candidate[i];
best_model = model_candidate[i];
}
}
compare_output(candidates, count_candidates, best_outliers, b_outliers);
free(model_candidate);
free(outliers_candidate);
}
|
[
"jfaj@mail.uni-paderborn.de"
] |
jfaj@mail.uni-paderborn.de
|
b1cc88c8c016043863bf5a19ecf8828d6b5e7e77
|
0ebb297fe3a7354d988661be5b1de8ab2019c60a
|
/code/common/ddl/node_ref.cpp
|
7bbf3641e51a16e0e0a427b20dfdd20eaa45c1f5
|
[] |
no_license
|
kamrann/workbase
|
a56e8ca3874ae5e71e4c77331ed10f59acff5914
|
ce2cade80365f885839bf96bfc5db5e57059ba39
|
refs/heads/master
| 2021-01-19T03:22:32.745349
| 2015-01-02T23:05:04
| 2015-01-02T23:05:04
| 15,985,205
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,823
|
cpp
|
// node_ref.cpp
#include "node_ref.h"
#include "values/value.h"
#include "values/navigator.h"
namespace ddl {
navigator nav_to_ref(node_ref const& ref, navigator nav)
{
auto rf = resolve_reference_unique(ref, nav);
if(rf)
{
return navigator{ nav.tree_, rf };
}
else
{
return{};
}
}
sd_node_ref_list resolve_reference(node_ref const& ref, navigator nav)
{
if(nav)
{
auto id = ref.nd.get_id();
auto fr = nav.find_by_id(id); // todo: perhaps this call will need to be passed info from node_ref::res context settings
if(!fr.by_location.empty())
{
if(ref.res == node_ref::Resolution::Unique)
{
auto const& first_list = fr.by_location.begin()->second;
if(first_list.size() == 1)
{
auto const& pth = first_list.front();
auto rnav = nav[pth];
return{ rnav.get_ref() };
}
else
{
throw std::runtime_error("ambiguous reference id lookup");
}
}
else // todo: more fine grained control of resolving context done here...
// currently just accept any matching id anywhere in hierarchy
{
sd_node_ref_list results;
for(auto const& entry : fr.by_location)
{
auto const& res_list = entry.second;
for(auto const& pth : res_list)
{
auto rnav = nav[pth];
results.insert(rnav.get_ref());
}
}
return results;
}
}
}
return{};
}
sd_node_ref resolve_reference_unique(node_ref const& ref, navigator nav)
{
auto res = resolve_reference(ref, nav);
if(res.size() != 1)
{
throw std::runtime_error("ambiguous reference id lookup");
}
else
{
return *res.begin();
}
}
sd_node_ref unique_reference(sd_node_ref_list const& list)
{
if(list.size() == 1)
{
return *list.begin();
}
else
{
return{};
}
}
}
|
[
"cjangus@gmail.com"
] |
cjangus@gmail.com
|
bddbfeec18fdf0b921628ec1b476ebf2d512a731
|
027a76f640874ede2cf27f1dc49611a2bbbb34dd
|
/gfg/string/anagram.cpp
|
580457fbc3fe47f011f8ab7894929668150d0441
|
[] |
no_license
|
ashishugi/MYCODES
|
b33cda06a18defd8f2de91b4a66cdb8eba55ca47
|
8e5e4d047ae415ab72ec4fd74171432e6c0cbb6e
|
refs/heads/master
| 2022-02-09T00:51:47.406788
| 2022-01-28T17:34:42
| 2022-01-28T17:34:42
| 165,395,936
| 17
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 865
|
cpp
|
#include<bits/stdc++.h>
#define loop(i,n) for(int i=0;i<n;i++)
using namespace std;
bool anagram(string s1,string s2){
int n=s1.length();
int m=s2.length();
if(n!=m){
return false;
}
map<char,int> m1;
map<char,int> m2;
loop(i,n){
m1[s1[i]]++;
m2[s2[i]]++;
}
map<char,int>::iterator i1 = m1.begin();
map<char,int>::iterator i2 = m2.begin();
for(;i1!=m1.end();i1++,i2++){
if(i1->first == i2->first){
if(i1->second != i2->second){
return false;
}
}else{
return false;
}
}
return true;
}
int main(void){
int t;
cin>>t;
while(t--){
string s1,s2;
cin>>s1>>s2;
if(anagram(s1,s2)){
cout<<"YES"<<endl;
}else{
cout<<"NO"<<endl;
}
}
return 0;
}
|
[
"ashishkumarguptacse@gmail.com"
] |
ashishkumarguptacse@gmail.com
|
cde2be3feffb26f18512cf0e5d04133b36252a3e
|
3189f9fc40192435a2f4edd258a0ea169ba62428
|
/CSES/Introductory Problems/palindromeReorder.cpp
|
d5d4c9a4605e3caba2cccd44188997725b67971d
|
[] |
no_license
|
lifchrs/CP
|
ee5820be5654784162145633ab58937056494264
|
7223731ae368f365afaec175c75540e7454165ec
|
refs/heads/master
| 2023-03-03T23:22:47.801445
| 2021-02-19T05:13:49
| 2021-02-19T05:13:49
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,086
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define se second
#define pb push_back
#define pf push_front
#define ll long long
#define F0R(i,a) for(int i=0;i<a;i++)
#define FOR(i,a,b) for(int i=a;i<b;i++)
ll binpow(ll a,ll b){
ll res=1;
while(b>0){
if(b & 1)
res*=a;
a*=a;
b>>=1;
}
return res;
}
int freq[27];
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
//ifstream cin("name.in");
//ofstream cout("name.out");
string a;
cin>>a;
FOR(i,0,27) freq[i]=0;
for(char x:a){
freq[x-'A']++;
}
int numOdd=0;
for(int i:freq){
if(i%2==1) numOdd++;
}
if(numOdd>1){
cout<<"NO SOLUTION\n";
return 0;
}
string first="";
string alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for(int i=0;i<27;i++){
if(freq[i]%2==0){
for(int x=0;x<freq[i]/2;x++) first+=alphabet[i];
}
}
//cout<<first;
string bruh=first;
reverse(first.begin(),first.end());
for(int i=0;i<27;i++){
if(freq[i]%2==1){
for(int x=0;x<freq[i];x++) first+=alphabet[i];
}
}
//cout<<"first: "<<first<<endl;
//cout<<"bruh: "<<bruh<<endl;
cout<<first+bruh<<endl;
}
|
[
"polavaramadhitya@gmail.com"
] |
polavaramadhitya@gmail.com
|
547a95aabbc7e693b2bd8818df367d8910feac32
|
9140dd125826503501d9cc111d36d604e93cd433
|
/Tree/Questions/Sum_at_lvl_K.cpp
|
149fd425da9cf22aeaa5fe6d34cf94392409c9e0
|
[] |
no_license
|
vibgyor98/dsalgocp
|
f7d43854886b97a468754fb6929ebfcce51b45e2
|
7260033c11b17601034153a082456ff7ddc4578d
|
refs/heads/master
| 2021-08-04T05:54:50.610133
| 2020-12-18T18:14:23
| 2020-12-18T18:14:23
| 228,390,576
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 894
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int data;
node* left;
node* right;
node(int d) {
data = d;
left = NULL;
right = NULL;
}
};
//constructing tree
node* buildTree() {
int d, num;
cin >> d;
node* root = new node(d);
cin >> num;
if (num == 2) {
root->left = buildTree();
root->right = buildTree();
} else if (num == 1) {
root->left = buildTree();
}
return root;
}
//Sum at kth level
int sum = 0;
void sum_at_Kth_level(node* root, int k) {
if (root == NULL) {
return;
}
if (k == 0) {
sum += root->data;
}
if (k < 1) {
return;
}
sum_at_Kth_level(root->left, k - 1);
sum_at_Kth_level(root->right, k - 1);
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
node* root = buildTree();
int k;
cin >> k;
sum_at_Kth_level(root, k);
cout << sum;
return 0;
}
|
[
"karsourav05@gmail.com"
] |
karsourav05@gmail.com
|
2b8253c21380f250d036538f69a902053cac8820
|
85f1cd01c68731a30bff2b99a9e21e5d3a81fb70
|
/data-structure/17.Dahua/all.cpp
|
09f00733266d17cff5cf48a40c92fe3c36fa2fec
|
[] |
no_license
|
ddayzzz/algorithm-and-basic-apps
|
f146ee9a31a61d92c963d6a14d17c59f3de67740
|
7ea0cedd32df0b8d207e85696e30105e87b003c8
|
refs/heads/master
| 2020-04-01T06:24:17.842635
| 2019-10-09T15:11:51
| 2019-10-09T15:11:51
| 152,945,967
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,379
|
cpp
|
// 大话数据结构1.cpp : 定义控制台应用程序的入口点。
//
#include "../stdafx.h"
#include "../00.Dahua_Datastructures_Common/StaticList.h"
#include "../00.Dahua_Datastructures_Common/DoubleList.h"
#include "../00.Dahua_Datastructures_Common/SharedStack.h"
#include "../00.Dahua_Datastructures_Common/LinkStack.h"
#include "../00.Dahua_Datastructures_Common/Calc.h"
#include "../00.Dahua_Datastructures_Common/LinkQueue.h"
#include "../00.Dahua_Datastructures_Common/String.h"
int main()
{
/* 静态链表的使用
CursorList l;
l = initialize_cursorlist(10);
insert_cursorlist(l, 1, 5);
insert_cursorlist(l, 2, 9);
insert_cursorlist(l, 3, 19);
insert_cursorlist(l, 4, 29);
StaticList *s = &l[2];
insert_cursorlist(l, 5, 39);
print_allelements(l);
free(l);
s->cursor;
*/
/*双端链表的使用
DoubleList dl;
dl = initialize_DoubleList();
insert_DoubleList(dl, 1, 3);
insert_DoubleList(dl, 2, 5);
insert_DoubleList(dl, 3, 6);
insert_DoubleList(dl, 4, 69);
print_DoubleList_prior(dl);
printf("-----------");
delete_DoubleList(dl, 3);
print_DoubleList_next(dl);
auto df = dl->next->next;
free_DoubleList(dl);
//print_DoubleList_next(dl);
*/
/* 共享的栈使用
SharedStack s;
s=create_sharedStack(6);
push_sharedStack(5, s, 1);
push_sharedStack(6, s, 1);
push_sharedStack(7, s, 1);
push_sharedStack(8, s, 1);
push_sharedStack(9, s, 2);
push_sharedStack(10, s, 2);
push_sharedStack(12, s, 2);
print_allelemaentsinSharedStack(s);
pop_sharedStack(s, 1);
popandtop_sharedStack(s, 2);
print_allelemaentsinSharedStack(s);
free_sharedStack(s);
*/
/*链栈的使用
LinkStack li;
li = create_empty_LinkStack();
push_LinkStack(5,li);
push_LinkStack(6, li);
push_LinkStack(66, li);
push_LinkStack(666, li);
topandpop_linkstack(li);
auto i = li->next->next;
push_LinkStack(66666, li);
print_all_linkstack(li);
free_all_linkstack(li);
*/
//char c[] = { '1','+','2','*','3','+','(','4','*','5','+','6',')','*','7','\0' };// { '9', '+', '(', '3', '-', '1', ')', '*', '3', '+', '1', '/', '2' };
//int s = sizeof(c) / sizeof(c[0]);
//char *gff=infixToSuffix(c, s-1);
//printf("%s", gff);
/* 中缀式 转后缀式
char c; int cnt = 0;
char p[256];
do
{
c = getchar();
if (c != ' ' && c !='\n')
{
p[cnt++] = c;
}
} while (cnt <256 && c != '\n');
p[cnt] = '\0';
char *f=infixToSuffix(p, cnt);
printf(" postfix is \'%s\'", f);
free(f);
*/
/*
LinkQueue lq;
lq = create_empty_linkqueue();
EnQueue_linkqueue(lq, 1);
EnQueue_linkqueue(lq, 2);
EnQueue_linkqueue(lq, 3);
//printf("%d\n",DeQueue_linkqueuq(lq));
//printf("%d\n", DeQueue_linkqueuq(lq));
//printf("%d\n", DeQueue_linkqueuq(lq));
destroy_allLinkQueue(lq);
*/
String h;
h = create_string('\0', 5);
int g = size_string(h);
for(int j=1;j<=5;++j)
push_back_string(h, '0'+j);
printf("%s", h->first);
insert_string(h, '6', 2);
String h2;
h2 = create_string('\0', 10);
for (int j = 1; j <= 9; ++j)
push_back_string(h2, '0'+j);
String hh = union_string(h, h2);
String p = create_string();
push_back_string(p, 's');
String hhh = create_string('2', 6);
push_back_string(hhh, 'A');
push_back_string(hhh, 'A');
push_back_string(hhh, 'A');
push_back_string(hhh, 'B');
push_back_string(hhh, 'D');
push_back_string(hhh, 'A');
int a = find_string_KMP(hhh,hh);
free_string(h);
getchar();
return 0;
}
|
[
"wangshu214@live.cn"
] |
wangshu214@live.cn
|
d3ce1da973457a36a3719e596fd370ee66a0d322
|
a4bb53a5255d77f3ae106e1e311a09f516696de3
|
/outputtable_node.hpp
|
2b15338bd3b6500344a84ec6c8291f4a896b1caf
|
[] |
no_license
|
GavriloJovanovic/Racoons
|
0598c5e3680ac3b932dcc904e06009f7ca7c7a86
|
216cbf1e0e72a4df7c339a12141af5b7823fe457
|
refs/heads/main
| 2023-01-05T19:24:25.347824
| 2020-11-07T21:25:05
| 2020-11-07T21:25:05
| 309,077,371
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 389
|
hpp
|
#ifndef OUTPUTTABLE_NODE_HPP
#define OUTPUTTABLE_NODE_HPP
#include "node.hpp"
#include <QPushButton>
#include <QObject>
class outputTable_node : public node
{
Q_OBJECT
public:
outputTable_node(int width,int height);
private:
QPushButton previewBtn;
public slots:
void load();
void browse();
void preview();
};
#endif // OUTPUTTABLE_NODE_HPP
|
[
"noreply@github.com"
] |
GavriloJovanovic.noreply@github.com
|
3af003b8d000d0f5db2d296783cc3635fc189ae1
|
e3c27edbd2f0a8e733cee84b90a906c0a6d7c176
|
/mpi/time.cpp
|
00f171c540eb8a47e2e062f015225edd99ac1be7
|
[] |
no_license
|
dmitryhd/dmitryhd_code
|
c32223da5506156a068bbb0f20ad4cd06fdf2166
|
5173f6f74d4fa1c9c5fba9ffc4fc9134c56f4b0c
|
refs/heads/master
| 2021-01-17T11:56:50.221745
| 2011-04-26T18:31:58
| 2011-04-26T18:31:58
| 1,650,576
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,356
|
cpp
|
/*Copyright 2011 Dmitry Khodakov
coded: 2.03.11
*/
#include <mpi.h>
#include <stdlib.h>
#include <stdint.h>
// mark of every message
#define TAG 0
void master();
void node();
int main(int argc, char *argv[]) {
int myid = 0;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
double tbegin, tend;
tbegin = MPI_Wtime();
if (myid == 0)
master();
else
node();
tend = MPI_Wtime();
if (myid == 0)
printf("%f\n", tend - tbegin);
MPI_Finalize();
return 0;
}
// master (id = 0) process, it split task and get first part of it
// args: last_number - bottom of natural sequence.
void master() {
int numproc = 1; // number of nodes in network
MPI_Comm_size(MPI_COMM_WORLD, &numproc);
MPI_Status stat; // status of receiving. I didn't use it here. Don't delete.
uint32_t sended_res; // result of partial computation by node
for (int i = 1, add_count = 0; i < numproc; ++i, ++add_count) {
MPI_Recv(&sended_res, 1, MPI_UNSIGNED_LONG, i, TAG, MPI_COMM_WORLD, &stat);
MPI_Send(&sended_res, 1, MPI_UNSIGNED_LONG, i, TAG, MPI_COMM_WORLD);
}
}
// calculating process, takes tasks from master
void node() {
MPI_Status stat;
uint32_t sended_res;
MPI_Send(&sended_res, 1, MPI_UNSIGNED_LONG, 0, TAG, MPI_COMM_WORLD);
MPI_Recv(&sended_res, 1, MPI_UNSIGNED_LONG, 0, TAG, MPI_COMM_WORLD, &stat);
}
|
[
"dmitryhd@google.com"
] |
dmitryhd@google.com
|
1507956ce53d53a3aa4bc14f2f28304e2c973d80
|
01eb9bea1e6c1b3eab913b3636a6895b1d2b39f5
|
/API/src/System.cpp
|
22b77647562fa4b733c1f2793de4a5f4fd95e73b
|
[
"MIT"
] |
permissive
|
thaolt/OtterUI
|
a5e4424341047eeac03c27bebceae6442763975b
|
a2c524378e4933bd772b44f4c56b5139e8b4094a
|
refs/heads/master
| 2021-05-30T04:24:15.442292
| 2015-08-21T18:35:58
| 2015-08-21T18:35:58
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,653
|
cpp
|
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "System.h"
#include "Scene.h"
#include "Data/OtterData.h"
#include "Graphics/Graphics.h"
#include "Memory/Memory.h"
#include "Common/Log.h"
namespace Otter
{
/* Constructor. Allocates an internal buffer from default allocators of size 'memorySize'
*/
System::System(int memorySize)
{
mScreenWidth = 0;
mScreenHeight = 0;
mMemoryBuffer = NULL;
if(memorySize > 0)
{
mMemoryBuffer = (uint8*)malloc(memorySize);
MemoryManager::initializeMemoryManager(mMemoryBuffer, memorySize);
}
mFileSystem = NULL;
mSoundSystem = NULL;
mGraphics = OTTER_NEW(Graphics, ());
SetResolution(1024, 768);
}
/* Constructor. Uses the provided buffer as its heap memory.
*/
System::System(uint8* pMemoryBuffer, int memorySize)
{
MemoryManager::initializeMemoryManager(pMemoryBuffer, memorySize);
InitLog(this);
mFileSystem = NULL;
mGraphics = NULL;
mScreenWidth = 0;
mScreenHeight = 0;
mMemoryBuffer = NULL;
SetResolution(1024, 768);
}
/* Destructor
*/
System::~System(void)
{
UnloadAllScenes();
DeinitLog();
mScenes.clear(true);
mPlugins.clear(true);
mOnSceneLoaded.Clear();
mOnSceneUnloaded.Clear();
mOnLog.Clear();
mOnMessage.Clear();
OTTER_DELETE(mGraphics);
mGraphics = NULL;
MemoryManager::deinitializeMemoryManager();
if(mMemoryBuffer)
{
free(mMemoryBuffer);
mMemoryBuffer = NULL;
}
}
/* Sets the file system. This object will be called
* when opening / closing / reading from files.
*/
Result System::SetFileSystem(IFileSystem* pFileSystem)
{
mFileSystem = pFileSystem;
return kResult_OK;
}
/* Sets the object responsible for rendering the GUI
*/
Result System::SetRenderer(IRenderer* pRenderer)
{
mGraphics->SetUserRenderer(pRenderer);
return kResult_OK;
}
/* Sets the sound system
*/
Result System::SetSoundSystem(ISoundSystem* pSoundSystem)
{
mSoundSystem = pSoundSystem;
return kResult_OK;
}
/* Adds a plugin
*/
Result System::AddPlugin(IPlugin* pPlugin)
{
if(pPlugin == NULL)
return kResult_Error;
int cnt = mPlugins.size();
for(int i = 0; i < cnt; i++)
{
if(mPlugins[i] == pPlugin)
return kResult_OK;
}
mPlugins.push_back(pPlugin);
return kResult_OK;
}
/**
* Enables / disables (cpu) pre-transforming of vertices.
* Enabling vertex pretransformation may reduce draw calls at the cost
* of additional CPU load.
*/
Result System::EnablePreTransformVerts(bool bEnable)
{
if(!mGraphics)
return kResult_Error;
mGraphics->EnablePreTransformVerts(bEnable);
return kResult_OK;
}
/**
* Enables / disables logging
*/
Result System::EnableLogging(bool bEnable)
{
if(bEnable)
{
InitLog(this);
}
else
{
DeinitLog();
}
return kResult_OK;
}
/* Sets the resolution of the UI. Can be called at any time.
*/
Result System::SetResolution(uint32 width, uint32 height)
{
mScreenWidth = width;
mScreenHeight = height;
int cnt = GetSceneCount();
for(int i = 0; i < cnt; i++)
if( Scene * s=GetScene(i) )
s->SetResolution(mScreenWidth, mScreenHeight);
return kResult_OK;
}
bool System::HasScene( char const * name ) const
{
assert(mFileSystem!=0);
void* pHandle = (void*)mFileSystem->Open(name, AccessFlag(kBinary | kRead));
if(pHandle == NULL)
return false;
mFileSystem->Close(pHandle);
return true;
}
/* Loads a scene from file
*/
Result System::LoadScene(const char* szPath, Scene** ppScene)
{
if(!mFileSystem)
return kResult_NoFileSystem;
void* pHandle = (void*)mFileSystem->Open(szPath, AccessFlag(kBinary | kRead));
if(pHandle == NULL)
return kResult_FileNotFound;
uint32 size = mFileSystem->Size(pHandle);
if(size == 0)
return kResult_InvalidFile;
uint8* pBuffer = (uint8*)OTTER_ALLOC(size);
uint32 readSize = mFileSystem->Read(pHandle, pBuffer, size);
mFileSystem->Close(pHandle);
// Check if we failed to read all the data, or if we
// simply failed to load the scene. Cleanup and bail if so.
if(readSize != size)
{
OTTER_FREE(pBuffer);
return kResult_FailedRead;
}
return LoadScene(pBuffer, size, false, ppScene);
}
/* Loads a scene from an existing in-memory buffer
*/
Result System::LoadScene(const uint8* pBuffer, uint32 bufferSize, bool bCopy, Scene** ppScene)
{
// Copy the data if necessary.
const uint8* pSceneBuffer = pBuffer;
if(bCopy)
{
pSceneBuffer = (uint8*)OTTER_ALLOC(bufferSize);
memcpy((uint8*)pSceneBuffer, pBuffer, bufferSize);
}
// Cast the buffer to the scene data object and verify it's a
// valid scene data buffer and version.
const SceneData* pSceneData = (const SceneData*)pSceneBuffer;
if(pSceneData->mFourCC != FOURCC_GGSC)
{
return kResult_InvalidSceneFile;
}
if(pSceneData->mVersion != SCENE_DATA_VERSION)
{
return kResult_InvalidSceneVersion;
}
Scene* pScene = OTTER_NEW(Scene, (this, mGraphics, mSoundSystem, pSceneData));
pScene->SetResolution(mScreenWidth, mScreenHeight);
mScenes.push_back(pScene);
mOnSceneLoaded(this, pScene);
if(ppScene)
*ppScene = pScene;
return kResult_OK;
}
/**
* Unloads the specified scene
*/
Result System::UnloadScene(Scene* pScene)
{
if(!pScene)
return kResult_Error;
uint32 numActiveViews = pScene->GetNumActiveViews();
for(uint32 i = 0; i < numActiveViews; i++)
{
View* view = pScene->GetActiveView(i);
view->OnDeactivate();
}
// Grab a pointer to the internal scene data in case we need
// to free it ourselves later.
const uint8* pData = (const uint8*)pScene->GetData();
mOnSceneUnloaded(this, pScene);
OTTER_DELETE(pScene);
// The data may not have come from us. If it's the memory manager's
// memory pool, we allocated it and so we must release it.
if(MemoryManager::isValid(pData))
{
OTTER_FREE((void*)pData);
}
for(uint32 i = 0; i < mScenes.size(); i++)
{
if(mScenes[i] == pScene)
{
mScenes.erase(i);
break;
}
}
return kResult_OK;
}
/**
* Unloads a scene by index
*/
Result System::UnloadScene(uint32 index)
{
Scene * s=GetScene(index);
assert(s!=0);
return UnloadScene(s);
}
/* Unloads the active scene
*/
Result System::UnloadAllScenes()
{
while(mScenes.size() > 0)
{
UnloadScene(mScenes[0]);
}
mScenes.clear();
return kResult_OK;
}
/* Returns a loaded scene by index
*/
Scene* System::GetScene(uint32 index)
{
if(index >= mScenes.size())
return 0;
return mScenes[index];
}
/* Returns the number of scenes currently loaded
*/
uint32 System::GetSceneCount()
{
return mScenes.size();
}
void System::BringToFront( Scene * s )
{
assert(s!=0);
for( int i=0,n=GetSceneCount(); i!=n; ++i )
{
Scene * ss=mScenes[i];
if( s==ss )
{
for( ; i!=n-1; ++i )
mScenes[i]=mScenes[i+1];
mScenes[i]=s;
return;
}
}
assert(0);
}
/* Draws the GUI
*/
Result System::Draw()
{
if(!mGraphics)
return kResult_NoRenderer;
uint32 numScenes = GetSceneCount();
if(numScenes)
{
mGraphics->Begin();
for(uint32 i = 0; i < numScenes; i++)
if( Scene * s=GetScene(i) )
s->Draw();
mGraphics->End();
}
return kResult_OK;
}
/* Updates the GUI
* "frameDelta" indicates the number of frames that have passed since last update.
*/
Result System::Update(float frameDelta)
{
uint32 numScenes = GetSceneCount();
if(numScenes)
{
for(uint32 i = 0; i < numScenes; i++)
if( Scene * s=GetScene(i) )
s->Update(frameDelta);
for(uint32 i = 0; i < numScenes; i++)
if( !GetScene(i) )
{
mScenes.erase(i);
break;
}
}
return kResult_OK;
}
/* Points (touches/mouse/etc) were pressed down
*/
void System::OnPointsDown(const Point* points, sint32 numPoints)
{
uint32 numScenes = GetSceneCount();
if(numScenes)
for(int i=numScenes; --i>=0; )
if( Scene * s=GetScene(i) )
if( s->OnPointsDown(points, numPoints) )
return;
}
/* Points (touches/mouse/etc) were released
*/
void System::OnPointsUp(const Point* points, sint32 numPoints)
{
uint32 numScenes = GetSceneCount();
if(numScenes)
for(int i=numScenes; --i>=0; )
if( Scene * s=GetScene(i) )
if( s->OnPointsUp(points, numPoints) )
return;
}
/* Points (touches/mouse/etc) were moved.
*/
void System::OnPointsMove(const Point* points, sint32 numPoints)
{
uint32 numScenes = GetSceneCount();
if(numScenes)
for(int i=numScenes; --i>=0; )
if( Scene * s=GetScene(i) )
if( s->OnPointsMove(points, numPoints) )
return;
}
};
|
[
"grafalgar@gmail.com"
] |
grafalgar@gmail.com
|
1fb85ca53367ccb1960657ed9c3c456f92fd6517
|
6b660cb96baa003de9e18e332b048c0f1fa67ab9
|
/External/SDK/BP_LargeShip_StandardHull_functions.cpp
|
546c1dcbe8f8c7e5bbbaaddf4176a2051a7b7562
|
[] |
no_license
|
zanzo420/zSoT-SDK
|
1edbff62b3e12695ecf3969537a6d2631a0ff36f
|
5e581eb0400061f6e5f93b3affd95001f62d4f7c
|
refs/heads/main
| 2022-07-30T03:35:51.225374
| 2021-07-07T01:07:20
| 2021-07-07T01:07:20
| 383,634,601
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,272
|
cpp
|
// Name: SoT, Version: 2.2.0.2
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function BP_LargeShip_StandardHull.BP_LargeShip_StandardHull_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)
void ABP_LargeShip_StandardHull_C::UserConstructionScript()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_LargeShip_StandardHull.BP_LargeShip_StandardHull_C.UserConstructionScript");
ABP_LargeShip_StandardHull_C_UserConstructionScript_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
void ABP_LargeShip_StandardHull_C::AfterRead()
{
AHull::AfterRead();
READ_PTR_FULL(Occluder, UStaticMeshComponent);
READ_PTR_FULL(Damage, UChildActorComponent);
READ_PTR_FULL(Art, UChildActorComponent);
}
void ABP_LargeShip_StandardHull_C::BeforeDelete()
{
AHull::BeforeDelete();
DELE_PTR_FULL(Occluder);
DELE_PTR_FULL(Damage);
DELE_PTR_FULL(Art);
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"Massimo.linker@gmail.com"
] |
Massimo.linker@gmail.com
|
d07068af9dad12a69eaa518988356552f54529e9
|
28a1460799e5d92459d468471b45d2d692f92450
|
/aufgabe2fertig/player.h
|
3100e9df196a4419bf58cc4fb043512a70dd52c9
|
[] |
no_license
|
Gabo0890/C-Aufgabe-2-SoSe-2018
|
528a1edf87a38b0372a8f3b0e99e69dcf0c76181
|
0eb17676586282591a4031c2af8df2bed7b261c4
|
refs/heads/master
| 2020-03-29T10:15:09.635266
| 2018-09-27T21:00:36
| 2018-09-27T21:00:36
| 149,795,954
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 359
|
h
|
#include <QGraphicsRectItem>
#include <QObject>
class myPlayer:public QObject, public QGraphicsRectItem {
Q_OBJECT
public:
void keyPressEvent(QKeyEvent * event);
public slots:
void spawn();
void spawn1();
void spawn2();
void spawn3();
//evtl noch spawn1(), spawn2() implementieren um einfacher enemies zu kategorisieren
};
|
[
"noreply@github.com"
] |
Gabo0890.noreply@github.com
|
c03d0632fdd245e28d301ba82e7d9f9a9acc3894
|
8a7efe320d8f0389b9d1c8d471fce6888680451d
|
/src/main.cpp
|
8d7b4c266895987dde751c34c0c19da6624c9dff
|
[] |
no_license
|
qwertyuiopasdfghjklqwertyuiop/CS2C.05.nonstd-Multiset.remove
|
aa077229c83a95b57cb38df39f9a21bf4c26989f
|
a44b242c09a55da7a7c7adce75c45951d87b044c
|
refs/heads/master
| 2021-08-08T08:59:32.296195
| 2017-11-10T01:24:48
| 2017-11-10T01:24:48
| 108,688,410
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,036
|
cpp
|
#include <iostream>
#include <cmath>
#include "./multiset.h"
using nonstd::MultiSet;
int main(const int argc, char ** argv){
if(argc != 3)
{
std::cerr << "./main BIGGEST_NUMBER NUM_INSERTIONS" << std::endl;
exit(1);
}
srand(time(NULL));
MultiSet<int> test;
const int BIGGEST_NUMBER = std::stoi(*(argv+1));
const int NUM_INSERTIONS = std::stoi(*(argv+2));
int myCounter = 0;
int toCountFor = rand() % BIGGEST_NUMBER;
for(int k = 0; k < NUM_INSERTIONS; k++)
{
int temp = rand() % BIGGEST_NUMBER;
test.insert(temp);
if(toCountFor == temp)
myCounter++;
}
std::cout << "Size: " << test.size() << std::endl;
std::cout << "Count for: " << toCountFor << std::endl;
std::cout << "Counted: " << test.count(toCountFor) << std::endl;
std::cout << "Removed: " << test.remove(toCountFor) << std::endl;
std::cout << "Removed again: " << test.remove(toCountFor) << std::endl;
std::cout << "New Size: " << test.size() << std::endl;
return 0;
}
|
[
"bobthefrank24685@gmail.com"
] |
bobthefrank24685@gmail.com
|
0044c75051c182a0ff04ba2b7440fd8ee70c5b9f
|
d9866786b5d6bf2d14aed66c3cfd511751dd1b57
|
/Sandbox/src/Snow/PointCloud.h
|
b45306dcef38058d956a4f811bff005ea8c9a081
|
[] |
no_license
|
kodai100/HydronEngine
|
6474b710f249f47619b79ebc5c4c3240d025a198
|
1670c556e90b05e733fbc29ae5eaeb3ca30b3283
|
refs/heads/master
| 2023-04-21T07:45:36.947492
| 2021-05-07T07:49:26
| 2021-05-07T07:49:26
| 361,784,814
| 4
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,168
|
h
|
#pragma once
#include <vector>
#include "SimConstants.h"
#include "Particle.h"
#include "Shape.h"
#define AREA_EPSILON 1e-5
inline float random_number(float lo, float hi){
return lo + rand() / (float) (RAND_MAX/(hi-lo));
}
class PointCloud {
public:
int size;
float max_velocity;
std::vector<Particle> particles;
PointCloud();
PointCloud(int cloud_size);
PointCloud(const PointCloud& orig);
virtual ~PointCloud();
//Transform points in cloud
void scale(Vector2f origin, Vector2f scale);
void translate(Vector2f off);
//Update particle data
void update();
//Merge two point clouds
void merge(const PointCloud& other);
//Get bounding box [xmin, xmax, ymin, ymax]
void bounds(float bounds[4]);
void draw();
//Generate particles that fill a set of shapes
static PointCloud* createShape(std::vector<Shape*>& snow_shapes){
//Compute area of all the snow shapes
float area = 0;
int len = snow_shapes.size(), num_shapes = 0;
for (int i=0; i<len; i++){
float indi_area = snow_shapes[i]->area();
if (indi_area > AREA_EPSILON && snow_shapes[i]->vertices.size() > 2){
num_shapes++;
area += indi_area;
}
}
//If there is no volume, we can't really do a snow sim
if (area < AREA_EPSILON)
return NULL;
//Otherwise, create our object
//Calculate particle settings
float particle_area = PARTICLE_DIAM*PARTICLE_DIAM,
particle_mass = particle_area*DENSITY;
int particles = area / particle_area;
//Randomly scatter points
PointCloud *obj = new PointCloud(particles);
float bounds[4];
int shape_num = 0, total_points = 0;
float max_vel = 0;
for (int i=0; i<len; i++){
float a = snow_shapes[i]->area();
Vector2f vel = snow_shapes[i]->vel;
if (vel.length_squared() > max_vel) max_vel = vel.length_squared();
if (a > AREA_EPSILON && snow_shapes[i]->vertices.size() > 2){
int points;
//Points given to each shape is proportional to their area
if (++shape_num < num_shapes)
points = a*particles/area;
//Last shape gets remainder, so we don't have round-off errors
else points = particles-total_points;
total_points += points;
//Estimate the centroid of the shape with the bounds
snow_shapes[i]->bounds(bounds);
float cx = (bounds[0]+bounds[1])/2.0,
cy = (bounds[2]+bounds[3])/2.0,
cw = bounds[1] - cx,
ch = bounds[3] - cy;
//Randomly scatter points in the shape until the quota is met
int points_found = 0;
srand(5);
while (points_found != points){
float tx = random_number(bounds[0], bounds[1]),
ty = random_number(bounds[2], bounds[3]);
//Check if this point is inside the shape
if (snow_shapes[i]->contains(tx, ty)){
//Randomly adjust hardness of snow
float adjust = (rand()/(float) RAND_MAX)*10;
//Make snow hardest on the outer edges
adjust *= ((fabs(tx-cx)/cw) + (fabs(ty-cy)/ch))/2.0;
//Add the snow particle
obj->particles.push_back(Particle(Vector2f(tx, ty), Vector2f(vel), particle_mass, LAMBDA, MU));
points_found++;
}
}
}
}
//Set initial max velocity
obj->max_velocity = max_vel;
return obj;
}
};
|
[
"kodai100@gmail.com"
] |
kodai100@gmail.com
|
b760068219e09d000ae682df11fe4f9793b91645
|
794ec36417d1f5fe9f8a8dfefee17169ba346447
|
/UVA/156/10094942_AC_0ms_0kB.cpp
|
60a8a42be89654e8e2a514e95147ca779ca58460
|
[] |
no_license
|
riba2534/My_ACM_Code
|
1d2f7dacb50f7e9ed719484419b3a7a41ba407cf
|
fa914ca98ad0794073bc1ccac8ab7dca4fe13f25
|
refs/heads/master
| 2020-03-24T01:19:19.889558
| 2019-03-11T03:01:09
| 2019-03-11T03:01:09
| 142,331,120
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,101
|
cpp
|
#include <cstdio>
#include <cstring>
#include <cctype>
#include <string>
#include <set>
#include <iostream>
#include <stack>
#include <map>
#include <cmath>
#include <queue>
#include <vector>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define N 10000+20
#define ll long long
using namespace std;
//map<string,int>mp;
//vector<string>v;
//string str(string s)
//{
// for(int i=0;i<s.length();i++)
// s[i]=tolower(s[i]);
// sort(s.beg)
//
//}
//int main()
//{
// string s;
// while(cin>>s&&s!="#")
// {
//
// }
//}
map<string,int>cnt;
vector<string>words;
string repr(string s)
{
string ans=s;
for(int i=0; i<ans.length(); i++)
ans[i]=tolower(ans[i]);
sort(ans.begin(),ans.end());
return ans;
}
int main()
{
int n=0;
string s;
while(cin>>s&&s!="#")
{
words.push_back(s);
string r=repr(s);
if(!cnt.count(r))
cnt[r]=0;
cnt[r]++;
}
vector<string>ans;
for(int i=0; i<words.size(); i++)
if(cnt[repr(words[i])]==1)
ans.push_back(words[i]);
sort(ans.begin(),ans.end());
for(int i=0; i<ans.size(); i++)
cout<<ans[i]<<endl;
return 0;
}
|
[
"riba2534@qq.com"
] |
riba2534@qq.com
|
b368a7db1d4b45fd8b7c3699ad56dd60463db67c
|
3702e384050f90bb8ad39db7002ec5f6fabe4047
|
/curses/game_manager.h
|
824abe36fbc8ee8e41cb3faaa086a3cebcaa4e5a
|
[] |
no_license
|
pviolette3/jamstacks
|
264872f292253206defb763af3d5b109cd008d73
|
94e2faed58d65ee4f5d1e86f8dd43200cd7d7b6c
|
refs/heads/master
| 2021-07-21T22:23:24.585472
| 2017-10-30T08:23:16
| 2017-10-30T08:23:16
| 94,112,596
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,078
|
h
|
#pragma once
#include <array>
#include <memory>
#include <vector>
#include <string>
#include <stdint.h>
namespace jam {
// Thread-safe game state
class GameManager {
public:
GameManager() {}
class Handler {
GameManager *gameManager_;
protected:
Handler(GameManager &gameManager) noexcept : gameManager_(&gameManager) {
gameManager_->registerHandler(*this);
}
GameManager const &gameManager() { return *gameManager_; }
public:
virtual ~Handler() noexcept {}
// Show cards, small blind, big blind, dealer token
virtual void onHandStart() noexcept = 0;
virtual void onHandComplete() noexcept = 0;
/// @returns 0 for check/fold (context dependent) or the bet.
virtual uint64_t onPlayersAction() noexcept = 0;
virtual void onOthersAction(size_t player) noexcept = 0;
virtual void onFlop() noexcept = 0;
virtual void onTurn() noexcept = 0;
virtual void onRiver() noexcept = 0;
};
private:
void registerHandler(Handler &handler) { handlers_.push_back(&handler); }
std::vector<Handler *> handlers_;
};
}
|
[
"terrelln@fb.com"
] |
terrelln@fb.com
|
f9709384ff71ed3a7cf59ec1a332ff1ad4439156
|
28d68af73c56375314efd07eaf6a1a9241a51ce3
|
/aws-cpp-sdk-core/source/utils/windows/FileSystemUtils.cpp
|
469bac3a2d1313184a389a5d15722baef9a49722
|
[
"JSON",
"MIT",
"Apache-2.0"
] |
permissive
|
zeliard/aws-sdk-cpp
|
93b560791fa359be25b201e9a6513bc3cb415046
|
14119f1f5bc159ce00a1332f86e117362afd3cb6
|
refs/heads/master
| 2021-01-16T22:49:18.731977
| 2016-01-04T01:54:38
| 2016-01-04T01:54:38
| 41,892,393
| 0
| 1
| null | 2015-09-04T01:35:43
| 2015-09-04T01:35:43
| null |
UTF-8
|
C++
| false
| false
| 3,669
|
cpp
|
/*
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. 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.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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 <aws/core/utils/FileSystemUtils.h>
#include <aws/core/utils/logging/LogMacros.h>
#include <aws/core/utils/StringUtils.h>
#include <Userenv.h>
#pragma warning( disable : 4996)
using namespace Aws::Utils;
static const char* LOG_TAG = "FileSystemUtils";
Aws::String FileSystemUtils::GetHomeDirectory()
{
static const char* HOME_DIR_ENV_VAR = "USERPROFILE";
AWS_LOGSTREAM_TRACE(LOG_TAG, "Checking " << HOME_DIR_ENV_VAR << " for the home directory.");
char* homeDir = std::getenv(HOME_DIR_ENV_VAR);
CHAR path[MAX_PATH];
AWS_LOGSTREAM_DEBUG(LOG_TAG, "Environment value for variable " << HOME_DIR_ENV_VAR << " is " << homeDir);
if(!homeDir)
{
AWS_LOG_WARN(LOG_TAG, "Home dir not stored in environment, trying to fetch manually from the OS.");
HANDLE hToken;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &hToken))
{
DWORD len = MAX_PATH;
if (GetUserProfileDirectoryA(hToken, path, &len))
{
homeDir = path;
}
CloseHandle(hToken);
}
AWS_LOGSTREAM_INFO(LOG_TAG, "Pulled " << homeDir << " as home directory from the OS.");
}
Aws::String retVal = homeDir ? StringUtils::Trim(static_cast<const char*>(homeDir)) : "";
if (!retVal.empty())
{
if (retVal.at(retVal.length() - 1) != PATH_DELIM)
{
retVal += PATH_DELIM;
}
}
return std::move(retVal);
}
bool FileSystemUtils::CreateDirectoryIfNotExists(const char* path)
{
AWS_LOGSTREAM_INFO(LOG_TAG, "Creating directory " << path);
if (CreateDirectoryA(path, nullptr))
{
AWS_LOGSTREAM_DEBUG(LOG_TAG, "Creation of directory " << path << " succeeded.")
return true;
}
else
{
DWORD errorCode = GetLastError();
AWS_LOGSTREAM_DEBUG(LOG_TAG, " Creation of directory " << path << " returned code: " << errorCode);
return errorCode == ERROR_ALREADY_EXISTS;
}
}
bool FileSystemUtils::RemoveFileIfExists(const char* path)
{
AWS_LOGSTREAM_INFO(LOG_TAG, "Deleting file: " << path);
if(DeleteFileA(path))
{
AWS_LOGSTREAM_DEBUG(LOG_TAG, "Successfully deleted file: " << path);
return true;
}
else
{
DWORD errorCode = GetLastError();
AWS_LOGSTREAM_DEBUG(LOG_TAG, "Deletion of file: " << path << " Returned error code: " << errorCode);
return errorCode == ERROR_FILE_NOT_FOUND;
}
}
bool FileSystemUtils::RelocateFileOrDirectory(const char* from, const char* to)
{
AWS_LOGSTREAM_INFO(LOG_TAG, "Moving file at " << from << " to " << to);
if(MoveFileA(from, to))
{
AWS_LOGSTREAM_DEBUG(LOG_TAG, "The moving operation of file at " << from << " to " << to << " Succeeded.");
return true;
}
else
{
int errorCode = GetLastError();
AWS_LOGSTREAM_DEBUG(LOG_TAG, "The moving operation of file at " << from << " to " << to << " Returned error code of " << errorCode);
return false;
}
}
|
[
"henso@amazon.com"
] |
henso@amazon.com
|
4c22ac117ce7ede470a64ac7e8b61a5e02adf6e4
|
3355e6cfe368490bdacdacb153cc8bea0b3a807d
|
/02-CPP/Leetcode/Leetcode/排序_数组/排序数组测试.cpp
|
325718f49b9e9c58b771345b3fe0e83bbaf3aa3d
|
[] |
no_license
|
CoderLiLe/DataStructureAlgorithm
|
1ecf077efbf19f3f08ee05879c9e2c1fa48dd736
|
f552e8d5e2f2b531e5b90dd0f16fd9208f0feadb
|
refs/heads/master
| 2021-11-19T09:27:15.688142
| 2021-10-12T12:10:47
| 2021-10-12T12:10:47
| 187,794,975
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,591
|
cpp
|
//
// 排序数组测试.cpp
// Leetcode
//
// Created by LiLe on 2021/7/21.
//
#include "排序数组测试.hpp"
#include <iostream>
#include "_0075_ 颜色分类.hpp"
#include "_0215_数组中的第K个最大元素.hpp"
#include "_0033_搜索旋转排序数组.hpp"
#include "_0034_在排序数组中查找元素的第一个和最后一个位置.hpp"
#include "VectorUtil.hpp"
using namespace std;
void test0033() {
vector<int> nums = {4,5,6,7,0,1,2};
cout << searchTarget(nums, 0) << endl;
cout << searchTarget(nums, 3) << endl;
vector<int> nums2 = {1};
cout << searchTarget(nums2, 0) << endl;
}
void test0033_02() {
vector<int> nums = {4,5,6,7,0,1,2};
cout << searchTarget2(nums, 0) << endl;
cout << searchTarget2(nums, 3) << endl;
vector<int> nums2 = {1};
cout << searchTarget2(nums2, 0) << endl;
}
void test0034() {
vector<int> nums = {5,7,7,8,8,10};
vector<int> res = searchRange(nums, 8);
vectorPrint(res);
vector<int> res2 = searchRange(nums, 6);
vectorPrint(res2);
vector<int> nums3 = {};
vector<int> res3 = searchRange(nums3, 0);
vectorPrint(res3);
}
void test0075() {
vector<int> nums = {2,0,2,1,1,0};
sortColors(nums);
for (auto val : nums) {
cout << val << " ";
}
cout << endl;
}
void test0215() {
vector<int> nums = {3, 2, 1, 5, 6, 4};
assert(5 == findKthLargest(nums, 2));
assert(5 == findKthLargest2(nums, 2));
}
void sortArraytest() {
// test0033();
// test0033_02();
test0034();
// test0075();
// test0215();
}
|
[
"lile@aihujing.com"
] |
lile@aihujing.com
|
08302da214060ab38e5c8fef0385027d88b860a7
|
5ebd5cee801215bc3302fca26dbe534e6992c086
|
/blazetest/src/mathtest/dmatsmatmult/UDbDCa.cpp
|
f23c37af79ef8d8d1319500c3f51c35f5bc9ba66
|
[
"BSD-3-Clause"
] |
permissive
|
mhochsteger/blaze
|
c66d8cf179deeab4f5bd692001cc917fe23e1811
|
fd397e60717c4870d942055496d5b484beac9f1a
|
refs/heads/master
| 2020-09-17T01:56:48.483627
| 2019-11-20T05:40:29
| 2019-11-20T05:41:35
| 223,951,030
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,536
|
cpp
|
//=================================================================================================
/*!
// \file src/mathtest/dmatsmatmult/UDbDCa.cpp
// \brief Source file for the UDbDCa dense matrix/sparse matrix multiplication math test
//
// Copyright (C) 2012-2019 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group nor the names of its contributors
// may be used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blaze/math/CompressedMatrix.h>
#include <blaze/math/DiagonalMatrix.h>
#include <blaze/math/DynamicMatrix.h>
#include <blaze/math/UpperMatrix.h>
#include <blazetest/mathtest/Creator.h>
#include <blazetest/mathtest/dmatsmatmult/OperationTest.h>
#include <blazetest/system/MathTest.h>
#ifdef BLAZE_USE_HPX_THREADS
# include <hpx/hpx_main.hpp>
#endif
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running 'UDbDCa'..." << std::endl;
using blazetest::mathtest::TypeA;
using blazetest::mathtest::TypeB;
try
{
// Matrix type definitions
using UDb = blaze::UpperMatrix< blaze::DynamicMatrix<TypeB> >;
using DCa = blaze::DiagonalMatrix< blaze::CompressedMatrix<TypeA> >;
// Creator type definitions
using CUDb = blazetest::Creator<UDb>;
using CDCa = blazetest::Creator<DCa>;
// Running tests with small matrices
for( size_t i=0UL; i<=6UL; ++i ) {
for( size_t j=0UL; j<=i; ++j ) {
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( i ), CDCa( i, j ) );
}
}
// Running tests with large matrices
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 31UL ), CDCa( 31UL, 7UL ) );
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 67UL ), CDCa( 67UL, 7UL ) );
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 127UL ), CDCa( 127UL, 13UL ) );
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 32UL ), CDCa( 32UL, 8UL ) );
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 64UL ), CDCa( 64UL, 8UL ) );
RUN_DMATSMATMULT_OPERATION_TEST( CUDb( 128UL ), CDCa( 128UL, 16UL ) );
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during dense matrix/sparse matrix multiplication:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
|
[
"klaus.iglberger@gmail.com"
] |
klaus.iglberger@gmail.com
|
4d0734b1ba9420495012630743a290149128b0a4
|
c5c71d44ae35aabbcfc63b2ba5faee9796542832
|
/Lista 09 - Recursividade/E24.cpp
|
9d88e944a2ad76571e79b4b47c755c29e635b31b
|
[
"MIT"
] |
permissive
|
vitordutra/algoritmos-programacao-ufsm-2018-2
|
fb75e6533955e51165e85ce35abe71848ceafd0f
|
721fe06da40a0b667098b5121ca1dfe0379e6f16
|
refs/heads/master
| 2020-12-28T10:20:22.124441
| 2020-02-04T20:06:57
| 2020-02-04T20:06:57
| 238,285,587
| 0
| 0
| null | null | null | null |
ISO-8859-1
|
C++
| false
| false
| 570
|
cpp
|
#include <stdio.h>
#include <stdlib.h>
/* Ex23 --> Os números de Pell são definidos pela seguinte recursão: P(n) = 0 se n = 0; P(n) = 1 se n = 1;
P(n) = 2P(n - 1) + P(n - 2) Alguns números desta sequência são: 0, 1, 2, 5, 12, 29, 70, 169, 408, 985...
Faça uma função recursiva que receba um número N e retorne o N-ésimo número de Pell.*/
int pell(int n) {
if(n == 0) {
return 0;
}
if(n == 1) {
return 1;
}
return 2 * pell(n - 1) + pell(n - 2);
}
int main(int argc, char *argv[]) {
printf("%d", pell(10));
return 0;
}
|
[
"noreply@github.com"
] |
vitordutra.noreply@github.com
|
c06147494d08b12c9f07c9beb3b58267ea91ec99
|
6e25ca122e98dc53738cc150556cfa4e4833ba4b
|
/src/cxx.cc
|
da05ee2f79f2d4f6d55511c8c7bf5818a5f78f52
|
[
"Apache-2.0",
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
BLQ5/cxx
|
4c8832a0202dd8bc1e2c0e42431b03ca48ab7686
|
041c9040ba4f678e87622ea59515e16f35eeb1e5
|
refs/heads/master
| 2022-12-04T00:22:22.154442
| 2020-08-26T05:16:15
| 2020-08-26T05:16:15
| 290,582,317
| 1
| 0
|
NOASSERTION
| 2020-08-26T19:07:26
| 2020-08-26T19:07:25
| null |
UTF-8
|
C++
| false
| false
| 11,729
|
cc
|
#include "../include/cxx.h"
#include <cstring>
#include <exception>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <vector>
template <typename Exception>
static void panic [[noreturn]] (const char *msg) {
#if defined(RUST_CXX_NO_EXCEPTIONS)
std::cerr << "Error: " << msg << ". Aborting." << std::endl;
std::terminate();
#else
throw Exception(msg);
#endif
}
extern "C" {
const char *cxxbridge03$cxx_string$data(const std::string &s) noexcept {
return s.data();
}
size_t cxxbridge03$cxx_string$length(const std::string &s) noexcept {
return s.length();
}
// rust::String
void cxxbridge03$string$new(rust::String *self) noexcept;
void cxxbridge03$string$clone(rust::String *self,
const rust::String &other) noexcept;
bool cxxbridge03$string$from(rust::String *self, const char *ptr,
size_t len) noexcept;
void cxxbridge03$string$drop(rust::String *self) noexcept;
const char *cxxbridge03$string$ptr(const rust::String *self) noexcept;
size_t cxxbridge03$string$len(const rust::String *self) noexcept;
// rust::Str
bool cxxbridge03$str$valid(const char *ptr, size_t len) noexcept;
} // extern "C"
namespace rust {
inline namespace cxxbridge03 {
String::String() noexcept { cxxbridge03$string$new(this); }
String::String(const String &other) noexcept {
cxxbridge03$string$clone(this, other);
}
String::String(String &&other) noexcept {
this->repr = other.repr;
cxxbridge03$string$new(&other);
}
String::~String() noexcept { cxxbridge03$string$drop(this); }
String::String(const std::string &s) : String(s.data(), s.length()) {}
String::String(const char *s) : String(s, std::strlen(s)) {}
String::String(const char *s, size_t len) {
if (!cxxbridge03$string$from(this, s, len)) {
panic<std::invalid_argument>("data for rust::String is not utf-8");
}
}
String &String::operator=(const String &other) noexcept {
if (this != &other) {
cxxbridge03$string$drop(this);
cxxbridge03$string$clone(this, other);
}
return *this;
}
String &String::operator=(String &&other) noexcept {
if (this != &other) {
cxxbridge03$string$drop(this);
this->repr = other.repr;
cxxbridge03$string$new(&other);
}
return *this;
}
String::operator std::string() const {
return std::string(this->data(), this->size());
}
const char *String::data() const noexcept {
return cxxbridge03$string$ptr(this);
}
size_t String::size() const noexcept { return cxxbridge03$string$len(this); }
size_t String::length() const noexcept { return cxxbridge03$string$len(this); }
String::String(unsafe_bitcopy_t, const String &bits) noexcept
: repr(bits.repr) {}
std::ostream &operator<<(std::ostream &os, const String &s) {
os.write(s.data(), s.size());
return os;
}
Str::Str() noexcept : repr(Repr{reinterpret_cast<const char *>(this), 0}) {}
Str::Str(const Str &) noexcept = default;
Str::Str(const std::string &s) : Str(s.data(), s.length()) {}
Str::Str(const char *s) : Str(s, std::strlen(s)) {}
Str::Str(const char *s, size_t len) : repr(Repr{s, len}) {
if (!cxxbridge03$str$valid(this->repr.ptr, this->repr.len)) {
panic<std::invalid_argument>("data for rust::Str is not utf-8");
}
}
Str &Str::operator=(Str other) noexcept {
this->repr = other.repr;
return *this;
}
Str::operator std::string() const {
return std::string(this->data(), this->size());
}
const char *Str::data() const noexcept { return this->repr.ptr; }
size_t Str::size() const noexcept { return this->repr.len; }
size_t Str::length() const noexcept { return this->repr.len; }
Str::Str(Repr repr_) noexcept : repr(repr_) {}
Str::operator Repr() noexcept { return this->repr; }
std::ostream &operator<<(std::ostream &os, const Str &s) {
os.write(s.data(), s.size());
return os;
}
extern "C" {
const char *cxxbridge03$error(const char *ptr, size_t len) {
char *copy = new char[len];
strncpy(copy, ptr, len);
return copy;
}
} // extern "C"
Error::Error(Str::Repr msg) noexcept : msg(msg) {}
Error::Error(const Error &other) {
this->msg.ptr = cxxbridge03$error(other.msg.ptr, other.msg.len);
this->msg.len = other.msg.len;
}
Error::Error(Error &&other) noexcept {
delete[] this->msg.ptr;
this->msg = other.msg;
other.msg.ptr = nullptr;
other.msg.len = 0;
}
Error::~Error() noexcept { delete[] this->msg.ptr; }
const char *Error::what() const noexcept { return this->msg.ptr; }
} // namespace cxxbridge03
} // namespace rust
extern "C" {
void cxxbridge03$unique_ptr$std$string$null(
std::unique_ptr<std::string> *ptr) noexcept {
new (ptr) std::unique_ptr<std::string>();
}
void cxxbridge03$unique_ptr$std$string$raw(std::unique_ptr<std::string> *ptr,
std::string *raw) noexcept {
new (ptr) std::unique_ptr<std::string>(raw);
}
const std::string *cxxbridge03$unique_ptr$std$string$get(
const std::unique_ptr<std::string> &ptr) noexcept {
return ptr.get();
}
std::string *cxxbridge03$unique_ptr$std$string$release(
std::unique_ptr<std::string> &ptr) noexcept {
return ptr.release();
}
void cxxbridge03$unique_ptr$std$string$drop(
std::unique_ptr<std::string> *ptr) noexcept {
ptr->~unique_ptr();
}
} // extern "C"
#define STD_VECTOR_OPS(RUST_TYPE, CXX_TYPE) \
size_t cxxbridge03$std$vector$##RUST_TYPE##$size( \
const std::vector<CXX_TYPE> &s) noexcept { \
return s.size(); \
} \
const CXX_TYPE *cxxbridge03$std$vector$##RUST_TYPE##$get_unchecked( \
const std::vector<CXX_TYPE> &s, size_t pos) noexcept { \
return &s[pos]; \
} \
void cxxbridge03$unique_ptr$std$vector$##RUST_TYPE##$null( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr) noexcept { \
new (ptr) std::unique_ptr<std::vector<CXX_TYPE>>(); \
} \
void cxxbridge03$unique_ptr$std$vector$##RUST_TYPE##$raw( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr, \
std::vector<CXX_TYPE> *raw) noexcept { \
new (ptr) std::unique_ptr<std::vector<CXX_TYPE>>(raw); \
} \
const std::vector<CXX_TYPE> \
*cxxbridge03$unique_ptr$std$vector$##RUST_TYPE##$get( \
const std::unique_ptr<std::vector<CXX_TYPE>> &ptr) noexcept { \
return ptr.get(); \
} \
std::vector<CXX_TYPE> \
*cxxbridge03$unique_ptr$std$vector$##RUST_TYPE##$release( \
std::unique_ptr<std::vector<CXX_TYPE>> &ptr) noexcept { \
return ptr.release(); \
} \
void cxxbridge03$unique_ptr$std$vector$##RUST_TYPE##$drop( \
std::unique_ptr<std::vector<CXX_TYPE>> *ptr) noexcept { \
ptr->~unique_ptr(); \
}
#define RUST_VEC_EXTERNS(RUST_TYPE, CXX_TYPE) \
void cxxbridge03$rust_vec$##RUST_TYPE##$new( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
void cxxbridge03$rust_vec$##RUST_TYPE##$drop( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
size_t cxxbridge03$rust_vec$##RUST_TYPE##$len( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
const CXX_TYPE *cxxbridge03$rust_vec$##RUST_TYPE##$data( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
size_t cxxbridge03$rust_vec$##RUST_TYPE##$stride() noexcept;
#define RUST_VEC_OPS(RUST_TYPE, CXX_TYPE) \
template <> \
Vec<CXX_TYPE>::Vec() noexcept { \
cxxbridge03$rust_vec$##RUST_TYPE##$new(this); \
} \
template <> \
void Vec<CXX_TYPE>::drop() noexcept { \
return cxxbridge03$rust_vec$##RUST_TYPE##$drop(this); \
} \
template <> \
size_t Vec<CXX_TYPE>::size() const noexcept { \
return cxxbridge03$rust_vec$##RUST_TYPE##$len(this); \
} \
template <> \
const CXX_TYPE *Vec<CXX_TYPE>::data() const noexcept { \
return cxxbridge03$rust_vec$##RUST_TYPE##$data(this); \
} \
template <> \
size_t Vec<CXX_TYPE>::stride() noexcept { \
return cxxbridge03$rust_vec$##RUST_TYPE##$stride(); \
}
// Usize and isize are the same type as one of the below.
#define FOR_EACH_NUMERIC(MACRO) \
MACRO(u8, uint8_t) \
MACRO(u16, uint16_t) \
MACRO(u32, uint32_t) \
MACRO(u64, uint64_t) \
MACRO(i8, int8_t) \
MACRO(i16, int16_t) \
MACRO(i32, int32_t) \
MACRO(i64, int64_t) \
MACRO(f32, float) \
MACRO(f64, double)
#define FOR_EACH_STD_VECTOR(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
MACRO(usize, size_t) \
MACRO(isize, rust::isize)
#define FOR_EACH_RUST_VEC(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
MACRO(bool, bool)
extern "C" {
FOR_EACH_STD_VECTOR(STD_VECTOR_OPS)
FOR_EACH_RUST_VEC(RUST_VEC_EXTERNS)
} // extern "C"
namespace rust {
inline namespace cxxbridge03 {
FOR_EACH_RUST_VEC(RUST_VEC_OPS)
} // namespace cxxbridge03
} // namespace rust
|
[
"dtolnay@gmail.com"
] |
dtolnay@gmail.com
|
55e8c78cdab3cbac1b1d60a45689a5d0554aecbd
|
186eda039ead30fb8fb141ae854f83ea4249f90d
|
/task2/matrix_vect.h
|
aeac8037542b237281db47153212e1f058f1d345
|
[] |
no_license
|
Chewbaccins/prak7
|
7853f9494135f55d79b6d537f42fcad6d3318d8e
|
67f2d8b49cdff9174e1484f58b41c4c6781378db
|
refs/heads/main
| 2023-02-06T14:29:29.875861
| 2020-12-26T07:04:37
| 2020-12-26T07:04:37
| 324,475,816
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,608
|
h
|
#include <iomanip>
#include <fstream>
#include <cassert>
typedef complex<double> complexd;
extern int commRank, commSize;
extern "C" {
// Cblacs declarations
void Cblacs_pinfo(int*, int*);
void Cblacs_get(int, int, int*);
void Cblacs_gridinit(int*, const char*, int, int);
void Cblacs_pcoord(int, int, int*, int*);
void Cblacs_gridexit(int);
void Cblacs_exit(int);
void Cblacs_barrier(int, const char*);
void Cdgerv2d(int, int, int, double*, int, int, int);
void Cdgesd2d(int, int, int, double*, int, int, int);
int numroc_(int*, int*, int*, int*, int*);
void descinit_(int *descArray, int *M, int *N, int *Mb, int *Nb, int *dummy1 , int *dummy2 , int *context, int *gridRows, int *info);
void pzheevd_(char *jobZ, char *upLo, int *N, complexd *A, int *ia, int *ja, int *descA, complexd *w,
complexd *Z, int *iz, int *jz, int *descZ, double *work, int *lwork, complexd *rwork, int *lrwork, int *iwork, int *liwork, int *info);
void pzgemm_(char *transA, char *transB, int *M, int *N, int *K, complexd *alpha, complexd *A, int *ia, int *ja, int *descA,
complexd *B, int *ib, int *jb, int *descB, complexd *beta, complexd *C, int *ic, int *jc, int *descC);
}
template <typename dataType> class Vector {
public:
dataType *data;
int length;
Vector(int N = 10) {
data = new dataType[N] {(dataType) 0};
if (data == NULL) {
cerr << "Error on vector allocation" << endl;
MPI_Finalize();
exit(-1);
}
length = N;
}
void resize(int N) {
delete[] data;
data = new dataType[N] {(dataType) 0};
if (data == NULL) {
cerr << "Error on vector allocation" << endl;
MPI_Finalize();
exit(-1);
}
length = N;
}
void read(string fileName) {
fstream f(fileName);
assert(f.is_open());
for (int i = 0; i < length; ++i) {
if (!f.eof()) f >> data[i];
if (f.eof()) {
cerr << "No enough values in input file" << endl;
MPI_Abort(MPI_COMM_WORLD, -1);
exit(-1);
}
}
f.close();
}
void normal() {
double norm = 0.0d;
for (int i = 0; i < length; ++i) {
norm += data[i].real() * data[i].real() + data[i].imag() * data[i].imag();
}
norm = sqrt(norm);
for (int i = 0; i < length; ++i) {
data[i] /= norm;
}
}
~Vector() {
delete[] data;
}
};
class Matrix_complexd {
public:
complexd *data;
int desc[9];
int lld;
Matrix_complexd(int proc_M = 2, int proc_N = 2, int globalN = 4, int localN = 2, int context = 0) {
data = new complexd[proc_M * proc_N] {0};
if (data == NULL) {
cerr << "Error on matrix allocation" << endl;
MPI_Finalize();
exit(-1);
}
lld = proc_M > 1 ? proc_M : 1;
int zero = 0, info = 0;
descinit_(desc, &globalN, &globalN, &localN, &localN, &zero, &zero, &context, &lld, &info);
if (info != 0) {
cerr << "Error on descinit_" << endl;
Cblacs_gridexit(context);
MPI_Finalize();
exit(-1);
}
}
void readMatrix(int globalN, int localN, int proc_M, int proc_N, int proc_Row, int proc_Col, string fileName) {
MPI_File mpiFile;
MPI_File_open(MPI_COMM_WORLD, "H", MPI_MODE_RDONLY, MPI_INFO_NULL, &mpiFile);
MPI_File_set_view(mpiFile, localN * proc_Col + localN * globalN * proc_Row, MPI_DOUBLE_COMPLEX, MPI_DOUBLE_COMPLEX, "native", MPI_INFO_NULL);
MPI_File_read_ordered(mpiFile, data, proc_M * proc_N, MPI_DOUBLE_COMPLEX, MPI_STATUS_IGNORE);
MPI_File_close(&mpiFile);
}
void gather(int Rows, int Cols, int proc_Row, int proc_Col, int globalN, int localN) { // void -> vector, gather -> gatherComplexD
Vector <complexd> gatheredMatrix; // not quite correct
Vector <int> displacements(commSize);
Vector <int> counts(commSize);
int zero = 0, displacement = 0;
for (int i = 0; i < Rows; ++i) {
for (int j = 0; j < Cols; ++j) {
int m = numroc_(&globalN, &localN, &i, &zero, &Rows);
int n = numroc_(&globalN, &localN, &j, &zero, &Cols);
counts.data[i * Cols + j] = m * n;
displacements.data[i * Cols + j] = displacement;
displacement += m * n;
}
}
int proc_M = numroc_(&globalN, &localN, &proc_Row, &zero, &Rows);
int proc_N = numroc_(&globalN, &localN, &proc_Col, &zero, &Cols);
if (commRank == 0) {
gatheredMatrix.resize(globalN * globalN);
}
MPI_Gatherv(data, proc_M * proc_N, MPI_DOUBLE_COMPLEX, gatheredMatrix.data, counts.data, displacements.data, MPI_DOUBLE_COMPLEX, 0, MPI_COMM_WORLD);
if (commRank == 0) {
for (int row = 0; row < Rows; ++row) {
int m = numroc_(&globalN, &localN, &row, &zero, &Rows);
for (int i = 0; i < m; ++i) {
for (int col = 0; col < Cols; ++col) {
int offset = displacements.data[row * Cols + col];
int n = numroc_(&globalN, &localN, &col, &zero, &Cols);
for (int j = 0; j < n; ++j)
cout << setw(23) << gatheredMatrix.data[offset + i * n + j];
}
cout << endl;
}
}
}
}
~Matrix_complexd() {
delete[] data;
}
};
|
[
"noreply@github.com"
] |
Chewbaccins.noreply@github.com
|
f05bf76ad5175f3dd1c832730e02d8a584a6c153
|
182d0c8add424d2e273d56e50fe871bcf654f020
|
/core/src/storage/s3/S3IOWriter.h
|
0464f1ecd5de6fe7e152b6e53b8af04a8b7c8ab4
|
[
"BSD-3-Clause",
"Zlib",
"LicenseRef-scancode-unknown-license-reference",
"JSON",
"LGPL-2.1-only",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"MIT"
] |
permissive
|
jielinxu/milvus
|
233c70573e83dfc82f526a0c9b77ce0a086fb10d
|
fc8e11666f08cd421ba040c7861eac598273d1b9
|
refs/heads/master
| 2020-12-14T21:41:11.957507
| 2020-01-19T09:58:34
| 2020-01-19T09:58:34
| 226,777,480
| 0
| 1
|
Apache-2.0
| 2019-12-09T03:33:48
| 2019-12-09T03:33:47
| null |
UTF-8
|
C++
| false
| false
| 1,195
|
h
|
// 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.
#pragma once
#include <string>
#include "storage/IOWriter.h"
namespace milvus {
namespace storage {
class S3IOWriter : public IOWriter {
public:
explicit S3IOWriter(const std::string& name);
~S3IOWriter();
void
write(void* ptr, size_t size) override;
size_t
length() override;
public:
std::string buffer_;
};
} // namespace storage
} // namespace milvus
|
[
"hai.jin@zilliz.com"
] |
hai.jin@zilliz.com
|
9457246fe4296b4dc3303a25ee40b4865e686767
|
27162a7b844853ae69a095116e375511e8cfc6e7
|
/source/circle.hpp
|
2001701c18f8305e7eb331642d8e3702c6eeceaf
|
[
"MIT"
] |
permissive
|
Fabi3nn3/programmiersprachen-aufgabenblatt-3
|
7c7cd4172bffe2778112de0deebb7ce27b6471c2
|
ac822ed6944c57d94baabbe0b2f4820c2a80fcba
|
refs/heads/master
| 2021-01-01T05:16:20.133630
| 2016-05-19T12:45:26
| 2016-05-19T12:45:26
| 58,547,805
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 351
|
hpp
|
#ifndef CIRCLE_HPP
#define CIRCLE_HPP
class Circle{
public:
Circle();
//const& !
Circle(float rad);
void setradius(float r); //Set Radius
float getradius(); // Get Radius
bool operator< (Circle const& b);
bool operator> (Circle const& b);
bool operator== (Circle const& b);
private:
float rad_;
};
#endif
|
[
"fabienne.hubricht@uni-weimar.de"
] |
fabienne.hubricht@uni-weimar.de
|
e2c6a1e0430fcc5680101b7147a6114e05961948
|
9244e84599ded6b097b6f15f0016094032f68664
|
/crescsw.cpp
|
83be3a667dbf8de4a5c58097a8a6db9e40ecec55
|
[] |
no_license
|
pedrohpp/C-
|
ee20dc5c7aed4a80c9a7855ebce231758503ddc5
|
a2e679d89e40551369cf2b759feadcbc25941f5c
|
refs/heads/master
| 2021-01-03T15:12:30.213371
| 2020-02-12T22:45:28
| 2020-02-12T22:45:28
| 240,126,261
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 369
|
cpp
|
#include <iostream>
using namespace std;
main(){
char ordem;
float n1,n2,n3;
cout<<"\n Digite o primeiro valor. ";
cin>>n1;
cout<<"\n Digite o segundo valor. ";
cin>>n2;
cout<<"\n Digite o terceiro valor. ";
cin>>n3;
cout<<"\n Digite a ordem desejada |(d)decrescente|(c)crescente| ";
cin>>ordem;
switch(ordem){
case 'd'
}
}
|
[
"noreply@github.com"
] |
pedrohpp.noreply@github.com
|
93a12c94a100d8b0a902e873554e299fc4ed7dcc
|
9e5d1e9414833472f43f3616e1c140f6ed5b6ee9
|
/NCKU_CP/Class_contest_6/64.cpp
|
1bafcacb1d22c27b18976857dc134937ef36d07a
|
[] |
no_license
|
junewaves/contests
|
a93dc3b3c1a167005fe12bb0ee6f330ac572f1c4
|
387860b65bdd3c1559f93c5f2d01c69ee364506e
|
refs/heads/master
| 2023-02-27T07:45:11.339127
| 2021-02-08T18:05:01
| 2021-02-08T18:05:01
| 254,631,323
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 480
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll a1 = 1919434LL; // * 10000000
const ll a2 = 2495775LL; // 1.1 ^ 31
const int m1 = 1e7;
const int m2 = 2e5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
while (n--) {
ll b, c, d;
cin >> b;
d = a2 * b;
c = a1 * b + d / m1;
int r = (d % m1 || c % m2) ? 1 : 0;
cout << c / m2 + r << '\n';
}
return 0;
}
|
[
"a0929551932@gmail.com"
] |
a0929551932@gmail.com
|
95295edc81d654e997b8657ee8116f5c73ff7c50
|
b6de8ad7f01c9d973fe7eabc4dde57ff4d4d6160
|
/C++ programming/1-1 C++ basics/computer password.cpp
|
28a3c9b86a3f7cc5ba62606fb04daec36dbea27c
|
[] |
no_license
|
seungminlll3420/C-PP
|
d33c6f969854e1affed57d91a260de628db62cb8
|
e459289d185bbb2350d1326806ede7f53a8037e0
|
refs/heads/master
| 2020-07-17T09:43:35.637688
| 2019-11-26T19:36:03
| 2019-11-26T19:36:03
| 205,996,375
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 345
|
cpp
|
#include <iostream>
#include <cstring>
using namespace std;
int main() {
char password[11];
cout << "Please enter your computer password." << endl;
while (true) {
cout << "password>>";
cin >> password;
if (strcmp(password, "c++") == 0) {
cout << "Exit the program.";
break;
}
else
cout << "The password is wrong.";
}
}
|
[
"seungminlll3420@gmail.com"
] |
seungminlll3420@gmail.com
|
f13a38988343ee62c7314886d719fc618586f69c
|
3c65f0944a3045486fca92a190eb7839d9e2684f
|
/read_write.cpp
|
eeb46fae463dcf3eb4b15646f0be3c87941e0636
|
[] |
no_license
|
AlexeyMakurin/twist-feronematic
|
1fdd00c7e645716cc903c37a64a003940f085056
|
febc43bda31ea3220e2a00e1df38ce9a12082801
|
refs/heads/twist-ferronematic_nmsm
| 2023-05-21T21:38:23.604790
| 2021-06-09T07:56:46
| 2021-06-09T07:56:46
| 372,394,155
| 0
| 0
| null | 2021-06-09T07:59:01
| 2021-05-31T05:39:06
|
C++
|
UTF-8
|
C++
| false
| false
| 1,480
|
cpp
|
#include "read_write.h"
void write(const TwistFerronematic& twist_feronematic) {
std::filesystem::create_directory("results");
std::filesystem::path dir("results");
std::filesystem::path file_name(twist_feronematic.Name() + ".csv");
std::filesystem::path path_to_file = dir / file_name;
std::ofstream file;
file.open(path_to_file);
file << "zeta" << "," << "phi" << "," << "psi" << "," << "g" << "\n";
for (size_t i = 0; i < twist_feronematic.Zeta().size(); ++i) {
file.precision(7);
file << twist_feronematic.Zeta()[i] << "," << twist_feronematic.Phi()[i] << "," <<
twist_feronematic.Psi()[i] << "," << twist_feronematic.G()[i] << "\n";
}
file.close();
}
std::vector<std::pair<std::set<double>, TwistFerronematic>> parse_json(char* argv[]) {
std::ifstream input(argv[1]);
nlohmann::json objJson;
input >> objJson;
objJson = objJson["twist_ferronematics"];
std::vector<std::pair<std::set<double>, TwistFerronematic>> reader;
std::set<double> h;
for (auto& twist_ferronematic : objJson) {
h = twist_ferronematic["h"].get<std::set<double>>();
TwistFerronematic tw(
twist_ferronematic["configuration"]["alpha"].get<double>(),
twist_ferronematic["configuration"]["b"].get<double>(),
twist_ferronematic["configuration"]["sigma"].get<double>(),
twist_ferronematic["configuration"]["kappa"].get<double>(),
twist_ferronematic["configuration"]["nodes"].get<int>()
);
reader.push_back(std::make_pair(h, tw));
}
return reader;
}
|
[
"makurin-1997@mail.ru"
] |
makurin-1997@mail.ru
|
cba720a81a1423e7eb3bc6ec4ddd98f7feb77b48
|
50c3e66d5a505f0a5ff5c25bb87c83c2d2171283
|
/test/test_output.cpp
|
a99d0ba99545a082b6b2dc2a13c4ffd4f656ea2f
|
[
"MIT"
] |
permissive
|
firefly1250/nano-cereal
|
6b0813ffcfe026d5adfdb8f6ad3ce8f98351b739
|
e8421d6759385f7c70fa1d02fffe73e7c13ba6fd
|
refs/heads/main
| 2023-06-03T11:40:36.200087
| 2021-06-19T08:47:19
| 2021-06-19T08:47:19
| 378,214,829
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,067
|
cpp
|
#include <nano-cereal/binary.hpp>
#include <cereal/archives/binary.hpp>
#include <iostream>
struct MyRecord {
uint8_t x;
int y[5];
enum E { a, b, c, d, e, f } z;
template <class Archive>
void serialize(Archive &ar) {
ar(x, y, z);
}
bool operator==(const MyRecord &m) {
if (x != m.x) return false;
for (int i = 0; i < 5; i++)
if (y[i] != m.y[i]) return false;
if (z != m.z) return false;
return true;
}
};
int main() {
etl::deque<uint8_t, 100> buf;
MyRecord output_data;
MyRecord input_data;
// output
{
output_data.x = 24;
output_data.y[3] = 5;
output_data.z = MyRecord::E::d;
nanocereal::ostream os(&buf);
nanocereal::BinaryOutputArchive archive(os);
archive(output_data);
}
std::string str;
std::copy(buf.begin(), buf.end(), std::back_inserter(str));
std::stringstream ss;
ss << str;
// input
{
cereal::BinaryInputArchive archive(ss);
archive(input_data);
}
const auto result = output_data == input_data;
std::cout << result << std::endl;
return 0;
}
|
[
"ynhrt1250@gmail.com"
] |
ynhrt1250@gmail.com
|
5a20bc9224a280debbeaa2030896ee73792a4aa6
|
1bbfeca83bac53d22b1110ca7f6c9a28bc46c22e
|
/ru-olymp-train-winter-2009/Submits/081227/10_25_51_02_A_0627.cpp
|
0c3081d5c9cbf246aa92618aa6952c0d30d0ba06
|
[] |
no_license
|
stden/olymp
|
a633c1dfb1dd8d184a123d6da89f46163d5fad93
|
d85a4bb0b88797ec878b64db86ad8ec8854a63cd
|
refs/heads/master
| 2016-09-06T06:30:56.466755
| 2013-07-13T08:48:16
| 2013-07-13T08:48:16
| 5,158,472
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,388
|
cpp
|
#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <algorithm>
#include <vector>
#include <list>
#include <string>
using namespace std;
#define TASKNAME "help"
void answer(bool result) {
printf(result ? "YES\n" : "NO\n");
exit(0);
}
int getcount(string str, string substr) {
int res = 0;
for (int pos = str.find(substr, 0); pos < str.size();
pos = str.find(substr, pos + 1))
res++;
return res;
}
bool is_rus(char ch) {
return ch > 127;
}
string lcase(string old) {
string res = "";
for (int i = 0; i < old.size(); i++) {
if ((old[i] >= 'A') && (old[i] <= 'Z'))
res += old[i] - 'A' + 'a';
else
res += old[i];
}
return res;
}
char file[1000000];
int main() {
freopen(TASKNAME ".in", "r", stdin);
freopen(TASKNAME ".out", "w", stdout);
fread(file, 1, 1000000, stdin);
string str = file; str = lcase(str);
if (string(str, 0, 7) == "program") answer(false);
if (str.find("close(", 0) < str.size()) answer(false);
if (str.find(":)", 0) < str.size()) answer(false);
if (str.find(":(", 0) < str.size()) answer(false);
if (str.find("-)", 0) < str.size()) answer(false);
if (str.find("-(", 0) < str.size()) answer(false);
if (string(str, 0, 2) == "//") answer(true);
if (str.find("zadach", 0) < str.size()) answer(false);
if (str.find(";;", 0) < str.size()) answer(false);
if (str.find("lib", 0) < str.size()) answer(true);
if (str.find("asm", 0) < str.size()) answer(true);
if (str.find("randseed", 0) < str.size()) answer(true);
if (str.find("__", 0) < str.size()) answer(true);
bool instr = 0;
int found = 0;
for (int i = 0; i < str.size(); i++) {
switch (str[i]) {
case '"':
if (!instr) instr = 1;
else if (instr == 1) instr = 0;
found = 0; break;
case '\'':
if (!instr) instr = 2;
else if (instr == 2) instr = 0;
found = 0; break;
case '/':if (!instr) found++; break;
default:found = 0; break;
}
if (found == 2) {
string comment =
string(str, i + 1, str.find("\n", i + 1) - i - 1);
for (int i = 0; i < comment.size(); i++)
if (is_rus(comment[i])) answer(false);
if (comment.find("created", 0) < comment.size()) answer(true);
if (comment.find("powered", 0) < comment.size()) answer(true);
if (comment.find("author", 0) < comment.size()) answer(true);
}
}
answer(true);
return 0;
}
|
[
"super.denis@gmail.com"
] |
super.denis@gmail.com
|
8ee5f6dc3b03fa2bdf7cc0b56ee05d0da23b406f
|
e1efe8a7dbf1544565cc1702ea0230537d1be62f
|
/programmes codeforces/Bulbs.cpp
|
ede669718d122c1637688ff477e1f2ae97912dd0
|
[] |
no_license
|
Sourav9063/Cpp-All-codes
|
d99061666b2d40961e458c95d7e436388a351eec
|
06369df7b5f7b9a4b091a49a74722ea41761914d
|
refs/heads/master
| 2023-03-08T09:25:18.843800
| 2023-02-06T15:19:29
| 2023-02-06T15:19:29
| 243,684,953
| 2
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,642
|
cpp
|
// Name: https://codeforces.com/problemset/problem/615/A
#include <bits/stdc++.h>
using namespace std;
#define ll long long int //lld
#define ull unsigned long long int //llu
#define pt cout << "*" \
<< "\n";
#define nl cout << "\n";
#define deb(x) cout << #x << "=" << x << "\n";
#define pb(a) emplace_back(a)
#define all(x) (x).begin(), (x).end()
#define rSort(x) sort((x).rbegin(), (x).rend())
#define Sourav \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
//template<typename... T>void read(T&... args) {((cin >> args), ...);}
template <class T>
inline void sarray(T *st, T *nd)
{
while (st < nd)
cin >> *st++; /*sf("%d", st++);*/
}
template <class T>
inline void parray(T *st, T *nd)
{
while (st < nd)
cout << *st++ << endl; /*sf("%d", st++);*/
}
ll tmp, ans;
int main()
{
Sourav;
#ifndef ONLINE_JUDGE
freopen("C:\\Users\\my_code\\input.in", "r", stdin);
freopen("C:\\Users\\my_code\\output.in", "w", stdout);
#endif
int n, m;
cin >> n >> m;
bool ar[m + 1];
for (int i = 1; i <= m; i++)
{
ar[i] = false;
}
for (int i = 0; i < n; i++)
{
int l;
cin >> l;
for (int i = 0; i < l; i++)
{
cin >> tmp;
ar[tmp] = true;
}
}
bool a = true;
for (int i = 1; i <= m; i++)
{
if (ar[i] == false)
{
a = false;
break;
};
}
cout << (a ? "YES" : "NO") << endl;
return 0;
}
/*
Documentation:
*/
|
[
"53114581+Sourav9063@users.noreply.github.com"
] |
53114581+Sourav9063@users.noreply.github.com
|
a44c3e41b2559f020bc788aebdd8bfa31a14cdc9
|
1470f1d211f52afd48d25dfb1eea177a69461b3c
|
/LeetCode-HARD/Leetcode057/Main.cpp
|
5fc55a611a5581bb815b83b99197d1e449616dfe
|
[] |
no_license
|
Mazziruso/LeetCode-Solution
|
31c1a923af64f38c851e53688136db2df2264c18
|
ea22c9f013381eb6c817182495828e459399fcad
|
refs/heads/master
| 2020-04-03T01:16:20.089306
| 2019-04-16T16:24:14
| 2019-04-16T16:24:14
| 154,925,727
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,855
|
cpp
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct Interval {
int start;
int end;
Interval() : start(0), end(0) {}
Interval(int s, int e) : start(s), end(e) {}
};
class Solution {
public:
vector<Interval> intervals;
int binarySearch(int l, int r, int k) {
int mid;
while(l<r) {
mid = l+(r-l)/2;
if(intervals[mid].start<k) {
l = mid+1;
} else {
r = mid;
}
}
if(intervals[l].start<k) {
return l+1;
}
return l;
}
vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
int n = intervals.size();
vector<Interval> res;
if(n==0) {
res.push_back(newInterval);
return res;
}
this->intervals = intervals;
int index;
Interval mergeInt;
int s,e;
//start
index = binarySearch(0, n-1, newInterval.start);
//start
if(index==n) {
s = (newInterval.start<=intervals[index-1].end) ? index-1 : index;
mergeInt.start = (newInterval.start<=intervals[index-1].end) ? intervals[index-1].start : newInterval.start;
} else if(intervals[index].start != newInterval.start) {
if(index>0 && intervals[index-1].end>=newInterval.start){
s = index-1;
mergeInt.start = intervals[index-1].start;
} else {
s = index;
mergeInt.start = newInterval.start;
}
} else {
s = index;
mergeInt.start = intervals[index].start;
}
//end
index = binarySearch(0, n-1, newInterval.end);
if(index==n) {
e = index;
mergeInt.end = max(newInterval.end, intervals[index-1].end);
} else if(intervals[index].start != newInterval.end) {
if(index>0 && intervals[index-1].end>=newInterval.end){
e = index;
mergeInt.end = intervals[index-1].end;
}else {
e = index;
mergeInt.end = newInterval.end;
}
} else {
e = index+1;
mergeInt.end = intervals[index].end;
}
index = 0;
while(index<s) {
res.push_back(intervals[index]);
index++;
}
res.push_back(mergeInt);
index=e;
while(index<n) {
res.push_back(intervals[index]);
index++;
}
return res;
}
};
int main() {
vector<Interval> ints({Interval(1,5)});
vector<Interval> res = Solution().insert(ints, Interval(2,3));
for(auto i : res) {
cout << i.start << " " << i.end << endl;
}
return 0;
}
|
[
"33518504+Mazziruso@users.noreply.github.com"
] |
33518504+Mazziruso@users.noreply.github.com
|
94636954d18f8498c97218f737439b9c7f53bbdb
|
50f2a23b6164e4161d06547d897b979608f9b6d1
|
/SDK/FG_Widget_BuildMenu_InfoBox_classes.hpp
|
94a85ac9ef208722d886796295b3890b39a121da
|
[] |
no_license
|
satisfactorymodding/SatisfactorySDK
|
35433a3bd19f34c7dfd0a4cf141a310be4b9d382
|
e9a2332e0f76b92c99d4072638c1560b8137e821
|
refs/heads/master
| 2020-05-24T11:21:41.715919
| 2019-10-10T07:48:30
| 2019-10-10T07:48:30
| 187,234,176
| 8
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,549
|
hpp
|
#pragma once
// Satisfactory SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "FG_Widget_BuildMenu_InfoBox_structs.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// WidgetBlueprintGeneratedClass Widget_BuildMenu_InfoBox.Widget_BuildMenu_InfoBox_C
// 0x0040 (0x0248 - 0x0208)
class UWidget_BuildMenu_InfoBox_C : public UUserWidget
{
public:
struct FPointerToUberGraphFrame UberGraphFrame; // 0x0208(0x0008) (ZeroConstructor, Transient, DuplicateTransient)
class UWidgetAnimation* IconAnim; // 0x0210(0x0008) (BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UWrapBox* mCostContainer; // 0x0218(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UTextBlock* mItemName; // 0x0220(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UImage* mPreviewIcon; // 0x0228(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class URichTextBlock* mRichTextBlock; // 0x0230(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UWrapBox* mStatContainer; // 0x0238(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UVerticalBox* VerticalBox_5; // 0x0240(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("WidgetBlueprintGeneratedClass Widget_BuildMenu_InfoBox.Widget_BuildMenu_InfoBox_C");
return ptr;
}
ESlateVisibility GetStatsVisibility();
void AnimateCostslots();
void ExecuteUbergraph_Widget_BuildMenu_InfoBox(int EntryPoint);
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"kronosdev45@gmail.com"
] |
kronosdev45@gmail.com
|
e9bce2b539abdc73fe43caa6146760776568e437
|
46f1a4060d00334f3a655b340e4afb211d413686
|
/Triangle.cc
|
609165151fb9bb850c3c44932233df1cafe965f0
|
[] |
no_license
|
BrianPopeck/render
|
da477c69de925c17c9f48aa1af8542dcb507e83b
|
c5929f48e7bcd7c48221c01d32158f4fa0d1d194
|
refs/heads/master
| 2022-08-15T21:35:20.202750
| 2020-05-19T01:51:55
| 2020-05-19T01:51:55
| 261,857,168
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 201
|
cc
|
#include "Triangle.h"
Triangle::Triangle(const Vector3& p0, const Vector3& p1, const Vector3& p2): vertices{p0, p1, p2} {}
const Vector3& Triangle::getVertex(int i) const {
return vertices[i];
}
|
[
"bpopeck4@gmail.com"
] |
bpopeck4@gmail.com
|
28ce4190f6a8a2cc9d781c31986e2a026064ea7a
|
1a7e9320129984b8ee59912fa4c7782e6429e56a
|
/main.cpp
|
e31443d460a3b5215078ee450616ee052f5dcc47
|
[] |
no_license
|
go2sea/DesignPattern
|
de64843c6086e90fc9b783d874a90feca16fe300
|
0c3a5e6b965a579613246bb117f0bd746070c21f
|
refs/heads/master
| 2021-01-10T10:50:10.388053
| 2016-01-04T14:38:47
| 2016-01-04T14:38:47
| 49,001,993
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 5,712
|
cpp
|
#pragma once
#include <iostream>
#include "Factory.h"
#include "AbstractFactory.h"
#include "Prototype.h"
#include "Builder.h"
#include "Singleton.h"
#include "Adapter.h"
#include "Bridge.h"
#include "Decorator.h"
#include "Proxy.h"
#include "TemplateMethod.h"
#include "Composite.h"
#include "ChainOfResponsibility.h"
#include "Flyweight.h"
#include "Command.h"
#include "Observer.h"
#include "Strategy.h"
#include "State.h"
#include "Iterator.h"
#include "Memento.h"
#include "Visitor.h"
using namespace std;
void main() {
//printf("%s\n\n", "This is an example of Factory-Method pattern:");
//Factory* fa = new FactoryA();
//Product* pa = fa->createProduct();
//Factory* fb = new FactoryB();
//Product* pb = fb->createProduct();
//printf("%s\n\n", "This is an example of Abstract-Factory pattern:");
////锤子科技生产
//AbstractFactory* smartisan = new Smartisan();
//AbstractSOC* sm_soc = smartisan->createSOC();
//AbstractScreen* sm_screen = smartisan->createScreen();
////小米科技生产
//AbstractFactory* mi = new Mi();
//AbstractSOC* mi_soc = mi->createSOC();
//AbstractScreen* mi_screen = mi->createScreen();
//printf("%s\n\n", "This is an example of Prototype pattern:");
//Prototype* p1 = new ConcretePrototypeA();
//Prototype* p1_copy = p1->clone();
//Prototype* p2 = new ConcretePrototypeB();
//Prototype* p2_copy = p2->clone();
//printf("%s\n\n", "This is an example of Builder pattern:");
////锤子手机build
//Director* sm_dr = new Director(new SmartisanBuilder());
//sm_dr->build();
////小米手机build
//Director* mi_dr = new Director(new MiBuilder());
//mi_dr->build();
//printf("%s\n\n", "This is an example of Singleton pattern::");
//Singleton::getInstance().test();
//printf("%s\n\n", "This is an example of Adapter pattern:");
//Adaptee* a = new Adaptee();
//Target* t = new Adapter(a);
//t->Request();
//printf("%s\n\n", "This is an example of Bridge pattern:");
//Music* midian = new MiDian();
//Music* xiushuijie = new XiuShuiJie();
//Phone* t1 = new T1(midian);
//Phone* t2 = new T2(xiushuijie);
//t1->ring();
//t2->ring();
//printf("%s\n\n", "This is an example of Decorator pattern:");
//IphoneComponent* ip6 = new Iphone6();
//IphoneComponent* ip6s = new Iphone6s(ip6);
//ip6s->multiTouch();
//printf("%s\n\n", "This is an example of Proxy pattern:");
//Subject* pro = new Proxy();
//pro->Request();
//pro->Request();
//printf("%s\n\n", "This is an example of Composite Pattern:");
//Composite* sm = new SmartisanT1();
//Leaf* soc = new SOC();
//Leaf* screen = new Screen();
//sm->add(soc);
//sm->add(screen);
//sm->sales();
//sm->remove(soc);
//sm->sales();
//sm->remove(sm->getChild(0));
//sm->sales();
//printf("%s\n\n", "This is am example of Template-Method pattern:");
//ConcreteAlgorithm* ca = new ConcreteAlgorithm();
//ca->templateMethod();
//printf("%s\n\n", "This is an example of ChainOfResponsibility pattern:");
//Handler* h1 = new ConcreteHandler1();
////h1作为h2的successor
//Handler* h2 = new ConcreteHandler2(h1);
//h2->handleRequest();
//printf("%s\n\n", "This is an example of Flyweight pattern:");
//FlyweightFactory* ff = new FlyweightFactory();
//ff->getFlyweight("ConcreteFlyweight1");
//ff->getFlyweight("ConcreteFlyweight1");
//ff->getFlyweight("ConcreteFlyweight2");
//ff->getFlyweight("ConcreteFlyweight2");
//printf("%s\n\n", "This is an example of Command pattern");
//Receiver* receiver = new Receiver();
//Command* command = new ConcreteCommand(receiver);
//Invoker* invoker = new Invoker(command);
//invoker->invoke();
//delete invoker;
//printf("%s\n\n", "This is an example of Observer pattern:");
//Observer* ob1 = new ConcreteObserver();
//Observer* ob2 = new ConcreteObserver();
//SSubject* sub = new ConcreteSSubject();
//sub->attach(ob1);
//sub->attach(ob2);
//sub->attach(ob1);
//sub->attach(ob2);
//sub->setState(1);
//sub->notify();
//sub->detach(ob1);
//sub->setState(2);
//sub->notify();
//delete sub;
//sub = NULL;
//ob1 = NULL;
//ob2 = NULL;
//printf("%s\n\n", "This is an example of Strategy pattern:");
//Traverse* dfs = new DFS();
//Context* context = new Context(dfs);
//context->process();
//delete context;
//context = NULL;
//dfs = NULL;
//printf("%s\n\n", "This is an example of State pattern:");
//State* hungry = new Hungry();
//State* thirsty = new Thirsty();
//Man* man = new Man(hungry);
//man->handle();
//man->changeState(thirsty);
//man->handle();
//delete man;
//man = NULL;
//thirsty = NULL;
//delete hungry;
//hungry = NULL;
//printf("%s\n\n", "This is an example of Iterator pattern:");
//Aggregate* aggregate = new ConcreteAggregate(5);
//Iterator* it = new ConcreteIterator(aggregate);
//it->first();
//for (; !it->isDone(); it->next())
// printf("%d\n", it->currentItem());
//delete it;
//it = NULL;
//printf("%s\n\n", "This is an example of Memento pattern:");
//Originator* pOriginator = new Originator("Old State!");
//Memento* pMemento = pOriginator->createMemento();
//pOriginator->printState();
//pOriginator->setState("New State!");
//pOriginator->printState();
//pOriginator->restoreState(pMemento);
//pOriginator->printState();
//delete pOriginator;
//pOriginator = NULL;
//delete pMemento;//默认析构函数是public的
//pMemento = NULL;
printf("%s\n\n", "This is an example of Visitor pattern:");
Visitor* pVisitor1 = new ConcreteVisitor1();
Visitor* pVisitor2 = new ConcreteVisitor2();
Element* pElementA = new ConcreteElementA();
Element* pElementB = new ConcreteElementB();
pElementA->accept(pVisitor1);
pElementA->accept(pVisitor2);
pElementB->accept(pVisitor1);
pElementB->accept(pVisitor2);
system("pause");
}
|
[
"412183136@qq.com"
] |
412183136@qq.com
|
9e740ee77750e1c3e6f4fe54e9c3f4df196bd8a1
|
72f6f0bbe19e07e684abfe953bfc36aeb5d2b692
|
/iterator/iterator/iterator.cpp
|
f23db4fb49560b312516ceef7acb1ff3367161f5
|
[] |
no_license
|
AlexID-0987/Testgit
|
ec7ab62f0a776b63c95c19cfccc22c25aaa57b29
|
f707acc6e854a66f15bc0ba3068440c1971f298f
|
refs/heads/master
| 2023-08-22T15:28:37.841162
| 2021-09-19T18:06:40
| 2021-09-19T18:06:40
| 305,180,932
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 746
|
cpp
|
// iterator.cpp : Этот файл содержит функцию "main". Здесь начинается и заканчивается выполнение программы.
//
#include <iostream>
#include<string>
#include<vector>
int main()
{
std::vector<std::string>myVector = { "Resminov Alex ID76859430 Deli", "Revtov Stasha ID5465464 Parish",
"Sidorov Fedul ID870689 Berlin","Petrow Rex ID897698 Warshawa" };
for (std::vector<std::string>::iterator i = myVector.begin(); i != myVector.end(); i++)
{
std::cout << *i << std::endl;
}
std::vector<std::string>::iterator it;
it = myVector.begin();
it++;
std::cout << *it << std::endl;
it++;
std::cout << *it << std::endl;
it+=1;
std::cout << *it << std::endl;
}
|
[
"a1980dominov@gmail.com"
] |
a1980dominov@gmail.com
|
30ddcafdb280533c0f6a08d74f7818e3e06c5adf
|
07ec50b64e3a2d7570a0fe964ce6fdf7216fb70d
|
/modular_a_star/modular_a_star.h
|
173a2e9c808c664cf82b8816cd776ced9b9952f4
|
[] |
no_license
|
Forrest-Z/modular-A-star
|
8cef7e09f9a97abefdfbf6a4889cff381509647d
|
f5a357cc98dab926939d92eac9c743c7470fe29a
|
refs/heads/master
| 2020-04-14T23:11:27.119446
| 2018-11-20T23:18:10
| 2018-11-20T23:18:10
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,286
|
h
|
#ifndef MODULAR_A_STAR_H
#define MODULAR_A_STAR_H
#include <iostream>
#include <vector>
#include "map.h"
/** Path Planner namespace
*/
namespace pp {
/** A Star algorithm - Path planner solver
*/
template<typename stateT, int nbStates>
class A_Star
{
public:
/** A* Contrustor takes as input a reference to a state
*/
A_Star(const IMap<stateT>& map)
: mMap(map)
{}
/** Search for path from start to goal.
* Expands the state provided as class template argument at each step.
*
* @param[in] grid Grid map with all possible and impossible locations
* @param[out] pathToGoal Path taken from beginning to the end
* @param[in] start Starting state
* @param[in|out] goal Goal to reach as inputs comes out as the reach state if success.
*
* @return Bool if final state has been reached, False otherwise
*/
bool search( std::vector<std::vector<int> >& grid
, std::vector<std::vector<std::vector<stateT> > >& pathToGoal
, stateT start
, stateT& goal )
{
// Tri dimensional vector for storing all spacial positions on the grid
// as well as the states within each positions that have been visited and closed.
mClosed = std::vector<std::vector<std::vector<int> > >( nbStates , std::vector<std::vector<int> >(grid.size()
, std::vector<int>(grid[0].size())));
// Tri dimensional vector for storing all states to be expanded.
pathToGoal = std::vector<std::vector<std::vector<stateT> > >( nbStates , std::vector<std::vector<stateT> >(grid.size()
, std::vector<stateT>(grid[0].size())));
// Set the first state as visited
mClosed[start.getInternalState()][start.getX()][start.getY()] = visited;
pathToGoal[start.getInternalState()][start.getX()][start.getY()] = start;
// Count number of expansions
int closedCount = 1;
// Stack all states to be visited
std::vector<stateT> opened = { start };
stateT currentState;
while(!opened.empty())
{
// Sort possible next steps to always expand towards the closest to the goal
std::sort(opened.begin(), opened.end());
currentState = opened[0];
opened.erase(opened.begin());
//std::cout << currentState.getX() << " " << currentState.getY() << "\n";
if (currentState.hasReached(goal))
{
std::cout << "Found path to goal in " << closedCount << " expansions.\n";
// Return the final state by replacing the goal input argument
goal = currentState;
return true;
}
// Expand state to get all next possible states from current one
std::vector<stateT*> nextStates;
currentState.expand(nextStates, goal);
for(auto& next : nextStates)
{
// If next state is not accessible, it is not added to the next possible states to visit
if (!mMap.isAccessible(*next)) continue;
if ( mClosed[next.getInternalState()][next.getX()][next.getY()] == accessibleLocation
&& (grid[next.getX()][next.getY()] == accessibleLocation
|| grid[next.getX()][next.getY()] == end) )
{
opened.push_back(next);
mClosed[next.getInternalState()][next.getX()][next.getY()] = visited;
pathToGoal[next.getInternalState()][next.getX()][next.getY()] = currentState;
++closedCount;
}
}
}
// If we end up here it's because no path was found.
std::cout << "No valid path found.\n";
goal = currentState;
return false;
}
/** Uses the 3D vector of past locations and states to reconstruct the path
*
* @return Path Sequence of states from the end to the beginning.
*/
std::vector<stateT> reconstructPath(std::vector<std::vector<std::vector<stateT> > > from, stateT start, stateT end)
{
std::vector<stateT> path = { end };
int internalState = end.getInternalState();
stateT current = from[internalState][end.getX()][end.getY()];
internalState = current.getInternalState();
while (!current.hasReached(start))
{
path.push_back(current);
current = from[internalState][current.getX()][current.getY()];
internalState = current.getInternalState();
}
path.push_back(current);
return path;
}
/**
* Get function to avoid overloading the search method with parameters.
*/
void getClosedStates(std::vector<std::vector<std::vector<int> > >& closed)
{
closed = mClosed;
}
private:
const IMap<stateT>& mMap; ///< Map object able to tell wheather the state is valid or not and signal when the goal has been reached.
std::vector<std::vector<std::vector<int> > > mClosed; ///< Set of all closed states to prevent revisiting them.
};
} // END: pp
#endif
|
[
"granie.guillaume@gmail.com"
] |
granie.guillaume@gmail.com
|
58519b599c35bcc7f370067fc786ed3605873681
|
d39d88fd160cf213b0f4c833c5c7565fdaa0abd1
|
/1 yellow belt/week 3/BusStopDecomposition2/original_solution/responses.h
|
7b8d4cce89cb91af17969786073ea32c60c081ae
|
[] |
no_license
|
DwarKapex/Cpp-Specialisation-Coursera-Yandex-MIPT
|
4b78691a4b64d8eb20ef64eaae3226f301283a6a
|
9a1a694640dbe994c3afda0fbd589ac1039b5d37
|
refs/heads/master
| 2022-05-19T18:01:48.352717
| 2022-03-08T06:15:48
| 2022-03-08T06:15:48
| 199,929,864
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 544
|
h
|
#pragma once
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
struct BusesForStopResponse {
vector<string> buses;
};
ostream& operator << (ostream& os, const BusesForStopResponse& r);
struct StopsForBusResponse {
string bus;
vector<pair<string, vector<string>>> stops_for_buses;
};
ostream& operator << (ostream& os, const StopsForBusResponse& r);
struct AllBusesResponse {
map<string, vector<string>> buses_to_stops;
};
ostream& operator << (ostream& os, const AllBusesResponse& r);
|
[
"vkozlov@magicleap.com"
] |
vkozlov@magicleap.com
|
e1785beb6d86bf9e86cb5f71b366cbabb25e8984
|
41b4adb10cc86338d85db6636900168f55e7ff18
|
/aws-cpp-sdk-support/include/aws/support/model/AttachmentDetails.h
|
32f12256d88f7cd9b7f10064ef37cf553c8bfb61
|
[
"JSON",
"MIT",
"Apache-2.0"
] |
permissive
|
totalkyos/AWS
|
1c9ac30206ef6cf8ca38d2c3d1496fa9c15e5e80
|
7cb444814e938f3df59530ea4ebe8e19b9418793
|
refs/heads/master
| 2021-01-20T20:42:09.978428
| 2016-07-16T00:03:49
| 2016-07-16T00:03:49
| 63,465,708
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,802
|
h
|
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. 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.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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.
*/
#pragma once
#include <aws/support/Support_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace Support
{
namespace Model
{
/**
* <p>The file name and ID of an attachment to a case communication. You can use
* the ID to retrieve the attachment with the <a>DescribeAttachment</a>
* operation.</p>
*/
class AWS_SUPPORT_API AttachmentDetails
{
public:
AttachmentDetails();
AttachmentDetails(const Aws::Utils::Json::JsonValue& jsonValue);
AttachmentDetails& operator=(const Aws::Utils::Json::JsonValue& jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>The ID of the attachment.</p>
*/
inline const Aws::String& GetAttachmentId() const{ return m_attachmentId; }
/**
* <p>The ID of the attachment.</p>
*/
inline void SetAttachmentId(const Aws::String& value) { m_attachmentIdHasBeenSet = true; m_attachmentId = value; }
/**
* <p>The ID of the attachment.</p>
*/
inline void SetAttachmentId(Aws::String&& value) { m_attachmentIdHasBeenSet = true; m_attachmentId = value; }
/**
* <p>The ID of the attachment.</p>
*/
inline void SetAttachmentId(const char* value) { m_attachmentIdHasBeenSet = true; m_attachmentId.assign(value); }
/**
* <p>The ID of the attachment.</p>
*/
inline AttachmentDetails& WithAttachmentId(const Aws::String& value) { SetAttachmentId(value); return *this;}
/**
* <p>The ID of the attachment.</p>
*/
inline AttachmentDetails& WithAttachmentId(Aws::String&& value) { SetAttachmentId(value); return *this;}
/**
* <p>The ID of the attachment.</p>
*/
inline AttachmentDetails& WithAttachmentId(const char* value) { SetAttachmentId(value); return *this;}
/**
* <p>The file name of the attachment.</p>
*/
inline const Aws::String& GetFileName() const{ return m_fileName; }
/**
* <p>The file name of the attachment.</p>
*/
inline void SetFileName(const Aws::String& value) { m_fileNameHasBeenSet = true; m_fileName = value; }
/**
* <p>The file name of the attachment.</p>
*/
inline void SetFileName(Aws::String&& value) { m_fileNameHasBeenSet = true; m_fileName = value; }
/**
* <p>The file name of the attachment.</p>
*/
inline void SetFileName(const char* value) { m_fileNameHasBeenSet = true; m_fileName.assign(value); }
/**
* <p>The file name of the attachment.</p>
*/
inline AttachmentDetails& WithFileName(const Aws::String& value) { SetFileName(value); return *this;}
/**
* <p>The file name of the attachment.</p>
*/
inline AttachmentDetails& WithFileName(Aws::String&& value) { SetFileName(value); return *this;}
/**
* <p>The file name of the attachment.</p>
*/
inline AttachmentDetails& WithFileName(const char* value) { SetFileName(value); return *this;}
private:
Aws::String m_attachmentId;
bool m_attachmentIdHasBeenSet;
Aws::String m_fileName;
bool m_fileNameHasBeenSet;
};
} // namespace Model
} // namespace Support
} // namespace Aws
|
[
"henso@amazon.com"
] |
henso@amazon.com
|
1193a4747bf8829379bbbfc4bca770f64af86f8b
|
c7ad1dd84604e275ebfc5a7e354b23ceb598fca5
|
/src/app/cn3d/conservation_colorer.hpp
|
6149c3bd62f5c91df021f0949a6d9dc140cf9481
|
[] |
no_license
|
svn2github/ncbi_tk
|
fc8cfcb75dfd79840e420162a8ae867826a3d922
|
c9580988f9e5f7c770316163adbec8b7a40f89ca
|
refs/heads/master
| 2023-09-03T12:30:52.531638
| 2017-05-15T14:17:27
| 2017-05-15T14:17:27
| 60,197,012
| 1
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,408
|
hpp
|
/* $Id$
* ===========================================================================
*
* PUBLIC DOMAIN NOTICE
* National Center for Biotechnology Information
*
* This software/database is a "United States Government Work" under the
* terms of the United States Copyright Act. It was written as part of
* the author's official duties as a United States Government employee and
* thus cannot be copyrighted. This software/database is freely available
* to the public for use. The National Library of Medicine and the U.S.
* Government have not placed any restriction on its use or reproduction.
*
* Although all reasonable efforts have been taken to ensure the accuracy
* and reliability of the software and data, the NLM and the U.S.
* Government do not and cannot warrant the performance or results that
* may be obtained by using this software or data. The NLM and the U.S.
* Government disclaim all warranties, express or implied, including
* warranties of performance, merchantability or fitness for any particular
* purpose.
*
* Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Authors: Paul Thiessen
*
* File Description:
* Classes to color alignment blocks by sequence conservation
*
* ===========================================================================
*/
#ifndef CN3D_CONSERVATION_COLORER__HPP
#define CN3D_CONSERVATION_COLORER__HPP
#include <corelib/ncbistl.hpp>
#include <map>
#include <vector>
#include "vector_math.hpp"
#include "cn3d_colors.hpp"
BEGIN_SCOPE(Cn3D)
class UngappedAlignedBlock;
class BlockMultipleAlignment;
class ConservationColorer
{
private:
const BlockMultipleAlignment *alignment;
typedef std::map < const UngappedAlignedBlock *, std::vector < int > > BlockMap;
BlockMap blocks;
typedef std::map < char, int > ColumnProfile;
typedef std::vector < ColumnProfile > AlignmentProfile;
AlignmentProfile alignmentProfile;
int GetProfileIndex(const UngappedAlignedBlock *block, int blockColumn) const
{ return blocks.find(block)->second[blockColumn]; }
void GetProfileIndexAndResidue(const UngappedAlignedBlock *block, int blockColumn, int row,
int *profileIndex, char *residue) const;
int nColumns;
bool basicColorsCurrent, fitColorsCurrent;
void CalculateBasicConservationColors(void);
void CalculateFitConservationColors(void);
std::vector < bool > identities;
typedef std::vector < Vector > ColumnColors;
ColumnColors varietyColors, weightedVarietyColors, informationContentColors;
typedef std::map < char, Vector > ResidueColors;
typedef std::vector < ResidueColors > FitColors;
FitColors fitColors;
typedef std::map < const UngappedAlignedBlock * , std::vector < Vector > > BlockFitColors;
BlockFitColors blockFitColors, blockZFitColors, blockRowFitColors;
public:
ConservationColorer(const BlockMultipleAlignment *parent);
// add an aligned block to the profile
void AddBlock(const UngappedAlignedBlock *block);
// frees memory used by color storage (but keeps blocks around)
void FreeColors(void);
// clears everything, including alignment blocks
void Clear(void);
// color accessors
const Vector *GetIdentityColor(const UngappedAlignedBlock *block, int blockColumn)
{
CalculateBasicConservationColors();
return GlobalColors()->Get(Colors::eConservationMap,
(identities[GetProfileIndex(block, blockColumn)] ? Colors::nConservationMap - 1 : 0));
}
const Vector *GetVarietyColor(const UngappedAlignedBlock *block, int blockColumn)
{
CalculateBasicConservationColors();
return &(varietyColors[GetProfileIndex(block, blockColumn)]);
}
const Vector *GetWeightedVarietyColor(const UngappedAlignedBlock *block, int blockColumn)
{
CalculateBasicConservationColors();
return &(weightedVarietyColors[GetProfileIndex(block, blockColumn)]);
}
const Vector *GetInformationContentColor(const UngappedAlignedBlock *block, int blockColumn)
{
CalculateBasicConservationColors();
return &(informationContentColors[GetProfileIndex(block, blockColumn)]);
}
const Vector *GetFitColor(const UngappedAlignedBlock *block, int blockColumn, int row)
{
int profileIndex;
char residue;
CalculateFitConservationColors();
GetProfileIndexAndResidue(block, blockColumn, row, &profileIndex, &residue);
return &(fitColors[profileIndex].find(residue)->second);
}
const Vector *GetBlockFitColor(const UngappedAlignedBlock *block, int row)
{
CalculateFitConservationColors();
return &(blockFitColors.find(block)->second[row]);
}
const Vector *GetBlockZFitColor(const UngappedAlignedBlock *block, int row)
{
CalculateFitConservationColors();
return &(blockZFitColors.find(block)->second[row]);
}
const Vector *GetBlockRowFitColor(const UngappedAlignedBlock *block, int row)
{
CalculateFitConservationColors();
return &(blockRowFitColors.find(block)->second[row]);
}
};
// screen residue to be in ncbistdaa
extern char ScreenResidueCharacter(char original);
END_SCOPE(Cn3D)
#endif // CN3D_CONSERVATION_COLORER__HPP
|
[
"thiessen@112efe8e-fc92-43c6-89b6-d25c299ce97b"
] |
thiessen@112efe8e-fc92-43c6-89b6-d25c299ce97b
|
f8c11ad2dbd834fbc5b7da9ebb35e06af204bbb0
|
a46f0d8693fb1979b475e68c782030fd0bcb18e7
|
/Ch4_18_SpeedOfSound/Ch4_18_SpeedOfSound/SpeedOfSound.cpp
|
a38de07dda5d6b2aeaf807df54b607953a998ea1
|
[] |
no_license
|
jgramelb/c-plus-plus
|
8c56c904ecde231d83c55ed579b88d429bd53d07
|
71d9efb2d1256ee08130737204b39312d1421b4a
|
refs/heads/master
| 2020-04-08T14:08:18.113375
| 2018-12-21T01:11:07
| 2018-12-21T01:11:07
| 159,423,571
| 2
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,961
|
cpp
|
/******************************************************
**Name: Jeannie Ramelb
**Date: December 20, 2018
**Description: Chapter 4 Problem 18. Speed of Sound
******************************************************/
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
void displayMenu();
int getChoice(int, int);
int main()
{
const int MIN_VALUE = 1;
const int MAX_VALUE = 4;
double feetAir, secAir, feetWater, secWater, feetSteel, secSteel;
displayMenu();
int choice = getChoice(MIN_VALUE, MAX_VALUE);
do {
if (choice == 1) {
cout << "Enter the number of feet a sound will travel through air " << endl;
cin.clear();
cin.ignore();
cin >> feetAir;
while (feetAir < 0.0) {
cout << "Please enter a positive number for the distance. ";
cin >> feetAir;
}
secAir = feetAir / 1100;
cout << "Time it will take for sound to travel " << feetAir <<
" feet through air is: " << secAir << "\n\n" << endl;
}
if (choice == 2) {
cout << "Enter the number of feet a sound will travel through water " << endl;
cin.clear();
cin.ignore();
cin >> feetWater;
while (feetWater < 0.0) {
cout << "Please enter a positive number for the distance. ";
cin >> feetWater;
}
secWater = feetWater / 4900;
cout << "Time it will take for sound to travel " << feetWater <<
" feet through air is: " << secWater << "\n\n" << endl;
}
if (choice == 3) {
cout << "Enter the number of feet a sound will travel through steel" << endl;
cin.clear();
cin.ignore();
cin >> feetSteel;
while (feetSteel < 0.0) {
cout << "Please enter a positive number for the distance. ";
cin >> feetSteel;
}
secSteel = feetSteel / 1100;
cout << "Time it will take for sound to travel " << feetSteel <<
" feet through air is: " << secSteel << "\n\n" << endl;
}
if (choice == 4) {
cout << "The program will now end " << endl;
}
} while (choice != 4);
return 0;
}
/***********************************************
**Description: displayMenu()
**This function displays the user's menu on the screen
**********************************************/
void displayMenu()
{
cout << "\n\nGThe Speed of Sound\n\n";
cout << "This program calculates the time it takes for\n"
<< "for the speed of sound based on the medium chosen. \n\n";
cout << "1. Air\n";
cout << "2. Water\n";
cout << "3. Steel\n";
cout << "4. Quit\n\n";
cout << "Enter your choice (1-4):";
}
/************************************************
**Description:: getChoice()
**This function get, validates, and returns the user's choice
*************************************************/
int getChoice(int min, int max)
{
int choice;
cin.clear();
cin >> choice;
while (!cin || choice < min || choice > max)
{
cout << "Choice must be between " << min << " and " << max << ". \n"
<< "Please re-enter choice: ";
cin.clear();
cin.ignore();
cin >> choice;
}
return choice;
}
|
[
"jeannie.ramelb@gmail.com"
] |
jeannie.ramelb@gmail.com
|
a9e99e48a679cf063991c8c271a9955381049906
|
f5c30d45080b330f3eacbb703cec8c196697b207
|
/src/CCryptingDlg.cpp
|
f0ce92e9ce14c27bec8b96b3ea015ede42ea8ec0
|
[] |
no_license
|
qr96/HelloCrypt
|
75c34b0442cb5e958abae2ef34d70eba676c7e9e
|
51a13964e28bd9a4ddf2a1c3725c9e6faf5d9aac
|
refs/heads/master
| 2022-12-11T11:55:45.446697
| 2020-09-01T11:32:29
| 2020-09-01T11:32:29
| 291,943,477
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,141
|
cpp
|
// CCryptingDlg.cpp: 구현 파일
//
#include "pch.h"
#include "HelloCrypt.h"
#include "CryptingDlg.h"
#include "afxdialogex.h"
// CCryptingDlg 대화 상자
IMPLEMENT_DYNAMIC(CCryptingDlg, CDialogEx)
CCryptingDlg::CCryptingDlg(CWnd* pParent /*=nullptr*/)
: CDialogEx(IDD_CRYPTING_DIALOG, pParent)
, crypt_password1(_T(""))
, crypt_password2(_T(""))
{
}
CCryptingDlg::~CCryptingDlg()
{
}
void CCryptingDlg::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_LIST1, crypt_list);
DDX_Text(pDX, IDC_CRYPT_PASSWORD1, crypt_password1);
DDV_MaxChars(pDX, crypt_password1, 16);
DDX_Text(pDX, IDC_CRYPT_PASSWORD2, crypt_password2);
DDV_MaxChars(pDX, crypt_password2, 16);
DDX_Control(pDX, IDC_PROGRESS1, m_Progress);
}
BEGIN_MESSAGE_MAP(CCryptingDlg, CDialogEx)
ON_NOTIFY(NM_CUSTOMDRAW, IDC_PROGRESS1, &CCryptingDlg::OnNMCustomdrawProgress1)
ON_WM_DROPFILES()
ON_BN_CLICKED(IDOK, &CCryptingDlg::OnBnClickedOk)
ON_LBN_SELCHANGE(IDC_LIST1, &CCryptingDlg::OnLbnSelchangeList1)
ON_BN_CLICKED(IDOK2, &CCryptingDlg::OnBnClickedOk2)
END_MESSAGE_MAP()
// CCryptingDlg 메시지 처리기
|
[
"qr96@naver.com"
] |
qr96@naver.com
|
e5f68fc5739139bd17107764b8865f094d98050a
|
94907d58c786a835b8ea51eaf5f5f922dd0f2cbc
|
/Form1.h
|
641202597e693d76e4eaaecff27a1734ab9a4dbf
|
[] |
no_license
|
jdsepulveda136/Projeto-Alfa
|
dd89cd656620837d01d686fe6af0eaefd30fa70e
|
8bc82bbfc53700b6eeb5135aec1f9708d805bdc3
|
refs/heads/master
| 2022-12-04T00:39:16.032258
| 2019-06-19T14:26:24
| 2019-06-19T14:26:24
| 190,013,995
| 0
| 0
| null | null | null | null |
ISO-8859-1
|
C++
| false
| false
| 45,300
|
h
|
#pragma once
namespace ProjCLR {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO;
/// <summary>
/// Summary for Form1
/// </summary>
public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Add the constructor code here
//
}
protected:
/// <summary>
/// Clean up any resources being used.
/// </summary>
~Form1()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::DataGridView^ data_infos;
private: System::Windows::Forms::Button^ bt_limpa;
private: System::Windows::Forms::Button^ bt_localiza;
private: System::Windows::Forms::TextBox^ txt_localiza;
private: System::Windows::Forms::TextBox^ txt_result;
private: System::Windows::Forms::Button^ bt_velhos;
private: System::Windows::Forms::Button^ bt_freguesia;
private: System::Windows::Forms::MenuStrip^ menuStrip1;
private: System::Windows::Forms::ToolStripMenuItem^ toolStripMenuItem1;
private: System::Windows::Forms::ToolStripMenuItem^ verLinhaParaAdicionarToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ delegadoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ mostrarColunaDelegadoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ sortearDelegadoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ reiniciarDatagridToolStripMenuItem;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ Nome;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ Freguesia;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ Nascimento;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ Sexo;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ Delegado;
private: System::Windows::Forms::ToolStripMenuItem^ estatisticasToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ removerLinhaSelecionadaToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ maisVelhosToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ guardaDelegadoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ clacularMédiasToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ melhorAlunoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ mostraNegativasToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ mostraReprovadosToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ mostraDelegadoToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ gerarNotasToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ ficheiroToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ sairToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ sobreToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ autorToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ versãoToolStripMenuItem;
private: System::Windows::Forms::DataGridView^ data_copia;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ copia_nome;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ copia_freguesia;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ copia_sexo;
private: System::Windows::Forms::DataGridViewTextBoxColumn^ copia_estado;
private: System::Windows::Forms::Button^ bt_copia;
private: System::Windows::Forms::TextBox^ txt_copia;
private: System::Windows::Forms::RadioButton^ rd_masc;
private: System::Windows::Forms::RadioButton^ rd_fem;
private: System::Windows::Forms::RadioButton^ rd_todos;
protected:
protected:
private:
/// <summary>
/// Required designer variable.
/// </summary>
System::ComponentModel::Container ^components;
#pragma region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
void InitializeComponent(void)
{
System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(Form1::typeid));
this->data_infos = (gcnew System::Windows::Forms::DataGridView());
this->Nome = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->Freguesia = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->Nascimento = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->Sexo = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->Delegado = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->bt_limpa = (gcnew System::Windows::Forms::Button());
this->bt_localiza = (gcnew System::Windows::Forms::Button());
this->txt_localiza = (gcnew System::Windows::Forms::TextBox());
this->txt_result = (gcnew System::Windows::Forms::TextBox());
this->bt_velhos = (gcnew System::Windows::Forms::Button());
this->bt_freguesia = (gcnew System::Windows::Forms::Button());
this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip());
this->ficheiroToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->sairToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->toolStripMenuItem1 = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->verLinhaParaAdicionarToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->reiniciarDatagridToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->gerarNotasToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->removerLinhaSelecionadaToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->delegadoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->mostrarColunaDelegadoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->sortearDelegadoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->guardaDelegadoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->mostraDelegadoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->estatisticasToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->maisVelhosToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->clacularMédiasToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->melhorAlunoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->mostraNegativasToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->mostraReprovadosToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->sobreToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->autorToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->versãoToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->data_copia = (gcnew System::Windows::Forms::DataGridView());
this->copia_nome = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->copia_freguesia = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->copia_sexo = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->copia_estado = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
this->bt_copia = (gcnew System::Windows::Forms::Button());
this->txt_copia = (gcnew System::Windows::Forms::TextBox());
this->rd_masc = (gcnew System::Windows::Forms::RadioButton());
this->rd_fem = (gcnew System::Windows::Forms::RadioButton());
this->rd_todos = (gcnew System::Windows::Forms::RadioButton());
(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->data_infos))->BeginInit();
this->menuStrip1->SuspendLayout();
(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->data_copia))->BeginInit();
this->SuspendLayout();
//
// data_infos
//
this->data_infos->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Bottom | System::Windows::Forms::AnchorStyles::Left));
this->data_infos->AutoSizeRowsMode = System::Windows::Forms::DataGridViewAutoSizeRowsMode::DisplayedCells;
this->data_infos->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
this->data_infos->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^ >(5) {
this->Nome, this->Freguesia,
this->Nascimento, this->Sexo, this->Delegado
});
this->data_infos->GridColor = System::Drawing::SystemColors::ActiveBorder;
this->data_infos->Location = System::Drawing::Point(12, 137);
this->data_infos->Name = L"data_infos";
this->data_infos->SelectionMode = System::Windows::Forms::DataGridViewSelectionMode::FullRowSelect;
this->data_infos->Size = System::Drawing::Size(552, 423);
this->data_infos->TabIndex = 0;
//
// Nome
//
this->Nome->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
this->Nome->FillWeight = 80;
this->Nome->HeaderText = L"Nome";
this->Nome->Name = L"Nome";
//
// Freguesia
//
this->Freguesia->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
this->Freguesia->FillWeight = 50;
this->Freguesia->HeaderText = L"Freguesia";
this->Freguesia->Name = L"Freguesia";
//
// Nascimento
//
this->Nascimento->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
this->Nascimento->FillWeight = 50;
this->Nascimento->HeaderText = L"Nascimento";
this->Nascimento->Name = L"Nascimento";
//
// Sexo
//
this->Sexo->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
this->Sexo->FillWeight = 15;
this->Sexo->HeaderText = L"Sexo";
this->Sexo->Name = L"Sexo";
//
// Delegado
//
this->Delegado->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
this->Delegado->FillWeight = 25;
this->Delegado->HeaderText = L"Delegado";
this->Delegado->Name = L"Delegado";
//
// bt_limpa
//
this->bt_limpa->Anchor = System::Windows::Forms::AnchorStyles::Top;
this->bt_limpa->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->bt_limpa->Location = System::Drawing::Point(12, 29);
this->bt_limpa->Name = L"bt_limpa";
this->bt_limpa->Size = System::Drawing::Size(218, 23);
this->bt_limpa->TabIndex = 1;
this->bt_limpa->Text = L"Reinicia Datagrid";
this->bt_limpa->UseVisualStyleBackColor = false;
this->bt_limpa->Click += gcnew System::EventHandler(this, &Form1::Bt_limpa_Click);
//
// bt_localiza
//
this->bt_localiza->Anchor = System::Windows::Forms::AnchorStyles::Top;
this->bt_localiza->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->bt_localiza->Location = System::Drawing::Point(12, 58);
this->bt_localiza->Name = L"bt_localiza";
this->bt_localiza->Size = System::Drawing::Size(218, 23);
this->bt_localiza->TabIndex = 2;
this->bt_localiza->Text = L"Localiza Nome";
this->bt_localiza->UseVisualStyleBackColor = false;
this->bt_localiza->Click += gcnew System::EventHandler(this, &Form1::Bt_localiza_Click);
//
// txt_localiza
//
this->txt_localiza->Anchor = System::Windows::Forms::AnchorStyles::Top;
this->txt_localiza->Location = System::Drawing::Point(118, 87);
this->txt_localiza->Name = L"txt_localiza";
this->txt_localiza->Size = System::Drawing::Size(217, 20);
this->txt_localiza->TabIndex = 3;
//
// txt_result
//
this->txt_result->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Bottom | System::Windows::Forms::AnchorStyles::Right));
this->txt_result->Location = System::Drawing::Point(480, 27);
this->txt_result->Multiline = true;
this->txt_result->Name = L"txt_result";
this->txt_result->Size = System::Drawing::Size(225, 89);
this->txt_result->TabIndex = 4;
this->txt_result->Visible = false;
this->txt_result->TextChanged += gcnew System::EventHandler(this, &Form1::Txt_result_TextChanged);
//
// bt_velhos
//
this->bt_velhos->Anchor = System::Windows::Forms::AnchorStyles::Top;
this->bt_velhos->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->bt_velhos->Location = System::Drawing::Point(236, 29);
this->bt_velhos->Name = L"bt_velhos";
this->bt_velhos->Size = System::Drawing::Size(218, 23);
this->bt_velhos->TabIndex = 5;
this->bt_velhos->Text = L"Quem é o mais velho\?";
this->bt_velhos->UseVisualStyleBackColor = false;
this->bt_velhos->Click += gcnew System::EventHandler(this, &Form1::Bt_velhos_Click);
//
// bt_freguesia
//
this->bt_freguesia->Anchor = System::Windows::Forms::AnchorStyles::Top;
this->bt_freguesia->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->bt_freguesia->Location = System::Drawing::Point(236, 58);
this->bt_freguesia->Name = L"bt_freguesia";
this->bt_freguesia->Size = System::Drawing::Size(218, 23);
this->bt_freguesia->TabIndex = 6;
this->bt_freguesia->Text = L"Quantos há desta freguesia";
this->bt_freguesia->UseVisualStyleBackColor = false;
this->bt_freguesia->Click += gcnew System::EventHandler(this, &Form1::Bt_freguesia_Click);
//
// menuStrip1
//
this->menuStrip1->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(5) {
this->ficheiroToolStripMenuItem,
this->toolStripMenuItem1, this->delegadoToolStripMenuItem, this->estatisticasToolStripMenuItem, this->sobreToolStripMenuItem
});
this->menuStrip1->Location = System::Drawing::Point(0, 0);
this->menuStrip1->Name = L"menuStrip1";
this->menuStrip1->Size = System::Drawing::Size(951, 24);
this->menuStrip1->TabIndex = 8;
this->menuStrip1->Text = L"menuStrip1";
//
// ficheiroToolStripMenuItem
//
this->ficheiroToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(1) { this->sairToolStripMenuItem });
this->ficheiroToolStripMenuItem->Name = L"ficheiroToolStripMenuItem";
this->ficheiroToolStripMenuItem->Size = System::Drawing::Size(61, 20);
this->ficheiroToolStripMenuItem->Text = L"Ficheiro";
//
// sairToolStripMenuItem
//
this->sairToolStripMenuItem->Name = L"sairToolStripMenuItem";
this->sairToolStripMenuItem->Size = System::Drawing::Size(93, 22);
this->sairToolStripMenuItem->Text = L"Sair";
this->sairToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::SairToolStripMenuItem_Click);
//
// toolStripMenuItem1
//
this->toolStripMenuItem1->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(4) {
this->verLinhaParaAdicionarToolStripMenuItem,
this->reiniciarDatagridToolStripMenuItem, this->gerarNotasToolStripMenuItem, this->removerLinhaSelecionadaToolStripMenuItem
});
this->toolStripMenuItem1->Name = L"toolStripMenuItem1";
this->toolStripMenuItem1->Size = System::Drawing::Size(64, 20);
this->toolStripMenuItem1->Text = L"Datagrid";
//
// verLinhaParaAdicionarToolStripMenuItem
//
this->verLinhaParaAdicionarToolStripMenuItem->Name = L"verLinhaParaAdicionarToolStripMenuItem";
this->verLinhaParaAdicionarToolStripMenuItem->Size = System::Drawing::Size(300, 22);
this->verLinhaParaAdicionarToolStripMenuItem->Text = L"Esconder linha para adicionar e cabeçalhos";
this->verLinhaParaAdicionarToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::VerLinhaParaAdicionarToolStripMenuItem_Click);
//
// reiniciarDatagridToolStripMenuItem
//
this->reiniciarDatagridToolStripMenuItem->Name = L"reiniciarDatagridToolStripMenuItem";
this->reiniciarDatagridToolStripMenuItem->Size = System::Drawing::Size(300, 22);
this->reiniciarDatagridToolStripMenuItem->Text = L"Reiniciar Datagrid";
this->reiniciarDatagridToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::ReiniciarDatagridToolStripMenuItem_Click);
//
// gerarNotasToolStripMenuItem
//
this->gerarNotasToolStripMenuItem->Name = L"gerarNotasToolStripMenuItem";
this->gerarNotasToolStripMenuItem->Size = System::Drawing::Size(300, 22);
this->gerarNotasToolStripMenuItem->Text = L"Gerar notas";
this->gerarNotasToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::GerarNotasToolStripMenuItem_Click);
//
// removerLinhaSelecionadaToolStripMenuItem
//
this->removerLinhaSelecionadaToolStripMenuItem->Name = L"removerLinhaSelecionadaToolStripMenuItem";
this->removerLinhaSelecionadaToolStripMenuItem->Size = System::Drawing::Size(300, 22);
this->removerLinhaSelecionadaToolStripMenuItem->Text = L"Remover linha selecionada";
this->removerLinhaSelecionadaToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::RemoverLinhaSelecionadaToolStripMenuItem_Click);
//
// delegadoToolStripMenuItem
//
this->delegadoToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(4) {
this->mostrarColunaDelegadoToolStripMenuItem,
this->sortearDelegadoToolStripMenuItem, this->guardaDelegadoToolStripMenuItem, this->mostraDelegadoToolStripMenuItem
});
this->delegadoToolStripMenuItem->Name = L"delegadoToolStripMenuItem";
this->delegadoToolStripMenuItem->Size = System::Drawing::Size(69, 20);
this->delegadoToolStripMenuItem->Text = L"Delegado";
//
// mostrarColunaDelegadoToolStripMenuItem
//
this->mostrarColunaDelegadoToolStripMenuItem->Name = L"mostrarColunaDelegadoToolStripMenuItem";
this->mostrarColunaDelegadoToolStripMenuItem->Size = System::Drawing::Size(223, 22);
this->mostrarColunaDelegadoToolStripMenuItem->Text = L"Mostrar coluna do delegado";
this->mostrarColunaDelegadoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MostrarColunaDelegadoToolStripMenuItem_Click);
//
// sortearDelegadoToolStripMenuItem
//
this->sortearDelegadoToolStripMenuItem->Name = L"sortearDelegadoToolStripMenuItem";
this->sortearDelegadoToolStripMenuItem->Size = System::Drawing::Size(223, 22);
this->sortearDelegadoToolStripMenuItem->Text = L"Sortear delegado";
this->sortearDelegadoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::SortearDelegadoToolStripMenuItem_Click);
//
// guardaDelegadoToolStripMenuItem
//
this->guardaDelegadoToolStripMenuItem->Name = L"guardaDelegadoToolStripMenuItem";
this->guardaDelegadoToolStripMenuItem->Size = System::Drawing::Size(223, 22);
this->guardaDelegadoToolStripMenuItem->Text = L"Guarda delegado";
this->guardaDelegadoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::GuardaDelegadoToolStripMenuItem_Click);
//
// mostraDelegadoToolStripMenuItem
//
this->mostraDelegadoToolStripMenuItem->Name = L"mostraDelegadoToolStripMenuItem";
this->mostraDelegadoToolStripMenuItem->Size = System::Drawing::Size(223, 22);
this->mostraDelegadoToolStripMenuItem->Text = L"Mostra delegado";
this->mostraDelegadoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MostraDelegadoToolStripMenuItem_Click);
//
// estatisticasToolStripMenuItem
//
this->estatisticasToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(5) {
this->maisVelhosToolStripMenuItem,
this->clacularMédiasToolStripMenuItem, this->melhorAlunoToolStripMenuItem, this->mostraNegativasToolStripMenuItem, this->mostraReprovadosToolStripMenuItem
});
this->estatisticasToolStripMenuItem->Name = L"estatisticasToolStripMenuItem";
this->estatisticasToolStripMenuItem->Size = System::Drawing::Size(76, 20);
this->estatisticasToolStripMenuItem->Text = L"Estatisticas";
//
// maisVelhosToolStripMenuItem
//
this->maisVelhosToolStripMenuItem->Name = L"maisVelhosToolStripMenuItem";
this->maisVelhosToolStripMenuItem->Size = System::Drawing::Size(180, 22);
this->maisVelhosToolStripMenuItem->Text = L"Mais velho(s)";
this->maisVelhosToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MaisVelhosToolStripMenuItem_Click);
//
// clacularMédiasToolStripMenuItem
//
this->clacularMédiasToolStripMenuItem->Name = L"clacularMédiasToolStripMenuItem";
this->clacularMédiasToolStripMenuItem->Size = System::Drawing::Size(180, 22);
this->clacularMédiasToolStripMenuItem->Text = L"Calcular médias";
this->clacularMédiasToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::ClacularMédiasToolStripMenuItem_Click);
//
// melhorAlunoToolStripMenuItem
//
this->melhorAlunoToolStripMenuItem->Name = L"melhorAlunoToolStripMenuItem";
this->melhorAlunoToolStripMenuItem->Size = System::Drawing::Size(180, 22);
this->melhorAlunoToolStripMenuItem->Text = L"Melhores alunos";
this->melhorAlunoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MelhorAlunoToolStripMenuItem_Click);
//
// mostraNegativasToolStripMenuItem
//
this->mostraNegativasToolStripMenuItem->BackColor = System::Drawing::SystemColors::Control;
this->mostraNegativasToolStripMenuItem->Name = L"mostraNegativasToolStripMenuItem";
this->mostraNegativasToolStripMenuItem->Size = System::Drawing::Size(180, 22);
this->mostraNegativasToolStripMenuItem->Text = L"Mostra negativas";
this->mostraNegativasToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MostraNegativasToolStripMenuItem_Click);
//
// mostraReprovadosToolStripMenuItem
//
this->mostraReprovadosToolStripMenuItem->Name = L"mostraReprovadosToolStripMenuItem";
this->mostraReprovadosToolStripMenuItem->Size = System::Drawing::Size(180, 22);
this->mostraReprovadosToolStripMenuItem->Text = L"Mostra reprovados";
this->mostraReprovadosToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::MostraReprovadosToolStripMenuItem_Click);
//
// sobreToolStripMenuItem
//
this->sobreToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {
this->autorToolStripMenuItem,
this->versãoToolStripMenuItem
});
this->sobreToolStripMenuItem->Name = L"sobreToolStripMenuItem";
this->sobreToolStripMenuItem->Size = System::Drawing::Size(49, 20);
this->sobreToolStripMenuItem->Text = L"Sobre";
//
// autorToolStripMenuItem
//
this->autorToolStripMenuItem->Name = L"autorToolStripMenuItem";
this->autorToolStripMenuItem->Size = System::Drawing::Size(108, 22);
this->autorToolStripMenuItem->Text = L"Autor";
this->autorToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::AutorToolStripMenuItem_Click);
//
// versãoToolStripMenuItem
//
this->versãoToolStripMenuItem->Name = L"versãoToolStripMenuItem";
this->versãoToolStripMenuItem->Size = System::Drawing::Size(108, 22);
this->versãoToolStripMenuItem->Text = L"Versão";
this->versãoToolStripMenuItem->Click += gcnew System::EventHandler(this, &Form1::VersãoToolStripMenuItem_Click);
//
// data_copia
//
this->data_copia->AllowUserToAddRows = false;
this->data_copia->AllowUserToDeleteRows = false;
this->data_copia->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
this->data_copia->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^ >(4) {
this->copia_nome,
this->copia_freguesia, this->copia_sexo, this->copia_estado
});
this->data_copia->Location = System::Drawing::Point(570, 137);
this->data_copia->Name = L"data_copia";
this->data_copia->ReadOnly = true;
this->data_copia->Size = System::Drawing::Size(369, 423);
this->data_copia->TabIndex = 9;
//
// copia_nome
//
this->copia_nome->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
this->copia_nome->HeaderText = L"Nome";
this->copia_nome->Name = L"copia_nome";
this->copia_nome->ReadOnly = true;
this->copia_nome->Width = 60;
//
// copia_freguesia
//
this->copia_freguesia->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
this->copia_freguesia->HeaderText = L"Freguesia";
this->copia_freguesia->Name = L"copia_freguesia";
this->copia_freguesia->ReadOnly = true;
this->copia_freguesia->Width = 78;
//
// copia_sexo
//
this->copia_sexo->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
this->copia_sexo->HeaderText = L"Sexo";
this->copia_sexo->Name = L"copia_sexo";
this->copia_sexo->ReadOnly = true;
this->copia_sexo->Width = 56;
//
// copia_estado
//
this->copia_estado->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
this->copia_estado->HeaderText = L"Estado";
this->copia_estado->Name = L"copia_estado";
this->copia_estado->ReadOnly = true;
this->copia_estado->Width = 65;
//
// bt_copia
//
this->bt_copia->Location = System::Drawing::Point(776, 87);
this->bt_copia->Name = L"bt_copia";
this->bt_copia->Size = System::Drawing::Size(75, 23);
this->bt_copia->TabIndex = 10;
this->bt_copia->Text = L"Copiar";
this->bt_copia->UseVisualStyleBackColor = true;
this->bt_copia->Click += gcnew System::EventHandler(this, &Form1::Bt_copia_Click);
//
// txt_copia
//
this->txt_copia->Location = System::Drawing::Point(734, 27);
this->txt_copia->Name = L"txt_copia";
this->txt_copia->Size = System::Drawing::Size(147, 20);
this->txt_copia->TabIndex = 11;
//
// rd_masc
//
this->rd_masc->AutoSize = true;
this->rd_masc->Location = System::Drawing::Point(752, 58);
this->rd_masc->Name = L"rd_masc";
this->rd_masc->Size = System::Drawing::Size(34, 17);
this->rd_masc->TabIndex = 12;
this->rd_masc->TabStop = true;
this->rd_masc->Text = L"M";
this->rd_masc->UseVisualStyleBackColor = true;
//
// rd_fem
//
this->rd_fem->AutoSize = true;
this->rd_fem->Location = System::Drawing::Point(794, 58);
this->rd_fem->Name = L"rd_fem";
this->rd_fem->Size = System::Drawing::Size(31, 17);
this->rd_fem->TabIndex = 13;
this->rd_fem->TabStop = true;
this->rd_fem->Text = L"F";
this->rd_fem->UseVisualStyleBackColor = true;
//
// rd_todos
//
this->rd_todos->AutoSize = true;
this->rd_todos->Location = System::Drawing::Point(837, 58);
this->rd_todos->Name = L"rd_todos";
this->rd_todos->Size = System::Drawing::Size(32, 17);
this->rd_todos->TabIndex = 14;
this->rd_todos->TabStop = true;
this->rd_todos->Text = L"T";
this->rd_todos->UseVisualStyleBackColor = true;
//
// Form1
//
this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
this->AutoSizeMode = System::Windows::Forms::AutoSizeMode::GrowAndShrink;
this->BackColor = System::Drawing::SystemColors::ControlLightLight;
this->ClientSize = System::Drawing::Size(951, 572);
this->Controls->Add(this->rd_todos);
this->Controls->Add(this->rd_fem);
this->Controls->Add(this->rd_masc);
this->Controls->Add(this->txt_copia);
this->Controls->Add(this->bt_copia);
this->Controls->Add(this->data_copia);
this->Controls->Add(this->bt_freguesia);
this->Controls->Add(this->bt_velhos);
this->Controls->Add(this->txt_result);
this->Controls->Add(this->txt_localiza);
this->Controls->Add(this->bt_localiza);
this->Controls->Add(this->bt_limpa);
this->Controls->Add(this->data_infos);
this->Controls->Add(this->menuStrip1);
this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
this->Icon = (cli::safe_cast<System::Drawing::Icon^>(resources->GetObject(L"$this.Icon")));
this->MainMenuStrip = this->menuStrip1;
this->Name = L"Form1";
this->Text = L"Jorge Sepúlveda";
this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load);
(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->data_infos))->EndInit();
this->menuStrip1->ResumeLayout(false);
this->menuStrip1->PerformLayout();
(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->data_copia))->EndInit();
this->ResumeLayout(false);
this->PerformLayout();
}
#pragma endregion
private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e)
{
inicializa();
//Cria o ficheiro de delegado
StreamWriter^ fp = gcnew StreamWriter("DELEGADO.TXT");
fp->Close();
data_infos->ColumnCount = 18;
data_infos->Columns[5]->Name = "d1";
data_infos->Columns[5]->HeaderText = "POR";
data_infos->Columns[6]->Name = "d2";
data_infos->Columns[6]->HeaderText = "ING";
data_infos->Columns[7]->Name = "d3";
data_infos->Columns[7]->HeaderText = "FIL";
data_infos->Columns[8]->Name = "d4";
data_infos->Columns[8]->HeaderText = "MAT";
data_infos->Columns[9]->Name = "d5";
data_infos->Columns[9]->HeaderText = "FÍS";
data_infos->Columns[10]->Name = "d6";
data_infos->Columns[10]->HeaderText = "QUÍ";
data_infos->Columns[11]->Name = "d7";
data_infos->Columns[11]->HeaderText = "GEO";
data_infos->Columns[12]->Name = "d8";
data_infos->Columns[12]->HeaderText = "HIS";
data_infos->Columns[13]->Name = "d9";
data_infos->Columns[13]->HeaderText = "EF";
data_infos->Columns[14]->Name = "d10";
data_infos->Columns[14]->HeaderText = "MOR";
data_infos->Columns[15]->Name = "med";
data_infos->Columns[15]->HeaderText = "MED";
data_infos->Columns[16]->Name = "neg";
data_infos->Columns[16]->HeaderText = "NEG";
data_infos->Columns[17]->Name = "est";
data_infos->Columns[17]->HeaderText = "EST";
data_infos->Columns[15]->Visible = false;
data_infos->Columns[16]->Visible = false;
data_infos->Columns[17]->Visible = false;
for (int i = 5; i < 17; i++)
{
data_infos->Columns[i]->Width = 35;
data_infos->Columns[i]->DefaultCellStyle->Alignment = DataGridViewContentAlignment::MiddleCenter;
}
for (size_t i = 5; i < 15; i++)
{
for (size_t j = 0; j < 20; j++)
{
data_infos->Rows[j]->Cells[i]->Value = geravalor();
}
}
}
//Função com a inicialização dos dados da datagridview
private: void inicializa()
{
data_infos->Rows->Clear();
data_infos->Rows->Add("Ana Rita Cunha", "Maximinos", 1998, "F");
data_infos->Rows->Add("Bela Costa Silva", "Lomar", 2002, "F");
data_infos->Rows->Add("Carlos Alberto Costa", "Sequeira", 1999, "M");
data_infos->Rows->Add("Carlos Daniel Ferreira", "Sequeira", 2001, "M");
data_infos->Rows->Add("Daniel Bastos Gomes", "Lovios", 1998, "M");
data_infos->Rows->Add("Daniel Silva Ferraz", "S. Vítor", 1999, "M");
data_infos->Rows->Add("Elvira Gomes Pendes", "Maximinos", 2001, "F");
data_infos->Rows->Add("Fernanda Maria Silva", "S. Vítor", 2002, "F");
data_infos->Rows->Add("Fernando Gomes Barros", "Maximinos", 1999, "M");
data_infos->Rows->Add("Gilherme Alexandre Barros", "Lamaçães", 2001, "M");
data_infos->Rows->Add("Hilda Fonseca Silva", "S. Geraldo", 1999, "F");
data_infos->Rows->Add("José Manuel Carvalho", "Gualtar", 1997, "M");
data_infos->Rows->Add("José Alberto Gomes", "Maximinos", 2001, "M");
data_infos->Rows->Add("Maria Silvéria Bastos", "Maximinos", 1997, "F");
data_infos->Rows->Add("Anabela Bastos Torres", "S. Vítor", 1996, "F");
data_infos->Rows->Add("Rui Vasco Santos", "Maximinos", 2002, "M");
data_infos->Rows->Add("Otávio Ferreira", "Maximinos", 1999, "M");
data_infos->Rows->Add("Silvério Silva Teixeira", "Lamaçães", 2001, "M");
data_infos->Rows->Add("Teodoro Armando Matos", "Maximinos", 2002, "M");
data_infos->Rows->Add("Zacarias Alexandre Sampaio", "Ferreiros", 1996, "M");
}
//Função mostrar/esconder linha e cabeçalhos
private: void mostra_adicionar()
{
if (data_infos->RowHeadersVisible)
{
try
{
data_infos->RowHeadersVisible = false;
data_infos->AllowUserToAddRows = false;
verLinhaParaAdicionarToolStripMenuItem->Text = "Mostrar linha adicionar e cabeçalho";
}
catch (...){}
}
else
{
try
{
data_infos->RowHeadersVisible = true;
data_infos->AllowUserToAddRows = true;
verLinhaParaAdicionarToolStripMenuItem->Text = "Esconder linha adicionar e cabeçalho";
}
catch (...){}
}
}
//Função que encontra o mais velho ou os mais velhos
//Escreve os nomes e o ano de nascimento na textbox
private: void mais_velhos()
{
int index = data_infos->Rows->Count - 1;
int data_velho = Convert::ToInt16(data_infos->Rows[0]->Cells[2]->Value);
String^ resultado = "Mais velho(s):\r\n";
for (size_t i = 1; i < index; i++)
{
if (Convert::ToInt16(data_infos->Rows[i]->Cells[2]->Value) < data_velho)
{
data_velho = Convert::ToInt16(data_infos->Rows[i]->Cells[2]->Value);
}
}
for (size_t i = 1; i < index; i++)
{
if (Convert::ToInt16(data_infos->Rows[i]->Cells[2]->Value) == data_velho)
{
resultado = resultado + Convert::ToString(data_infos->Rows[i]->Cells[0]->Value) + ", " + Convert::ToString(data_infos->Rows[i]->Cells[2]->Value) + "\r\n";
}
}
txt_result->Visible = true;
txt_result->Text = resultado;
}
private: void mostra_delegado()
{
if (data_infos->Columns["Delegado"]->Visible == false)
{
//data_infos->Width = data_infos->Width + 100;
data_infos->Columns["Delegado"]->Visible = true;
mostrarColunaDelegadoToolStripMenuItem->Text = "Esconder coluna do delegado";
}
else
{
//data_infos->Width = data_infos->Width - 100;
data_infos->Columns["Delegado"]->Visible = false;
mostrarColunaDelegadoToolStripMenuItem->Text = "Mostrar coluna do delegado";
}
}
//Função para gerar as notas
private: int geravalor()
{
//devolve valor entre 6 e 20
//para gerar números aleatórios:
Random^ r = gcnew Random();
int avaliacao;
int contador = 0;
for (int k = 0; k < 9999999; k++)
{
//diversão ao processador,
//para melhorar a geração de aleatórios
}
//gera um número entre 6 e 20
avaliacao = r->Next(6, 21);
if (avaliacao < 10) { avaliacao = r->Next(6, 21); }
return avaliacao;
}
private: System::Void Bt_limpa_Click(System::Object^ sender, System::EventArgs^ e)
{
inicializa();
}
private: System::Void Bt_localiza_Click(System::Object^ sender, System::EventArgs^ e)
{
String^ busca = txt_localiza->Text->ToUpper();
int index = data_infos->Rows->Count-1;
for (size_t i = 0; i < index; i++)
{
if (data_infos->Rows[i]->Cells[0]->Value->ToString()->ToUpper()==busca)
{
txt_result->Visible = true;
txt_result->Text = data_infos->Rows[i]->Cells[0]->Value->ToString();
}
index--;
}
}
//Botão mais velhos
private: System::Void Bt_velhos_Click(System::Object^ sender, System::EventArgs^ e)
{
mais_velhos();
}
private: System::Void Bt_freguesia_Click(System::Object^ sender, System::EventArgs^ e)
{
int index = data_infos->Rows->Count - 1;
int cont_freg = 0;
String^ nomes = "Sexo masculino: \r\n\r\n";
for (size_t i = 0; i < index; i++)
{
if (data_infos->Rows[i]->Cells[1]->Value->ToString()->ToUpper() == txt_localiza->Text->ToUpper() && data_infos->Rows[i]->Cells[3]->Value->ToString()->ToUpper()== "M")
{
nomes = nomes + Convert::ToString(data_infos->Rows[i]->Cells[0]->Value->ToString()) + "\r\n";
cont_freg++;
}
}
txt_result->Visible = true;
txt_result->Text = nomes + "\r\nTotal: " + Convert::ToString(cont_freg);
}
private: System::Void VerLinhaParaAdicionarToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
mostra_adicionar();
}
private: System::Void MostrarColunaDelegadoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
mostra_delegado();
}
private: System::Void SortearDelegadoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
Random^ sorteio = gcnew Random();//para gerar números aleatórios
int x = sorteio->Next(1, 20); //gera um número entre 1 e 20
int index = data_infos->Rows->Count - 1;
for (size_t i = 0; i < index; i++)
{
data_infos->Rows[i]->Cells[4]->Value=" ";
}
data_infos->Rows[x]->Cells[4]->Value = "X";
}
private: System::Void ReiniciarDatagridToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
inicializa();
}
private: System::Void Txt_result_TextChanged(System::Object^ sender, System::EventArgs^ e) {}
//Apagar linha selecionada
private: System::Void RemoverLinhaSelecionadaToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
int index = data_infos->Rows->Count - 1;
for (size_t i = 0; i < index; i++)
{
if (data_infos->Rows[i]->Selected)
{
data_infos->Rows->RemoveAt(i);
}
}
}
//Menu mais velhos
private: System::Void MaisVelhosToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
mais_velhos();
}
//Guardar nome do delegado em ficheiro (incompleto)
private: System::Void GuardaDelegadoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
String^ nome_delegado;
StreamWriter^ fp = gcnew StreamWriter("DELEGADO.TXT");
int index = data_infos->Rows->Count - 1;
for (size_t i = 0; i < index; i++)
{
if (data_infos->Rows[i]->Cells[4]->Value == "X")
{
nome_delegado = Convert::ToString(data_infos->Rows[i]->Cells[0]->Value);
}
}
fp->WriteLine(nome_delegado);
fp->Close();
}
//Menu da média
private: System::Void ClacularMédiasToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
data_infos->Columns[15]->Visible = true;
calcula_media();
}
//Função que calcula as média
private: void calcula_media()
{
float media = 0;
float soma = 0;
for (size_t linhas = 0; linhas < 20; linhas++)
{
soma = 0;
for (size_t colunas = 5; colunas < 15; colunas++)
{
soma = soma + Convert::ToInt16(data_infos->Rows[linhas]->Cells[colunas]->Value);
}
media = soma / 10;
data_infos->Rows[linhas]->Cells[15]->Value = media.ToString("f2");
}
data_infos->Columns[15]->DefaultCellStyle->ForeColor = Color::Blue;
}
//Procura as média mais altas e escreve na textbox
private: System::Void MelhorAlunoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
int media = 0;
int media_alta = 0;
String^ resultado = "";
for (size_t linhas = 0; linhas < 20; linhas++)
{
for (size_t colunas = 5; colunas < 15; colunas++)
{
media = media + Convert::ToInt16(data_infos->Rows[linhas]->Cells[colunas]->Value);
}
media = media / 10;
if (media > media_alta)
{
resultado = "";
media_alta = media;
resultado = resultado + Convert::ToString(data_infos->Rows[linhas]->Cells[0]->Value) + " " + Convert::ToString(media) + "\r\n";
}
else if (media==media_alta)
{
resultado = resultado + Convert::ToString(data_infos->Rows[linhas]->Cells[0]->Value) + " " + Convert::ToString(media) + "\r\n";
}
}
for (size_t linhas = 0; linhas < 20; linhas++)
{
for (size_t colunas = 5; colunas < 15; colunas++)
{
if (Convert::ToInt16(data_infos->Rows[linhas]->Cells[colunas]->Value) >=18)
{
data_infos->Rows[linhas]->Cells[colunas]->Style->BackColor = Color::Green;
}
}
}
txt_result->Visible = true;
txt_result->Text = resultado;
}
//Botão contar as negativas
private: System::Void MostraNegativasToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
data_infos->Columns[16]->Visible = true;
conta_negativas();
}
//Função que conta as negativas
private: void conta_negativas()
{
int contador = 0;
for (size_t linhas = 0; linhas < 20; linhas++)
{
int contador = 0;
for (size_t colunas = 5; colunas < 15; colunas++)
{
if (Convert::ToInt16(data_infos->Rows[linhas]->Cells[colunas]->Value) < 10)
{
data_infos->Rows[linhas]->Cells[colunas]->Style->BackColor = Color::OrangeRed;
contador++;
}
if (Convert::ToInt16(data_infos->Rows[linhas]->Cells[colunas]->Value) < 8)
{
data_infos->Rows[linhas]->Cells[colunas]->Style->BackColor = Color::Red;
}
}
data_infos->Rows[linhas]->Cells[16]->Value = contador;
}
}
private: System::Void MostraReprovadosToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
data_infos->Columns[17]->Visible = true;
reprovados();
}
private: void reprovados()
{
bool reprovados = false;
conta_negativas();
for (size_t linhas = 0; linhas < 20; linhas++)
{
reprovados = false;
for (size_t colunas = 5; colunas < 15; colunas++)
{
//Verifica se o aluno tem uma nota abaixo de 8
if (Convert::ToDouble(data_infos->Rows[linhas]->Cells[colunas]->Value) < 8)
{
reprovados = true;
}
}
//Verifica se o numero de negativas é maior que 2
if (Convert::ToDouble(data_infos->Rows[linhas]->Cells[16]->Value)>2)
{
reprovados = true;
}
//Coloca o estado na grid
if (reprovados)
{
data_infos->Rows[linhas]->Cells[17]->Value = "Rep.";
}
else
{
data_infos->Rows[linhas]->Cells[17]->Value = "Ap.";
}
}
}
private: System::Void MostraDelegadoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
int n_linhas = data_infos->Rows->Count - 1;
StreamReader^ fp = gcnew StreamReader("DELEGADO.TXT"); String^ nome = fp->ReadLine(); if (existe(nome))
{
for (size_t i = 0; i < n_linhas; i++)
{ //limpa a coluna:
data_infos->Rows[i]->Cells[4]->Value = "";
}
for (size_t i = 0; i < n_linhas; i++)
{
if (nome == data_infos->Rows[i]->Cells[0]->Value->ToString())
{ //o nome foi encontrado:
data_infos->Rows[i]->Cells[4]->Value = "X";
}
}
}
fp->Close();
}
private: bool existe(String^ s)
{
//afirmação: esse nome não existe:
bool encontrado = false;
for (size_t i = 0; i < data_infos->Rows->Count - 1; i++)
{
//se existir na grid, trocar o estado da vairável de boole:
if (data_infos->Rows[i]->Cells[0]->Value->ToString() == s) encontrado = true;
}
return encontrado;
}
//Gerar notas aleatorias
private: System::Void GerarNotasToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
for (size_t i = 5; i < 15; i++)
{
for (size_t j = 0; j < 20; j++)
{
data_infos->Rows[j]->Cells[i]->Value = geravalor();
}
}
}
//Fechar o programa
private: System::Void SairToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
Application::Exit();
}
//Nome do autor
private: System::Void AutorToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) {
MessageBox::Show("Jorge Sepúlveda");
}
//Informação sobre a versão
private: System::Void VersãoToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) {
MessageBox::Show("v0.0.2 \nVersão alfa, use por sua conta e risco.");
}
private: System::Void Bt_copia_Click(System::Object^ sender, System::EventArgs^ e)
{
//data_infos->Columns[17]->Visible = true;
reprovados();
data_copia->Rows->Clear();
String^ copia_nome = " ";
String^ copia_freguesia = " ";
String^ copia_sexo = " ";
String^ copia_estado = " ";
for (size_t linhas = 0; linhas < 20; linhas++)
{
if (Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value) == txt_copia->Text && rd_masc->Checked)
{
if (Convert::ToString(data_infos->Rows[linhas]->Cells[3]->Value)=="M")
{
copia_nome = Convert::ToString(data_infos->Rows[linhas]->Cells[0]->Value);
copia_freguesia = Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value);
copia_sexo = Convert::ToString(data_infos->Rows[linhas]->Cells[3]->Value);
copia_estado = Convert::ToString(data_infos->Rows[linhas]->Cells[17]->Value);
data_copia->Rows->Add(copia_nome, copia_freguesia, copia_sexo, copia_estado);
}
}
if (Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value) == txt_copia->Text && rd_fem->Checked)
{
if (Convert::ToString(data_infos->Rows[linhas]->Cells[3]->Value) == "F")
{
copia_nome = Convert::ToString(data_infos->Rows[linhas]->Cells[0]->Value);
copia_freguesia = Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value);
copia_sexo = Convert::ToString(data_infos->Rows[linhas]->Cells[3]->Value);
copia_estado = Convert::ToString(data_infos->Rows[linhas]->Cells[17]->Value);
data_copia->Rows->Add(copia_nome, copia_freguesia, copia_sexo, copia_estado);
}
}
if (Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value) == txt_copia->Text && rd_todos->Checked)
{
copia_nome = Convert::ToString(data_infos->Rows[linhas]->Cells[0]->Value);
copia_freguesia = Convert::ToString(data_infos->Rows[linhas]->Cells[1]->Value);
copia_sexo = Convert::ToString(data_infos->Rows[linhas]->Cells[3]->Value);
copia_estado = Convert::ToString(data_infos->Rows[linhas]->Cells[17]->Value);
data_copia->Rows->Add(copia_nome, copia_freguesia, copia_sexo, copia_estado);
}
}
}
};
}
|
[
"jdsepulveda136@gmail.com"
] |
jdsepulveda136@gmail.com
|
a23019c5e491d371b0cd71202736ba03bc8f8ece
|
5f0faeb7bbbe6372631b97928b3f6658c17b5de3
|
/P5_Extended_Kalman_Filters/src/kalman_filter.h
|
c246bb1bb378e05d8dad6a6d617bd95271723f4d
|
[
"MIT"
] |
permissive
|
ShaliniShivakumar/Self-Driving-Car-Nanodegree
|
f800a476534c96a879d7f64d5172ee8bc1a1b0c1
|
b805e0568d2729578099c40209c2a8a3aa3194c3
|
refs/heads/main
| 2023-04-10T00:25:46.295999
| 2021-03-27T13:04:30
| 2021-03-27T13:04:30
| 351,864,932
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,493
|
h
|
#ifndef KALMAN_FILTER_H_
#define KALMAN_FILTER_H_
#include "Eigen/Dense"
#include <iostream>
class KalmanFilter {
public:
/**
* Constructor
*/
KalmanFilter();
/**
* Destructor
*/
virtual ~KalmanFilter();
/**
* Init Initializes Kalman filter
* @param x_in Initial state
* @param P_in Initial state covariance
* @param F_in Transition matrix
* @param H_in Measurement matrix
* @param R_in Measurement covariance matrix
* @param Q_in Process covariance matrix
*/
void Init(Eigen::VectorXd &x_in, Eigen::MatrixXd &P_in, Eigen::MatrixXd &F_in,
Eigen::MatrixXd &H_in, Eigen::MatrixXd &R_in, Eigen::MatrixXd &Q_in);
/**
* Prediction Predicts the state and the state covariance
* using the process model
* @param delta_T Time between k and k+1 in s
*/
void Predict();
/**
* Updates the state by using standard Kalman Filter equations
* @param z The measurement at k+1
*/
void Update(const Eigen::VectorXd &z);
/**
* Updates the state by using Extended Kalman Filter equations
* @param z The measurement at k+1
*/
void UpdateEKF(const Eigen::VectorXd &z);
// state vector
Eigen::VectorXd x_;
// state covariance matrix
Eigen::MatrixXd P_;
// state transition matrix
Eigen::MatrixXd F_;
// process covariance matrix
Eigen::MatrixXd Q_;
// measurement matrix
Eigen::MatrixXd H_;
// measurement covariance matrix
Eigen::MatrixXd R_;
};
#endif // KALMAN_FILTER_H_
|
[
"shalini.shivakumar17@gmail.com"
] |
shalini.shivakumar17@gmail.com
|
6fdb81348c36f5acdf7a2a1d372fbc614de22470
|
2a9cfac3061038c5a4408673878a0dd05832b7ac
|
/Move.cpp
|
5127fef36ec29248ab443d03d8b8b61019edad35
|
[] |
no_license
|
AlexanderFair/consolechess
|
21f9309f8d292755d6e636f27023bf1520102765
|
d9f2416b422cf8cd697f2fdcd24868a49af614ec
|
refs/heads/master
| 2023-04-06T17:12:14.270823
| 2021-04-19T03:33:21
| 2021-04-19T03:33:21
| 359,300,794
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 99
|
cpp
|
#include "Move.h"
Move::Move(int ifrom, int ito) : to(ito), from(ifrom) {
}
Move::~Move() {
}
|
[
"noreply@github.com"
] |
AlexanderFair.noreply@github.com
|
82e74661401d038e50284361fba37fd22b44ddc3
|
142ddd4c42dc7ff65fd9b531cfd0adbfe2a1dd34
|
/export/servers/physics/joints/cone_twist_joint_sw.h
|
cb97d921221e0e43346c7dc6b54dccb8a99ff872
|
[
"LicenseRef-scancode-free-unknown",
"MIT",
"BSL-1.0",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"CC0-1.0",
"OFL-1.1",
"LicenseRef-scancode-unknown-license-reference",
"Unlicense",
"FTL",
"BSD-3-Clause",
"Bitstream-Vera",
"MPL-2.0",
"Zlib",
"CC-BY-4.0"
] |
permissive
|
GhostWalker562/godot-admob-iOS-precompiled
|
3fa99080f224d1b4c2dacac31e3786cebc034e2d
|
18668d2fd7ea4bc5a7e84ddba36481fb20ee4095
|
refs/heads/master
| 2023-04-03T23:31:36.023618
| 2021-07-29T04:46:45
| 2021-07-29T04:46:45
| 195,341,087
| 24
| 2
|
MIT
| 2023-03-06T07:20:25
| 2019-07-05T04:55:50
|
C++
|
UTF-8
|
C++
| false
| false
| 5,287
|
h
|
/*************************************************************************/
/* cone_twist_joint_sw.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* 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. */
/*************************************************************************/
/*
Adapted to Godot from the Bullet library.
*/
/*
Bullet Continuous Collision Detection and Physics Library
ConeTwistJointSW is Copyright (c) 2007 Starbreeze Studios
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.
Written by: Marcus Hennix
*/
#ifndef CONE_TWIST_JOINT_SW_H
#define CONE_TWIST_JOINT_SW_H
#include "servers/physics/joints/jacobian_entry_sw.h"
#include "servers/physics/joints_sw.h"
///ConeTwistJointSW can be used to simulate ragdoll joints (upper arm, leg etc)
class ConeTwistJointSW : public JointSW {
#ifdef IN_PARALLELL_SOLVER
public:
#endif
union {
struct {
BodySW *A;
BodySW *B;
};
BodySW *_arr[2];
};
JacobianEntrySW m_jac[3]; //3 orthogonal linear constraints
real_t m_appliedImpulse;
Transform m_rbAFrame;
Transform m_rbBFrame;
real_t m_limitSoftness;
real_t m_biasFactor;
real_t m_relaxationFactor;
real_t m_swingSpan1;
real_t m_swingSpan2;
real_t m_twistSpan;
Vector3 m_swingAxis;
Vector3 m_twistAxis;
real_t m_kSwing;
real_t m_kTwist;
real_t m_twistLimitSign;
real_t m_swingCorrection;
real_t m_twistCorrection;
real_t m_accSwingLimitImpulse;
real_t m_accTwistLimitImpulse;
bool m_angularOnly;
bool m_solveTwistLimit;
bool m_solveSwingLimit;
public:
virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_CONE_TWIST; }
virtual bool setup(real_t p_timestep);
virtual void solve(real_t p_timestep);
ConeTwistJointSW(BodySW *rbA, BodySW *rbB, const Transform &rbAFrame, const Transform &rbBFrame);
void setAngularOnly(bool angularOnly) {
m_angularOnly = angularOnly;
}
void setLimit(real_t _swingSpan1, real_t _swingSpan2, real_t _twistSpan, real_t _softness = 0.8f, real_t _biasFactor = 0.3f, real_t _relaxationFactor = 1.0f) {
m_swingSpan1 = _swingSpan1;
m_swingSpan2 = _swingSpan2;
m_twistSpan = _twistSpan;
m_limitSoftness = _softness;
m_biasFactor = _biasFactor;
m_relaxationFactor = _relaxationFactor;
}
inline int getSolveTwistLimit() {
return m_solveTwistLimit;
}
inline int getSolveSwingLimit() {
return m_solveTwistLimit;
}
inline real_t getTwistLimitSign() {
return m_twistLimitSign;
}
void set_param(PhysicsServer::ConeTwistJointParam p_param, real_t p_value);
real_t get_param(PhysicsServer::ConeTwistJointParam p_param) const;
};
#endif // CONE_TWIST_JOINT_SW_H
|
[
"pvu2002@outlook.com"
] |
pvu2002@outlook.com
|
925572a98bf37e4ff1ab6094b6849069b06bed99
|
560fc2ce85280b08a018a5f6f6eba93e9161f8fb
|
/source/helpers/dirty.hpp
|
93115d9be7703ee7d985ef8d34628fadcc0dd87f
|
[] |
no_license
|
segrax/firy
|
c62411611351c3820439abcc093a6b3bd3934b9a
|
aceb0a6ad7536734d6e48f3edeeefb5e3305ec56
|
refs/heads/master
| 2023-02-11T13:53:21.667990
| 2021-01-17T01:33:59
| 2021-01-17T01:33:59
| 312,756,321
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,144
|
hpp
|
/*
* FIRY
* ---------------
*
* Copyright (C) 2019-2021
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
namespace firy {
namespace helpers {
class cDirty {
public:
cDirty() : mDirty(false) {}
virtual inline bool isDirty() const { return mDirty; }
/**
* Set dirty state, return state
*/
virtual inline bool dirty(const bool pVal = true) { mDirty = pVal; return mDirty; }
private:
volatile bool mDirty;
};
}
}
|
[
"robcrossfield@gmail.com"
] |
robcrossfield@gmail.com
|
6aa5b0d877d3a912639b4b15f8c1531542d05bc9
|
45bf55ec0e4fc8a6893ec2ff8f223b52c3c2708f
|
/Cascade/bl.cpp
|
018274c98ec684e1fe2fd1500c48a9183a0a129d
|
[] |
no_license
|
qiaoranliqu/WorkSpace
|
e4fd72e81e475f771442b678cb0d858b8c108939
|
a62a357c26a665597170dc6cb13f6901664ebb95
|
refs/heads/master
| 2023-01-01T08:17:03.549045
| 2020-10-30T13:06:30
| 2020-10-30T13:06:30
| 294,959,563
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 795
|
cpp
|
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
int ty,key,val;
map<int,int>mp;
int main()
{
freopen("data.in","r",stdin);
freopen("bl.out","w",stdout);
for (int i=0;i<500000;++i)
{
scanf("%d%d",&ty,&key);
if (ty==0)
{
scanf("%d",&val);
mp[key]=val;
}
else if (ty==1)
{
if (mp.find(key)==mp.end()) puts("None key matches!");
else
printf("%d\n",mp[key]);
}
else if (ty==2)
{
if (mp.find(key)==mp.end()) puts("This key is already deleted!");
else mp.erase(key);
}
else if (ty==3)
{
scanf("%d",&val);
mp[key]=val;
}
}
}
|
[
"857075272@qq.com"
] |
857075272@qq.com
|
22aef41ae568ac9770b4afc5fdc2de085b87fcf0
|
75a9a84935c5cf75b17e93827f2f9a5d5f4d5777
|
/mistakes/Array.cpp
|
967bb1a18f17a01583ef129ec23b0db58625b36e
|
[] |
no_license
|
weetee/something
|
8bfdf64839f86f03aaae1f82811596ede52f2885
|
2674b7b9f0a77815f4592b3b445a4332ffb0e2e9
|
refs/heads/master
| 2020-08-30T10:15:03.411361
| 2018-07-31T00:01:41
| 2018-07-31T00:01:41
| 94,389,644
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 739
|
cpp
|
#include <iostream>
using namespace std;
int main()
{
cout << "------------" << endl;
int arr[3][2] = {{0,1}, {2,3}, {4,5}};
int *p = arr[0];
cout << p[0] << endl; //0
cout << "------------" << endl;
int b = 2, c = 7, d = 5;
int a;
a = ++b, c--, d+3;
cout << a << endl; //3
cout << "------------" << endl;
char c_arr[3][3] = {{'a','b','c'},{'d','e','f'}, {'g','h','i'}};
cout << c_arr[1][4] << endl; //h
cout << "------------" << endl;
int (*p_arr)[2] = arr;
cout << *(*(p_arr+1)+1) << endl; //3
cout << "------------" << endl;
char str[][10] = {"China", "Beijing"};
char *p_str = str[0];
cout << p_str + 10 << endl; //Beijing
return 0;
}
|
[
"weitaoee@gmail.com"
] |
weitaoee@gmail.com
|
23b97277f3a966c6296ed7154b6a4689fa265f51
|
14a8e2b7c1c7e89dde8e1b840be5bcf8672599cc
|
/HandDetector_Native/HDStreamSink.cpp
|
e4e0075e8ee388b7fa30e631dd36f7bca2ef2da2
|
[] |
no_license
|
MickaelSERENO/HoloLens_HandDetector
|
bf2acc6c4490c76722104c94e1637646009e038e
|
d1d72b89909f3d819f928576023f99233d05a160
|
refs/heads/master
| 2020-05-29T16:51:37.129979
| 2020-02-14T15:39:11
| 2020-02-14T15:39:11
| 189,260,453
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 21,326
|
cpp
|
#include "HDStreamSink.h"
#include <string>
#include "ICameraIntrinsics.h"
#include "utils.h"
namespace Sereno
{
// Class-static matrix of operations vs states.
// If an entry is TRUE, the operation is valid from that state.
BOOL HDStreamSink::validStateMatrix[State_Count][Op_Count] =
{
// States: Operations:
// SetType Start Restart Pause Stop Sample Marker
/* NotSet */ TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
/* Ready */ TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE,
/* Start */ TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE,
/* Pause */ TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
/* Stop */ TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE,
};
HDStreamSink::HDStreamSink() : m_workQueueCB(this, &HDStreamSink::OnDispatchWorkItem)
{
TRACE(L"In Constructor\n")
}
HDStreamSink::~HDStreamSink()
{
TRACE(L"In Destructor\n");
}
IFACEMETHODIMP_(ULONG) HDStreamSink::AddRef()
{
TRACE(L"In AddRef\n")
return InterlockedIncrement(&m_cRef);
}
IFACEMETHODIMP_(ULONG) HDStreamSink::Release()
{
TRACE(L"In Release\n")
long cRef = InterlockedDecrement(&m_cRef);
if (cRef == 0)
{
delete this;
}
return cRef;
}
HRESULT HDStreamSink::QueryInterface(REFIID riid, void **ppv)
{
TRACE(L"In QueryInterface\n")
if (ppv == nullptr)
return E_POINTER;
(*ppv) = nullptr;
HRESULT hr = S_OK;
if(riid == IID_IUnknown || riid == IID_IMFStreamSink || riid == IID_IMFMediaEventGenerator)
{
(*ppv) = static_cast<IMFStreamSink*>(this);
AddRef();
}
else if(riid == IID_IMFMediaTypeHandler)
{
(*ppv) = static_cast<IMFMediaTypeHandler*>(this);
AddRef();
}
else
hr = E_NOINTERFACE;
if(FAILED(hr) && riid == IID_IMarshal)
{
if(m_spFTM == nullptr)
{
AutoLock lock(m_critSec);
if(m_spFTM == nullptr)
hr = CoCreateFreeThreadedMarshaler(static_cast<IMFStreamSink*>(this), &m_spFTM);
}
if(SUCCEEDED(hr))
{
if(m_spFTM == nullptr)
hr = E_UNEXPECTED;
else
hr = m_spFTM.Get()->QueryInterface(riid, ppv);
}
}
return hr;
}
HRESULT HDStreamSink::Initialize(IMFMediaSink* parent, HandDetector_Native::IHDMediaSinkClbk^ clbk, DWORD identifier)
{
TRACE(L"In Initialize\n")
m_clbk = clbk;
m_identifier = identifier;
AutoLock lock(m_critSec);
Microsoft::WRL::ComPtr<IMFMediaType> mediaType;
CHECK(MFCreateEventQueue(&m_spEventQueue))
m_spSink = parent;
CHECK(MFAllocateSerialWorkQueue(MFASYNC_CALLBACK_QUEUE_STANDARD, &m_workQueueId))
//Create the current media type
CHECK(MFCreateMediaType(&mediaType))
CHECK(mediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video))
CHECK(mediaType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB24))
CHECK(SetCurrentMediaType(mediaType.Get()))
return S_OK;
}
HRESULT HDStreamSink::BeginGetEvent(IMFAsyncCallback *pCallback, IUnknown *punkState)
{
TRACE(L"In BeginGetEvent\n")
AutoLock lock(m_critSec);
CHECK(m_spEventQueue->BeginGetEvent(pCallback, punkState))
return S_OK;
}
HRESULT HDStreamSink::EndGetEvent(IMFAsyncResult *pResult, IMFMediaEvent **ppEvent)
{
TRACE(L"In EndGetEvent\n")
AutoLock lock(m_critSec);
CHECK(m_spEventQueue->EndGetEvent(pResult, ppEvent))
return S_OK;
}
HRESULT HDStreamSink::GetEvent(DWORD dwFlags, IMFMediaEvent **ppEvent)
{
TRACE(L"In GetEvent\n")
// NOTE:
// GetEvent can block indefinitely, so we don't hold the lock.
// This requires some juggling with the event queue pointer.
Microsoft::WRL::ComPtr<IMFMediaEventQueue> spQueue;
{
AutoLock lock(m_critSec);
spQueue = m_spEventQueue;
}
// Now get the event.
CHECK(spQueue->GetEvent(dwFlags, ppEvent))
return S_OK;
}
HRESULT HDStreamSink::QueueEvent(MediaEventType met, REFGUID guidExtendedType, HRESULT hrStatus, PROPVARIANT const *pvValue)
{
TRACE(L"In QueueEvent\n")
CHECK(m_spEventQueue->QueueEventParamVar(met, guidExtendedType, hrStatus, pvValue))
return S_OK;
}
HRESULT HDStreamSink::GetIdentifier(DWORD *pdwIdentifier)
{
TRACE(L"In GetIdentifier\n")
*pdwIdentifier = 0;
return S_OK;
}
HRESULT HDStreamSink::GetMediaSink(IMFMediaSink **ppMediaSink)
{
TRACE(L"In GetMediaSink\n")
AutoLock lock(m_critSec);
return m_spSink->QueryInterface(IID_IMFMediaSink, (void**)ppMediaSink);
}
HRESULT HDStreamSink::GetMediaTypeHandler(IMFMediaTypeHandler **ppHandler)
{
TRACE(L"In GetMediaTypeHandler\n")
AutoLock lock(m_critSec);
return QueryInterface(IID_IMFMediaTypeHandler, (void**)ppHandler);
}
HRESULT HDStreamSink::ProcessSample(IMFSample *pSample)
{
TRACE(L"In ProcessSample\n")
if(pSample == nullptr)
return E_INVALIDARG;
AutoLock lock(m_critSec);
//Validate the operation.
CHECK(ValidateOperation(OpProcessSample))
SampleData sampleData(ST_SAMPLE);
sampleData.asCOM = pSample;
pSample->AddRef();
m_queueData.push(sampleData);
QueueAsyncOperation(OpProcessSample);
//Ask new frame
CHECK(QueueEvent(MEStreamSinkRequestSample, GUID_NULL, S_OK, nullptr))
return S_OK;
}
HRESULT HDStreamSink::PlaceMarker(MFSTREAMSINK_MARKER_TYPE eMarkerType, const PROPVARIANT *pvarMarkerValue, const PROPVARIANT *pvarContextValue)
{
TRACE(L"In PlaceMarker\n")
AutoLock lock(m_critSec);
CHECK(ValidateOperation(OpPlaceMarker))
Marker* marker = new Marker(eMarkerType, pvarMarkerValue, pvarContextValue);
SampleData sampleData(ST_MARKER);
sampleData.asMarker = std::shared_ptr<Marker>(marker);
m_queueData.push(sampleData);
// Unless we are paused, start an async operation to dispatch the next sample/marker.
if(m_state != State_Paused)
QueueAsyncOperation(OpPlaceMarker); // Increments ref count on pOp.
return S_OK;
}
HRESULT HDStreamSink::Flush()
{
TRACE(L"In Flush\n");
return S_OK;
}
HRESULT HDStreamSink::Shutdown()
{
TRACE(L"In Shutdown\n");
return S_OK;
}
HRESULT HDStreamSink::IsMediaTypeSupported(IMFMediaType *pMediaType, IMFMediaType **ppMediaType)
{
TRACE(L"In IsMediaTypeSupported\n");
if(pMediaType == nullptr)
return E_INVALIDARG;
AutoLock lock(m_critSec);
GUID majorType = GUID_NULL;
CHECK(pMediaType->GetGUID(MF_MT_MAJOR_TYPE, &majorType))
if (majorType != MFMediaType_Video)
{
TRACE(L"Not a video media type...\n");
return MF_E_INVALIDTYPE;
}
GUID guiNewSubtype;
CHECK(pMediaType->GetGUID(MF_MT_SUBTYPE, &guiNewSubtype));
if (guiNewSubtype != MFVideoFormat_RGB24 &&
guiNewSubtype != MFVideoFormat_ARGB32 &&
guiNewSubtype != MFVideoFormat_L8 &&
guiNewSubtype != MFVideoFormat_L16 &&
guiNewSubtype != MFVideoFormat_D16)
{
TRACE(L"Not the correct media SubType...\n");
return MF_E_INVALIDTYPE;
}
// We don't return any "close match" types.
if(ppMediaType)
*ppMediaType = nullptr;
return S_OK;
}
HRESULT HDStreamSink::GetMediaTypeCount(DWORD *pdwTypeCount)
{
TRACE(L"In GetMediaTypeCount\n");
if (pdwTypeCount == nullptr)
return E_INVALIDARG;
*pdwTypeCount = 1;
return S_OK;
}
HRESULT HDStreamSink::GetMediaTypeByIndex(DWORD dwIndex, IMFMediaType **ppType)
{
TRACE(L"In GetMediaTypeByIndex\n");
if (ppType == nullptr)
{
return E_INVALIDARG;
}
AutoLock lock(m_critSec);
if(dwIndex > 0)
return MF_E_NO_MORE_TYPES;
else
{
*ppType = m_spCurrentType.Get();
if(*ppType != nullptr)
(*ppType)->AddRef();
}
return S_OK;
}
HRESULT HDStreamSink::SetCurrentMediaType(IMFMediaType *pMediaType)
{
TRACE(L"In SetCurrentMediaType\n");
AutoLock lock(m_critSec);
// We don't allow format changes after streaming starts.
CHECK(ValidateOperation(OpSetMediaType));
// We set media type already
if (m_state >= State_Ready)
CHECK(IsMediaTypeSupported(pMediaType, nullptr));
CHECK(MFCreateMediaType(m_spCurrentType.ReleaseAndGetAddressOf()));
CHECK(pMediaType->CopyAllItems(m_spCurrentType.Get()));
if(m_state < State_Ready)
m_state = State_Ready;
else if(m_state > State_Ready)
{
Microsoft::WRL::ComPtr<IMFMediaType> spType;
CHECK(MFCreateMediaType(&spType));
CHECK(pMediaType->CopyAllItems(spType.Get()));
ProcessFormatChange(spType.Get());
}
QueueEvent(MEStreamSinkFormatChanged, GUID_NULL, S_OK, nullptr);
UINT32 width, height;
if (FAILED(MFGetAttributeSize(m_spCurrentType.Get(), MF_MT_FRAME_SIZE, &width, &height)))
{
TRACE(L"Could not get the size attribute...\n");
return S_OK;
}
m_streamWidth = width;
m_streamHeight = height;
UINT32 framerateNum = -1, framerateDenum=1;
if (FAILED(MFGetAttributeRatio(m_spCurrentType.Get(), MF_MT_FRAME_RATE, &framerateNum, &framerateDenum)))
TRACE(L"Could not get the framerate attribute...\n");
GUID guiNewSubtype;
CHECK(pMediaType->GetGUID(MF_MT_SUBTYPE, &guiNewSubtype));
//Delete the old hand detector
if (m_handDetector != NULL)
{
delete m_handDetector;
m_handDetector = NULL;
}
//Create the hand detector
//We detect between 25 and 80 centimeters, with a blob of minimum size = 900 pixels
//Maximum wrist length : 100 pixels
if (guiNewSubtype == MFVideoFormat_L8)
m_handDetector = new HandDetection<D8Func>(width, height, 230, 630, 15, 700, 110);
else if (guiNewSubtype == MFVideoFormat_D16 || guiNewSubtype == MFVideoFormat_L16)
m_handDetector = new HandDetection<D16Func>(width, height, 230, 630, 15, 700, 110);
else
TRACE(L"Could not determine GUID %ld\n", guiNewSubtype);
m_mediaSubtype = guiNewSubtype;
TRACE(L"Media type setted. Width: %d, Height: %d, framerate: %f, format: %ws\n", width, height, (float)((INT32)framerateNum) / framerateDenum,
(guiNewSubtype == MFVideoFormat_D16 ? L"D16" :
(guiNewSubtype == MFVideoFormat_RGB24 ? L"RGB24" :
(guiNewSubtype == MFVideoFormat_L8 ? L"L8" :
(guiNewSubtype == MFVideoFormat_L16 ? L"L16" : L"ARGB32")))));
return S_OK;
}
HRESULT HDStreamSink::GetCurrentMediaType(IMFMediaType **ppMediaType)
{
TRACE(L"In GetCurrentMediaType\n")
AutoLock lock(m_critSec);
*ppMediaType = m_spCurrentType.Get();
if(*ppMediaType)
(*ppMediaType)->AddRef();
return S_OK;
}
HRESULT HDStreamSink::GetMajorType(GUID *pguidMajorType)
{
TRACE(L"In GetMajorType")
AutoLock lock(m_critSec);
*pguidMajorType = MFMediaType_Video;
return S_OK;
}
HRESULT HDStreamSink::Start(MFTIME start)
{
TRACE(L"In Start\n")
AutoLock lock(m_critSec);
CHECK(ValidateOperation(OpStart))
m_state = State_Started;
CHECK(QueueAsyncOperation(OpStart))
return S_OK;
}
HRESULT HDStreamSink::Restart()
{
TRACE(L"In Restart\n")
AutoLock lock(m_critSec);
CHECK(ValidateOperation(OpRestart))
m_state = State_Started;
CHECK(QueueAsyncOperation(OpRestart))
return S_OK;
}
HRESULT HDStreamSink::Stop()
{
TRACE(L"In Stop\n")
AutoLock lock(m_critSec);
CHECK(ValidateOperation(OpStop))
m_state = State_Stopped;
CHECK(QueueAsyncOperation(OpStop))
return S_OK;
}
HRESULT HDStreamSink::Pause()
{
TRACE(L"In Pause\n")
AutoLock lock(m_critSec);
CHECK(ValidateOperation(OpPause))
m_state = State_Paused;
CHECK(QueueAsyncOperation(OpPause))
return S_OK;
}
void HDStreamSink::ProcessFormatChange(IMFMediaType *pMediaType)
{
TRACE(L"In process format change\n")
// Add the media type to the sample queue.
SampleData sampleData(ST_MEDIATYPE);
sampleData.asCOM = pMediaType;
pMediaType->AddRef();
m_queueData.push(sampleData);
// Unless we are paused, start an async operation to dispatch the next sample.
// Queue the operation.
QueueAsyncOperation(OpSetMediaType);
}
// Puts an async operation on the work queue.
HRESULT HDStreamSink::QueueAsyncOperation(StreamOperation op)
{
TRACE(L"In Queue Async Operation\n")
AutoLock _lock(m_critSec);
Microsoft::WRL::ComPtr<AsyncOperation> spOp;
spOp.Attach(new AsyncOperation(op)); // Created with ref count = 1
CHECK(MFPutWorkItem2(m_workQueueId, 0, &m_workQueueCB, spOp.Get()))
return S_OK;
}
BOOL HDStreamSink::ValidateOperation(StreamOperation op) const
{
return validStateMatrix[m_state][op];
}
HRESULT HDStreamSink::OnDispatchWorkItem(IMFAsyncResult *pAsyncResult)
{
TRACE(L"New work Item received\n")
Microsoft::WRL::ComPtr<IUnknown> spState;
CHECK(pAsyncResult->GetState(&spState))
// The state object is a AsyncOperation object.
AsyncOperation *asyncOP = static_cast<AsyncOperation *>(spState.Get());
StreamOperation op = asyncOP->op;
switch(op)
{
case OpStart:
case OpRestart:
{
TRACE(L"Sending Operation Start\n");
AutoLock _lock(m_critSec);
CHECK(QueueEvent(MEStreamSinkStarted, GUID_NULL, S_OK, nullptr))
CHECK(QueueEvent(MEStreamSinkRequestSample, GUID_NULL, S_OK, nullptr))
TRACE(L"End Operation Start\n")
break;
}
case OpPause:
{
AutoLock _lock(m_critSec);
TRACE(L"Sending Operation Paused\n");
CHECK(QueueEvent(MEStreamSinkPaused, GUID_NULL, S_OK, nullptr))
break;
}
case OpStop:
{
AutoLock _lock(m_critSec);
TRACE(L"Sending Operation Stopped\n");
CHECK(QueueEvent(MEStreamSinkStopped, GUID_NULL, S_OK, nullptr))
TRACE(L"End Operation Start\n")
break;
}
case OpProcessSample:
{
TRACE(L"Processing sample in work item thread\n")
//Fetch sample data
IMFSample* sample = NULL;
{
AutoLock _lock(m_critSec);
SampleData& sd = m_queueData.front();
sample = static_cast<IMFSample*>(sd.asCOM.Get());
m_queueData.pop();
}
MFPinholeCameraIntrinsics cameraIntrinsics;
sample->GetBlob(MFSampleExtension_PinholeCameraIntrinsics, (UINT8*)(&cameraIntrinsics), 1, NULL);
IMFMediaBuffer* sampleBuffer;
unsigned long bufferCount;
sample->GetBufferCount(&bufferCount);
sample->ConvertToContiguousBuffer(&sampleBuffer);
BYTE* rawBuffer;
DWORD bufferCurrentLength;
sampleBuffer->Lock(&rawBuffer, NULL, &bufferCurrentLength);
//Update the hand position
CHECK(UpdateHandDetection(sample, rawBuffer, bufferCurrentLength))
//Release the frame
sampleBuffer->Unlock();
sampleBuffer->Release();
sample->Release();
break;
}
case OpPlaceMarker:
{
AutoLock _lock(m_critSec);
QueueEvent(MEStreamSinkMarker, GUID_NULL, S_OK, nullptr);
m_queueData.pop();
break;
}
case OpSetMediaType:
{
AutoLock _lock(m_critSec);
m_queueData.pop();
break;
}
default:
break;
}
TRACE(L"End onWorkItem received\n")
return S_OK;
}
HRESULT HDStreamSink::UpdateHandDetection(IMFSample* sample, BYTE* rawBuffer, unsigned long bufferCurrentLength)
{
//WriteSampleToFile(rawBuffer, bufferCurrentLength);
if (m_handDetector != NULL)
{
//Update the status
m_handDetector->updateDetection(rawBuffer);
//Call the callback interface
if (m_clbk != nullptr)
{
Platform::Collections::Vector<HandDetector_Native::Hand^>^ hands = ref new Platform::Collections::Vector<HandDetector_Native::Hand^>();
//Determine what depth function to use
DepthFunc depthFunc = NULL;
if (m_mediaSubtype == MFVideoFormat_D16 || m_mediaSubtype == MFVideoFormat_L16)
depthFunc = &D16Func::depthAt;
else if (m_mediaSubtype == MFVideoFormat_L8)
depthFunc = &D8Func::depthAt;
//Get the camera parameters
HandDetector_Native::CameraParameter camera;
//First the spatial coordinate system
Microsoft::WRL::ComPtr<IUnknown> spUnknown;
Microsoft::WRL::ComPtr<IInspectable> spSpatialCoordinateSystem = NULL;
if(SUCCEEDED(sample->GetUnknown(MFSampleExtension_Spatial_CameraCoordinateSystem, IID_PPV_ARGS(&spUnknown))))
spUnknown.As(&spSpatialCoordinateSystem);
memset(&camera.CameraViewTransform, 0, sizeof(camera.CameraViewTransform));
memset(&camera.CameraProjectionTransform, 0, sizeof(camera.CameraProjectionTransform));
memset(&camera.CameraIntrinsics, 0, sizeof(camera.CameraIntrinsics));
//Then camera parameters
UINT32 blobSize;
if(FAILED(sample->GetBlob(MFSampleExtension_Spatial_CameraViewTransform, (UINT8*)(&camera.CameraViewTransform), sizeof(camera.CameraViewTransform), &blobSize)))
TRACE("Failed to get camera view transform\n")
if(FAILED(sample->GetBlob(MFSampleExtension_Spatial_CameraProjectionTransform, (UINT8*)(&camera.CameraProjectionTransform), sizeof(camera.CameraProjectionTransform), &blobSize)))
TRACE("Failed to get camera projection transform\n")
if(FAILED(sample->GetBlob(MFSampleExtension_PinholeCameraIntrinsics, (UINT8*)&camera.CameraIntrinsics, sizeof(camera.CameraIntrinsics), &blobSize)))
TRACE("Failed to get pinhole camera intrinsics\n")
SensorStreaming::ICameraIntrinsics* sensorStreamingCameraIntrinsics = NULL;
if(SUCCEEDED(sample->GetUnknown(SensorStreaming::MFSampleExtension_SensorStreaming_CameraIntrinsics, IID_PPV_ARGS(&spUnknown))))
sensorStreamingCameraIntrinsics = (SensorStreaming::ICameraIntrinsics*)spUnknown.Get();
//If found
if(depthFunc)
{
//Create the WinRT proxy object
if (sensorStreamingCameraIntrinsics == NULL)
{
for (const auto& h : m_handDetector->getHands())
{
HandDetector_Native::Hand^ hand = ref new HandDetector_Native::Hand();
hand->InPixels = true;
//Palm position
hand->PalmX = h.palmX;
hand->PalmY = h.palmY;
hand->PalmZ = depthFunc(h.palmX, h.palmY, m_streamWidth, rawBuffer);
//Fingers
for (const auto& f : h.fingers)
{
HandDetector_Native::Finger finger;
finger.TipX = f.tipX;
finger.TipY = f.tipY;
finger.TipZ = depthFunc(f.tipX, f.tipY, m_streamWidth, rawBuffer);
hand->Fingers->Append(finger);
}
//Wrist
hand->WristX = h.wristPosX;
hand->WristY = h.wristPosY;
hand->WristZ = depthFunc(h.wristPosX, h.wristPosY, m_streamWidth, rawBuffer);
hands->Append(hand);
}
}
else
{
for (const auto& h : m_handDetector->getHands())
{
HandDetector_Native::Hand^ hand = ref new HandDetector_Native::Hand();
//Palm Position
float outXY[2];
float inXY[2] = { (float)h.palmX, (float)h.palmY};
float depth = -depthFunc(h.palmX, h.palmY, m_streamWidth, rawBuffer)/1000.0f;
sensorStreamingCameraIntrinsics->MapImagePointToCameraUnitPlane(inXY, outXY);
float z = depth / sqrt(outXY[0] * outXY[0] + outXY[1] * outXY[1] + 1);
hand->PalmX = z*outXY[0];
hand->PalmY = z*outXY[1];
hand->PalmZ = z;
//Fingers
for (const auto& f : h.fingers)
{
HandDetector_Native::Finger finger;
inXY[0] = f.tipX;
inXY[1] = f.tipY;
depth = -depthFunc(f.tipX, f.tipY, m_streamWidth, rawBuffer)/1000.0f;
sensorStreamingCameraIntrinsics->MapImagePointToCameraUnitPlane(inXY, outXY);
z = depth / sqrt(outXY[0] * outXY[0] + outXY[1] * outXY[1] + 1);
finger.TipX = z*outXY[0];
finger.TipY = z*outXY[1];
finger.TipZ = z;
hand->Fingers->Append(finger);
}
//Wrist positions
inXY[0] = (float)(h.wristPosX);
inXY[1] = (float)(h.wristPosY);
depth = -depthFunc(h.wristPosX, h.wristPosY, m_streamWidth, rawBuffer)/1000.0f;
sensorStreamingCameraIntrinsics->MapImagePointToCameraUnitPlane(inXY, outXY);
z = depth / sqrt(outXY[0] * outXY[0] + outXY[1] * outXY[1] + 1);
hand->WristX = z * outXY[0];
hand->WristY = z * outXY[1];
hand->WristZ = z;
//Copy the ROIs information
hand->BlobROIMinX = h.blobMinROI[0];
hand->BlobROIMinY = h.blobMinROI[1];
hand->BlobROIMaxX = h.blobMaxROI[0];
hand->BlobROIMaxY = h.blobMaxROI[1];
hand->WristROIMinX = h.wristMinROI[0];
hand->WristROIMinY = h.wristMinROI[1];
hand->WristROIMaxX = h.wristMaxROI[0];
hand->WristROIMaxY = h.wristMaxROI[1];
hands->Append(hand);
}
}
}
//Call the interface
if(spSpatialCoordinateSystem != NULL)
m_clbk->OnHandUpdate(camera, safe_cast<Windows::Perception::Spatial::SpatialCoordinateSystem^>(reinterpret_cast<Platform::Object^>(spSpatialCoordinateSystem.Get())), hands);
}
}
return S_OK;
}
HRESULT HDStreamSink::WriteSampleToFile(BYTE* rawBuffer, unsigned long bufferCurrentLength)
{
uint32_t width;
uint32_t height;
Platform::String^ strPath = Windows::Storage::ApplicationData::Current->LocalFolder->Path;
const wchar_t* path = strPath->Data();
wchar_t fileName[2048];
swprintf_s(fileName, 2048, L"%s/frame%d.ppm", path, m_frameID++);
FILE* f;
_wfopen_s(&f, fileName, L"w");
TRACE(L"Writing to %s\n", fileName)
char header[256];
{
AutoLock _lock(m_critSec);
CHECK(MFGetAttributeSize(m_spCurrentType.Get(), MF_MT_FRAME_SIZE, &width, &height))
}
sprintf_s(header, 256, "P2\n%d %d\n%d", width, height, (1 << 16) - 1);
fwrite(header, sizeof(char), strlen(header), f);
std::string txt;
for (DWORD i = 0; i < bufferCurrentLength / 2; i++)
{
if (i % 70 == 0)
txt.push_back('\n');
char intStr[16];
sprintf_s(intStr, 16, "%d ", (int)((int)rawBuffer[2 * i] + (int)(rawBuffer[2 * i + 1] << 8)));
txt += intStr;
}
fwrite(txt.c_str(), sizeof(char), txt.length(), f);
TRACE(L"End writting")
fclose(f);
return S_OK;
}
}
|
[
"serenomickael@gmail.com"
] |
serenomickael@gmail.com
|
898acf96ad6963127045b76e5008e8bbc2913077
|
62e744795a2d8e1e3587cdef33ee176d7e564b7b
|
/Seagull-Core/src/Renderer/RenderCommand.cpp
|
7ee28969f44040d0cae6a347bfb2b1dddf6515f0
|
[
"MIT"
] |
permissive
|
Catddly/Seagull-Engine-Discarded
|
49bde4b8d3d16d6d519c2372176eb97b7c0a9931
|
fb51b66812eca6b70ed0e35ecba091e9874b5bea
|
refs/heads/main
| 2023-06-16T15:10:49.754971
| 2020-11-15T11:26:26
| 2020-11-15T11:26:26
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 188
|
cpp
|
#include "sgpch.h"
#include "RenderCommand.h"
#include "Platform/DirectX/DirectX12RendererAPI.h"
namespace SG
{
RendererAPI* RenderCommand::s_RendererAPI = new DirectX12RendererAPI();
}
|
[
"illmewds@gmail.com"
] |
illmewds@gmail.com
|
58d890572d1940a6787e4d7fe1353b06d219759e
|
bf013ac9608c7f11ec9ee1eb1197529422d02848
|
/huggle/exceptionwindow.hpp
|
81921b9e23dff63ab6d9c38183910cf39acb9785
|
[] |
no_license
|
9shi/huggle3-qt-lx
|
e2064d04f378a0356df639c26723efdb79daf58b
|
07974ded3bddb16d982ee8376d4374a88bf704d9
|
refs/heads/master
| 2021-01-15T14:18:22.456129
| 2014-01-09T15:31:34
| 2014-01-09T15:32:13
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,178
|
hpp
|
//This program is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
#ifndef EXCEPTIONWINDOW_H
#define EXCEPTIONWINDOW_H
#if _MSC_VER
#define TRACING 0
#else
#define TRACING 1
#endif
#include <QDialog>
#include "core.hpp"
#if TRACING
//#include <execinfo.h>
#endif
#include "exception.hpp"
namespace Ui
{
class ExceptionWindow;
}
namespace Huggle
{
//! Recovery window
class ExceptionWindow : public QDialog
{
Q_OBJECT
public:
explicit ExceptionWindow(Exception *e);
~ExceptionWindow();
private slots:
void on_pushButton_clicked();
void on_pushButton_3_clicked();
private:
Ui::ExceptionWindow *ui;
};
}
#endif // EXCEPTIONWINDOW_H
|
[
"benapetr@gmail.com"
] |
benapetr@gmail.com
|
0eb57ac7beca6040ff07bbc832e1cdfbbc0c2ac9
|
719f6aa6740f92d84091f30263901540b6daa864
|
/SummerNodeProject/Model/HashTable2016.hpp
|
d664c8c578a4099ffb1f63b6f80e2235740a6825
|
[] |
no_license
|
tonidavis/SummerNodeProject
|
05e0cf49b57293284d39a717877ef7b274278cac
|
52d912d2b68cd1206f2760782899b73d26febfb9
|
refs/heads/master
| 2021-01-20T19:57:04.650936
| 2016-07-29T20:22:55
| 2016-07-29T20:22:55
| 64,252,126
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 697
|
hpp
|
//
// HashTable2016.hpp
// SummerNodeProject
//
// Created by Henrichsen, Cody on 7/29/16.
// Copyright © 2016 CTEC. All rights reserved.
//
#ifndef HashTable2016_hpp
#define HashTable2016_hpp
#include "HashNode.cpp"
template <class Type>
class HashTable
{
private:
long capacity;
long size;
double efficiencyPercentage;
HashNode<Type> * front;
bool isPrime(int sampleNumber);
void resize();
long nextPrime(long current);
long findPosition(Type data);
long handleCollision(Type data, long currentPosition);
public:
HashTable();
void add(Type data);
bool remove(Type data);
void displayContents();
};
#endif /* HashTable2016_hpp */
|
[
"cody.henrichsen@740s-pl-114.local"
] |
cody.henrichsen@740s-pl-114.local
|
298c7c18d7706c162db908249255c10e56a1871e
|
b110c07c077672594db91a2827a97b189cd0f761
|
/reference/bfs.cpp
|
3ce6eaaa15e54507616aba32f715cec37a142953
|
[] |
no_license
|
sandheepp/Shortest-cycle-in-a-graph
|
acc68ac23fce9298124af48f1a1df55455f5289d
|
7966b76890029ec460db8ee7a4a8e16d41d5c033
|
refs/heads/master
| 2022-12-03T15:06:54.599918
| 2020-08-26T17:03:45
| 2020-08-26T17:03:45
| 203,951,051
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,853
|
cpp
|
/*
BFS (G, s) //Where G is the graph and s is the source node
let Q be queue.
Q.enqueue( s ) //Inserting s in queue until all its neighbour vertices are marked.
mark s as visited.
while ( Q is not empty)
//Removing that vertex from queue,whose neighbour will be visited now
v = Q.dequeue( )
//processing all the neighbours of v
for all neighbours w of v in Graph G
if w is not visited
Q.enqueue( w ) //Stores w in Q to further visit its neighbour.
mark w as visited.
*/
// A C++ Program to detect cycle in a graph
#include<iostream>
#include <list>
#include <limits.h>
using namespace std;
class Graph
{
int V; // No. of vertices
list<int> *adj; // Pointer to an array containing adjacency lists
bool isCyclicUtil(int v, bool visited[], bool *rs); // used by isCyclic()
public:
Graph(int V); // Constructor
void addEdge(int v, int w); // to add an edge to graph
bool isCyclic(); // returns true if there is a cycle in this graph
};
Graph::Graph(int V)
{
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w)
{
adj[v].push_back(w); // Add w to v’s list.
}
// This function is a variation of DFSUtil() in https://www.geeksforgeeks.org/archives/18212
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack)
{
if(visited[v] == false)
{
// Mark the current node as visited and part of recursion stack
visited[v] = true;
recStack[v] = true;
// Recur for all the vertices adjacent to this vertex
list<int>::iterator i;
for(i = adj[v].begin(); i != adj[v].end(); ++i)
{
if ( !visited[*i] && isCyclicUtil(*i, visited, recStack) )
return true;
else if (recStack[*i])
continue;
}
}
recStack[v] = false; // remove the vertex from recursion stack
return false;
}
// Returns true if the graph contains a cycle, else false.
// This function is a variation of DFS() in https://www.geeksforgeeks.org/archives/18212
bool Graph::isCyclic()
{
// Mark all the vertices as not visited and not part of recursion
// stack
bool *visited = new bool[V];
bool *recStack = new bool[V];
for(int i = 0; i < V; i++)
{
visited[i] = false;
recStack[i] = false;
}
// Call the recursive helper function to detect cycle in different
// DFS trees
for(int i = 0; i < V; i++)
if (isCyclicUtil(i, visited, recStack))
return true;
return false;
}
int main()
{
// Create a graph given in the above diagram
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(2, 3);
g.addEdge(3, 3);
if(g.isCyclic())
cout << "Graph contains cycle";
else
cout << "Graph doesn't contain cycle";
return 0;
}
|
[
"sandheep.p01gmail.com"
] |
sandheep.p01gmail.com
|
8067ef50ebb7a77e10fed2e23e528025153efef8
|
29e2f465fcd00023849f8a99f25c038eb1b488a1
|
/source/util/ck_util.cpp
|
7eb05ea4087c2c941e729c00ced7a8c524bb59f5
|
[] |
no_license
|
Kiti-Nomad/catcake
|
e8fdaef9cab9d048e09d214105f71c08830f7644
|
7e5ed2bfd47d3e500860f9c3dab3d231198e244a
|
refs/heads/master
| 2022-02-05T01:17:23.438907
| 2018-07-03T10:37:43
| 2018-07-03T10:37:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,492
|
cpp
|
/*
Copyright (c) 2007-2010 Takashi Kitao
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 "ck_util_all.h"
#include "ck_res_all.h"
#include "ck_low_level_api.h"
u32 ckUtil::strlen(const char* str)
{
if (!str)
{
ckThrow(ExceptionInvalidArgument);
}
u32 len = 0;
while (*str)
{
str++;
len++;
}
return len;
}
u32 ckUtil::wcslen(const wchar_t* str)
{
if (!str)
{
ckThrow(ExceptionInvalidArgument);
}
u32 len = 0;
while (*str)
{
str++;
len++;
}
return len;
}
void ckUtil::charToWchar(wchar_t* buf, u32 buf_size, const char* str)
{
if (!buf || buf_size == 0 || !str)
{
ckThrow(ExceptionInvalidArgument);
}
for (u32 i = 0; i < buf_size; i++)
{
char c = str[i];
if (!c)
{
buf[i] = L'\0';
break;
}
buf[i] = c;
}
buf[buf_size - 1] = L'\0';
}
const char* ckUtil::getBasename(const char* filename)
{
if (!filename)
{
ckThrow(ExceptionInvalidArgument);
}
const char* base = filename;
for (const char* c = base; *c != '\0'; c++)
{
if (*c == '\\' || *c == '/' || *c == ':')
{
base = c + 1;
}
}
return base;
}
const char* ckUtil::getExtension(const char* filename)
{
if (!filename) {
ckThrow(ExceptionInvalidArgument);
}
const char* ext = getBasename(filename);
for ( ; *ext != '\0'; ext++) {
if (*ext == '.') return ext + 1;
}
return ext;
}
void ckUtil::calcNormalAsTriangles(ckVec* normal, const ckPrim::PrimData* prim_data, u16 vert_num, bool is_smoothing)
{
if (!normal || !prim_data || vert_num == 0)
{
ckThrow(ExceptionInvalidArgument);
}
if (vert_num < 3)
{
for (s32 i = 0; i < vert_num; i++)
{
normal[i] = ckVec::Z_UNIT;
}
return;
}
u16 tri_vert_num = (vert_num / 3) * 3;
for (s32 i = 0; i < tri_vert_num; i += 3)
{
ckVec vec1 = prim_data[i + 1].pos - prim_data[i].pos;
ckVec vec2 = prim_data[i + 2].pos - prim_data[i].pos;
normal[i] = normal[i + 1] = normal[i + 2] = vec1.cross(vec2).normalize();
}
for (s32 i = tri_vert_num; i < vert_num; i++)
{
normal[i] = ckVec::Z_UNIT;
}
if (!is_smoothing)
{
return;
}
u32 mark_buf_size = sizeof(u16) * vert_num;
u16* mark_buf = static_cast<u16*>(ckMalloc(mark_buf_size));
ckMemMgr::memset(mark_buf, 0, mark_buf_size);
for (s32 i = 0; i < vert_num; i++)
{
if (mark_buf[i] > 0)
{
continue;
}
u16 mark = i + 1;
u16 mark_num = 1;
const ckVec& pos1 = prim_data[i].pos;
const ckVec& n1 = normal[i];
ckVec avgn = n1;
mark_buf[i] = mark;
for (s32 j = i + 1; j < vert_num; j++)
{
const ckVec& pos2 = prim_data[j].pos;
const ckVec& n2 = normal[j];
if (pos1.x == pos2.x && pos1.y == pos2.y && pos1.z == pos2.z)
{
r32 inner = n1.dot(n2);
if (inner > 0.7071f) // cos 45
{
mark_buf[j] = mark;
mark_num++;
if (inner < 1.0f - ckMath::EPSILON)
{
avgn += n2;
}
}
}
}
if (mark_num > 1)
{
if (avgn.x == 0.0f && avgn.y == 0.0f && avgn.z == 0.0f)
{
continue;
}
avgn = avgn.normalize();
for (s32 j = i; j < vert_num; j++)
{
if (mark_buf[j] == mark)
{
normal[j] = avgn;
}
}
}
}
ckFree(mark_buf);
}
bool ckUtil::readJpegInfo(u16* width, u16* height, ckTex::TexFormat* format, const void* data, u32 data_size)
{
if (!width || !height || !format || !data || data_size == 0)
{
ckThrow(ExceptionInvalidArgument);
}
ckLowLevelAPI::TextureFormat texture_format;
bool res = ckLowLevelAPI::readJpegInfo(width, height, &texture_format, data, data_size);
*format = static_cast<ckTex::TexFormat>(ckTex::FORMAT_PNG_RGB + texture_format);
//*format = ckTex::FORMAT_JPEG_RGB;
return res;
}
bool ckUtil::readJpegImage(void* buf, u32 buf_size, u32 buf_line_size, const void* data, u32 data_size)
{
if (!buf || buf_size == 0 || buf_line_size == 0 || !data || data_size == 0)
{
ckThrow(ExceptionInvalidArgument);
}
return ckLowLevelAPI::readJpegImage(buf, buf_size, buf_line_size, data, data_size);
}
bool ckUtil::readPNGInfo(u16* width, u16* height, ckTex::TexFormat* format, const void* data, u32 data_size)
{
if (!width || !height || !format || !data || data_size == 0)
{
ckThrow(ExceptionInvalidArgument);
}
ckLowLevelAPI::TextureFormat texture_format;
bool res = ckLowLevelAPI::readPNGInfo(width, height, &texture_format, data, data_size);
*format = static_cast<ckTex::TexFormat>(ckTex::FORMAT_PNG_RGB + texture_format);
return res;
}
bool ckUtil::readPNGImage(void* buf, u32 buf_size, u32 buf_line_size, const void* data, u32 data_size)
{
if (!buf || buf_size == 0 || buf_line_size == 0 || !data || data_size == 0)
{
ckThrow(ExceptionInvalidArgument);
}
return ckLowLevelAPI::readPNGImage(buf, buf_size, buf_line_size, data, data_size);
}
void ckUtil::loadWindowsFont(const char* filename)
{
if (!filename)
{
ckThrow(ExceptionInvalidArgument);
}
char buf[256];
ckLowLevelAPI::getWindowsFontDirectory(buf, 256);
ckStr<char, 255> str = buf;
str += filename;
ckResMgr::loadResource(str.getString(), true);
}
void ckUtil::loadShader(ckID shd_id, const char* vert_file, const char* frag_file, u8 uni_num, u8 att_num, u8 tex_num)
{
ckID vert_id = ckID::genID();
char* vert_code = NULL;
if (vert_file)
{
ckResMgr::loadResourceAs(vert_id, vert_file, false);
ckRes res = ckResMgr::getResource(vert_id);
vert_code = static_cast<char*>(ckMalloc(res.getDataSize() + 1));
ckMemMgr::memcpy(vert_code, res.getData<void>(), res.getDataSize());
vert_code[res.getDataSize()] = '\0';
ckResMgr::removeResource(vert_id);
}
ckID frag_id = ckID::genID();
char* frag_code = NULL;
if (frag_file)
{
ckResMgr::loadResourceAs(frag_id, frag_file, false);
ckRes res = ckResMgr::getResource(frag_id);
frag_code = static_cast<char*>(ckMalloc(res.getDataSize() + 1));
ckMemMgr::memcpy(frag_code, res.getData<void>(), res.getDataSize());
frag_code[res.getDataSize()] = '\0';
ckResMgr::removeResource(frag_id);
}
ckDrawMgr::newShader(shd_id, vert_code, frag_code, uni_num, att_num, tex_num);
if (vert_code)
{
ckFree(vert_code);
}
if (frag_code)
{
ckFree(frag_code);
}
}
|
[
"root@berry-love.tk"
] |
root@berry-love.tk
|
f24c11d4a9bd5f7539a40f86af21a9dae5e6654e
|
934f7ba52f4856129effe9948d4de5573307c776
|
/Utils/Quantize Wrap.cpp
|
f3eef809fbcae9675509fed55c6e16c67fed1ace
|
[] |
no_license
|
FluffyQuack/JA2-113
|
9663176a66610e7685e953aafe66b9fdfad0e474
|
a53fb01b69ec12296b6022613e978ba713b90c32
|
refs/heads/master
| 2023-05-05T08:05:41.594371
| 2021-05-18T15:17:25
| 2021-05-18T15:17:25
| 368,576,923
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,022
|
cpp
|
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include "types.h"
#include "himage.h"
#include "Quantize.h"
#include "Quantize Wrap.h"
#include "phys math.h"
typedef struct
{
UINT8 r;
UINT8 g;
UINT8 b;
} RGBValues;
BOOLEAN QuantizeImage( UINT8 *pDest, UINT8 *pSrc, INT16 sWidth, INT16 sHeight, SGPPaletteEntry *pPalette )
{
INT16 sNumColors;
// FIRST CREATE PALETTE
CQuantizer q( 255, 6 );
q.ProcessImage( pSrc, sWidth, sHeight );
sNumColors = q.GetColorCount();
memset( pPalette, 0, sizeof( SGPPaletteEntry ) * 256 );
q.GetColorTable( (RGBQUAD*)pPalette );
// THEN MAP IMAGE TO PALETTE
// OK, MAPIT!
MapPalette( pDest, pSrc, sWidth, sHeight, sNumColors, pPalette );
return( TRUE );
}
void MapPalette( UINT8 *pDest, UINT8 *pSrc, INT16 sWidth, INT16 sHeight, INT16 sNumColors, SGPPaletteEntry *pTable )
{
INT32 cX, cY, cnt, bBest;
real dLowestDist;
real dCubeDist;
vector_3 vTableVal, vSrcVal, vDiffVal;
UINT8 *pData;
RGBValues *pRGBData;
pRGBData = (RGBValues*)pSrc;
for ( cX = 0; cX < sWidth; cX++ )
{
for ( cY = 0; cY < sHeight; cY++ )
{
// OK, FOR EACH PALETTE ENTRY, FIND CLOSEST
bBest = 0;
dLowestDist = (float)9999999;
pData = &(pSrc[ ( cY * sWidth ) + cX ]);
for ( cnt = 0; cnt < sNumColors; cnt++ )
{
vSrcVal.x = pRGBData[ ( cY * sWidth ) + cX ].r;
vSrcVal.y = pRGBData[ ( cY * sWidth ) + cX ].g;
vSrcVal.z = pRGBData[ ( cY * sWidth ) + cX ].b;
vTableVal.x = pTable[ cnt ].peRed;
vTableVal.y = pTable[ cnt ].peGreen;
vTableVal.z = pTable[ cnt ].peBlue;
// Get Dist
vDiffVal = VSubtract( &vSrcVal, &vTableVal );
// Get mag dist
dCubeDist = VGetLength( &(vDiffVal) );
if ( dCubeDist < dLowestDist )
{
dLowestDist = dCubeDist;
bBest = cnt;
}
}
// Now we have the lowest value
// Set into dest
pData = &(pDest[ ( cY * sWidth ) + cX ]);
//Set!
*pData = (UINT8)bBest;
}
}
}
|
[
"git@fluffyquack.com"
] |
git@fluffyquack.com
|
6f3ad2842e57324c3364977274302b57eace6450
|
0805ca8bb3e2aa9027efc413677e2a74791146c0
|
/src/rpc/protocol.cpp
|
e85ab142d6e4540d182e420298255030ebb694c2
|
[
"MIT"
] |
permissive
|
omn14/scicoin
|
f2403bb26b76029a4c7466d329e2c505772a32ce
|
8b48d9e800304781de7a777f4a93432357b0b133
|
refs/heads/master
| 2021-01-16T18:09:29.231945
| 2017-11-24T16:10:45
| 2017-11-24T16:10:45
| 100,041,187
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,739
|
cpp
|
// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "rpc/protocol.h"
#include "random.h"
#include "tinyformat.h"
#include "util.h"
#include "utilstrencodings.h"
#include "utiltime.h"
#include "version.h"
#include <stdint.h>
#include <fstream>
/**
* JSON-RPC protocol. Scicoin speaks version 1.0 for maximum compatibility,
* but uses JSON-RPC 1.1/2.0 standards for parts of the 1.0 standard that were
* unspecified (HTTP errors and contents of 'error').
*
* 1.0 spec: http://json-rpc.org/wiki/specification
* 1.2 spec: http://jsonrpc.org/historical/json-rpc-over-http.html
*/
UniValue JSONRPCRequestObj(const std::string& strMethod, const UniValue& params, const UniValue& id)
{
UniValue request(UniValue::VOBJ);
request.push_back(Pair("method", strMethod));
request.push_back(Pair("params", params));
request.push_back(Pair("id", id));
return request;
}
UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const UniValue& id)
{
UniValue reply(UniValue::VOBJ);
if (!error.isNull())
reply.push_back(Pair("result", NullUniValue));
else
reply.push_back(Pair("result", result));
reply.push_back(Pair("error", error));
reply.push_back(Pair("id", id));
return reply;
}
std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id)
{
UniValue reply = JSONRPCReplyObj(result, error, id);
return reply.write() + "\n";
}
UniValue JSONRPCError(int code, const std::string& message)
{
UniValue error(UniValue::VOBJ);
error.push_back(Pair("code", code));
error.push_back(Pair("message", message));
return error;
}
/** Username used when cookie authentication is in use (arbitrary, only for
* recognizability in debugging/logging purposes)
*/
static const std::string COOKIEAUTH_USER = "__cookie__";
/** Default name for auth cookie file */
static const std::string COOKIEAUTH_FILE = ".cookie";
fs::path GetAuthCookieFile()
{
fs::path path(GetArg("-rpccookiefile", COOKIEAUTH_FILE));
if (!path.is_complete()) path = GetDataDir() / path;
return path;
}
bool GenerateAuthCookie(std::string *cookie_out)
{
const size_t COOKIE_SIZE = 32;
unsigned char rand_pwd[COOKIE_SIZE];
GetRandBytes(rand_pwd, COOKIE_SIZE);
std::string cookie = COOKIEAUTH_USER + ":" + HexStr(rand_pwd, rand_pwd+COOKIE_SIZE);
/** the umask determines what permissions are used to create this file -
* these are set to 077 in init.cpp unless overridden with -sysperms.
*/
std::ofstream file;
fs::path filepath = GetAuthCookieFile();
file.open(filepath.string().c_str());
if (!file.is_open()) {
LogPrintf("Unable to open cookie authentication file %s for writing\n", filepath.string());
return false;
}
file << cookie;
file.close();
LogPrintf("Generated RPC authentication cookie %s\n", filepath.string());
if (cookie_out)
*cookie_out = cookie;
return true;
}
bool GetAuthCookie(std::string *cookie_out)
{
std::ifstream file;
std::string cookie;
fs::path filepath = GetAuthCookieFile();
file.open(filepath.string().c_str());
if (!file.is_open())
return false;
std::getline(file, cookie);
file.close();
if (cookie_out)
*cookie_out = cookie;
return true;
}
void DeleteAuthCookie()
{
try {
fs::remove(GetAuthCookieFile());
} catch (const fs::filesystem_error& e) {
LogPrintf("%s: Unable to remove random auth cookie file: %s\n", __func__, e.what());
}
}
|
[
"sirole@gmail.com"
] |
sirole@gmail.com
|
4c9203c8dbc3603cfecd04bfcba404489d925d40
|
c3869ba42919ce534216a7585931c0e0a8216955
|
/upp/uppsrc/Docking/Docking.h
|
9fb90dfc534461fcc96a531fefd0d9524cc621e6
|
[] |
no_license
|
RanJi0128/Chromium-customization
|
018c977c26a270387a2d9b3c1855a0668691b477
|
89b3550d7fc6f1b61f5e6023c293b82c521c509d
|
refs/heads/master
| 2020-07-13T01:31:26.499121
| 2019-08-29T07:07:17
| 2019-08-29T07:07:17
| 204,954,330
| 2
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 21,626
|
h
|
#ifndef _Docking_Docking_h_
#define _Docking_Docking_h_
#include <CtrlLib/CtrlLib.h>
#include <TabBar/TabBar.h>
namespace Upp {
class DockWindow;
#include "ToolWin.h"
#include "DockableCtrl.h"
#include "DockMenu.h"
#include "DockTabBar.h"
#include "DockCont.h"
#include "DockPane.h"
class DockWindow : public TopWindow {
public:
typedef DockWindow CLASSNAME;
enum {
DOCK_NONE = -1,
DOCK_LEFT = SplitterFrame::LEFT,
DOCK_TOP = SplitterFrame::TOP,
DOCK_RIGHT = SplitterFrame::RIGHT,
DOCK_BOTTOM = SplitterFrame::BOTTOM,
};
virtual void State(int reason);
virtual bool Key(dword key, int count);
protected:
enum { TIMEID_ACTION_CHECK = Ctrl::TIMEID_COUNT,
TIMEID_ANIMATE,
TIMEID_ANIMATE_DELAY,
TIMEID_COUNT };
// DnD interface
struct HighlightCtrl : public DockableCtrl {
HighlightCtrl() { BackPaint(); }
void ClearHighlight() { img.Clear(); buffer.Clear(); }
void SetHighlight(const Value& hl, bool _isnested, bool cannest, Image bg = Image());
void SetNested(bool _isnested);
void CreateBuffer();
virtual void Paint(Draw& w);
int oldframesize;
Rect bounds;
private:
Image img;
Image buffer;
bool isnested;
bool cannest;
const Value *highlight;
};
struct PosInfo : public Moveable<PosInfo> {
PosInfo() : state(DockCont::STATE_NONE) {}
DockCont::DockState state; // State info
Ptr<DockCont> tabcont;// Only valid when ctrl was tabbed
String data; // Serialized context info dependent on state
};
protected:
// Highlight control
virtual HighlightCtrl& GetHighlightCtrl() { return hlc; }
void StartHighlight(DockCont *dcptr);
void Highlight(int align, DockCont& cont, DockCont *target);
void StopHighlight(bool do_animatehl);
virtual bool NeedFrameReorder(int align);
bool IsReorderingFrames() { return prehighlightframepos >= 0; }
// Called by containers to signal drag-drop events
virtual void ContainerDragStart(DockCont& dc);
virtual void ContainerDragMove(DockCont& dc);
virtual void ContainerDragEnd(DockCont& dc);
// Container docking/undocking
void DockContainer(int align, DockCont& c, int pos = -1);
void DockAsTab(DockCont& target, DockableCtrl& dc);
void DockContainerAsTab(DockCont& target, DockCont& c, bool do_nested);
void FloatContainer(DockCont& c, Point p = Null, bool move = true);
void FloatFromTab(DockCont& c, DockableCtrl& tab) { FloatFromTab(c, *CreateContainer(tab)); }
void FloatFromTab(DockCont& c, DockCont& tab);
void AutoHideContainer(int align, DockCont& c);
void CloseContainer(DockCont& c);
DockCont *TabifyGroup(String group);
void Undock(DockCont& c);
void Unfloat(DockCont& c);
void Detach(DockCont& c) { Undock(c); Unfloat(c); }
// For finding drag-drop targets and computing boundary rect
DockCont *GetMouseDockTarget();
DockCont *FindDockTarget(DockCont& dc, int& al);
int FindDocker(const Ctrl *dc);
Rect GetAlignBounds(int al, Rect r, bool center, bool allow_lr = true, bool allow_tb = true);
int GetPointAlign(const Point p, Rect r, bool center, bool allow_lr = true, bool allow_tb = true);
int GetQuad(Point p, Rect r);
Rect GetFinalAnimRect(int align, Ctrl& c);
// Helpers
bool IsTL(int align) const { return align < 2; } //ie (align == DOCK_LEFT || align == DOCK_TOP)
bool IsTB(int align) const { return align & 1; } //ie (align == DOCK_TOP || align == DOCK_BOTTOM)
int GetDockAlign(const Ctrl& c) const;
int GetDockAlign(const Point& p) const;
int GetAutoHideAlign(const DockCont& c) const;
bool IsFrameAnimating(int align) const { return frameanim[align].inc; }
bool IsPaneAnimating(int align) const { return dockpane[align].IsAnimating(); }
bool CheckNesting() const { return (GetMouseFlags() & nesttoggle) ? !nestedtabs : nestedtabs; }
void DoHotKeys(dword key);
void SaveDockerPos(DockableCtrl& dc, PosInfo& pi);
void SetDockerPosInfo(DockableCtrl& dc, const PosInfo& pi);
friend class DockCont;
private:
bool init;
bool tabbing;
bool autohide;
bool animatehl;
bool animatefrm;
bool animatewnd;
bool nestedtabs;
bool grouping;
bool menubtn;
bool closebtn;
bool hidebtn;
bool dockable[4];
bool locked;
bool tabtext;
bool tabalign;
bool frameorder;
bool showlockedhandles;
bool childtoolwindows;
dword nesttoggle;
String layoutbackup;
int dockframepos;
int prehighlightframepos;
Array<DockCont> conts;
Vector<DockableCtrl *> dockers;
ArrayMap<String, String> layouts;
Array<DockableCtrl> ctrls;
HighlightCtrl hlc;
DockPane dockpane[4];
SplitterFrame dockframe[4];
AutoHideBar hideframe[4];
DockMenu menu;
Vector<PosInfo> dockerpos;
struct FrameAnim {
FrameAnim() : target(0), inc(0) {}
int target;
int inc;
};
FrameAnim frameanim[4];
int animdelay;
public:
// If you are attaching DockableCtrls programmatically it must be done in an overloaded DockInit.
// It is called after Ctrl::OPEN in order so that docking can be done with the correct window size.
virtual void DockInit() { }
// Attaches all the required frames to the DockWindow.
// It is called internally on Ctrl::Open so should not usually be needed
void DockLayout(bool tb_precedence = true);
// Functions for registering/deregistering externally owned DockableCtrls
// NOTE: Registering is automatically done when using Dock/Float etc functions, but Register
// also be called before DockInit (eg in constructor), and are prefered if you are only going
// to be serializing the DockWindow layout
DockableCtrl& Register(DockableCtrl& dc);
void Deregister(const DockableCtrl& dc);
// Creates an internal DockableCtrl for you to allow simple wrapping of GUI elements
DockableCtrl& Dockable(Ctrl& ctrl, WString title);
DockableCtrl& Dockable(Ctrl& ctrl, const char *title = 0) { return Dockable(ctrl, (WString)title); }
// More flexible methods for creating internally stored DockableCtrl derived classes
template<class T>
T& CreateDockable(WString title);
template<class T>
T& CreateDockable(const char *title = 0) { return CreateDockable<T>((WString)title); }
// Get a list of all registered DockableCtrls (including externally owned ones
const Vector<DockableCtrl *>& GetDockableCtrls() const { return dockers; }
// Simple docking control
void DockLeft(DockableCtrl& dc, int pos = -1) { Dock(DOCK_LEFT, dc, pos); }
void DockTop(DockableCtrl& dc, int pos = -1) { Dock(DOCK_TOP, dc, pos); }
void DockRight(DockableCtrl& dc, int pos = -1) { Dock(DOCK_RIGHT, dc, pos); }
void DockBottom(DockableCtrl& dc, int pos = -1) { Dock(DOCK_BOTTOM, dc, pos); }
void Dock(int align, DockableCtrl& dc, int pos = -1);
// Attaches 'dc' as a tab to 'target', wherever it may be
void Tabify(DockableCtrl& target, DockableCtrl& dc);
// Detaches the passed ctrl as a floating window
void Float(DockableCtrl& dc, Point p = Null);
void Float(DockableCtrl& dc, const char *title, Point p = Null);
// Attaches the passed ctrl to the autohide frames on the window edges
// If no alignment is given the ctrl will be autohidden where it is docked or to the top bar if not docked
void AutoHide(DockableCtrl& dc);
void AutoHide(int align, DockableCtrl& dc);
// Closes the window, detaching it from and docking panes or autohide frames.
// This just 'hides' the window, it can be opened again at any time.
void Close(DockableCtrl& dc);
// Activate the passed ctrl. If open this will make sure it's the active tab, if
// closed the ctrls last known position will be restored (see RestoreDockerPos)
void ActivateDockable(Ctrl& c);
// As above, but you can pass any child ctrl of the DockableCtrl (useful with the Dockable functions)
void ActivateDockableChild(Ctrl& c);
// When DockableCtrls change state a record of their last position is stored internally.
// These functions can restore the previous DockableCtrl's postion of force a save of the current one
void SaveDockerPos(DockableCtrl& dc);
void RestoreDockerPos(DockableCtrl& dc, bool savefirst = false);
// Toggle window visibility. If the window is open it is hidden, if it is hidden it is restored
void HideRestoreDocker(DockableCtrl& dc);
// Group docking ctrl. These work the same way as for single DockableCtrls but apply to the passed group
// TabDockGroup and DockGroup will respect the DockAllowed settings for DockableCtrls
void DockGroup(int align, String group, int pos = -1);
void FloatGroup(String group);
void AutoHideGroup(int align, String group);
void AutoHideGroup(String group);
void TabFloatGroup(String group);
void CloseGroup(String group);
void TabDockGroup(int align, String group, int pos = -1);
// These variants of DockGroup and DockTabGroup ignore the DockAllowed settings
void ForceDockGroup(int align, String group, int pos = -1);
void ForceTabDockGroup(int align, String group, int pos = -1);
// Check docking frame visibility. If there are no docked ctrls it will be invisibly
bool IsDockVisible(int align) const { ASSERT(align >= 0 && align <= 4); return dockpane[align].IsVisible(); }
// Manually sets the size of a docking frame
void SetFrameSize(int align, int size);
// Animation settings. Disabling various forms of animation can improve performance when
// you have complex displays/GUIs in either DockableCtrls of the DockWindow client area
DockWindow& AnimateDelay(int ms) { animdelay = max(ms, 0); return *this; }
DockWindow& Animate(bool highlight = true, bool frames = true, bool windows = true, int ticks = 10, int interval = 20);
DockWindow& NoAnimate() { return Animate(false, false); }
bool IsAnimated() const { return animatehl || animatewnd; }
bool IsAnimatedHighlight() const { return animatehl; }
bool IsAnimatedFrames() const { return animatefrm; }
bool IsAnimatedWindows() const { return animatewnd; }
// Lock control. When the layout is locked the user cannot use the drag-drop functionality, the
// title bar buttons or the titlebar context menus. ShowLockedHandles determines whether the
// title bar is shown on docked ctrls when the layout is locked.
void LockLayout(bool lock = true);
void UnlockLayout() { LockLayout(true); }
bool IsLocked() const { return locked; }
DockWindow& ShowLockedHandles(bool show = true) { showlockedhandles = show; SyncAll(); return *this; }
bool IsShowingLockedHandles() const { return showlockedhandles; }
// Enableing TabAutoAlign will move docked tab bars depending on where their contained is docked.
// For instance, a collection of controls docked one the left edge will have it's tab bar moved
// to its ;left hand side
DockWindow& TabAutoAlign(bool al = true);
// If this is disabled only icons will be shown when windows are tabbed (in containers of autohidden)
DockWindow& TabShowText(bool text = true);
// Enable/Disable tabbing support
DockWindow& Tabbing(bool _tabbing = true) { tabbing = _tabbing; return *this; }
DockWindow& NoTabbing() { return Tabbing(false); }
bool IsTabbing() const { return tabbing; }
// Enable/Disable multi-layer tab support (groups of tabs stored as a tab in another group)
// When enabled the user can use this function by holding NestedToggleKey during a drag-drop
DockWindow& NestedTabs(bool _nestedtabs = true) { nestedtabs = _nestedtabs; return *this; }
DockWindow& NoNestedTabs() { return NestedTabs(false); }
bool IsNestedTabs() const { return nestedtabs; }
dword NestedToggleKey() { return nesttoggle; }
DockWindow& SetNestedToggleKey(dword key) { nesttoggle = key; return *this; }
// Enable/Disable grouping support
DockWindow& Grouping(bool grouping = true);
DockWindow& NoGrouping() { return Grouping(false); }
bool IsGrouping() const { return grouping; }
// Allows the user to change docking frame precedence/ordering. By default the left and right
// frames take precedence over the top/bottom frames (meaning they occupy the entire height of the window)
// When this option is enabled the user chan change this by dragging to the appropriate corner of the frame
DockWindow& FrameReordering(bool reorder = true){ frameorder = reorder; return *this;}
DockWindow& NoFrameReordering() { return FrameReordering(false); }
bool IsFrameReordering() const { return frameorder; }
DockWindow& SetFrameOrder(int first, int second = DOCK_NONE, int third = DOCK_NONE, int fourth = DOCK_NONE);
// Allow/Block docking to particular sides of the DockWindow. This works in conjunction with
// the settings in the DockableCtrl class.
DockWindow& AllowDockAll();
DockWindow& AllowDockNone();
DockWindow& AllowDockLeft(bool v = true) { dockable[DOCK_LEFT] = v; return *this; }
DockWindow& AllowDockTop(bool v = true) { dockable[DOCK_TOP] = v; return *this; }
DockWindow& AllowDockRight(bool v = true) { dockable[DOCK_RIGHT] = v; return *this; }
DockWindow& AllowDockBottom(bool v = true) { dockable[DOCK_BOTTOM] = v; return *this; }
DockWindow& AllowDock(int a, bool v = true) { ASSERT(a >= 0 && a < 4); dockable[a] = v; return *this; }
bool IsDockAllowed(int align) const { ASSERT(align >= 0 && align < 4); return dockable[align]; }
bool IsDockAllowed(int align, DockableCtrl& dc) const;
bool IsDockAllowedLeft() const { return dockable[DOCK_LEFT]; }
bool IsDockAllowedTop() const { return dockable[DOCK_TOP]; }
bool IsDockAllowedRight() const { return dockable[DOCK_RIGHT]; }
bool IsDockAllowedBottom() const { return dockable[DOCK_BOTTOM]; }
bool IsDockAllowedAny() const { return dockable[DOCK_LEFT] || dockable[DOCK_TOP]
|| dockable[DOCK_RIGHT] || dockable[DOCK_BOTTOM]; }
bool IsDockAllowedNone() const { return !IsDockAllowedAny(); }
// Enable/Disable the AutoHide functions
DockWindow& AutoHide(bool v = true);
bool IsAutoHide() { return autohide; }
// Determines which buttons are visible on docked/autohidden DockableCtrl title bars
DockWindow& WindowButtons(bool menu, bool hide, bool close);
bool HasMenuButtons() const { return menubtn; }
bool HasHideButtons() const { return hidebtn; }
bool HasCloseButtons() const { return closebtn; }
// When enabled (default) floating DockableCtrl windows are set to be tool windows
// (exactly what this means varies between OSs)
void ChildToolWindows(bool v = true) { childtoolwindows = v; SyncAll(); }
bool HasToolWindows() const { return childtoolwindows; }
// Opens the standard Docking Configuration dialog (see DockConfig)
void DockManager();
// Returns the standard Docking menu so that an application can add it to it's main menu bar
void DockWindowMenu(Bar& bar);
// SerializeWindow serialized both the DockWindow layout and the window position/state (using TopWindow::SerializePlacement)
void SerializeWindow(Stream& s);
// SerializeLayout only serializes the DockQWindow layout
void SerializeLayout(Stream& s, bool withsavedlayouts = true);
// Saves/Load/Manage dockwindow layouts. Theese are handy for saving different
// GUI configurations for different application states (like editing/debugging)
int SaveLayout(String name);
void LoadLayout(int ix);
void LoadLayout(String name);
void DeleteLayout(String name) { layouts.RemoveKey(name); }
String GetLayoutName(int ix) const { return layouts.GetKey(ix); }
int LayoutCount() const { return layouts.GetCount(); }
const ArrayMap<String, String>& GetLayouts() const { return layouts; }
// Serializes/Loads layout to/from an internal buffer (used for cancelling changes in the DockConfig window)
// The difference between this and Save/LoadLayout is that it also backs-up the saved layouts
void BackupLayout();
void RestoreLayout();
// This enables/disables all floating windows. This can be used to prevent the user
// moving windows when a dialog is visible (like DockConfig)
void DisableFloating() { EnableFloating(false); }
void EnableFloating(bool enable = true);
// Changes the Chameleon style for the highlight ctrl
void SetHighlightStyle(DockableCtrl::Style& s) { GetHighlightCtrl().SetStyle(s); }
// Constructer
DockWindow();
private:
// Container management
DockCont *GetContainer(Ctrl& dc) { return dynamic_cast<DockCont *>(dc.GetParent()); }
DockCont *CreateContainer();
DockCont *CreateContainer(DockableCtrl& dc);
void DestroyContainer(DockCont& c);
DockCont *GetReleasedContainer(DockableCtrl& dc);
void SyncContainer(DockCont& c);
void SyncAll();
// Helpers
void Dock0(int align, Ctrl& c, int pos, bool do_animatehl = false, bool ishighlight = false);
void Dock0(int align, Ctrl& c, int pos, Size sz, bool do_animatehl = false, bool ishighlight = false);
void Undock0(Ctrl& c, bool do_animatehl = false, int fsz = -1, bool ishighlight = false);
void Activate(DockableCtrl& dc);
void DoFrameSize(bool animate, int align, int targetsize);
void FrameAnimateTick();
void DoFrameReorder(int align);
void UndoFrameReorder();
Size CtrlBestSize(const Ctrl& c, int align, bool restrict = true) const;
void ClearLayout();
};
class PopUpDockWindow : public DockWindow {
public:
struct Style : ChStyle<Style> {
Value inner[5];
Value outer[4];
Value hide[4];
Value highlight;
int innersize;
int outersize;
};
static const Style& StyleDefault();
protected:
virtual void ContainerDragStart(DockCont& dc);
virtual void ContainerDragMove(DockCont& dc);
virtual void ContainerDragEnd(DockCont& dc);
private:
struct PopUpButton : public Ctrl {
const Value *icon;
const Value *hlight;
virtual void Paint(Draw& w) { Rect r = GetSize(); ChPaint(w, r, *icon); if (hlight) ChPaint(w, r, *hlight); }
PopUpButton() { hlight = NULL; }
};
const Style *style;
DockCont *last_target;
PopUpButton *last_popup;
PopUpButton inner[5];
PopUpButton outer[4];
PopUpButton hide[4];
bool showhide;
int PopUpHighlight(PopUpButton *pb, int cnt);
void ShowOuterPopUps(DockCont& dc);
void ShowInnerPopUps(DockCont& dc, DockCont *target);
void ShowPopUp(PopUpButton& pb, const Rect& r);
void HidePopUps(bool _inner, bool _outer);
public:
PopUpDockWindow& SetStyle(const Style& s);
PopUpDockWindow();
PopUpDockWindow& AutoHidePopUps(bool v = true) { showhide = v; return *this; }
};
#define LAYOUTFILE <Docking/Docking.lay>
#include <CtrlCore/lay.h>
class DockConfigDlg : public WithDockConfigLayout<TopWindow>
{
public:
typedef DockConfigDlg CLASSNAME;
DockConfigDlg(DockWindow& dockwindow);
private:
DockWindow & dock;
const Vector<DockableCtrl *>& dockers;
VectorMap<String, int> groups;
DockMenu menu;
String backup;
int all;
DockableCtrl *highlight;
void RefreshTree(bool dogroups = false);
void OnTreeContext(Bar& bar);
void OnSaveLayout();
void OnLoadLayout();
void OnDeleteLayout();
void OnTreeCursor();
void OnListCursor();
void OnNewGroup();
void OnDeleteGroup();
void OnOK();
void OnCancel();
void OnLock();
void OnTreeDrag();
void OnTreeDrop(int parent, int ii, PasteClip& d);
void Highlight(DockableCtrl *dc);
void StopHighlight();
void DeleteGroup(int id);
String DockerString(DockableCtrl *dc) const;
String PositionString(DockableCtrl *dc) const;
int ListIndex() const;
void DupePrompt(String type);
};
template <class T>
T& DockWindow::CreateDockable(WString title)
{
T &q = ctrls.Create<T>();
Register(q.Title(title));
return q;
}
}
#endif
|
[
"you@example.com"
] |
you@example.com
|
9b63ca09918d20b1c9366b3706b22d7881b90c17
|
1a749e90a8a70df85d027cba362dc517e901b8a0
|
/linear.cpp
|
867acadf1a00b5907b121cbf4765231cdf8432da
|
[] |
no_license
|
kunalkumar37/c-programming
|
2cb11bd9b96ea86a1fa4dc5eff031e217d54661a
|
d3c02753cdea628774484da4fb331b4a4057078d
|
refs/heads/master
| 2023-07-13T05:01:46.989537
| 2021-08-20T10:51:28
| 2021-08-20T10:51:28
| 310,206,689
| 2
| 1
| null | 2021-08-20T10:51:29
| 2020-11-05T06:13:27
|
C++
|
UTF-8
|
C++
| false
| false
| 441
|
cpp
|
#include<iostream>
#include<climits>
using namespace std;
int main()
{
int n;
cin>>n;
int arr[n];
for(int i=1;i<=n;i++)
{
cin>>arr[i];
}
int maxno=INT_MIN;
int minno=INT_MAX;
for(int i=0;i<n;i++)
{
if(arr[i]>maxno)
{
maxno=arr[i];
}
if(arr[i]<minno)
{
minno=arr[i];
}
}
cout<<maxno<<endl<<minno;
return 0;
}
|
[
"61112064+kunalkumar37@users.noreply.github.com"
] |
61112064+kunalkumar37@users.noreply.github.com
|
8b99460b41621dab359dbcb60e47ae2c33bd858e
|
3bc55e096d0a9fd5b70de6838d5c127bf45e3bf2
|
/double_dispatch1.cpp
|
4531bcae7b0c39845b17dfce15ed30a4e66cb510
|
[
"MIT"
] |
permissive
|
mjaimin/design_patterns
|
90975441c6e2442bd4f5991904cd713b18953e84
|
0d5ebcbb0e8a71bf31f7ea3bf3f308837cf72b76
|
refs/heads/master
| 2022-04-01T16:04:11.735641
| 2020-01-06T02:10:45
| 2020-01-06T02:10:45
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,896
|
cpp
|
// Double dispatching via virtual functions
#include <iostream>
#include <memory>
#include <string>
class Cat;
class Bird;
class Dog;
struct IAnimal
{
virtual std::string name() const = 0;
virtual void play(const IAnimal&) const = 0;
virtual void play(const Cat&) const = 0;
virtual void play(const Bird&) const = 0;
virtual void play(const Dog&) const = 0;
virtual ~IAnimal() = default;
};
class Cat: public IAnimal
{
public:
std::string name() const override
{
return "Cat";
}
void play(const IAnimal& animal) const override
{
animal.play(*this); // double dispatching
}
void play(const Cat&) const override;
void play(const Dog&) const override;
void play(const Bird&) const override;
};
class Dog: public IAnimal
{
public:
std::string name() const override
{
return "Dog";
}
void play(const IAnimal& animal) const override
{
animal.play(*this); // double dispatching
}
void play(const Cat&) const override;
void play(const Dog&) const override;
void play(const Bird&) const override;
};
class Bird: public IAnimal
{
public:
std::string name() const override
{
return "Bird";
}
void play(const IAnimal& animal) const override
{
animal.play(*this); // double dispatching
}
void play(const Cat&) const override;
void play(const Dog&) const override;
void play(const Bird&) const override;
};
void Cat::play(const Cat& cat) const
{
std::cout << name() << " plays with " << cat.name() << '\n';
}
void Cat::play(const Bird& bird) const
{
std::cout << name() << " plays with " << bird.name() << '\n';
}
void Cat::play(const Dog& dog) const
{
std::cout << name() << " plays with " << dog.name() << '\n';
}
void Dog::play(const Cat& cat) const
{
std::cout << name() << " plays with " << cat.name() << '\n';
}
void Dog::play(const Bird& bird) const
{
std::cout << name() << " plays with " << bird.name() << '\n';
}
void Dog::play(const Dog& dog) const
{
std::cout << name() << " plays with " << dog.name() << '\n';
}
void Bird::play(const Cat& cat) const
{
std::cout << name() << " plays with " << cat.name() << '\n';
}
void Bird::play(const Bird& bird) const
{
std::cout << name() << " plays with " << bird.name() << '\n';
}
void Bird::play(const Dog& dog) const
{
std::cout << name() << " plays with " << dog.name() << '\n';
}
void play(const IAnimal& first, const IAnimal& second)
{
second.play(first);
}
int main()
{
std::unique_ptr<IAnimal> upCat{std::make_unique<Cat>()};
std::unique_ptr<IAnimal> upDog{std::make_unique<Dog>()};
std::unique_ptr<IAnimal> upBird{std::make_unique<Bird>()};
play(*upCat, *upDog);
play(*upCat, *upBird);
play(*upDog, *upBird);
play(*upDog, *upCat);
play(*upBird, *upCat);
play(*upBird, *upDog);
}
|
[
"vsoftco@gmail.com"
] |
vsoftco@gmail.com
|
939aec2ebbb2ee99895dbcc243c6c34be1eef793
|
fb6ecd662c1b7eb156df99d3b1dbaa3702e17244
|
/include/gals/input-fields/levelset.h
|
b3f973fdba5a601b829e316a75b9eb86c869d5c6
|
[
"BSD-3-Clause"
] |
permissive
|
acrlakshman/gradient-augmented-levelset-cuda
|
440176d6f2906fc00cc55fae861a443867949995
|
63f4b7225940fabd5a3145a0faa97bdcfc9b4e6e
|
refs/heads/master
| 2020-04-21T05:48:58.879857
| 2019-07-29T15:22:26
| 2019-07-29T15:22:26
| 169,350,742
| 1
| 0
|
BSD-3-Clause
| 2019-08-18T19:04:29
| 2019-02-06T03:35:56
|
C++
|
UTF-8
|
C++
| false
| false
| 2,220
|
h
|
///////////////////////////////////////////////////////////////////////////////
// Copyright 2019 Lakshman Anumolu, Raunak Bardia.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors
// may be used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
///////////////////////////////////////////////////////////////////////////////
#pragma once
#include "gals/utilities/vec3.h"
#include <string>
namespace GALS
{
namespace INPUT_FIELDS
{
struct Levelset {
std::string name; //! Name of levelset field.
GALS::CPU::Vec3<double> center; //! Center of levelset field for few levelset types.
double radius; //! Radius of levelset field for few object types.
std::string gradient_scheme; //! Scheme to compute gradient of levelset field.
};
} // namespace INPUT_FIELDS
} // namespace GALS
|
[
"acrlakshman@yahoo.co.in"
] |
acrlakshman@yahoo.co.in
|
59b809e7464365b10fdbe79497ef8bc335ad16ed
|
1f013e822124dfe9b4611f1fe08675a23871566e
|
/home/TomaszGusciora/z1/LAN.cpp
|
65277a4f2570107579360ad0ff82ef6cdccd2605
|
[] |
no_license
|
dtraczewski/zpk2014
|
a1d9a26d25ff174561e3b20c8660901178d827a5
|
548970bc5a9a02215687cb143d2f3f44307ff252
|
refs/heads/master
| 2021-01-21T06:06:32.044028
| 2015-09-06T12:17:07
| 2015-09-06T12:17:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 141
|
cpp
|
#include <iostream>
using namespace std;
int main(){
int nr,rok;
cin >> nr >> rok;
cout << ((nr % 10) * 2 + 5) * 50 + 1764 - rok << endl;
}
|
[
"tgusciora@student.uw.edu.pl"
] |
tgusciora@student.uw.edu.pl
|
78e01f84b733ee0c20708ab3fa9e620181fa3e21
|
2c738fe6fef5ffcd24af68f35257ec9d6359710f
|
/src/signALib/SAVariantCaster.h
|
0132a4f626990992c147cf1227c6b583170558ff
|
[] |
no_license
|
zxqdlenovo/sa
|
6fffb1e61ac698f9bce4698993fa7b8abc06fd99
|
ce22face1da284070dd44681f6b34b8eb867f781
|
refs/heads/master
| 2020-03-18T19:11:11.815652
| 2018-04-24T05:54:40
| 2018-04-24T05:54:40
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,074
|
h
|
#ifndef SAVARIANTCASTER_H
#define SAVARIANTCASTER_H
#include <QVariant>
#include <QIODevice>
#include "SALibGlobal.h"
///
/// \brief 扩展QVariant的转换
///
class SALIB_EXPORT SAVariantCaster
{
public:
SAVariantCaster();
static QString variantToString(const QVariant& var);
static QVariant stringToVariant(const QString& var, const QString& typeName);
template<typename T>
static QString converVariantToBase64String(const QVariant& var)
{
if(var.canConvert<T>())
{
QByteArray byte;
QDataStream st(&byte,QIODevice::ReadWrite);
T ba = var.value<T>();
st << ba;
return QString(byte.toBase64());
}
return QString();
}
template<typename T>
static QVariant converBase64StringToVariant(const QString& base64)
{
QByteArray byte = QByteArray::fromBase64(base64.toLocal8Bit());
QDataStream st(&byte,QIODevice::ReadWrite);
T ba;
st >> ba;
return QVariant::fromValue(ba);
}
};
#endif // SAVARIANTCASTER_H
|
[
"czy.t@163.com"
] |
czy.t@163.com
|
697e62f43e1cf2d5cd7669e3e70d567f24f2db7a
|
85e7114ea63a080c1b9b0579e66c7a2d126cffec
|
/SDK/SoT_BP_Eye_Col_Brown_03_Desc_classes.hpp
|
30b47f4a0da02dcd6b4b53771aae062b0e26ce51
|
[] |
no_license
|
EO-Zanzo/SeaOfThieves-Hack
|
97094307d943c2b8e2af071ba777a000cf1369c2
|
d8e2a77b1553154e1d911a3e0c4e68ff1c02ee51
|
refs/heads/master
| 2020-04-02T14:18:24.844616
| 2018-10-24T15:02:43
| 2018-10-24T15:02:43
| 154,519,316
| 0
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 734
|
hpp
|
#pragma once
// Sea of Thieves (1.2.6) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "SoT_BP_eye_col_brown_03_Desc_structs.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass BP_eye_col_brown_03_Desc.BP_eye_col_brown_03_Desc_C
// 0x0000 (0x00E0 - 0x00E0)
class UBP_eye_col_brown_03_Desc_C : public UClothingDesc
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindObject<UClass>("BlueprintGeneratedClass BP_eye_col_brown_03_Desc.BP_eye_col_brown_03_Desc_C");
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"zp2kshield@gmail.com"
] |
zp2kshield@gmail.com
|
8c152f80717ccf4e8547ce7b32c2ac01b2e2e8cb
|
7970d87f6871c5562db95ea91439054dbea1e333
|
/GameObject.h
|
bd8427332613097f98b3d3844ca080a2f31edcd2
|
[] |
no_license
|
rkqls00/D2D1
|
6493303ac0afcc25127786e09462f36638fe1aa3
|
0dbde18bfcca2b1590ae71b80a11adc014a25691
|
refs/heads/master
| 2022-11-26T11:39:23.835884
| 2020-08-02T12:27:11
| 2020-08-02T12:27:11
| 284,225,348
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 901
|
h
|
#pragma once
class CGameObject : public IGameObject //0504
{
protected:
D2D1_POINT_2F m_Pos; //위치
CSprite* m_Sprite; //이미지
D2D1_POINT_2F m_BPos;
public:
D2D1_POINT_2F m_Scale; //크기
D2D1_RECT_F m_rTiled; //사이즈
INT m_tag;
CStringW m_Name; //이름
BOOL m_isLive; //죽음? 살음?
INT m_PLife; //플레이어의 생명
INT m_BLife; //보스 생명
INT m_Option;
CGameObject(LPCWSTR sFileName, D2D1_POINT_2F Pos, int sprWidth, int sprHeight, int tag);
virtual ~CGameObject(void);
virtual void Render() override; //비어있어도 정의는 해야됨
virtual void FrameMove(DWORD elapsed) override; //비어있어도 정의는 해야됨
virtual void Control( CInput* Input) override; //07 //비어있어도 정의는 해야됨
D2D1_POINT_2F GetPos() { return m_Pos; }
};
|
[
"53118916+gabin00@users.noreply.github.com"
] |
53118916+gabin00@users.noreply.github.com
|
ce3b48135d568d3503558bebfc0694f523b72d87
|
b6607ecc11e389cc56ee4966293de9e2e0aca491
|
/codeforces.com/Contests/160 div 2/A/A.cpp
|
2a191ea1cc56e5f169afc2da77f930d67143566e
|
[] |
no_license
|
BekzhanKassenov/olymp
|
ec31cefee36d2afe40eeead5c2c516f9bf92e66d
|
e3013095a4f88fb614abb8ac9ba532c5e955a32e
|
refs/heads/master
| 2022-09-21T10:07:10.232514
| 2021-11-01T16:40:24
| 2021-11-01T16:40:24
| 39,900,971
| 5
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,087
|
cpp
|
/****************************************
** Solution by Bekzhan Kassenov **
****************************************/
#include <iostream>
#include <cstdio>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <list>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <iomanip>
using namespace std;
#define PII pair <int, int>
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define VI vector <int>
#define sqr(x) (x) * (x)
#define INF (int) (2e9)
#define MOD (1000 * 1000 * 1000 + 7)
#define ull unsigned long long
#define ll long long
int cnt(int n)
{
int ans = 0;
while (n)
{
if (n % 10 == 4 || n % 10 == 7)
ans++;
n /= 10;
}
return ans;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("in", "r", stdin);
#endif
int n, k;
cin >> n >> k;
int ans = 0;
int x;
for (int i = 0; i < n ;i++)
{
cin >> x;
if (cnt(x) <= k)
ans++;
}
cout << ans;
return 0;
}
|
[
"bekzhan.kassenov@nu.edu.kz"
] |
bekzhan.kassenov@nu.edu.kz
|
f4dadd70b3f2e23d9c1798ec721f467493bdab58
|
f005b1511ca69533ee31649a2a921f0238aea784
|
/cxx/indexer/cxx/testdata/template/template_var_ps_completes.cc
|
ca6d858c57e3101f975774435318d37d89f88da0
|
[
"Apache-2.0"
] |
permissive
|
gameduell/kythe
|
8bce30ab0dd7ad968754702357bc853ca247181a
|
be21e512a21d8e37604d6a9d373a963ad9cf4f6d
|
refs/heads/master
| 2016-09-05T23:21:04.111891
| 2015-07-24T14:10:32
| 2015-07-24T14:10:32
| 39,763,950
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 270
|
cc
|
// Checks completion edges for variable template partial specializations.
template <typename T, typename S> extern T z;
//- @z defines VarZPsAbsDecl
template <typename U> extern int z<int, U>;
//- @z completes/uniquely VarZPsAbsDecl
template <typename U> int z<int, U>;
|
[
"itar@dl-pir.office.gameduell.de"
] |
itar@dl-pir.office.gameduell.de
|
acbe9f00e126d5788b6727a2a79b97e966a057cc
|
a265e6cb1bb132d551cf1bba068bf3357d81ce1c
|
/SimpleTrees/trees.h
|
10aa93882a035b0ab10c17b6cb40d1105ee824c6
|
[] |
no_license
|
Can-ZHOU/CS2LL3
|
50eee24530251be98db3348ba1b24c6f19bedc0c
|
1c0d6d4ef6da3a02ac9c8473d4ac917403535b2d
|
refs/heads/master
| 2022-11-22T00:12:32.091726
| 2020-07-24T16:37:07
| 2020-07-24T16:37:07
| 257,650,144
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 942
|
h
|
#include "rules.h"
#include <fstream>
using namespace std;
#if !defined TREE_H
#define TREE_H
//! a node in a syntax tree
class Tree {
public:
Category mother; //!< label of node in a tree
vector<Tree *> dtrs; //!< the daughters of the node, each being a dynamically allocated Tree pointer
Tree(void);
~Tree(void);
Tree(Category c); //!< sets mother to c
Tree(Category m, vector<Tree *> ds);
// pertaining to drawing the output
void drawtree(void); //!< shows the tree on standard output with standard ascii characters
void draw_just_top(void); //!< shows the top-layer on standard output with standard ascii characters
void dot_tree(void); //!< uses the dot program and ghostscript to show tree in graphical way
void dot_tree(ostream& f);
static int node_count;
private:
void drawdtrs(vector<Tree *> dtrs, string prefix);
void drawtree(Tree *t, int prefix);
void printspaces(int prefix);
};
#endif
|
[
"zhoucan1999@outlook.com"
] |
zhoucan1999@outlook.com
|
004c14afa6a1bf3d004fc75012742eb415995ed0
|
02095cd4aeaa3a0d724f7362cdb8795fe9a81620
|
/oplink/algorithms/team/src/skeleton/utils/fuzzylite/src/term/Gaussian.cpp
|
153095a7aa455fc056c88fc803fdce9f34cdcd28
|
[] |
no_license
|
PAL-ULL/software-metco
|
ba5123cb1423fed4a2ac678ab375728ba4bbfbc8
|
59edc4e49bddbd9fc7237bf2f24271bdfc8afd79
|
refs/heads/master
| 2021-04-15T04:12:56.292543
| 2021-03-08T13:29:14
| 2021-03-08T13:29:14
| 126,484,450
| 10
| 5
| null | 2020-07-21T18:43:10
| 2018-03-23T12:49:10
|
C++
|
UTF-8
|
C++
| false
| false
| 1,889
|
cpp
|
/* Copyright 2013 Juan Rada-Vilela
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.
*/
/*
* Gaussian.cpp
*
* Created on: 29/11/2012
* Author: jcrada
*/
#include "fl/term/Gaussian.h"
#include <cmath>
#include <sstream>
namespace fl {
Gaussian::Gaussian(const std::string& name,
scalar mean, scalar sigma)
: Term(name), _mean(mean), _standardDeviation(sigma) {
}
Gaussian::~Gaussian() {
}
std::string Gaussian::className() const {
return "Gaussian";
}
Gaussian* Gaussian::copy() const {
return new Gaussian(*this);
}
scalar Gaussian::membership(scalar x) const {
if (fl::Op::isNan(x)) return fl::nan;
return std::exp((-(x - _mean) * (x - _mean)) / (2 * _standardDeviation * _standardDeviation));
}
std::string Gaussian::toString() const {
std::ostringstream ss;
ss << className()
<< " (" <<fl::Op::str( _mean) << ", "
<< fl::Op::str(_standardDeviation) << ")";
return ss.str();
}
void Gaussian::setMean(scalar c) {
this->_mean = c;
}
scalar Gaussian::getMean() const {
return this->_mean;
}
void Gaussian::setStandardDeviation(scalar sigma) {
this->_standardDeviation = sigma;
}
scalar Gaussian::getStandardDeviation() const {
return this->_standardDeviation;
}
}
|
[
"edusegre@gmail.com"
] |
edusegre@gmail.com
|
9b14e12e1c3e166cc2a814f722840526661dc145
|
1aacdaac8e30f7571be9b21e5b3f8deba16fc5ea
|
/practice_problems/toffee.cpp
|
d78bfc980c7f8c188a7ed415058a7df77171572e
|
[] |
no_license
|
Priyam1207/Placement_practice_ques
|
216beb53e71e59554cf7654461d0594b5395a4e1
|
b243f3d563da4b21825661fdb46329e69bd4c8ba
|
refs/heads/main
| 2023-06-14T15:40:52.349660
| 2021-07-12T11:31:16
| 2021-07-12T11:31:16
| 381,821,067
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 403
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int>kids(n);
for(int i=0; i < n;i++){
cin >> kids[i];
}
int max = *max_element(kids.begin(), kids.end());
int extra;
cin >> extra;
for(int i=0; i <n;i++){
if(kids[i]+extra >= max)
cout << "true ";
else
cout << "false ";
}
}
|
[
"noreply@github.com"
] |
Priyam1207.noreply@github.com
|
bce79249197ec720c090c0db8b2bdb932a8a5f4e
|
a743342cf4057a7c2cc573e79602bf89c00b3579
|
/GraphViewer/GrClock.cpp
|
95a38c8ac533ff9e2dec8bbc810f39cd56158392
|
[] |
no_license
|
prografix/prografix.github.io
|
deddc17515c93566616e74b292b7e4fb1136064f
|
4f316beb0fa24b98aec8eb127bd294c012c60538
|
refs/heads/master
| 2023-07-25T09:48:34.670827
| 2023-07-09T13:55:25
| 2023-07-09T13:55:25
| 166,195,307
| 3
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 895
|
cpp
|
#include "GrClock.h"
#include "time.h"
GrClock::GrClock() : bBack(false), bPause(false)
{
pre_clock = clock();
cur_tick = 0;
}
long GrClock::get()
{
if ( bPause == false )
{
long cur_clock = clock();
long cl = cur_clock - pre_clock;
pre_clock = cur_clock;
if ( bBack )
{
cur_tick -= cl;
if ( cur_tick < 0 ) cur_tick = 0;
}
else
{
cur_tick += cl;
}
}
return cur_tick;
}
void GrClock::back()
{
if ( bPause )
{
bPause = false;
pre_clock = clock();
}
bBack = true;
}
void GrClock::begin()
{
pre_clock = clock();
cur_tick = 0;
}
void GrClock::pause()
{
bPause = true;
}
void GrClock::forward()
{
if ( bPause )
{
bPause = false;
pre_clock = clock();
}
bBack = false;
}
GrClock grClock;
|
[
"shevchenka@narod.ru"
] |
shevchenka@narod.ru
|
c602a022e747f23f7fbfc8b6e94fa59f9f89ee00
|
48c27471b8d5aa435ae7ff45f74ba88576a9b68a
|
/src/qt/guiutil.cpp
|
2e58d1499f121efba105f815b26e4d23db9fc549
|
[
"MIT"
] |
permissive
|
eysho/BestKnownGame-Coins---Source
|
591798ee8c561212756032d5c945838f724c702b
|
32cfcbdd9ce45671fcab93133628982470c91cff
|
refs/heads/master
| 2021-01-10T19:31:47.795365
| 2014-09-05T18:42:40
| 2014-09-05T18:42:40
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 16,464
|
cpp
|
// Copyright (c) 2011-2014 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <QApplication>
#include "guiutil.h"
#include "bitcoinaddressvalidator.h"
#include "walletmodel.h"
#include "bitcoinunits.h"
#include "util.h"
#include "init.h"
#include <QDateTime>
#include <QDoubleValidator>
#include <QFont>
#include <QLineEdit>
#if QT_VERSION >= 0x050000
#include <QUrlQuery>
#else
#include <QUrl>
#endif
#include <QTextDocument> // for Qt::mightBeRichText
#include <QAbstractItemView>
#include <QClipboard>
#include <QFileDialog>
#include <QDesktopServices>
#include <QThread>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#ifdef WIN32
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "shlwapi.h"
#include "shlobj.h"
#include "shellapi.h"
#endif
namespace GUIUtil {
QString dateTimeStr(const QDateTime &date)
{
return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") + date.toString("hh:mm");
}
QString dateTimeStr(qint64 nTime)
{
return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
}
QFont bitcoinAddressFont()
{
QFont font("Monospace");
font.setStyleHint(QFont::TypeWriter);
return font;
}
void setupAddressWidget(QLineEdit *widget, QWidget *parent)
{
widget->setMaxLength(BitcoinAddressValidator::MaxAddressLength);
widget->setValidator(new BitcoinAddressValidator(parent));
widget->setFont(bitcoinAddressFont());
}
void setupAmountWidget(QLineEdit *widget, QWidget *parent)
{
QDoubleValidator *amountValidator = new QDoubleValidator(parent);
amountValidator->setDecimals(8);
amountValidator->setBottom(0.0);
widget->setValidator(amountValidator);
widget->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
}
bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
{
// return if URI is not valid or is no bitcoin URI
if(!uri.isValid() || uri.scheme() != QString("nichts"))
return false;
SendCoinsRecipient rv;
rv.address = uri.path();
rv.amount = 0;
#if QT_VERSION < 0x050000
QList<QPair<QString, QString> > items = uri.queryItems();
#else
QUrlQuery uriQuery(uri);
QList<QPair<QString, QString> > items = uriQuery.queryItems();
#endif
for (QList<QPair<QString, QString> >::iterator i = items.begin(); i != items.end(); i++)
{
bool fShouldReturnFalse = false;
if (i->first.startsWith("req-"))
{
i->first.remove(0, 4);
fShouldReturnFalse = true;
}
if (i->first == "label")
{
rv.label = i->second;
fShouldReturnFalse = false;
}
else if (i->first == "amount")
{
if(!i->second.isEmpty())
{
if(!BitcoinUnits::parse(BitcoinUnits::BTC, i->second, &rv.amount))
{
return false;
}
}
fShouldReturnFalse = false;
}
if (fShouldReturnFalse)
return false;
}
if(out)
{
*out = rv;
}
return true;
}
bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
{
// Convert bitcoin:// to bitcoin:
//
// Cannot handle this later, because bitcoin:// will cause Qt to see the part after // as host,
// which will lower-case it (and thus invalidate the address).
if(uri.startsWith("nichts://"))
{
uri.replace(0, 11, "nichts:");
}
QUrl uriInstance(uri);
return parseBitcoinURI(uriInstance, out);
}
QString HtmlEscape(const QString& str, bool fMultiLine)
{
#if QT_VERSION < 0x050000
QString escaped = Qt::escape(str);
#else
QString escaped = str.toHtmlEscaped();
#endif
if(fMultiLine)
{
escaped = escaped.replace("\n", "<br>\n");
}
return escaped;
}
QString HtmlEscape(const std::string& str, bool fMultiLine)
{
return HtmlEscape(QString::fromStdString(str), fMultiLine);
}
void copyEntryData(QAbstractItemView *view, int column, int role)
{
if(!view || !view->selectionModel())
return;
QModelIndexList selection = view->selectionModel()->selectedRows(column);
if(!selection.isEmpty())
{
// Copy first item (global clipboard)
QApplication::clipboard()->setText(selection.at(0).data(role).toString(), QClipboard::Clipboard);
// Copy first item (global mouse selection for e.g. X11 - NOP on Windows)
QApplication::clipboard()->setText(selection.at(0).data(role).toString(), QClipboard::Selection);
}
}
void setClipboard(const QString& str)
{
QApplication::clipboard()->setText(str, QClipboard::Clipboard);
QApplication::clipboard()->setText(str, QClipboard::Selection);
}
QString getSaveFileName(QWidget *parent, const QString &caption,
const QString &dir,
const QString &filter,
QString *selectedSuffixOut)
{
QString selectedFilter;
QString myDir;
if(dir.isEmpty()) // Default to user documents location
{
#if QT_VERSION < 0x050000
myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
#else
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
}
else
{
myDir = dir;
}
QString result = QFileDialog::getSaveFileName(parent, caption, myDir, filter, &selectedFilter);
/* Extract first suffix from filter pattern "Description (*.foo)" or "Description (*.foo *.bar ...) */
QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
QString selectedSuffix;
if(filter_re.exactMatch(selectedFilter))
{
selectedSuffix = filter_re.cap(1);
}
/* Add suffix if needed */
QFileInfo info(result);
if(!result.isEmpty())
{
if(info.suffix().isEmpty() && !selectedSuffix.isEmpty())
{
/* No suffix specified, add selected suffix */
if(!result.endsWith("."))
result.append(".");
result.append(selectedSuffix);
}
}
/* Return selected suffix if asked to */
if(selectedSuffixOut)
{
*selectedSuffixOut = selectedSuffix;
}
return result;
}
Qt::ConnectionType blockingGUIThreadConnection()
{
if(QThread::currentThread() != qApp->thread())
{
return Qt::BlockingQueuedConnection;
}
else
{
return Qt::DirectConnection;
}
}
bool checkPoint(const QPoint &p, const QWidget *w)
{
QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
if (!atW) return false;
return atW->topLevelWidget() == w;
}
bool isObscured(QWidget *w)
{
return !(checkPoint(QPoint(0, 0), w)
&& checkPoint(QPoint(w->width() - 1, 0), w)
&& checkPoint(QPoint(0, w->height() - 1), w)
&& checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
&& checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
}
void openDebugLogfile()
{
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
/* Open debug.log with the associated application */
if (boost::filesystem::exists(pathDebug))
QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(pathDebug.string())));
}
ToolTipToRichTextFilter::ToolTipToRichTextFilter(int size_threshold, QObject *parent) :
QObject(parent), size_threshold(size_threshold)
{
}
bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt)
{
if(evt->type() == QEvent::ToolTipChange)
{
QWidget *widget = static_cast<QWidget*>(obj);
QString tooltip = widget->toolTip();
if(tooltip.size() > size_threshold && !tooltip.startsWith("<qt") && !Qt::mightBeRichText(tooltip))
{
// Envelop with <qt></qt> to make sure Qt detects this as rich text
// Escape the current message as HTML and replace \n by <br>
tooltip = "<qt>" + HtmlEscape(tooltip, true) + "</qt>";
widget->setToolTip(tooltip);
return true;
}
}
return QObject::eventFilter(obj, evt);
}
#ifdef WIN32
boost::filesystem::path static StartupShortcutPath()
{
return GetSpecialFolderPath(CSIDL_STARTUP) / "Nichts.lnk";
}
bool GetStartOnSystemStartup()
{
// check for Bitcoin.lnk
return boost::filesystem::exists(StartupShortcutPath());
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
// If the shortcut exists already, remove it for updating
boost::filesystem::remove(StartupShortcutPath());
if (fAutoStart)
{
CoInitialize(NULL);
// Get a pointer to the IShellLink interface.
IShellLink* psl = NULL;
HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL,
CLSCTX_INPROC_SERVER, IID_IShellLink,
reinterpret_cast<void**>(&psl));
if (SUCCEEDED(hres))
{
// Get the current executable path
TCHAR pszExePath[MAX_PATH];
GetModuleFileName(NULL, pszExePath, sizeof(pszExePath));
TCHAR pszArgs[5] = TEXT("-min");
// Set the path to the shortcut target
psl->SetPath(pszExePath);
PathRemoveFileSpec(pszExePath);
psl->SetWorkingDirectory(pszExePath);
psl->SetShowCmd(SW_SHOWMINNOACTIVE);
psl->SetArguments(pszArgs);
// Query IShellLink for the IPersistFile interface for
// saving the shortcut in persistent storage.
IPersistFile* ppf = NULL;
hres = psl->QueryInterface(IID_IPersistFile,
reinterpret_cast<void**>(&ppf));
if (SUCCEEDED(hres))
{
WCHAR pwsz[MAX_PATH];
// Ensure that the string is ANSI.
MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().string().c_str(), -1, pwsz, MAX_PATH);
// Save the link by calling IPersistFile::Save.
hres = ppf->Save(pwsz, TRUE);
ppf->Release();
psl->Release();
CoUninitialize();
return true;
}
psl->Release();
}
CoUninitialize();
return false;
}
return true;
}
#elif defined(LINUX)
// Follow the Desktop Application Autostart Spec:
// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
boost::filesystem::path static GetAutostartDir()
{
namespace fs = boost::filesystem;
char* pszConfigHome = getenv("XDG_CONFIG_HOME");
if (pszConfigHome) return fs::path(pszConfigHome) / "autostart";
char* pszHome = getenv("HOME");
if (pszHome) return fs::path(pszHome) / ".config" / "autostart";
return fs::path();
}
boost::filesystem::path static GetAutostartFilePath()
{
return GetAutostartDir() / "nichts.desktop";
}
bool GetStartOnSystemStartup()
{
boost::filesystem::ifstream optionFile(GetAutostartFilePath());
if (!optionFile.good())
return false;
// Scan through file for "Hidden=true":
std::string line;
while (!optionFile.eof())
{
getline(optionFile, line);
if (line.find("Hidden") != std::string::npos &&
line.find("true") != std::string::npos)
return false;
}
optionFile.close();
return true;
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
if (!fAutoStart)
boost::filesystem::remove(GetAutostartFilePath());
else
{
char pszExePath[MAX_PATH+1];
memset(pszExePath, 0, sizeof(pszExePath));
if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath)-1) == -1)
return false;
boost::filesystem::create_directories(GetAutostartDir());
boost::filesystem::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out|std::ios_base::trunc);
if (!optionFile.good())
return false;
// Write a bitcoin.desktop file to the autostart directory:
optionFile << "[Desktop Entry]\n";
optionFile << "Type=Application\n";
optionFile << "Name=Nichts\n";
optionFile << "Exec=" << pszExePath << " -min\n";
optionFile << "Terminal=false\n";
optionFile << "Hidden=false\n";
optionFile.close();
}
return true;
}
#elif defined(Q_OS_MAC)
// based on: https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m
#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl);
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl)
{
// loop through the list of startup items and try to find the bitcoin app
CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, NULL);
for(int i = 0; i < CFArrayGetCount(listSnapshot); i++) {
LSSharedFileListItemRef item = (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction | kLSSharedFileListDoNotMountVolumes;
CFURLRef currentItemURL = NULL;
LSSharedFileListItemResolve(item, resolutionFlags, ¤tItemURL, NULL);
if(currentItemURL && CFEqual(currentItemURL, findUrl)) {
// found
CFRelease(currentItemURL);
return item;
}
if(currentItemURL) {
CFRelease(currentItemURL);
}
}
return NULL;
}
bool GetStartOnSystemStartup()
{
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
return !!foundItem; // return boolified object
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
if(fAutoStart && !foundItem) {
// add bitcoin app to startup item list
LSSharedFileListInsertItemURL(loginItems, kLSSharedFileListItemBeforeFirst, NULL, NULL, bitcoinAppUrl, NULL, NULL);
}
else if(!fAutoStart && foundItem) {
// remove item
LSSharedFileListItemRemove(loginItems, foundItem);
}
return true;
}
#else
bool GetStartOnSystemStartup() { return false; }
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
#endif
HelpMessageBox::HelpMessageBox(QWidget *parent) :
QMessageBox(parent)
{
header = tr("Nichts-Qt") + " " + tr("version") + " " +
QString::fromStdString(FormatFullVersion()) + "\n\n" +
tr("Usage:") + "\n" +
" nichts-qt [" + tr("command-line options") + "] " + "\n";
coreOptions = QString::fromStdString(HelpMessage());
uiOptions = tr("UI options") + ":\n" +
" -lang=<lang> " + tr("Set language, for example \"de_DE\" (default: system locale)") + "\n" +
" -min " + tr("Start minimized") + "\n" +
" -splash " + tr("Show splash screen on startup (default: 1)") + "\n";
setWindowTitle(tr("Nichts-Qt"));
setTextFormat(Qt::PlainText);
// setMinimumWidth is ignored for QMessageBox so put in non-breaking spaces to make it wider.
setText(header + QString(QChar(0x2003)).repeated(50));
setDetailedText(coreOptions + "\n" + uiOptions);
}
void HelpMessageBox::printToConsole()
{
// On other operating systems, the expected action is to print the message to the console.
QString strUsage = header + "\n" + coreOptions + "\n" + uiOptions;
fprintf(stdout, "%s", strUsage.toStdString().c_str());
}
void HelpMessageBox::showOrPrint()
{
#if defined(WIN32)
// On Windows, show a message box, as there is no stderr/stdout in windowed applications
exec();
#else
// On other operating systems, print help text to console
printToConsole();
#endif
}
} // namespace GUIUtil
|
[
"eysho@bkg.me"
] |
eysho@bkg.me
|
ede9af4b94dc79135513a74e933029851ee49da9
|
4c09e5660989a0346fb093f5387badf5bf90f8fc
|
/lab4a_question6.cpp
|
201a2d90eb568b63c9116393ef705e3ae3e7add2
|
[] |
no_license
|
kishoresourav/CS141-Assignments
|
96b55253954ac273cf280ad6e15bfbf38026e742
|
be4f182eadccfefc66f70dc61b3b82a388a24cee
|
refs/heads/master
| 2021-01-19T17:31:14.539767
| 2017-09-15T16:04:30
| 2017-09-15T16:04:30
| 101,066,482
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 379
|
cpp
|
#include <iostream>
using namespace std;
void myFun(int x,int y)
{
int i ,j, count=0;
for(i=(x+1);i<=y;i++)
{
count=0;
for(j=2;j<i;j++)
{
if(i%j==0)
{
count++;
}
}
if(count==0)
{
cout<<i<<" ";
}
}
;
}
int main()
{
int x,y;
cout<<"Enter lower number : ";
cin>>x;
cout<<"Enter upper number : ";
cin>>y;
myFun(x,y);
return 0;
}
|
[
"noreply@github.com"
] |
kishoresourav.noreply@github.com
|
213075517d0993938109345d949b7aa3afb7b462
|
7a92206984e9007948afaa363adbb95c06897a74
|
/demo/DesignPatternsTest/Facade.hpp
|
64f8134eae754279f59870d530f3fd8704da431e
|
[] |
no_license
|
fengbingchun/Messy_Test
|
6a801414a36581bce16edbde122b66ac86b57ddb
|
b55fcfc4b8adc538f9ac70bf78aa391a50b20241
|
refs/heads/master
| 2023-06-26T18:07:59.679346
| 2023-06-22T06:23:16
| 2023-06-22T06:23:16
| 55,020,860
| 305
| 171
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,315
|
hpp
|
#ifndef FBC_MESSY_TEST_FACADE_HPP_
#define FBC_MESSY_TEST_FACADE_HPP_
#include <iostream>
class SubSysOne
{
public:
void MethodOne()
{
std::cout << "方法一" << std::endl;
}
};
class SubSysTwo
{
public:
void MethodTwo()
{
std::cout << "方法二" << std::endl;
}
};
class SubSysThree
{
public:
void MethodThree()
{
std::cout << "方法三" << std::endl;
}
};
//外观类
class Facade
{
private:
SubSysOne* sub1;
SubSysTwo* sub2;
SubSysThree* sub3;
public:
Facade()
{
sub1 = new SubSysOne();
sub2 = new SubSysTwo();
sub3 = new SubSysThree();
}
~Facade()
{
delete sub1;
delete sub2;
delete sub3;
}
void FacadeMethod()
{
sub1->MethodOne();
sub2->MethodTwo();
sub3->MethodThree();
}
};
// ================================================
class Subsystem1
{
public:
Subsystem1();
~Subsystem1();
void Operation();
protected:
private:
};
class Subsystem2
{
public:
Subsystem2();
~Subsystem2();
void Operation();
protected:
private:
};
class Facade_1
{
public:
Facade_1();
~Facade_1();
void OperationWrapper();
protected:
private:
Subsystem1* _subs1;
Subsystem2* _subs2;
};
int test_Facade1();
int test_Facade2();
#endif // FBC_MESSY_TEST_FACADE_HPP_
|
[
"fengbingchun@163.com"
] |
fengbingchun@163.com
|
2b378fd3dbd952ddbbf825a53b5e0a7f55e83bc4
|
92a9f837503a591161330d39d061ce290c996f0e
|
/SiNDY-u/ConvertHeightNode/RoadWalkLinkInfo.h
|
12c6446e83f74798dc98369d2441ac1ce9599da5
|
[] |
no_license
|
AntLJ/TestUploadFolder
|
53a7dae537071d2b1e3bab55e925c8782f3daa0f
|
31f9837abbd6968fc3a0be7610560370c4431217
|
refs/heads/master
| 2020-12-15T21:56:47.756829
| 2020-01-23T07:33:23
| 2020-01-23T07:33:23
| 235,260,509
| 1
| 1
| null | null | null | null |
SHIFT_JIS
|
C++
| false
| false
| 2,518
|
h
|
#pragma once
struct RoadWalkLinkRec
{
long e_divid;
IGeometryPtr e_ipGeoemtry;
RoadWalkLinkRec()
:e_divid(-1)
{}
bool operator < (const RoadWalkLinkRec roadWalkLinkRec) const {
return e_divid < roadWalkLinkRec.e_divid;
}
};
class RoadWalkLinkInfo
{
public:
RoadWalkLinkInfo(void);
~RoadWalkLinkInfo(void);
/*
* @brief staticメンバ変数の初期化
* @note ルートパスの設定のみ
* @param shpRootPath [in] 道路・歩行者Shape格納フォルダルートパス
*/
void Init(LPCTSTR shpRootPath){
m_shpRootPath = shpRootPath;
};
/*
* @brief 変換対象道路歩行者リンクセット
* @param mesh [in] 変換対象メッシュ
* @retval true 成功
* @retval false 失敗
*/
bool SetRoadWalkLinkInfo(const long secondMesh);
/*
* @brief 任意のobjectidを持つ道路・歩行者Shape情報のイテレータを取得(const_iterator)
* @param objectid [in] 検索するobjectid
* @return コンストイテレータ
*/
std::map<long, std::set<RoadWalkLinkRec>>::const_iterator find(const long objectid) const
{
return m_recordInfo.find(objectid);
}
/*
* @brief 道路・歩行者Shape情報コンテナの終端を指すイテレータ取得(const_iterator)
* @return コンストイテレータ
*/
std::map<long, std::set<RoadWalkLinkRec>>::const_iterator end() const
{
return m_recordInfo.end();
}
private:
/*
* @brief インデックス取得
* @param ipFeatureClass [in] 道路・歩行者リンクフィーチャクラス
* @param shpName [in] shpファイル名
* @retval true 成功
* @retval false 失敗
*/
bool SetIndex(const IFeatureClassPtr& ipFeatureClass, LPCTSTR shpName);
/*
* @brief 道路・歩行者リンクレコード情報取得
* @param ipFeature [in] 道路・歩行者リンクフィーチャ
* @param shpName [in] shpファイル名
* @param objectid [out] objectid
* @param roadWalkLinkRec [out] 道路・歩行者レコード情報
* @retval true 成功
* @retval false 失敗
*/
bool GetRecInfo(const IFeaturePtr& ipFeature, LPCTSTR shpName, long& objectid, RoadWalkLinkRec& roadWalkLinkRec);
private:
static CString m_shpRootPath; //!< 道路・歩行者Shape格納フォルダルートパス
std::map<long, std::set<RoadWalkLinkRec>> m_recordInfo; //!< 道路・歩行者Shape情報(キーobjectid)
static long m_objectidIndex;
static long m_dividIndex;
};
|
[
"noreply@github.com"
] |
AntLJ.noreply@github.com
|
d82590407324ec144f6943b2d6ecc1304ceaab3b
|
83b10056a4aaffee446a58e00ee68918e9e9664e
|
/99dan.cpp
|
333eda7ba3958fb580060276ac53ede7e8f6ddd5
|
[] |
no_license
|
jacod2/web1
|
0b5d9a8dc1ad68990ca7b6dc681d2fa0f258cd2d
|
22513b1794fac8f91d33bf164edc118817212b6b
|
refs/heads/master
| 2021-07-11T23:27:51.471168
| 2021-05-11T09:39:41
| 2021-05-11T09:39:41
| 244,867,457
| 0
| 1
| null | null | null | null |
UHC
|
C++
| false
| false
| 583
|
cpp
|
#include <iostream>
using namespace std;
void main()
{
int iNum = 1,iNum_first = 2,iNum_second = 1;
cout << "구구단 2단을 출력합니다" << endl;
while (9 >= iNum)
{
cout << "2 * " << iNum << " = " << 2 * iNum << endl;
iNum++;
}
cout << endl << "구구단을 2단 부터 9단까지 출력합니다" << endl;
while (9 >= iNum_first)
{
iNum_second = 1;
while (9 >= iNum_second)
{
cout << iNum_first << " * " << iNum_second << " = " << iNum_first * iNum_second << endl;
iNum_second++;
}
cout << endl;
iNum_first++;
}
}
|
[
"noreply@github.com"
] |
jacod2.noreply@github.com
|
0f18a97c3d5ad0d5ce437338882abf3feff8e25b
|
748565c05766fd5610f9b22dfb4cf7279f264921
|
/Knights of Valor/Camera.cpp
|
d1d351bd90fbf73d6c84488740eaf0403cf24ad6
|
[] |
no_license
|
ACEenterprise/Knights-of-Valor
|
f7e90d0bf149e31f0759ab8c10164ed77a80541a
|
070e3982967de54d7c753adb3af90e83ec481155
|
refs/heads/master
| 2021-01-20T17:51:07.599918
| 2017-05-26T10:48:58
| 2017-05-26T10:48:58
| 90,893,579
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 425
|
cpp
|
#include"Camera.h"
Camera::Camera(Map* map)
{
this->map = map;
}
void Camera::centrate(Knight* knight)
{
this->knight = knight;
}
void Camera::action(Graphics &g)
{
map->setX((1280 / 2 / 64) * 64-knight->getX());
map->setY((720 / 2 / 64) * 64 -knight->getY());
knight->draw(g, (1280 / 2 / 64) * 64, (720 / 2 / 64) * 64);
}
int Camera::getX()
{
return map->getX();
}
int Camera::getY()
{
return map->getY();
}
|
[
"stoicaastefan@gmail.com"
] |
stoicaastefan@gmail.com
|
6c098daf69fa7221aed60082ea711cb0b7cf3ead
|
8822cb65b438ad65b84f4623223eced7932203db
|
/Coursework/Project/main.cpp
|
f02c9f073825cf8ddb52451dac4ca17a823faf0c
|
[] |
no_license
|
Sergey-Chushev/Lab
|
d7881c084bd1b7807b359912c6e455d158647a19
|
aeecf6b4b0ebfd3323d91afff5139c6f9517b85c
|
refs/heads/master
| 2020-07-31T14:24:09.722154
| 2020-06-22T18:55:34
| 2020-06-22T18:55:34
| 210,633,424
| 2
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 362
|
cpp
|
#include "mainwindow.h"
#include "new_user.h"
#include <QtGui>
#include <QTextCodec>
#include <QApplication>
int main(int argc, char *argv[])
{
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8")); //чтоб не было краказябл
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
|
[
"noreply@github.com"
] |
Sergey-Chushev.noreply@github.com
|
f4e409c6fdb6c39e1d4e157a97e3f27872afac90
|
3415cce948e5cc506280d9683bacd06a022acb39
|
/include/container.h
|
853adc5258c069da0237334d08dc7b6cadf35f95
|
[
"MIT"
] |
permissive
|
Articula/RPG-Game-Engine
|
d7da9949c3379f19f8b7cebaa3fc1f4e51acd224
|
dd0ae407b813593a2f7936d3c53e892673d2cc50
|
refs/heads/master
| 2020-06-04T08:40:10.085327
| 2014-06-26T21:27:07
| 2014-06-26T21:27:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 594
|
h
|
/*
* container.h
*
* Created on: Dec 8, 2013
* Author: faye
*/
#ifndef CONTAINER_H_
#define CONTAINER_H_
#include <list>
#include <string>
#include "drawable.h"
class Container:
public Drawable
{
public:
Container();
virtual ~Container();
virtual std::list<Container*> GetChildren();
static bool LoadAttribute (const std::string* attribute,
const std::string* value);
protected:
private:
const std::string* pId_;
Container* pParent_;
std::list<Container*> children_;
};
#endif /* CONTAINER_H_ */
|
[
"articula@hotmail.com"
] |
articula@hotmail.com
|
aa5f1c10ff6f057ea70152a7c523db55fb01b197
|
ed5669151a0ebe6bcc8c4b08fc6cde6481803d15
|
/magma-1.5.0/src/dgeqrf3_gpu.cpp
|
9d254383bc427fa11bb269a3d02bc7ce3fc3f292
|
[] |
no_license
|
JieyangChen7/DVFS-MAGMA
|
1c36344bff29eeb0ce32736cadc921ff030225d4
|
e7b83fe3a51ddf2cad0bed1d88a63f683b006f54
|
refs/heads/master
| 2021-09-26T09:11:28.772048
| 2018-05-27T01:45:43
| 2018-05-27T01:45:43
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,803
|
cpp
|
/*
-- MAGMA (version 1.5.0) --
Univ. of Tennessee, Knoxville
Univ. of California, Berkeley
Univ. of Colorado, Denver
@date September 2014
@generated from zgeqrf3_gpu.cpp normal z -> d, Wed Sep 17 15:08:32 2014
*/
#include "common_magma.h"
/* ////////////////////////////////////////////////////////////////////////////
-- Auxiliary function: 'a' is pointer to the current panel holding the
Householder vectors for the QR factorization of the panel. This routine
puts ones on the diagonal and zeros in the upper triangular part of 'a'.
The upper triangular values are stored in work.
*/
void dsplit_diag_block3(int ib, double *a, int lda, double *work) {
int i, j;
double *cola, *colw;
double c_zero = MAGMA_D_ZERO;
double c_one = MAGMA_D_ONE;
for (i=0; i < ib; i++) {
cola = a + i*lda;
colw = work + i*ib;
for (j=0; j < i; j++) {
colw[j] = cola[j];
cola[j] = c_zero;
}
colw[i] = cola[i];
cola[i] = c_one;
}
}
/**
Purpose
-------
DGEQRF3 computes a QR factorization of a real M-by-N matrix A:
A = Q * R.
This version stores the triangular dT matrices used in
the block QR factorization so that they can be applied directly (i.e.,
without being recomputed) later. As a result, the application
of Q is much faster. Also, the upper triangular matrices for V have 0s
in them and the corresponding parts of the upper triangular R are
stored separately in dT.
Arguments
---------
@param[in]
m INTEGER
The number of rows of the matrix A. M >= 0.
@param[in]
n INTEGER
The number of columns of the matrix A. N >= 0.
@param[in,out]
dA DOUBLE_PRECISION array on the GPU, dimension (LDDA,N)
On entry, the M-by-N matrix A.
On exit, the elements on and above the diagonal of the array
contain the min(M,N)-by-N upper trapezoidal matrix R (R is
upper triangular if m >= n); the elements below the diagonal,
with the array TAU, represent the orthogonal matrix Q as a
product of min(m,n) elementary reflectors (see Further
Details).
@param[in]
ldda INTEGER
The leading dimension of the array dA. LDDA >= max(1,M).
To benefit from coalescent memory accesses LDDA must be
divisible by 16.
@param[out]
tau DOUBLE_PRECISION array, dimension (min(M,N))
The scalar factors of the elementary reflectors (see Further
Details).
@param[out]
dT (workspace) DOUBLE_PRECISION array on the GPU,
dimension (2*MIN(M, N) + (N+31)/32*32 )*NB,
where NB can be obtained through magma_get_dgeqrf_nb(M).
It starts with MIN(M,N)*NB block that store the triangular T
matrices, followed by the MIN(M,N)*NB block of the diagonal
matrices for the R matrix. The rest of the array is used as workspace.
@param[out]
info INTEGER
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
or another error occured, such as memory allocation failed.
Further Details
---------------
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I - tau * v * v'
where tau is a real scalar, and v is a real vector with
v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
and tau in TAU(i).
@ingroup magma_dgeqrf_comp
********************************************************************/
extern "C" magma_int_t
magma_dgeqrf3_gpu( magma_int_t m, magma_int_t n,
double *dA, magma_int_t ldda,
double *tau, double *dT,
magma_int_t *info )
{
#define dA(a_1,a_2) (dA + (a_2)*(ldda) + (a_1))
#define dT(a_1) (dT + (a_1)*nb)
#define d_ref(a_1) (dT + ( minmn+(a_1))*nb)
#define dd_ref(a_1) (dT + (2*minmn+(a_1))*nb)
#define work(a_1) (work + (a_1))
#define hwork (work + (nb)*(m))
magma_int_t i, k, minmn, old_i, old_ib, rows, cols;
magma_int_t ib, nb;
magma_int_t ldwork, lddwork, lwork, lhwork;
double *work, *ut;
/* check arguments */
*info = 0;
if (m < 0) {
*info = -1;
} else if (n < 0) {
*info = -2;
} else if (ldda < max(1,m)) {
*info = -4;
}
if (*info != 0) {
magma_xerbla( __func__, -(*info) );
return *info;
}
k = minmn = min(m,n);
if (k == 0)
return *info;
nb = magma_get_dgeqrf_nb(m);
lwork = (m + n + nb)*nb;
lhwork = lwork - m*nb;
if (MAGMA_SUCCESS != magma_dmalloc_pinned( &work, lwork )) {
*info = MAGMA_ERR_HOST_ALLOC;
return *info;
}
ut = hwork+nb*(n);
memset( ut, 0, nb*nb*sizeof(double));
magma_queue_t stream[2];
magma_queue_create( &stream[0] );
magma_queue_create( &stream[1] );
ldwork = m;
lddwork= n;
if ( (nb > 1) && (nb < k) ) {
/* Use blocked code initially */
old_i = 0; old_ib = nb;
for (i = 0; i < k-nb; i += nb) {
ib = min(k-i, nb);
rows = m -i;
magma_dgetmatrix_async( rows, ib,
dA(i,i), ldda,
work(i), ldwork, stream[1] );
if (i > 0) {
/* Apply H' to A(i:m,i+2*ib:n) from the left */
cols = n-old_i-2*old_ib;
magma_dlarfb_gpu( MagmaLeft, MagmaConjTrans, MagmaForward, MagmaColumnwise,
m-old_i, cols, old_ib,
dA(old_i, old_i ), ldda, dT(old_i), nb,
dA(old_i, old_i+2*old_ib), ldda, dd_ref(0), lddwork);
/* store the diagonal */
magma_dsetmatrix_async( old_ib, old_ib,
ut, old_ib,
d_ref(old_i), old_ib, stream[0] );
}
magma_queue_sync( stream[1] );
lapackf77_dgeqrf(&rows, &ib, work(i), &ldwork, tau+i, hwork, &lhwork, info);
/* Form the triangular factor of the block reflector
H = H(i) H(i+1) . . . H(i+ib-1) */
lapackf77_dlarft( MagmaForwardStr, MagmaColumnwiseStr,
&rows, &ib,
work(i), &ldwork, tau+i, hwork, &ib);
/* Put 0s in the upper triangular part of a panel (and 1s on the
diagonal); copy the upper triangular in ut. */
magma_queue_sync( stream[0] );
dsplit_diag_block3(ib, work(i), ldwork, ut);
magma_dsetmatrix( rows, ib, work(i), ldwork, dA(i,i), ldda );
if (i + ib < n) {
/* Send the triangular factor T to the GPU */
magma_dsetmatrix( ib, ib, hwork, ib, dT(i), nb );
if (i+nb < k-nb) {
/* Apply H' to A(i:m,i+ib:i+2*ib) from the left */
magma_dlarfb_gpu( MagmaLeft, MagmaConjTrans, MagmaForward, MagmaColumnwise,
rows, ib, ib,
dA(i, i ), ldda, dT(i), nb,
dA(i, i+ib), ldda, dd_ref(0), lddwork);
}
else {
cols = n-i-ib;
magma_dlarfb_gpu( MagmaLeft, MagmaConjTrans, MagmaForward, MagmaColumnwise,
rows, cols, ib,
dA(i, i ), ldda, dT(i), nb,
dA(i, i+ib), ldda, dd_ref(0), lddwork);
/* Fix the diagonal block */
magma_dsetmatrix( ib, ib, ut, ib, d_ref(i), ib );
}
old_i = i;
old_ib = ib;
}
}
} else {
i = 0;
}
/* Use unblocked code to factor the last or only block. */
if (i < k) {
ib = n-i;
rows = m-i;
magma_dgetmatrix( rows, ib, dA(i, i), ldda, work, rows );
lhwork = lwork - rows*ib;
lapackf77_dgeqrf(&rows, &ib, work, &rows, tau+i, work+ib*rows, &lhwork, info);
magma_dsetmatrix( rows, ib, work, rows, dA(i, i), ldda );
}
magma_queue_destroy( stream[0] );
magma_queue_destroy( stream[1] );
magma_free_pinned( work );
return *info;
} /* magma_dgeqrf_gpu */
#undef dA
#undef dT
#undef d_ref
#undef work
|
[
"cjy7117@gmail.com"
] |
cjy7117@gmail.com
|
b433b22fe50dc715620baed3d99a9adc78b52999
|
60b1b24de7f2315bdec25747b0cdb4b0746ce820
|
/v3/software/AS64/source/expr.cpp
|
04c73285229bf893ae5d099985b7c3559cfd6dc2
|
[] |
no_license
|
robfinch/ANY-1
|
c436c52a1b7d0adba2d54313596ba030820d8096
|
0a47c5dc055b85dff92a4ab14a65b7efd16f1196
|
refs/heads/main
| 2023-07-24T22:36:06.640147
| 2021-09-09T04:24:13
| 2021-09-09T04:24:13
| 332,168,690
| 4
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,243
|
cpp
|
// ============================================================================
// __
// \\__/ o\ (C) 2014-2021 Robert Finch, Waterloo
// \ __ / All rights reserved.
// \/_// robfinch<remove>@finitron.ca
// ||
//
// AS64 - Assembler
// - 64 bit CPU
//
// This source file 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 3 of the License, or
// (at your option) any later version.
//
// This source file 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/>.
//
// ============================================================================
//
#include "stdafx.h"
int64_t expr();
int nsym;
// id
// const
// (expr)
// >expr
int64_t primary(int64_t* def)
{
int64_t val;
SYM *sym;
static char buf[500];
ZeroMemory(buf,sizeof(buf));
*def = 1;
switch(token) {
case tk_id:
if (lastid[0]=='.') // local label
sprintf(buf, "%s%s", current_label, lastid);
else
strcpy(buf, lastid);
sym = find_symbol(buf);
if (!sym)
sym = new_symbol(buf);
if (current_symbol) {
sym->parent = current_symbol->ord;
}
val = sym->value.low;
if (sym->segment < 5)
nsym++;
lastsym = sym;
sym->referenceCount++;
*def = sym->isDefined;
NextToken();
if (token==tk_eol)
prevToken();
break;
case tk_icon:
val = ival.low;
NextToken();
if (token==tk_eol)
prevToken();
break;
case '\'':
inptr++;
if (*inptr=='\\') {
inptr++;
switch(*inptr) {
case '\r': val = '\r'; NextToken(); expect('\''); return (val);
case '\n': val = '\n'; NextToken(); expect('\''); return (val);
case '\t': val = '\t'; NextToken(); expect('\''); return (val);
case '\f': val = '\f'; NextToken(); expect('\''); return (val);
case '\b': val = '\b'; NextToken(); expect('\''); return (val);
}
}
val = *inptr;
NextToken();
expect('\'');
break;
case '(':
NextToken();
val = expr();
expect(')');
break;
default:
if (token=='>' && gCpu==5) {
val = expr();
val >>= 12;
}
else if (token=='<' && gCpu==5) {
val = expr();
val &= 0xFFF;
}
else {
//printf("Syntax error.\r\n");
val = 0;
if (token != tk_eol)
NextToken();
}
break;
}
return val;
}
// !unary
// -unary
// +unary
// ~unary
// primary
int64_t unary(int64_t* def)
{
int64_t val;
switch(token) {
case '!': NextToken(); return !unary(def);
case '-': NextToken(); return -unary(def);
case '+': NextToken(); return +unary(def);
case '~': NextToken(); return ~unary(def);
default:
return primary(def);
}
}
// unary
// unary [*/%] unary
int64_t mult_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = unary(&def1);
while(1) {
switch(token) {
case '*': NextToken(); val = val * unary(&def2);
*def = *def && (def1 && def2);
break;
case '/': NextToken(); val = val / unary(&def2);
*def = *def && (def1 && def2);
break;
case '%': NextToken(); val = val % unary(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
// mult_expr
// mult_expr [+-] add_expr_list
//
int64_t add_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = mult_expr(&def1);
while (1) {
switch(token) {
case '+': NextToken(); val = val + mult_expr(&def2);
*def = *def && (def1 && def2);
break;
case '-': NextToken(); val = val - mult_expr(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
int64_t shift_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = add_expr(&def1);
while(1) {
switch(token) {
case tk_lshift: NextToken(); val = val << add_expr(&def2);
*def = *def && (def1 && def2);
break;
case tk_rshift: NextToken(); val = val >> add_expr(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
int64_t relational_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = shift_expr(&def1);
while (1) {
switch(token) {
case tk_lt: NextToken(); val = val <shift_expr(&def2);
*def = *def && (def1 && def2);
break;
case tk_le: NextToken(); val = val<=shift_expr(&def2);
*def = *def && (def1 && def2);
break;
case tk_gt: NextToken(); val = val >shift_expr(&def2);
*def = *def && (def1 && def2);
break;
case tk_ge: NextToken(); val = val>=shift_expr(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
// relational_expr
// relational_expr & equals_expr_list
//
int64_t equals_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = relational_expr(&def1);
while (1) {
switch(token) {
case tk_eq: NextToken(); val = val == relational_expr(&def2);
*def = *def && (def1 && def2);
break;
case tk_ne: NextToken(); val = val != relational_expr(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
// equals_expr
// equals_expr & bitwise_expr_list
//
int64_t bitwise_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = equals_expr(&def1);
while (1) {
switch(token) {
case '&': NextToken(); val = val & equals_expr(&def2);
*def = *def && (def1 && def2);
break;
case '^': NextToken(); val = val ^ equals_expr(&def2);
*def = *def && (def1 && def2);
break;
case '|': NextToken(); val = val | equals_expr(&def2);
*def = *def && (def1 && def2);
break;
default: goto j1;
}
}
j1:
return val;
}
// bitwise_expr
// bitwise_expr && and_expr_list
//
int64_t and_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = bitwise_expr(&def1);
while(token==tk_land) {
NextToken();
val = val && bitwise_expr(&def2);
*def = *def && (def1 && def2);
}
return val;
}
// and_expr
// and_expr || or_expr_list
//
int64_t or_expr(int64_t* def)
{
int64_t val;
int64_t def1, def2;
val = and_expr(&def1);
while(token==tk_lor) {
NextToken();
val = val || and_expr(&def2);
*def = *def && (def1 && def2);
}
return val;
}
int64_t expr()
{
int64_t val;
int64_t def;
nsym = 0;
lastsym = (SYM*)NULL;
if (token=='#')
NextToken();
val = or_expr(&def);
// We only care about the symbol if relocatable output is being generated.
// Setting the symbol to NULL will result in no rel records being output.
if (nsym > 1 || !rel_out)
lastsym = (SYM *)NULL;
return val;
}
int64_t expr_def(int64_t *def)
{
int64_t val;
nsym = 0;
lastsym = (SYM*)NULL;
if (token == '#')
NextToken();
val = or_expr(def);
// We only care about the symbol if relocatable output is being generated.
// Setting the symbol to NULL will result in no rel records being output.
if (nsym > 1 || !rel_out)
lastsym = (SYM*)NULL;
return val;
}
|
[
"5563401+robfinch@users.noreply.github.com"
] |
5563401+robfinch@users.noreply.github.com
|
16ee72a51f1b035594c5dbc3d30901c8995a5385
|
e51dec71c96c21b1e5af2202262792e1b3f32491
|
/ship.h
|
9d6f59a58f7091e724bd9918cbc376ae6288e66c
|
[] |
no_license
|
hansione/AAA
|
16e1b7c642e63807b52f4a303b77584573989bb6
|
4e76f1a7d68efaf9ca09a4af66fa3f5c564a68cf
|
refs/heads/main
| 2023-06-20T10:56:52.685757
| 2021-07-22T13:04:57
| 2021-07-22T13:04:57
| 388,453,523
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 482
|
h
|
#pragma once
#include "gameNode.h"
class ship : public gameNode
{
protected:
image* _image; //이미지
RECT _rc; //렉트
float _x, _y; //중점좌표
float _angle; //각도
float _speed;
float _radius;
public:
ship();
~ship();
virtual HRESULT init(const char* imageName, int x, int y);
virtual void release();
virtual void update();
virtual void render();
virtual void draw();
virtual void keyControl();
virtual void move();
};
|
[
"noreply@github.com"
] |
hansione.noreply@github.com
|
b781d7bd0f94a1c1c87ba834c5d6d2e3a739451b
|
590c5112081e588cbe7c5914c7eb3b2ff9937b40
|
/include/ZSTL/ZHashMap.hpp
|
7e4c7b39c23f4058c117091c35f920ddbbdbf30e
|
[] |
no_license
|
crertel/onizuka-oculus-client
|
ce9045a1e86a5d1fe5bb992e0c5f8fa0ffa528ee
|
9ef665d8e14aca193b1fc5faa41954a8a5eaa641
|
refs/heads/master
| 2021-01-17T11:51:51.204928
| 2014-01-26T12:48:12
| 2014-01-26T12:48:12
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 36,931
|
hpp
|
/*
ZHashMap.hpp
Author: James Russell <jcrussell@762studios.com>
Created: 12/24/2011
Purpose:
Templated hash map implementation.
License:
This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
http://sam.zoy.org/wtfpl/COPYING for more details.
*/
#pragma once
#ifndef _ZHASHMAP_HPP
#define _ZHASHMAP_HPP
#include <ZSTL/ZPair.hpp>
#include <ZSTL/ZArray.hpp>
#include <ZSTL/ZList.hpp>
//Default number of buckets
#ifndef ZHASHMAP_DEFAULT_BUCKETS
#define ZHASHMAP_DEFAULT_BUCKETS (31)
#endif
//Default load factor for the HashMap (expressed as an integer percentage LF / 100)
#ifndef ZHASHMAP_DEFAULT_LOADFACTOR
#define ZHASHMAP_DEFAULT_LOADFACTOR (75)
#endif
//Factor by which HashMap grows when loadfactor is exceeded
#ifndef ZHASHMAP_DEFAULT_GROWFACTOR
#define ZHASHMAP_DEFAULT_GROWFACTOR (2.0)
#endif
//Number of nodes for the lists stored locally (safe since we never splice)
#ifndef ZHASHMAP_DEFAULT_LOCAL_NODES
#define ZHASHMAP_DEFAULT_LOCAL_NODES (10)
#endif
//Forward Declaration of ZHashMap
template < typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA >
class ZHashMap;
//Forward Declaration of ZHashMapIterator
template <typename K, typename V, typename HT>
class ZHashMapIterator;
/*
Forward Declaration of ZHashMap Method Implementation Structures
Existence of these structures allows for template specialization of
individual methods of the ZHashMap class. In order to specialize
a single method of ZHashMap, simply specialize the corresponding
method implementation structure.
*/
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Clear struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_ClearImpl {
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::ContainsKey struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_ContainsKeyImpl {
inline static bool Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::ContainsValue struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_ContainsValueImpl {
inline static bool Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const V& _value);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Empty struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_EmptyImpl {
inline static bool Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Erase struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_EraseImpl {
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key);
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, ZHashMapIterator<K, V, HT>& _itr);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Get struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_GetImpl {
inline static V& Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Put struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_PutImpl {
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key);
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key, const V& _value);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Resize struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_ResizeImpl {
inline static void Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, size_t _buckets);
};
//Forward Declaration of ZHashMap<K, V, HT, H, LF, LA, AA>::Size struct
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
struct ZHashMap_SizeImpl {
inline static size_t Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self);
};
///////////////////////////////////////
/* Hash Comparator, Hasher, HashNode */
///////////////////////////////////////
/*
Hash comparator class, which compares elements with the == operator.
*/
template <typename T>
struct ZHashComparator
{
ZHashComparator() { } //Silence Sun C++ warnings about uninitialized structs
//operator overload which returns true if equivalent (as per ==), false otherwise
bool operator () (const T& _a, const T& _b) const
{
if ((T)_a == (T)_b)
return true;
else
return false;
}
};
/*
Hasher class, which produces hash values of objects for use in ZHashMap.
The template parameter T is the type we will be hashing.
The template parameter HT is the hash type that is computed.
*/
template <typename T, typename HT>
class ZHasher
{
public:
//Comparator for use with equals and less than
ZHashComparator<T> Comp;
//Default hash function, which attempts to cast the object as a hash value
HT Hash(const T& _obj) const
{
return (HT)_obj;
}
//Default comparison function, which compares objects (should return 0 if not equal, !0 otherwise)
int Equals(const T& _first, const T& _second) const
{
return Comp(_first, _second);
}
};
/*
Hash node structure, which contains a key, a value, and the pre-computed hash for
the key as well as the hash mod (bucket). This node is stored within a ZListNode
for hash chaining.
The template parameter K is the key type.
The template parameter V is the value type.
The template parameter HT is the hash type.
*/
template <typename K, typename V, typename HT>
struct ZHashNode
{
ZHashNode() { } //Silence Sun C++ warnings about uninitialized structs
K Key; //The contained key
V Value; //The contained value
HT Hash; //The hash of the key
size_t HashMod; //The hash mod number of buckets (gives bucket)
};
///////////////////////
/* ZHashMap Iterator */
///////////////////////
/*
Iterator for ZHashMap.
The template parameter K is the key type.
The template parameter V is the value type.
The template parameter HT is the hash type.
*/
template <typename K, typename V, typename HT>
class ZHashMapIterator
{
private:
//The current node we are pointing to
ZListNode< ZHashNode<K, V, HT> > *Node;
//The end node of the map
ZListNode< ZHashNode<K, V, HT> > *EndNode;
public:
/*
Default Constructor.
*/
ZHashMapIterator()
: Node(NULL), EndNode(NULL) { }
/*
Useful constructor.
@param _node - the node we are to begin iterating at
*/
ZHashMapIterator(ZListNode< ZHashNode<K, V, HT> >* _node, ZListNode< ZHashNode<K, V, HT> >* _endNode)
: Node(_node), EndNode(_endNode) { }
/*
Copy Constructor.
@param _other - the other iterator
*/
ZHashMapIterator(const ZHashMapIterator& _other)
: Node(_other.Node), EndNode(_other.EndNode) { }
/*
public ZHashMapIterator<K, V, HT>::CheckNodeCurrent
Node check function that does not allow the current node to point to NULL.
@return (void)
*/
void CheckNodeCurrent() const
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(Node != NULL, "ZHashMap Iterator Invalid!");
#endif
}
/*
public ZHashMapIterator<K, V, HT>::CheckNodeNext
Node check function that does not allow Node to be 'End'
@return (void)
*/
void CheckNodeNext() const
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(Node != NULL && Node != EndNode, "ZHashMap Iterator Next Invalid!");
#endif
}
/*
public ZHashMapIterator<K, V, HT>::CheckNodePrevious
Node check function that does not allow Node to be 'Begin'
@return (void)
*/
void CheckNodePrevious() const
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(Node != NULL && Node->Previous != EndNode, "ZHashMap Iterator Previous Invalid!");
#endif
}
/*
public ZHashMapIterator<K, V, HT>::GetNode
Gets the node that this iterator is currently pointed at.
@return (ZListNode<T>*) - the node we are currently pointed at
*/
ZListNode< ZHashNode<K, V, HT> >* GetNode() const
{ return Node; }
/*
public ZHashMapIterator<K, V, HT>::SetNode
Sets the current node for this iterator. Useful for when the
underlying list changes state.
@param _node - the node to point this iterator at
@return (void)
*/
void SetNode(ZListNode< ZHashNode<K, V, HT> >* _node)
{ Node = _node; }
/*
public ZHashMapIterator<K, V, HT>::GetKey
Gets the key this iterator points to.
@return (const K&) - the key pointed to
*/
const K& GetKey() const
{ CheckNodeCurrent(); return Node->Element.Key; }
/*
public ZHashMapIterator<K, V, HT>::GetValue
Gets the value this iterator points to.
@return (V&) - the value pointed to
*/
V& GetValue() const
{ CheckNodeCurrent(); return Node->Element.Value; }
/*
public ZHashMapIterator<K, V, HT>::HasCurrent
Determines if this iterator currently points to a valid element.
@return (bool) - true if element at current position
*/
bool HasCurrent() const
{ return Node != NULL && Node != EndNode; }
/*
public ZHashMapIterator<K, V, HT>::HasNext
Determines if this iterator has a valid element after the current element.
@return (bool) - true if element after current, false otherwise
*/
bool HasNext() const
{ return Node != NULL && Node != EndNode && Node->Next != EndNode; }
/*
public ZHashMapIterator<K, V, HT>::HasPrev
Determines if this iterator has a valid element before the current element.
@return (bool) - true if element before current, false otherwise
*/
bool HasPrev() const
{ return Node != NULL && Node->Previous != EndNode; }
/*
public ZHashMapIterator<K, V, HT>::Next
Advances this iterator to the next element.
@return (void)
@assert - if this would advance past end
*/
void Next()
{ ++(*this); }
/*
public ZHashMapIterator<K, V, HT>::Prev
Returns this iterator to the previous element.
@return (void)
@assert - if this would advance past begin
*/
void Prev()
{ --(*this); }
/*
public ZHashMapIterator<K, V, HT>::SetValue
Sets the value mapped to the given key.
@return (void)
@assert - if this is the end node
*/
void SetValue(const V& _value)
{ CheckNodeCurrent(); Node->Element.Value = _value; }
//Operator overrides
ZHashMapIterator& operator ++ () { CheckNodeNext(); Node = Node->Next; return *this; }
ZHashMapIterator operator ++ (int) { ZListNode< ZHashNode<K, V, HT> > *node = Node; CheckNodeNext(); Node = Node->Next; return ZHashMapIterator(node, EndNode); }
ZHashMapIterator operator + (int _value) { ZHashMapIterator itr(*this); for (int i = 0; i < _value; i++) ++itr; return itr; }
ZHashMapIterator& operator += (int _value) { for (int i = 0; i < _value; i++) ++(*this); return *this; }
ZHashMapIterator& operator -- () { CheckNodePrevious(); Node = Node->Previous; return *this; }
ZHashMapIterator operator -- (int) { ZListNode< ZHashNode<K, V, HT> > *node = Node; CheckNodePrevious(); Node = Node->Previous; return ZHashMapIterator(node, EndNode); }
ZHashMapIterator operator - (int _value) { ZHashMapIterator itr(*this); for (int i = _value; i > 0; i--) --itr; return itr; }
ZHashMapIterator& operator -= (int _value) { for (int i = 0; i < _value; i--) --(*this); return *this; }
ZHashMapIterator& operator = (const ZHashMapIterator &_other) { Node = _other.Node; EndNode = _other.EndNode; return *this; }
bool operator == (const ZHashMapIterator& _other) const { return (Node == _other.Node) && (EndNode == _other.EndNode); }
bool operator != (const ZHashMapIterator& _other) const { return !( (*this)==_other ); }
const ZHashNode<K, V, HT>& operator * () const { CheckNodeCurrent(); return Node->Element; }
};
/////////////////////////////
/* ZHashMap Implementation */
/////////////////////////////
/*
Templated dynamic hash map implementation. Uses chained hashing and (optional) load factor
balancing to ensure it behaves gracefully even under heavy load. This implementation does
not maintain order between keys.
The template parameter K is the key type, which must be hashable.
The template parameter V is the value type, which need not be hashable.
The template parameter HT is the hash type. This should generally correspond to something
like a 32-bit or 64-bit unsigned integer. It must be compatible with the modulo operator.
The template parameter H is the hasher type, which defaults to the ZHasher for K using hash type
HT. The hasher must expose the same methods as ZHasher (Hash, Equals).
The template parameter LF is the load factor of the hash map given as an integral value between
0 (hashmap will not resize) and 100. Load factor is then computed as (double)(LF / 100). Whenever
the current load factor exceeds this value, the number of buckets is increased (map is resized).
The template parameter LA is the allocator type to use for list nodes. It must allocate ZListNode
instances containing type ZHashNode<K, V, HT>.
The template parameter AA is the allocator type to pass along to the contained ZArray. It must allocate
arrays of type ZListNode< ZHashNode< K, V > >*.
*/
template <typename K, typename V,
typename HT = ZHashValue32, typename H = ZHasher<K, HT>, size_t LF = ZHASHMAP_DEFAULT_LOADFACTOR,
typename LA = ZListPooledAllocator< ZHashNode<K, V, HT>, ZHASHMAP_DEFAULT_LOCAL_NODES >,
typename AA = ZArrayAllocator< ZListNode< ZHashNode<K, V, HT> >*, ZHASHMAP_DEFAULT_BUCKETS> >
class ZHashMap
{
friend struct ZHashMap_ClearImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_ContainsKeyImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_ContainsValueImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_EmptyImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_EraseImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_GetImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_PutImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_ResizeImpl<K, V, HT, H, LF, LA, AA>;
friend struct ZHashMap_SizeImpl<K, V, HT, H, LF, LA, AA>;
private:
H Hasher; //The hasher for our keys
LA NodeAllocator; //Allocator for chained hashing
size_t ElementCount; //The element count
ZArray< ZListNode< ZHashNode<K, V, HT> >*, AA> Map; //The map
ZListNode< ZHashNode<K, V, HT> > EmptyNode; //The end node for the hash map
//Resizes and copies the HashMap if we exceed LoadFactor (LF of 0 indicates we should not resize)
inline void CheckLoadFactor()
{
//This will evaluate to false if LF == 0, true if LF > 0 (done to avoid C4127)
if ((void)LF,LF)
{
double currentLoadFactor = LoadFactor();
if (currentLoadFactor > ((double)LF / (double)100.0))
Resize((size_t)((double)Map.Size() * ZHASHMAP_DEFAULT_GROWFACTOR));
}
}
//Gets a bucket given a hash code
inline size_t GetBucket(HT _hash) const
{
return _hash % Map.Size();
}
public:
/*
Iterator type for ZHashMap. Allows ZHashMap::Iterator notation.
*/
typedef ZHashMapIterator< K, V, HT > Iterator;
/*
Default Constructor.
*/
ZHashMap()
: ElementCount(0), Map(ZHASHMAP_DEFAULT_BUCKETS)
{
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
Map.Resize(ZHASHMAP_DEFAULT_BUCKETS, NULL);
}
/*
Parameterized Constructor.
@param _buckets - the number of buckets the hashmap should use
*/
ZHashMap(size_t _buckets)
: ElementCount(0), Map(_buckets)
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(_buckets > 0, "Cannot make ZHashMap with no buckets!");
#endif
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
Map.Resize(_buckets, NULL);
}
/*
Copy constructor.
@param _other - the other hash map
*/
ZHashMap(const ZHashMap<K, V, HT, H, LF, LA, AA>& _other)
: ElementCount(_other.Size()), Map(_other.Size())
{
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
Map.Resize(_other.Size(), NULL);
for (typename ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator itr = _other.Begin(); itr != _other.End(); ++itr)
Put((*itr).Key, (*itr).Value);
}
/*
Copy constructor that can copy hash maps with other template types. Key
and Value type must be the same.
@param _other - the other hash map
*/
template <typename OHT, typename OH, size_t OLF, typename OLA, typename OAA>
ZHashMap(const ZHashMap<K, V, OHT, OH, OLF, OLA, OAA>& _other)
: ElementCount(_other.Size()), Map(_other.Size())
{
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
Map.Resize(_other.Map.Size(), NULL);
for (typename ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator itr = _other.Begin(); itr != _other.End(); ++itr)
Put((*itr).Key, (*itr).Value);
}
/*
= operator overload. Makes a copy of another hash map. This version is needed to
override the default version.
@param _other - the other hash map
@return (ZHashMap<K, V, HT, H, LF, LA, AA>) - this hash map
*/
ZHashMap<K, V, HT, H, LF, LA, AA>& operator = (const ZHashMap<K, V, HT, H, LF, LA, AA>& _other)
{
Clear();
ElementCount = _other.ElementCount;
Map.Resize(_other.Map.Size());
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
for (typename ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator itr = _other.Begin(); itr != _other.End(); ++itr) {
Put((*itr).Key, (*itr).Value);
}
return *this;
}
/*
= operator overload.
@param _other - the other hash map
@return (ZHashMap<K, V, HT, H, LF, LA, AA>) - this hash map
*/
template <typename OHT, typename OH, size_t OLF, typename OLA, typename OAA>
ZHashMap<K, V, HT, H, LF, LA, AA>& operator = (const ZHashMap<K, V, OHT, OH, OLF, OLA, OAA>& _other)
{
Clear();
ElementCount = _other.ElementCount;
Map.Resize(_other.Map.Size()());
EmptyNode.Next = &EmptyNode;
EmptyNode.Previous = &EmptyNode;
for (typename ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator itr = _other.Begin(); itr != _other.End(); ++itr) {
Put((*itr).Key, (*itr).Value);
}
return *this;
}
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::operator[]
Gets a value from the map. Functionally the same as Get.
@param _key - the key to lookup
@return (V&) - the value mapped to _key
@assert - if the key is not mapped
*/
V& operator [] (const K& _key)
{ return Get(_key); }
/*
public ZHashMap<K, V, H, LF, lA, AA>::Begin
Gets an iterator to the first element in the hash map. Keep in mind
that hash map elements are unordered.
@return (ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator) - iterator to the first element
*/
Iterator Begin() const
{ return ZHashMapIterator< K, V, HT >(const_cast<ZListNode< ZHashNode<K, V, HT> >* >(&EmptyNode)->Next,
const_cast<ZListNode< ZHashNode<K, V, HT> >* >(&EmptyNode)); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Clear
Clears the hash map of all keys and values.
@return (void)
*/
void Clear()
{ ZHashMap_ClearImpl<K, V, HT, H, LF, LA, AA>::Call(*this); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::ContainsKey
Determines if the hash map contains the given key.
@param _key - the key to check
@return (bool) - boolean indicating if the hash map contains the key
*/
bool ContainsKey(const K& _key) const
{ return ZHashMap_ContainsKeyImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _key); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::ContainsValue
Determines if the hash map contains the given value.
@param _value - the value to check for
@return (bool) - boolean indicating if the hash map contains the value
*/
bool ContainsValue(const V& _value) const
{ return ZHashMap_ContainsValueImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _value); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Empty
Indicates whether or not the hash map is empty.
@return (bool) - boolean indicating the hash map is empty (free of keys and values)
*/
bool Empty() const
{ return ZHashMap_EmptyImpl<K, V, HT, H, LF, LA, AA>::Call(*this); }
/*
public ZHashMap<K, V, H, LF, lA, AA>::End
Gets an iterator to the end node in the hash map. Keep in mind
that hash map elements are unordered.
@return (ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator) - iterator to the end node
*/
Iterator End() const
{ return ZHashMapIterator< K, V, HT >(const_cast<ZListNode< ZHashNode<K, V, HT> >* >(&EmptyNode),
const_cast<ZListNode< ZHashNode<K, V, HT> >* >(&EmptyNode)); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Erase
Removes the associated key and mapped value.
@param _key - the key to lookup
@return (void) - this hash map
@assert - if the key is not mapped
*/
void Erase(const K& _key)
{ ZHashMap_EraseImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _key); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Erase
Removes the key and mapped value given by the iterator. This version is more
efficient than the key-only version because no hash lookup is performed.
@param _itr - iterator to the hash node to remove
@return (void)
@assert - if it is the end iterator
*/
void Erase(Iterator& _itr)
{ ZHashMap_EraseImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _itr); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Find
Returns an iterator to the element mapped to the given key. Will return
the End() iterator if not mapped.
@param _key - the key to look up
@return (ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator) - iterator to the element,
End() if not found
*/
Iterator Find(const K& _key) const
{
HT hash = Hasher.Hash(_key);
size_t bucket = GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = Map.Data()[bucket];
while (node != NULL && node != &EmptyNode && node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && Hasher.Equals(_key, node->Element.Key) != 0)
return Iterator(node, const_cast< ZListNode< ZHashNode<K, V, HT> > *>(&EmptyNode));
node = node->Next;
}
return End();
}
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Get
Gets the value mapped to the given key.
@param _key - the key to look up
@return (V&) - the value mapped to _key
@assert - if the key is not present in the map
*/
V& Get(const K& _key) const
{ return ZHashMap_GetImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _key); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Keys
Gets a list of keys in the map. Uses the method 'PushBack' to add the
keys.
@param C - the container type to push the keys into, which must contain
type K and have a 'PushBack' method
@param _container - the container to put the keys into
@return - ZList containing all the keys in the map
*/
template <typename C>
void Keys(C& _container) const
{
Iterator itr = Begin();
while (itr.HasCurrent())
{
_container.PushBack((*itr).Key);
itr.Next();
}
}
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::LoadFactor
Returns the current load factor of the hash map, as determined by number
of elements over number of buckets.
@return (double) - the load factor
*/
double LoadFactor() const
{
return (double)ElementCount / (double)Map.Size();
}
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Mappings
Gets a list of all the key value mappings in the hash map. Adds pairs of
mappings using 'PushBack'.
@param C - the container type to push the keys into, which must contain
type ZPair<K, V> and have a 'PushBack' method
@param _container - the container to put the keys into
@return (ZList<ZPair<K, V>>)- list of key-value pairs
*/
template <typename C>
void Mappings(C& _container) const
{
Iterator itr = Begin();
while (itr.HasCurrent())
{
_container.PushBack(ZPair<K, V>((*itr).Key, (*itr).Value));
itr.Next();
}
}
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Put
Puts the given key into the map with a default constructed value of type V.
@param _key - the key to place in the map
*/
void Put(const K& _key)
{ return ZHashMap_PutImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _key); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Put
Puts the given key and value combination into the hash map.
@param _key - the key to associate with _value
@param _value - the value to lookup using _key
*/
void Put(const K& _key, const V& _value)
{ return ZHashMap_PutImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _key, _value); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Resize
Sets the number of buckets the hashmap will use. Existing elements will be re-hashed into the map.
@param _buckets - number of buckets to use
@return (ZHashMap<K, V, HT, H, LF, LA, AA>&) - this map
*/
void Resize(size_t _buckets)
{ ZHashMap_ResizeImpl<K, V, HT, H, LF, LA, AA>::Call(*this, _buckets); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Size
Returns the number of mapped key-value pairs in the map.
@return (size_t) - the number of key value pairs
*/
size_t Size() const
{ return ZHashMap_SizeImpl<K, V, HT, H, LF, LA, AA>::Call(*this); }
/*
public ZHashMap<K, V, HT, H, LF, LA, AA>::Values
Gets a list of values in the map.
@param C - the container type to push the keys into, which must contain
type V and have a 'PushBack' method
@param _container - the container to put the keys into
@return (ZList<V>)- ZList containing all the values in the map
*/
template <typename C>
void Values(C& _container) const
{
Iterator itr = Begin();
while (itr.HasCurrent())
{
_container.PushBack((*itr).Value);
itr.Next();
}
}
};
////////////////////////////////////////////
/* Non-Specialized Method Implementations */
////////////////////////////////////////////
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_ClearImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self)
{
ZListNode< ZHashNode<K, V, HT> >* node = _self.EmptyNode.Next;
while (node != &_self.EmptyNode)
{
node = node->Next;
_self.NodeAllocator.Deallocate(node->Previous);
}
for (size_t i = 0; i < _self.Map.Size(); i++)
_self.Map.Data()[i] = NULL;
_self.EmptyNode.Next = &_self.EmptyNode;
_self.EmptyNode.Previous = &_self.EmptyNode;
_self.ElementCount = 0;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
bool ZHashMap_ContainsKeyImpl<K, V, HT, H, LF, LA, AA>::Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key)
{
HT hash = _self.Hasher.Hash(_key);
size_t bucket = _self.GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = _self.Map.Data()[bucket];
while (node != NULL && node != &_self.EmptyNode && node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && _self.Hasher.Equals(_key, node->Element.Key) != 0)
return true;
node = node->Next;
}
return false;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
bool ZHashMap_ContainsValueImpl<K, V, HT, H, LF, LA, AA>::Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const V& _value)
{
typename ZHashMap<K, V, HT, H, LF, LA, AA>::Iterator itr = _self.Begin();
while (itr.HasCurrent())
{
if ((*itr).Value == _value)
return true;
itr.Next();
}
return false;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
bool ZHashMap_EmptyImpl<K, V, HT, H, LF, LA, AA>::Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self)
{
return _self.ElementCount == 0;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_EraseImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key)
{
HT hash = _self.Hasher.Hash(_key);
size_t bucket = _self.GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = _self.Map.Data()[bucket];
while (node != NULL && node != &_self.EmptyNode && node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && _self.Hasher.Equals(_key, node->Element.Key) != 0)
{
ZListNode< ZHashNode<K, V, HT> >* prevNode = node->Previous;
ZListNode< ZHashNode<K, V, HT> >* nextNode = node->Next;
prevNode->Next = nextNode;
nextNode->Previous = prevNode;
//If the bucket maps to this node, it must change (either Next or NULL)
if (_self.Map.Data()[bucket] == node)
{
if (nextNode->Element.HashMod == bucket)
_self.Map.Data()[bucket] = nextNode;
else
_self.Map.Data()[bucket] = NULL;
}
_self.NodeAllocator.Deallocate(node);
_self.ElementCount--;
return;
}
node = node->Next;
}
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_EraseImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, ZHashMapIterator<K, V, HT>& _itr)
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(_itr != _self.End(), "ZHashMap: Cannot Erase End iterator!");
#endif
ZListNode< ZHashNode<K, V, HT> >* node = _itr.GetNode();
ZListNode< ZHashNode<K, V, HT> >* prevNode = node->Previous;
ZListNode< ZHashNode<K, V, HT> >* nextNode = node->Next;
size_t bucket = node->Element.HashMod;
prevNode->Next = nextNode;
nextNode->Previous = prevNode;
//If the bucket maps to this node, it must change (either Next or NULL)
if (_self.Map.Data()[node->Element.HashMod] == node)
{
if (nextNode->Element.HashMod == bucket)
_self.Map.Data()[bucket] = nextNode;
else
_self.Map.Data()[bucket] = NULL;
}
_self.NodeAllocator.Deallocate(node);
_self.ElementCount--;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
V& ZHashMap_GetImpl<K, V, HT, H, LF, LA, AA>::Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key)
{
HT hash = _self.Hasher.Hash(_key);
size_t bucket = _self.GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = _self.Map.Data()[bucket];
while (node != NULL && node != &_self.EmptyNode && node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && _self.Hasher.Equals(_key, node->Element.Key) != 0)
return node->Element.Value;
node = node->Next;
}
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ERROR("ZHashMap: Get could not find value!");
#endif
//If the runtime assert is ignored and we continue, return ref to a static local variable
//This is effectively 'undefined' behavior
static V val;
return val;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_PutImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key)
{
_self.CheckLoadFactor();
HT hash = _self.Hasher.Hash(_key);
size_t bucket = _self.GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = _self.Map.Data()[bucket];
if (node == NULL)
{
//Empty bucket, so search for the next node
for (size_t i = bucket + 1; i < _self.Map.Size(); i++)
{
node = _self.Map.Data()[i];
if (node != NULL)
break;
}
//No node was found, so use the empty node
if (node == NULL)
node = &_self.EmptyNode;
}
else
{
//Non-empty bucket, so see if we are already mapped
while (node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && _self.Hasher.Equals(_key, node->Element.Key) != 0)
return;
node = node->Next;
}
}
//Not mapped, so insert (node is currently one past where we should be)
ZListNode< ZHashNode<K, V, HT> >* newNode = _self.NodeAllocator.Allocate();
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(newNode != NULL, "ZHashMap: Unable to allocate hash node!");
#endif
//If the bucket has NULL linkage, set it
if (_self.Map.Data()[bucket] == NULL)
_self.Map.Data()[bucket] = newNode;
newNode->Next = node;
newNode->Previous = node->Previous;
newNode->Element.Key = _key;
newNode->Element.Value = V(); //Be sure to default construct the value instance
newNode->Element.Hash = hash;
newNode->Element.HashMod = bucket;
newNode->Previous->Next = newNode;
newNode->Next->Previous = newNode;
_self.ElementCount++;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_PutImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, const K& _key, const V& _value)
{
_self.CheckLoadFactor();
HT hash = _self.Hasher.Hash(_key);
size_t bucket = _self.GetBucket(hash);
ZListNode< ZHashNode<K, V, HT> >* node = _self.Map.Data()[bucket];
if (node == NULL)
{
//Empty bucket, so search for the next node
for (size_t i = bucket + 1; i < _self.Map.Size(); i++)
{
node = _self.Map.Data()[i];
if (node != NULL)
break;
}
//No node was found, so use the empty node
if (node == NULL)
node = &_self.EmptyNode;
}
else
{
//Non-empty bucket, so see if we are already mapped
while (node->Element.HashMod == bucket)
{
if (node->Element.Hash == hash && _self.Hasher.Equals(_key, node->Element.Key) != 0)
{
node->Element.Value = _value;
return;
}
node = node->Next;
}
}
//Not mapped, so insert (node is currently one past where we should be)
ZListNode< ZHashNode<K, V, HT> >* newNode = _self.NodeAllocator.Allocate();
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(newNode != NULL, "ZHashMap: Unable to allocate hash node!");
#endif
//If the bucket has NULL linkage, set it
if (_self.Map.Data()[bucket] == NULL)
_self.Map.Data()[bucket] = newNode;
newNode->Next = node;
newNode->Previous = node->Previous;
newNode->Element.Key = _key;
newNode->Element.Value = _value;
newNode->Element.Hash = hash;
newNode->Element.HashMod = bucket;
newNode->Previous->Next = newNode;
newNode->Next->Previous = newNode;
_self.ElementCount++;
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
void ZHashMap_ResizeImpl<K, V, HT, H, LF, LA, AA>::Call(ZHashMap<K, V, HT, H, LF, LA, AA>& _self, size_t _buckets)
{
#if !ZSTL_DISABLE_RUNTIME_CHECKS
ZSTL_ASSERT(_buckets > 0, "ZHashMap: Unable to resize to zero buckets!");
#endif
//Get a pointer to the first non-empty element (which may itself be the empty element)
ZListNode< ZHashNode<K, V, HT> >* node = _self.EmptyNode.Next;
//Clear out the map completely
for (size_t i = 0; i < _self.Map.Size(); i++)
_self.Map.Data()[i] = NULL;
_self.EmptyNode.Next = &_self.EmptyNode;
_self.EmptyNode.Previous = &_self.EmptyNode;
_self.Map.Resize(_buckets, NULL);
//Loop through our previous nodes and place them back in the map in their new spots
while (node != &_self.EmptyNode)
{
//Compute new bucket
node->Element.HashMod = node->Element.Hash % _buckets;
//Determine where we should be placing this node
ZListNode< ZHashNode<K, V, HT> >* curNode = node;
ZListNode< ZHashNode<K, V, HT> >* nextNode = _self.Map.Data()[node->Element.HashMod];
//Get the next node to place now, before we scribble the pointers
node = curNode->Next;
//If the bucket has NULL linkage, next node
if (nextNode == NULL)
{
//Empty bucket, so search for the next nextNode
for (size_t i = curNode->Element.HashMod + 1; i < _self.Map.Size(); i++)
{
nextNode = _self.Map.Data()[i];
if (nextNode != NULL)
break;
}
//No nextNode was found, so use the empty nextNode
if (nextNode == NULL)
nextNode = &_self.EmptyNode;
}
//Reestablish linkage
curNode->Next = nextNode;
curNode->Previous = nextNode->Previous;
curNode->Previous->Next = curNode;
curNode->Next->Previous = curNode;
//Since we are pushing front, this always means we set the pointer
_self.Map.Data()[curNode->Element.HashMod] = curNode;
}
}
/*************************************************************************/
template <typename K, typename V, typename HT, typename H, size_t LF, typename LA, typename AA>
size_t ZHashMap_SizeImpl<K, V, HT, H, LF, LA, AA>::Call(const ZHashMap<K, V, HT, H, LF, LA, AA>& _self)
{
return _self.ElementCount;
}
#endif
|
[
"PTB6082@C6499970EB677A4.amer.homedepot.com"
] |
PTB6082@C6499970EB677A4.amer.homedepot.com
|
49e1231a6c62191ece894c1d971d1c7a4d8236b4
|
4897b9d75d851a81606d19a0e046b32eb16aa1bd
|
/other/lcp/09/09_bfs.cpp
|
abde9cb2f9f50a84eab728ca225fb311b1e2e763
|
[] |
no_license
|
tiankonguse/leetcode-solutions
|
0b5e3a5b3f7063374e9543b5f516e9cecee0ad1f
|
a36269c861bd5797fe3835fc179a19559fac8655
|
refs/heads/master
| 2023-09-04T11:01:00.787559
| 2023-09-03T04:26:25
| 2023-09-03T04:26:25
| 33,770,209
| 83
| 38
| null | 2020-05-12T15:13:59
| 2015-04-11T09:31:39
|
C++
|
UTF-8
|
C++
| false
| false
| 2,242
|
cpp
|
#include "base.h"
typedef long long ll;
typedef long long LL;
typedef unsigned long long ull;
typedef unsigned long long ULL;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
// const int mod = 1e9 + 7;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_queue = priority_queue<T>;
// lower_bound 大于等于
// upper_bound 大于
// vector/array: upper_bound(vec.begin(), vec.end(), v)
// map: m.upper_bound(v)
// reserve vector预先分配内存
// reverse(v.begin(), v.end()) 反转
// sum = accumulate(a.begin(), a.end(), 0);
// unordered_map / unordered_set
// 排序，小于是升序：[](auto&a, auto&b){ return a < b; })
// 优先队列 priority_queue<Node>：大于是升序
// struct Node{
// int t;
// bool operator<(const Node & that)const { return this->t > that.t; }
// };
const LL INF = 0x3f3f3f3f3f3f3f3fll;
const double PI = acos(-1.0), eps = 1e-7;
const int inf = 0x3f3f3f3f, ninf = 0xc0c0c0c0, mod = 1000000007;
const int max3 = 2100, max4 = 11100, max5 = 200100, max6 = 2000100;
// 基本思路，BFS，每个节点至多入队一次，for 循环内每个节点只扫描一次
// 复杂度：O(n)
class Solution {
public:
int minJump(vector<int>& jump) {
int n = jump.size();
vector<int> vis(n, 0);
queue<pair<int, int>> que;
que.push({0, 0});
vis[0] = 1;
int max_left = 1;
while(!que.empty()){
auto [v, step] = que.front(); que.pop();
int next_pos = v + jump[v];
if(next_pos >= n){
return step + 1;
}
if(vis[next_pos] == 0){ // 向后跳
que.push({next_pos, step + 1});
vis[next_pos] = 1;
}
// 向前跳
for(;max_left <= v; max_left++){
if(vis[max_left]) continue;
que.push({max_left, step + 1});
vis[max_left] = 1;
}
}
return 0;
}
};
int main() {
// vector<double> ans = {1.00000,-1.00000,3.00000,-1.00000};
// vector<vector<int>> cars = {{1, 2}, {2, 1}, {4, 3}, {7, 2}};
// TEST_SMP1(Solution, getCollisionTimes, ans, cars);
return 0;
}
|
[
"i@tiankonguse.com"
] |
i@tiankonguse.com
|
6a3d3958f55df50ab20f21ab6fb20e197fb55dca
|
851387ba96f2cd553f198b18a73881ecea420bc4
|
/src/svgpath_quadratic_curve_abs.h
|
e5350d88ce9cf848283504647d066b66f33665bf
|
[] |
no_license
|
SetCalm/XPlotterSVG
|
56588bdb5655c4f44a6221d20cbaeb3172c2f13e
|
ad86f6f62cc815144253f40f59ab6e5cb1d40e71
|
refs/heads/master
| 2022-01-13T20:17:49.918322
| 2017-11-04T15:15:09
| 2017-11-04T15:15:09
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,285
|
h
|
/* XPlotterSVG - Convert SVG to GCode
Copyright (C) 2017 Samuel Pickard
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
#ifndef SVGPATH_QUADRATIC_CURVE_ABS_H
#define SVGPATH_QUADRATIC_CURVE_ABS_H
#include "svgpath_command.h"
class SVGPath_Quadratic_Curve_Abs : public SVGPath_Command
{
protected:
QTextStream* mGcode;
TransformationStack* mTrans;
void plotCurve(double stepSize, Point2D startPoint, Point2D endPoint, Point2D controlPoint);
public:
SVGPath_Quadratic_Curve_Abs();
void process(QQueue<QString>* commandQueue, QTextStream* gcode, TransformationStack trans);
};
#endif // SVGPATH_QUADRATIC_CURVE_ABS_H
|
[
"sjp@appmancer.com"
] |
sjp@appmancer.com
|
8749ce083d33638e3dd669d4c15d27b53376aa7e
|
f5758d1e30fd4ea1e9e1db6e19345fef77e2a470
|
/CuartoEntregable/Evidencia/Graph/CSV.cpp
|
d1387a128e1714569ca1ce4e244c9caca6469feb
|
[] |
no_license
|
JorgePerC/SItuacionProblemaDataEst
|
fac83eed331f16276bac0e0a28596141e428d89f
|
f71804b9f6cbfe8f06a179846b5d2354fbadf104
|
refs/heads/master
| 2023-01-28T12:11:58.609021
| 2020-12-02T06:00:01
| 2020-12-02T06:00:01
| 297,765,627
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,901
|
cpp
|
//
// CSV.cpp
// POO_Class
//
// Created by Luis Alberto Fernández Castro on 21/09/20.
// Copyright © 2020 LF Coding. All rights reserved.
//
#include <algorithm>
#include "CSV.hpp"
CSV::CSV() {
this->filename = "";
}
/**
* Class to read file.csv
* Arg:
* string filename -> name of the file to read
*/
CSV::CSV(string filename) {
this->filename = filename;
}
/**
* Returns a vector containg the information
* from the file.csv. Vector type is Details.
* Iterates over the file.csv lines.
*/
vector<Details> CSV::read_csv_details() {
vector<Details> lines;
ifstream file(this->filename);
if(!file.is_open()) {
throw runtime_error("File can't be opened.");
} else {
}
string line;
while(getline(file, line)) {
stringstream ss(line);
string date;
string time;
string sourceIp;
int sourcePort;
string a;
string aTest;
string sourceName;
string destinationIp;
int destinationPort;
string b;
string bTest;
string destinationName;
getline(ss, date, ',');
getline(ss, time, ',');
getline(ss, sourceIp, ',');
getline(ss, a, ',');
stringstream aconv(a);
aconv >> aTest;
if (aTest == "-") {
stringstream conva("-1");
conva >> sourcePort;
} else {
stringstream conva(a);
conva >> sourcePort;
}
getline(ss, sourceName, ',');
getline(ss, destinationIp, ',');
getline(ss, b, ',');
stringstream bconv(b);
bconv >> bTest;
if (bTest == "-") {
stringstream convb("-1");
convb >> destinationPort;
} else {
stringstream convb(b);
convb >> destinationPort;
}
ss >> destinationName;
lines.push_back(Details(date, time, sourceIp, sourcePort, sourceName, destinationIp, destinationPort, destinationName));
}
file.close();
return lines;
}
vector<string> CSV::getUniqueRowData(){
vector<string> lines;
ifstream file(this->filename);
if(!file.is_open()) {
throw runtime_error("File can't be opened.");
}
string line;
while(getline(file, line)) {
stringstream ss(line);
string date;
string time;
string sourceIp;
int sourcePort;
string a;
string aTest;
string sourceName;
string destinationIp;
int destinationPort;
string b;
string bTest;
string destinationName;
getline(ss, date, ',');
// getline(ss, time, ',');
// getline(ss, sourceIp, ',');
// getline(ss, a, ',');
// stringstream aconv(a);
// aconv >> aTest;
// if (aTest == "-") {
// stringstream conva("-1");
// conva >> sourcePort;
// } else {
// stringstream conva(a);
// conva >> sourcePort;
// }
// getline(ss, sourceName, ',');
// getline(ss, destinationIp, ',');
// getline(ss, b, ',');
// stringstream bconv(b);
// bconv >> bTest;
// if (bTest == "-") {
// stringstream convb("-1");
// convb >> destinationPort;
// } else {
// stringstream convb(b);
// convb >> destinationPort;
// }
// ss >> destinationName;
if(lines.empty()){
lines.push_back(date);
}
if(find(lines.begin(), lines.end(), date) != lines.end()) {
/* do nothing */
} else {
lines.push_back(date);
}
}
file.close();
return lines;
}
|
[
"jorgeperez_1@live.com"
] |
jorgeperez_1@live.com
|
d23ec87cb3c33db1b88bee7f9e0487e8ed2acb27
|
9c3edb19f7a3cbcd9e7948394313d6776f3d6a1d
|
/statemachine/stringmaxlengthtransition.h
|
5d8c1ec98c50532c3df09f031a844d908651e482
|
[] |
no_license
|
Aschen/cutebox-public
|
6dd198c04608db199d7cf3fe90b3136ec4b19b5b
|
672c3512ee4f1f1fa60a2163c80d32735c3febc0
|
refs/heads/master
| 2021-01-19T06:06:12.742472
| 2016-09-13T12:17:13
| 2016-09-13T12:17:13
| 65,465,713
| 0
| 1
| null | null | null | null |
ISO-8859-1
|
C++
| false
| false
| 1,172
|
h
|
/******************************************************************************
COPYRIGHT (c) 2008 - 2010 by RG Systèmes Corporation.
This software has been provided pursuant to a License Agreement
containing restrictions on its use. This software contains
valuable trade secrets and proprietary information of
RG Systèmes Corporation and is protected by law. It may
not be copied or distributed in any form or medium, disclosed
to third parties, reverse engineered or used in any manner not
provided for in said License Agreement except with the prior
written authorization from RG Systèmes Corporation.
******************************************************************************/
#ifndef STRINGMAXLENGTHTRANSITION_H
#define STRINGMAXLENGTHTRANSITION_H
#include <QString>
#include "transition.h"
class StringMaxLengthTransition : public Transition
{
public:
StringMaxLengthTransition(int maxLength);
protected:
virtual bool eventTest(TransitionEvent * event) const;
private:
int m_maxLength;
};
#endif // STRINGMAXLENGTHTRANSITION_H
|
[
"a.maret@studio-hb.com"
] |
a.maret@studio-hb.com
|
cdd25edf0503dbc54f87f59ab27386a80472a9c7
|
abed321ee597cede0e1585a7f2fdbd887a50f020
|
/realsense_ros_object/test/object_test.cpp
|
8951de15983cb793463ce16252642d6c7a961325
|
[
"Apache-2.0"
] |
permissive
|
Hadisalman/realsense_samples_ros
|
fa2efa4ac6e50d900e58ac1dc9f339938155141b
|
82c53df9413b5a6d859e65c7fd3d8736086f169e
|
refs/heads/kinetic-devel
| 2021-01-18T19:05:52.914213
| 2017-08-17T16:39:34
| 2017-08-17T16:39:34
| 100,526,891
| 1
| 0
| null | 2017-08-16T19:51:02
| 2017-08-16T19:51:01
| null |
UTF-8
|
C++
| false
| false
| 2,344
|
cpp
|
// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2016 Intel Corporation. All Rights Reserved
#include <gtest/gtest.h>
#include <ros/ros.h>
#include "realsense_ros_object/ObjectsInBoxes.h"
#include <image_transport/image_transport.h>
bool objects_in_boxes_recieved = false;
bool camera_info_recieved = false;
int image_width = 0;
int image_height = 0;
realsense_ros_object::ObjectsInBoxes last_objs;
TEST(RealsenseTests, testObj)
{
EXPECT_TRUE(camera_info_recieved);
EXPECT_TRUE(objects_in_boxes_recieved);
if (!objects_in_boxes_recieved) return;
for(auto objs : last_objs.objects_vector)
{
EXPECT_GT(objs.object.object_name.length(), 1);
EXPECT_GT(objs.object_bbox.width, 0);
EXPECT_GT(objs.object_bbox.height, 0);
if(objs.object_bbox.height > objs.object_bbox.width)
{
if(objs.location.vert_margin != 0 || objs.location.horiz_margin != 0)
{
EXPECT_GT(objs.location.vert_margin, objs.location.horiz_margin);
}
}
else if (objs.object_bbox.height < objs.object_bbox.width)
{
if(objs.location.vert_margin != 0 || objs.location.horiz_margin != 0)
{
EXPECT_LT(objs.location.vert_margin, objs.location.horiz_margin);
}
}
}
}
void localized_tracked_objects_callback(
const realsense_ros_object::ObjectsInBoxes::ConstPtr& msg)
{
objects_in_boxes_recieved = true;
last_objs = *msg;
}
void color_camera_info_callback(const sensor_msgs::CameraInfo::ConstPtr & camera_info)
{
camera_info_recieved = true;
image_width = camera_info->width;
image_height = camera_info->height;
}
int main(int argc, char **argv) try
{
testing::InitGoogleTest(&argc, argv);
ros::init(argc, argv, "utest");
ros::NodeHandle nh;
ROS_INFO_STREAM("RealSense OBJECT test - Initializing Tests...");
ros::Subscriber sub_cam_pose = nh.subscribe("camera/color/camera_info", 10, &color_camera_info_callback);
ros::Subscriber sub_reloc_pose = nh.subscribe("realsense/localized_tracked_objects", 10, &localized_tracked_objects_callback);
ros::Duration duration;
duration.sec = 10;
duration.sleep();
ros::spinOnce();
ROS_INFO_STREAM("RealSense OBJECT test - Running Tests...");
return RUN_ALL_TESTS();
}
catch (...) {} // catch the "testing::internal::<unnamed>::ClassUniqueToAlwaysTrue" from gtest
|
[
"matthew.c.curfman@intel.com"
] |
matthew.c.curfman@intel.com
|
ba9690ef049018796b11875c48debf8968158cc3
|
7bcb66d652628227febe3b19579ac9efbe98addd
|
/PAUI/PlottingImageListener.hpp
|
6785ab87f8d88fb38f5c1ff785b0b78c44db713f
|
[] |
no_license
|
AntonioTavares24/PAUI-RAPOSA
|
ab2bdda925b6b99912f090928b5595ded0129a24
|
a2786ecb88dc883724d4a23d2823ce7d03273e6f
|
refs/heads/master
| 2023-01-09T12:38:22.628219
| 2020-11-06T18:05:15
| 2020-11-06T18:05:15
| 310,671,485
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 11,738
|
hpp
|
#pragma once
#include <iostream>
#include <memory>
#include <chrono>
#include <thread>
#include <mutex>
#include <fstream>
#include <map>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <boost/filesystem.hpp>
#include <boost/timer/timer.hpp>
#include <boost/program_options.hpp>
#include <boost/algorithm/string.hpp>
#include "ImageListener.h"
using namespace affdex;
class PlottingImageListener : public ImageListener
{
std::mutex mMutex;
std::deque<std::pair<Frame, std::map<FaceId, Face> > > mDataArray;
double mCaptureLastTS;
double mCaptureFPS;
double mProcessLastTS;
double mProcessFPS;
std::ofstream &fStream;
std::chrono::time_point<std::chrono::system_clock> mStartT;
const bool mDrawDisplay;
const int spacing = 10;
const float font_size = 0.5f;
const int font = cv::FONT_HERSHEY_COMPLEX_SMALL;
std::vector<std::string> expressions;
std::vector<std::string> emotions;
std::vector<std::string> emojis;
std::vector<std::string> headAngles;
std::map<affdex::Glasses, std::string> glassesMap;
std::map<affdex::Gender, std::string> genderMap;
std::map<affdex::Age, std::string> ageMap;
std::map<affdex::Ethnicity, std::string> ethnicityMap;
public:
PlottingImageListener(std::ofstream &csv, const bool draw_display)
: fStream(csv), mDrawDisplay(draw_display), mStartT(std::chrono::system_clock::now()),
mCaptureLastTS(-1.0f), mCaptureFPS(-1.0f),
mProcessLastTS(-1.0f), mProcessFPS(-1.0f)
{
expressions = {
"smile", "innerBrowRaise", "browRaise", "browFurrow", "noseWrinkle",
"upperLipRaise", "lipCornerDepressor", "chinRaise", "lipPucker", "lipPress",
"lipSuck", "mouthOpen", "smirk", "eyeClosure", "attention", "eyeWiden", "cheekRaise",
"lidTighten", "dimpler", "lipStretch", "jawDrop"
};
emotions = {
"joy", "fear", "disgust", "sadness", "anger",
"surprise", "contempt", "valence", "engagement"
};
headAngles = { "pitch", "yaw", "roll" };
emojis = std::vector<std::string> {
"relaxed", "smiley", "laughing",
"kissing", "disappointed",
"rage", "smirk", "wink",
"stuckOutTongueWinkingEye", "stuckOutTongue",
"flushed", "scream"
};
genderMap = std::map<affdex::Gender, std::string> {
{ affdex::Gender::Male, "male" },
{ affdex::Gender::Female, "female" },
{ affdex::Gender::Unknown, "unknown" },
};
glassesMap = std::map<affdex::Glasses, std::string> {
{ affdex::Glasses::Yes, "yes" },
{ affdex::Glasses::No, "no" }
};
ageMap = std::map<affdex::Age, std::string> {
{ affdex::Age::AGE_UNKNOWN, "unknown"},
{ affdex::Age::AGE_UNDER_18, "under 18" },
{ affdex::Age::AGE_18_24, "18-24" },
{ affdex::Age::AGE_25_34, "25-34" },
{ affdex::Age::AGE_35_44, "35-44" },
{ affdex::Age::AGE_45_54, "45-54" },
{ affdex::Age::AGE_55_64, "55-64" },
{ affdex::Age::AGE_65_PLUS, "65 plus" }
};
ethnicityMap = std::map<affdex::Ethnicity, std::string> {
{ affdex::Ethnicity::UNKNOWN, "unknown"},
{ affdex::Ethnicity::CAUCASIAN, "caucasian" },
{ affdex::Ethnicity::BLACK_AFRICAN, "black african" },
{ affdex::Ethnicity::SOUTH_ASIAN, "south asian" },
{ affdex::Ethnicity::EAST_ASIAN, "east asian" },
{ affdex::Ethnicity::HISPANIC, "hispanic" }
};
fStream << "TimeStamp,faceId,interocularDistance,glasses,age,ethnicity,gender,dominantEmoji,";
for (std::string angle : headAngles) fStream << angle << ",";
for (std::string emotion : emotions) fStream << emotion << ",";
for (std::string expression : expressions) fStream << expression << ",";
for (std::string emoji : emojis) fStream << emoji << ",";
fStream << std::endl;
fStream.precision(4);
fStream << std::fixed;
}
FeaturePoint minPoint(VecFeaturePoint points)
{
VecFeaturePoint::iterator it = points.begin();
FeaturePoint ret = *it;
for (; it != points.end(); it++)
{
if (it->x < ret.x) ret.x = it->x;
if (it->y < ret.y) ret.y = it->y;
}
return ret;
};
FeaturePoint maxPoint(VecFeaturePoint points)
{
VecFeaturePoint::iterator it = points.begin();
FeaturePoint ret = *it;
for (; it != points.end(); it++)
{
if (it->x > ret.x) ret.x = it->x;
if (it->y > ret.y) ret.y = it->y;
}
return ret;
};
double getProcessingFrameRate()
{
std::lock_guard<std::mutex> lg(mMutex);
return mProcessFPS;
}
double getCaptureFrameRate()
{
std::lock_guard<std::mutex> lg(mMutex);
return mCaptureFPS;
}
int getDataSize()
{
std::lock_guard<std::mutex> lg(mMutex);
return mDataArray.size();
}
std::pair<Frame, std::map<FaceId, Face>> getData()
{
std::lock_guard<std::mutex> lg(mMutex);
std::pair<Frame, std::map<FaceId, Face>> dpoint = mDataArray.front();
mDataArray.pop_front();
return dpoint;
}
void onImageResults(std::map<FaceId, Face> faces, Frame image) override
{
std::lock_guard<std::mutex> lg(mMutex);
mDataArray.push_back(std::pair<Frame, std::map<FaceId, Face>>(image, faces));
std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
std::chrono::milliseconds milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now - mStartT);
double seconds = milliseconds.count() / 1000.f;
mProcessFPS = 1.0f / (seconds - mProcessLastTS);
mProcessLastTS = seconds;
};
void onImageCapture(Frame image) override
{
std::lock_guard<std::mutex> lg(mMutex);
mCaptureFPS = 1.0f / (image.getTimestamp() - mCaptureLastTS);
mCaptureLastTS = image.getTimestamp();
};
void outputToFile(const std::map<FaceId, Face> faces, const double timeStamp)
{
if (faces.empty())
{
fStream << timeStamp << ",nan,nan,no,unknown,unknown,unknown,unknown,";
for (std::string angle : headAngles) fStream << "nan,";
for (std::string emotion : emotions) fStream << "nan,";
for (std::string expression : expressions) fStream << "nan,";
for (std::string emoji : emojis) fStream << "nan,";
fStream << std::endl;
}
for (auto & face_id_pair : faces)
{
Face f = face_id_pair.second;
fStream << timeStamp << ","
<< f.id << ","
<< f.measurements.interocularDistance << ","
<< glassesMap[f.appearance.glasses] << ","
<< ageMap[f.appearance.age] << ","
<< ethnicityMap[f.appearance.ethnicity] << ","
<< genderMap[f.appearance.gender] << ","
<< affdex::EmojiToString(f.emojis.dominantEmoji) << ",";
float *values = (float *)&f.measurements.orientation;
for (std::string angle : headAngles)
{
fStream << (*values) << ",";
values++;
}
values = (float *)&f.emotions;
for (std::string emotion : emotions)
{
fStream << (*values) << ",";
values++;
}
values = (float *)&f.expressions;
for (std::string expression : expressions)
{
fStream << (*values) << ",";
values++;
}
values = (float *)&f.emojis;
for (std::string emoji : emojis)
{
fStream << (*values) << ",";
values++;
}
fStream << std::endl;
}
}
void drawValues(const float * first, const std::vector<std::string> names,
const int x, int &padding, const cv::Scalar clr,
cv::Mat img)
{
for (std::string name : names)
{
if (std::abs(*first) > 5.0f)
{
char m[50];
sprintf(m, "%s: %3.2f", name.c_str(), (*first));
cv::putText(img, m, cv::Point(x, padding += spacing), font, font_size, clr);
}
first++;
}
}
void draw(const std::map<FaceId, Face> faces, Frame image)
{
std::shared_ptr<BYTE> imgdata = image.getBGRByteArray();
cv::Mat img = cv::Mat(image.getHeight(), image.getWidth(), CV_8UC3, imgdata.get());
const int left_margin = 30;
cv::Scalar clr = cv::Scalar(0, 0, 255);
cv::Scalar header_clr = cv::Scalar(255, 0, 0);
for (auto & face_id_pair : faces)
{
Face f = face_id_pair.second;
VecFeaturePoint points = f.featurePoints;
for (auto& point : points) //Draw face feature points.
{
cv::circle(img, cv::Point(point.x, point.y), 2.0f, cv::Scalar(0, 0, 255));
}
FeaturePoint tl = minPoint(points);
FeaturePoint br = maxPoint(points);
//Output the results of the different classifiers.
int padding = tl.y + 10;
cv::putText(img, "APPEARANCE", cv::Point(br.x, padding += (spacing * 2)), font, font_size, header_clr);
cv::putText(img, genderMap[f.appearance.gender], cv::Point(br.x, padding += spacing), font, font_size, clr);
cv::putText(img, glassesMap[f.appearance.glasses], cv::Point(br.x, padding += spacing), font, font_size, clr);
cv::putText(img, ageMap[f.appearance.age], cv::Point(br.x, padding += spacing), font, font_size, clr);
cv::putText(img, ethnicityMap[f.appearance.ethnicity], cv::Point(br.x, padding += spacing), font, font_size, clr);
Orientation headAngles = f.measurements.orientation;
char strAngles[100];
sprintf(strAngles, "Pitch: %3.2f Yaw: %3.2f Roll: %3.2f Interocular: %3.2f",
headAngles.pitch, headAngles.yaw, headAngles.roll, f.measurements.interocularDistance);
char fId[10];
sprintf(fId, "ID: %i", f.id);
cv::putText(img, fId, cv::Point(br.x, padding += spacing), font, font_size, clr);
cv::putText(img, "MEASUREMENTS", cv::Point(br.x, padding += (spacing * 2)), font, font_size, header_clr);
cv::putText(img, strAngles, cv::Point(br.x, padding += spacing), font, font_size, clr);
cv::putText(img, "EMOJIS", cv::Point(br.x, padding += (spacing * 2)), font, font_size, header_clr);
cv::putText(img, "dominantEmoji: " + affdex::EmojiToString(f.emojis.dominantEmoji),
cv::Point(br.x, padding += spacing), font, font_size, clr);
drawValues((float *)&f.emojis, emojis, br.x, padding, clr, img);
cv::putText(img, "EXPRESSIONS", cv::Point(br.x, padding += (spacing * 2)), font, font_size, header_clr);
drawValues((float *)&f.expressions, expressions, br.x, padding, clr, img);
cv::putText(img, "EMOTIONS", cv::Point(br.x, padding += (spacing * 2)), font, font_size, header_clr);
drawValues((float *)&f.emotions, emotions, br.x, padding, clr, img);
}
char fps_str[50];
sprintf(fps_str, "capture fps: %2.0f", mCaptureFPS);
cv::putText(img, fps_str, cv::Point(img.cols - 110, img.rows - left_margin - spacing), font, font_size, clr);
sprintf(fps_str, "process fps: %2.0f", mProcessFPS);
cv::putText(img, fps_str, cv::Point(img.cols - 110, img.rows - left_margin), font, font_size, clr);
cv::imshow("analyze video", img);
std::lock_guard<std::mutex> lg(mMutex);
cv::waitKey(30);
}
};
|
[
"66315859+AntonioTavares24@users.noreply.github.com"
] |
66315859+AntonioTavares24@users.noreply.github.com
|
336c142c0ea06c3627f66d6151b9a2e8d99596a3
|
4ec6194bb6d1f8ad3e7c382dc6d98b8267a9f3e3
|
/src/storage/FCS.h
|
3f6eb530bf6248554c0aafd0dffd1e4050f362bc
|
[
"MIT",
"LicenseRef-scancode-other-permissive"
] |
permissive
|
goodwill2684/Firebase-ESP-Client
|
025c1b46cccdc51c00c67d7b8fa03bb0de22d414
|
861a08257d732093a699bee385675d73c65c3797
|
refs/heads/main
| 2023-07-02T23:12:56.464087
| 2021-08-15T10:02:15
| 2021-08-15T10:02:15
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,199
|
h
|
/**
* Google's Firebase Storage class, FCS.h version 1.1.3
*
* This library supports Espressif ESP8266 and ESP32
*
* Created August 15, 2021
*
* This work is a part of Firebase ESP Client library
* Copyright (c) 2021 K. Suwatchai (Mobizt)
*
* The MIT License (MIT)
* Copyright (c) 2021 K. Suwatchai (Mobizt)
*
*
* Permission is hereby granted, free of charge, to any person returning 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 "FirebaseFS.h"
#ifdef ENABLE_FB_STORAGE
#ifndef FB_Storage_H
#define FB_Storage_H
#include <Arduino.h>
#include "Utils.h"
#include "session/FB_Session.h"
class FB_Storage
{
friend class Firebase_ESP_Client;
public:
struct RequestType;
FB_Storage();
~FB_Storage();
/** Upload file to the Firebase Storage data bucket.
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
* @param localFileName The file path includes its name to upload.
* @param storageType The enum of memory storage type e.g. mem_storage_type_flash and mem_storage_type_sd. The file systems can be changed in FirebaseFS.h.
* @param remotetFileName The file path includes its name of uploaded file in data bucket.
* @param mime The file MIME type
* .
* @return Boolean value, indicates the success of the operation.
*
* @note Use FirebaseData.downloadURL() to get the download link.
*
*/
bool upload(FirebaseData *fbdo, const char *bucketID, const char *localFileName, fb_esp_mem_storage_type storageType, const char *remotetFileName, const char *mime);
/** Upload byte array to the Firebase Storage data bucket.
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
* @param data The byte array of data.
* @param len The size of byte array data in bytes.
* @param remotetFileName The file path includes its name of uploaded file in data bucket.
* @param mime The file MIME type
* .
* @return Boolean value, indicates the success of the operation.
*
* @note Use FirebaseData.downloadURL() to get the download link.
*
*/
bool upload(FirebaseData *fbdo, const char *bucketID, const uint8_t *data, size_t len, const char *remoteFileName, const char *mime);
/** Download file from the Firebase Storage data bucket.
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
* @param remotetFileName The file path includes its name of file in the data bucket to download.
* @param localFileName The file path includes its name to save.
* @param storageType The enum of memory storage type e.g. mem_storage_type_flash and mem_storage_type_sd. The file systems can be changed in FirebaseFS.h.
*
* @return Boolean value, indicates the success of the operation.
*
*/
bool download(FirebaseData *fbdo, const char *bucketID, const char *remoteFileName, const char *localFileName, fb_esp_mem_storage_type storageType);
/** Get the meta data of file in Firebase Storage data bucket
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
* @param remotetFileName The file path includes its name of file in the data bucket.
*
* @return Boolean value, indicates the success of the operation.
*
* @note Use the FileMetaInfo type data to get name, bucket, contentType, size,
* generation, etag, crc32, downloadTokens properties from file.
*
*/
bool getMetadata(FirebaseData *fbdo, const char *bucketID, const char *remoteFileName);
/** Delete file from Firebase Storage data bucket
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
* @param remotetFileName The file path includes its name of file in the data bucket.
*
* @return Boolean value, indicates the success of the operation.
*
*/
bool deleteFile(FirebaseData *fbdo, const char *bucketID, const char *fileName);
/** List all files in the Firebase Storage data bucket.
*
* @param fbdo The pointer to Firebase Data Object.
* @param bucketID The Firebase storage bucket ID in the project.
*
* @return Boolean value, indicates the success of the operation.
*
* @note Use the FileList type data to get name and bucket properties for each item.
*
*/
bool listFiles(FirebaseData *fbdo, const char *bucketID);
private:
UtilsClass *ut = nullptr;
void begin(UtilsClass *u);
bool sendRequest(FirebaseData *fbdo, struct fb_esp_fcs_req_t *req);
void rescon(FirebaseData *fbdo, const char *host);
bool fcs_connect(FirebaseData *fbdo);
bool fcs_sendRequest(FirebaseData *fbdo, struct fb_esp_fcs_req_t *req);
bool handleResponse(FirebaseData *fbdo);
};
#endif
#endif //ENABLE
|
[
"k_suwatchai@hotmail.com"
] |
k_suwatchai@hotmail.com
|
abcdf1bff260ae165d7cff0ea915374a95087daf
|
edcde36aec5ab5166510e9e2fb6afd369deaf13c
|
/src/compiler/tempest/sema/convert/subtype.cpp
|
5107b8c7f76c50107c45f396afa71af2780018c2
|
[] |
no_license
|
viridia/tempest
|
585f6f44b7047f60a9799fd082e168e815bd8264
|
a0ecf8269dc68edf182dce62bbef6b9602a0adc6
|
refs/heads/master
| 2020-03-23T11:53:47.431485
| 2018-11-16T01:59:28
| 2018-11-16T01:59:28
| 141,525,372
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,075
|
cpp
|
#include "tempest/error/diagnostics.hpp"
#include "tempest/sema/convert/predicate.hpp"
#include "tempest/sema/graph/primitivetype.hpp"
#include "tempest/sema/transform/applyspec.hpp"
namespace tempest::sema::convert {
using namespace tempest::sema::graph;
using namespace llvm;
using tempest::error::diag;
using tempest::sema::transform::TempMapTypeVars;
bool isSubtype(
const TypeDefn* st, Env& stEnv,
const TypeDefn* bt, Env& btEnv) {
if (bt == st) {
if (btEnv.args.size() != stEnv.args.size()) {
return false;
}
// Make sure type arguments are the same
for (auto param : bt->allTypeParams()) {
if (!isEqual(btEnv.args[param->index()], stEnv.args[param->index()])) {
return false;
}
}
return true;
}
MemberArray bases;
if (bt->type()->kind == st->type()->kind) {
bases = st->extends();
} else if (bt->type()->kind == Type::Kind::INTERFACE || bt->type()->kind == Type::Kind::TRAIT) {
bases = st->implements();
} else {
return false;
}
for (auto base : bases) {
if (base->kind == Defn::Kind::SPECIALIZED) {
auto sp = static_cast<const SpecializedDefn*>(base);
TempMapTypeVars apply(stEnv.args);
Env newEnv;
newEnv.params = sp->typeParams();
newEnv.args = apply.transformArray(sp->typeArgs());
if (auto baseDefn = dyn_cast<TypeDefn>(sp->generic())) {
if (isSubtype(baseDefn, newEnv, bt, btEnv)) {
return true;
}
} else {
assert(false && "Invalid base type");
}
} else if (auto baseDefn = dyn_cast<TypeDefn>(base)) {
if (isSubtype(baseDefn, stEnv, bt, btEnv)) {
return true;
}
} else {
assert(false && "Invalid base type");
}
}
return false;
}
// TODO: Check for structural typing.
// If st is a class and bt is an interface or trait;
// if st is a struct, interface, trait, alias, and bt is a trait.
// And we probably want to cache the result.
}
|
[
"viridia@gmail.com"
] |
viridia@gmail.com
|
74d27be2f454624d2c6ec9f3580239d2e6be984d
|
eaa3ae87183bb5f6848fa1c6a401355bc0dd61f5
|
/Huffman/HuffmanTree.h
|
12b019a497b3d0e1cc3369a10ca8c2b3e3f2aeb5
|
[
"MIT"
] |
permissive
|
Happyxianyueveryday/mip-homework
|
c21f8d4c830c1f9b8d271b5ed0c0959cc095b118
|
8c4148bd7b7beb7b17cecb3f059ce3766d63f36e
|
refs/heads/master
| 2020-09-12T01:55:28.152745
| 2020-02-23T15:03:00
| 2020-02-23T15:03:00
| 222,261,153
| 5
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 5,881
|
h
|
#ifndef HUFFMAN_TREE_H
#define HUFFMAN_TREE_H
#include "Forest.h"
#include <iostream>
#include <string>
#include <cstdlib>
#include <map>
#include <vector>
#include <queue>
/**
* HuffmanTree: 哈夫曼树结构
*/
class HuffmanTree
{
public:
// 1. constructor
HuffmanTree(std::map<char, double> dic);
HuffmanTree(double leaves[], char words[], int size);
// 2. copy controller
HuffmanTree(const HuffmanTree &other);
HuffmanTree & operator = (const HuffmanTree &other);
// 3. methods
std::string toString();
std::map<char, std::string> getHuffmanCode();
// 4. destructor
~HuffmanTree();
// 5. domains
private:
TreeNode *treeroot;
TreeNode *__copyTree(TreeNode *root);
void __deleteTree(TreeNode *root);
};
/**
* HuffmanTree: 根据给定的叶子结点构造哈夫曼树
* param dic: 字符到出现频率的映射表
*/
HuffmanTree::HuffmanTree(std::map<char, double> dic)
{
// 1. 首先将各个叶子结点构造成单独的树，并使用这些树构建成森林
Forest forest;
for(auto a=dic.begin();a!=dic.end();a++)
{
TreeNode *temp=new TreeNode(a->second, a->first);
forest.insert(temp);
}
// 2. 每次从森林中弹出两个最小的树left和right，创建一个新的根结点，将弹出的树left和right分别作为新根结点的左右子树，新的根结点的值就等于left和right的根结点的值之和
while(forest.length()>1)
{
TreeNode *left=forest.pop();
TreeNode *right=forest.pop();
TreeNode *newroot=new TreeNode(left->val+right->val);
newroot->left=left;
newroot->right=right;
forest.insert(newroot);
}
// 3. 最终森林中剩下的一个树就是哈夫曼树
treeroot=forest.pop();
}
/**
* HuffmanTree: 根据给定的叶子结点构造哈夫曼树
* param leaves: 输入的字符的出现频率
* param words: 输入的各个频率对应的字符
* param size: 输入数组的大小
*/
HuffmanTree::HuffmanTree(double leaves[], char words[], int size)
{
// 1. 首先将各个叶子结点构造成单独的树，并使用这些树构建成森林
Forest forest;
for(int i=0;i<size;i++)
{
TreeNode *temp=new TreeNode(leaves[i], words[i]);
forest.insert(temp);
}
// 2. 每次从森林中弹出两个最小的树left和right，创建一个新的根结点，将弹出的树left和right分别作为新根结点的左右子树，新的根结点的值就等于left和right的根结点的值之和
while(forest.length()>1)
{
TreeNode *left=forest.pop();
TreeNode *right=forest.pop();
TreeNode *newroot=new TreeNode(left->val+right->val);
newroot->left=left;
newroot->right=right;
forest.insert(newroot);
}
// 3. 最终森林中剩下的一个树就是哈夫曼树
treeroot=forest.pop();
}
/**
* HuffmanTree: 拷贝构造函数
*/
HuffmanTree::HuffmanTree(const HuffmanTree &other)
{
treeroot=__copyTree(other.treeroot);
}
/**
* operator =: 拷贝赋值运算符
*/
HuffmanTree & HuffmanTree::operator = (const HuffmanTree &other)
{
if(&other==this)
return (*this);
__deleteTree(treeroot);
treeroot=__copyTree(other.treeroot);
return (*this);
}
/**
* toString: 按层次遍历输出哈夫曼树
* return: 所构建的哈夫曼树的层次遍历序列
*/
std::string HuffmanTree::toString()
{
std::string res;
if(!treeroot)
return res;
std::queue<TreeNode *> que;
que.push(treeroot);
while(que.size())
{
TreeNode *temp=que.front();
char value[100];
itoa(temp->val, value, 10);
res=res+std::string(value)+" ";
que.pop();
if(temp->left)
que.push(temp->left);
if(temp->right)
que.push(temp->right);
}
return res;
}
/**
* getHuffmanCode: 从哈夫曼树获得哈夫曼编码
* return: 从叶子结点的值到哈夫曼编码的映射
* note: 从哈夫曼树得到哈夫曼编码的算法非常容易，将通向左子结点的边记为0，将通向右子结点的边记为1，对于每个叶子结点，从根结点到叶子结点的路径所代表的0或者1组合起来，就得到最终的哈夫曼编码
*/
std::map<char, std::string> HuffmanTree::getHuffmanCode()
{
std::map<char, std::string> res;
if(!treeroot)
return res;
std::queue<std::pair<TreeNode *, std::string> > que;
que.push(std::make_pair(treeroot, ""));
while(que.size())
{
std::pair<TreeNode *, std::string> temp=que.front();
que.pop();
if(!temp.first->left&&!temp.first->right) // 若遇到叶子结点，则将对应的哈夫曼编码写入结果中
{
res[temp.first->chr]=temp.second;
}
if(temp.first->left)
que.push(make_pair(temp.first->left, temp.second+"0"));
if(temp.first->right)
que.push(make_pair(temp.first->right, temp.second+"1"));
}
return res;
}
/**
* ~HuffmanTree: 本类的析构函数
*/
HuffmanTree::~HuffmanTree()
{
if(!treeroot)
return;
std::queue<TreeNode *> que;
que.push(treeroot);
while(que.size())
{
TreeNode *temp=que.front();
que.pop();
if(temp->left)
que.push(temp->left);
if(temp->right)
que.push(temp->right);
delete temp;
}
}
/**
* __copyTree: 制作树的拷贝
*/
TreeNode *HuffmanTree::__copyTree(TreeNode *root)
{
if(!root)
return NULL;
else if(!root->left&&!root->right)
{
TreeNode *res=new TreeNode(root->val);
return res;
}
else
{
TreeNode *res=new TreeNode(root->val);
res->left=__copyTree(root->left);
res->right=__copyTree(root->right);
return res;
}
}
/**
* __deleteTree: 删除树并释放树的内存
*/
void HuffmanTree::__deleteTree(TreeNode *root)
{
if(!root)
return;
else
{
TreeNode *left=root->left;
TreeNode *right=root->right;
delete root;
__deleteTree(left);
__deleteTree(right);
}
}
#endif
|
[
"noreply@github.com"
] |
Happyxianyueveryday.noreply@github.com
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.