text
stringlengths 8
6.88M
|
|---|
#include<cstdio>
#include<algorithm>
#include<map>
#include<set>
using namespace std;
const int MAX_N = 100000;
int P;
int a[MAX_N];
void solve(){
set<int> all;
for (int i=0; i < P; i++){
all.insert(a[i]);
}
int n= all.size();
int s=0, t=0, num=0;
map<int, int> count;
int res = P;
for(;;){
while(t<P && num<n){
if(count[a[t++]]++ == 0){
num++;
}
}
if(num < n) break;
res = min(res, t-s);
if(--count[a[s++]] == 0){
num--;
}
}
printf("%d\n", res);
}
|
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
int main(int argc, char **argv)
{
if (argc != 2) {
return 0;
}
std::ifstream f(argv[1]); // first argument is the test file
while (true) {
std::string line;
std::getline(f, line);
if (f.fail()) {
break;
}
size_t p1 = line.find_first_of(',');
int last = atoi(line.substr(0, p1).c_str());
std::cout << last;
line = line.substr(p1+1);
while (true) {
size_t n1 = line.find_first_of(',');
int n = atoi(line.substr(0, n1).c_str());
if (last != n) {
std::cout << ',' << n;
last = n;
}
line = line.substr(n1+1);
if (n1 == std::string::npos) {
break;
}
}
std::cout << '\n';
}
return 0;
}
|
#include<iostream>
#include<unordered_map>
#include<string>
using namespace std;
const int LM = (int)(1e6) + 3;
int k;
char str[LM];
int cnt[4];
struct Data {
int a, c, g, t;
};
struct myHash {
size_t operator()(const Data &d) const{
return d.a * (1000) * (1000) * (1000) + d.c * (1000) * (1000) + d.g * (1000) + d.t;
}
};
struct myEqual {
size_t operator()(const Data& d1, const Data&d2) const {
return (d1.a == d2.a) && (d1.c == d2.c) && (d1.g == d2.g) && (d1.t == d2.t);
}
};
unordered_map<Data, int, myHash, myEqual> htab;
void update(Data & _cur, char c, int param) {
if (c == 'A') _cur.a += param;
if (c == 'C') _cur.c += param;
if (c == 'G') _cur.g += param;
if (c == 'T') _cur.t += param;
}
int main() {
freopen("input.txt", "r", stdin);
scanf("%d", &k);
scanf("%s", str);
int rst = -1;
Data cur{ 0, 0, 0, 0 };
for (int i = 0; str[i]; i++) {
update(cur, str[i], 1);
if (i >= k) update(cur, str[i - k], -1);
rst=max(rst, ++htab[cur]);
}
printf("%d\n", rst);
return 0;
}
|
#if (stratos == 0)
void AIN()
{
for( channel = 0; channel < 8; channel++) /// per ognuno degli 8 channels del multiplexer vado poi a leggere tutti gli ingressi analogici (cioè l'uscita di ogni plexer)
{
#if (LED_rings == 1)
LED_rings_ ();
shifter.write();
#endif
#if (main_encoder == 1)
if (lastbutton[encoder_mempos[0]] == 64 || dmxtable[general_mempos] == 0)
// 64 = no encoder action - the MAIN spinner has priority over any other action.
#endif
{
virtual_touch_end(0);
if (maxvalue[general_mempos] == 0 ){ PADS();}
// if (dmxtable[general_mempos] >1)
// {senseEncoder_2nd();} // carica MSB LSB [1] // // gli input pin su cui viene letto il secondo encoder sono 33 e 41
///////////////////////////////////////////////////////////////////
if (valuetable[general_mempos] !=1 ) // nomobo setup
setPlexer(channel); // all 4051's are set on the channel to be read
// if (dmxtable[general_mempos] >1)
// {senseEncoder_2nd();} // carica MSB LSB [1] // // gli input pin su cui viene letto il secondo encoder sono 33 e 41
for(plexer = 0; plexer <
5+boolean(maxvalue[general_mempos]) // se si attivano i pads (mettendo maxvalue = 0) l'analogico A5 non viene letto
; plexer++) // plexer 0,1,2,3,4 - the 5th plexer is read at higher speed (pads and 2nd encoder)
{
chan = (plexer * 8) + channel ;
///////////////////////////////////////////////////////////////////////////////////// autodetect
if (eeprom_preset_active == 0) // se NON trovo un preset nella eeprom
{
valore = analogRead(plexer);
if (valore < upper_val /// se premo un pulsante - valore scende
&& dmxtable[chan] < 3
)
{
detect_plexer();
if (valore > 448 && valore < 576 ) // se si ha un valore intermedio
{
{
modetable[chan] = 11;
typetable[chan]= 176;
}
// test1();
}
}
qwertyvalue[chan] = valore /32; // registra la lettura per un futuro confronto in un range 0-255
}
////////////////////////////////////////////////////////////////////////////////////////////////// fine autodetect
else // trovo un preset nella eeprom
{
if (modetable[chan] < 11) // per tutti i pulsanti si usa digitalread, che legge in modo più rapido
#if defined (__AVR_ATmega32U4__)
valore = digitalRead(plexer+18)*1020; //
#endif
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
valore = digitalRead(plexer+14)*1020; //
#endif
else if (modetable[chan] < 19 || modetable[chan] == 27) valore = analogRead(plexer); // si usa analogread per i pots
#if (encoders_generic == 1)
else if (modetable[chan] == 19) // encoders
{
#if defined (__AVR_ATmega32U4__)
MSB[1]= digitalRead(plexer+18); //
LSB[1]= digitalRead(plexer+19); //
#endif
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
MSB[1] = digitalRead(plexer+14); //
LSB[1]= digitalRead(plexer+15);
#endif
}
#endif
if (channel == 5 && dmxtable[general_mempos] >1) { // gestione del SIDE SPINNER
#if defined (__AVR_ATmega32U4__)
MSB[1]= digitalRead(22);
LSB[1]= digitalRead(23);
#endif
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
MSB[1]= digitalRead(18);
LSB[1]= digitalRead(19);
#endif
updateEncoder(encoder_mempos[1]);
encoder(encoder_mempos[1]);
}
}
// if ((mousex-127) != 0 )
// if (chan == 39)
// { Serial.print(valore);
// Serial.println(" / ");// Serial.println(mousex-127);
// delay(50);
// }
ain_nucleo();
}
// __________________________________________________________
if (minvalue[general_mempos] > 0) // vedi se il plexer EXTRA è attivato
{
#if (pullups_active == 1)
digitalWrite(9, HIGH);
#endif
#if defined (__AVR_ATmega32U4__)
valore = analogRead(9);
#endif
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
valore = 1000*(!digitalRead(9));
#endif
chan = channel + 48;
ain_nucleo();
}
// ______________________________________________________
else virtual_touch_end(1); // se non c'e' l'extraplex, c'e' il touch2 // col suo virtualtouch
}
#if (main_encoder == 1)
else {
encoder(encoder_mempos[0]);
}
#endif
} // end PLEXER
} // end ain
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////
void ain_nucleo()
{
#if defined (__AVR_ATmega32U4__)
if (mouse_mempos > 0 ) mouse_control () ;
#endif
if ( modetable[chan] == 0) {}
else if ( modetable[chan] > 0 && modetable[chan]< 11) {push_buttons(); }
else if (modetable[chan] < 16) pots(); // pots + hypercurves - 11, 12,13,14,15,
else if (modetable[chan] == 16) user_item();
else if (modetable[chan] == 17) { if (valore < 512) lastbutton[page_mempos] =0; else lastbutton[page_mempos] =1;} // page switch
else if (modetable[chan] == 18) { // beam
#if defined (__AVR_ATmega32U4__)
digitalWrite(18+plexer, LOW); // tolgo la pullup
valore = analogRead(plexer); beam();
digitalWrite(18+plexer, HIGH); // rimetto la pullup
#endif
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
digitalWrite(14+plexer, LOW);
valore = analogRead(plexer); beam();
digitalWrite(14+plexer, HIGH);
#endif
}
#if (encoders_generic == 1)
else if (modetable[chan] == 19) {updateEncoder(chan);
// Serial.println(lastbutton[chan]); delay(100);
encoder(chan); }
#endif
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if (stratos == 0)
void detect_plexer()
{
{
if (channel >4) scala_learn = -1; else scala_learn = 1;
// mi serviva un variabile int non usata nel default preset...
// scala_learn qui mi serve per leggere un input plexer diverso dall'attuale
// solo nel caso in cui channel > 4 devo andare a leggere un input " in avanti" altrimenti rischierei di leggere
// l'input di un'altro plexer
if (valuetable[chan] == valuetable[chan+scala_learn]) // solo se non e' ancora stata effettuata la diversificazione
{ //----------------------
if ((valore/128) <20 && qwertyvalue[chan+scala_learn]>30)
// se il valore attuale e' diverso da un valore precedente all'interno dello stesso gruppo-plexer
{ // i valori di valuetable dentro il gruppo-plexer vanno resi tutti diversi
{ setPlexer(channel+scala_learn);
if ( analogRead(plexer)> upper_val) /// valori molto diversi
// { setPlexer(channel+(scala_learn*2)); // controlla ancora
// if ( analogRead(plexer) > upper_val )
// diversifica_valuetable ();
// }
diversifica_valuetable ();
setPlexer(channel); // torna al plexer normale
} }
} // --------------------------
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void diversifica_valuetable ()
{
for (byte i = 0; i <8; i++)
{ valuetable[i+(plexer*8)] = i+(plexer*8) +60
;
}
}
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void scale_learn(byte pitch)
{
if (lastbutton[touch_mempos[0]] == 0 || lastbutton[touch_mempos[1]] == 0) // se il touch è premuto/toccato
{
if (dmxtable[encoder_mempos[0]] == 3) encodervaluepot[0] = pitch * 8;
if (scala_reset == 1) // azzera la scala
for (byte i =0; i < scala_lenght; i++){
scala_array[i] = 0;
scala_learn= 0;
scala_reset =0; }
scala_array[scala_counter] = (pitch - (pitch/12)*12)+1; // 0 == nessuna nota,
scala_counter++;
if (scala_counter >= scala_lenght) scala_counter = 0;
scala_learn =0;
for (byte i =0; i< scala_lenght; i++)
{
// if (scala_array[i] != 0)
if (scala_array[i] >0 ) // 0 = nessuna nota da caricare nella scala
bitWrite(scala_learn, scala_array[i]-1, 1);
}
}
}
/////////////////////////////////////////////////////---------------------------
void update_scala(byte quale_spinner) // quale_spinner è 0 top 1 side
// richiamato da setup_mempos() e da switchpage()
{
// scala[4] è un array che cotiene 4 scale... scalaSpinner0-page1, scalaSpinner1-page1, ScalaSpinner0-page2, scalaSpinner1-page2
// per caricare una scala dalla eeprom di servono 12 BIT - per le 12 note di un'ottava
// i primi 7 BIT sono dentro valuetable
// gli altri 5 BIT sono dentro lastencoded[2]
// lastEncoded[] viene ricaricata ogni volta che si carica un preset - quindi è sempre "attuale" rispetto alla pagina.
for (byte i = 0; i< 7; i++) {
bitWrite(scala[quale_spinner+(page/max_modifiers)*2],i, bitRead(valuetable[encoder_mempos[quale_spinner]+max_modifiers] ,i) );
//bitWrite(scala[numero+2],i, bitRead(valuetable[encoder_mempos[numero]+max_modifiers] ,i) );
}
for (byte i = 0; i< 5; i++) {
bitWrite(scala[quale_spinner+(page/max_modifiers)*2],i+7, bitRead(lastEncoded[quale_spinner] , i) );
// bitWrite(scala[numero+2],i+7, bitRead(lastEncoded[numero] , i) );
/*
// old version
for (byte i = 0; i< 7; i++) {
bitWrite(scala[numero],i, bitRead(valuetable[encoder_mempos[numero]] ,i) );
bitWrite(scala[numero+2],i, bitRead(valuetable[encoder_mempos[numero]+max_modifiers] ,i) );
}
for (byte i = 0; i< 5; i++) {
bitWrite(scala[numero],i+7, bitRead(maxvalue[encoder_mempos[numero]] , i) );
bitWrite(scala[numero+2],i+7, bitRead(maxvalue[encoder_mempos[numero]+max_modifiers] , i) );
*/
}
}
////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
#if (stratos == 0 )
void setPlexer( byte channel)
{
// set the selector pins HIGH and LOW to match the binary value of channel
for(byte bit = 0; bit < 3; bit++)
{
byte pin = bit+4; // the pin wired to the multiplexer select bit
byte isBitSet = bitRead(channel, bit); // true if given bit set in channel
digitalWrite(pin, isBitSet);
}
}
#endif
|
#include<iostream>
#include<string>
using namespace std;
class kolejka
{
private:
int pojemnosc;
int pocz;
int ile;
string *Q;
public:
kolejka(int x);
kolejka();
kolejka(const kolejka &queue);
kolejka(kolejka &&source);
kolejka(initializer_list<string>H);
~kolejka();
void wloz(string w);
string wyciagnij();
string sprawdz();
int rozmiar();
};
|
#include "OneWire.h"
#include <SoftwareSerial.h> //"soft" serial port to prevent display corruption during upload
#define SensorPin A1 //pH meter Analog output to Arduino Analog Input 0
#define Offset 2.67 //deviation compensation
#define LED 12
#define samplingInterval 20
#define printInterval 800
#define ArrayLength 40 //times of collection
int pHArray[ArrayLength]; //Store the average value of the sensor feedback
int pHArrayIndex=0;
int DS18S20_Pin = 5; //DS18S20 temperature sensor signal pin on digital 4
//int button1 = 7; //button 1 pin (calibration)
//int button2 = 8; //button 2 pin (test)
//Temperature chip i/o
OneWire ds(DS18S20_Pin); //DS18S20 temperature sensor on digital pin 4
//LCD Serial i/o
SoftwareSerial mySerial(8,6); //Attach RX to digital pin 2
#include "dht.h"
const int transistorPin = 9; //I/O pin for controlling heating pad
dht DHT; //temperature sensor object
#define DHT22_DATA_PIN 7
unsigned long lastTime = 0;
unsigned long waitTime = 2000;
const uint8_t PIN_IN = 2; //Digital PIN, Envelop signal
const uint8_t PIN_LED_OUT = 13; //LED PIN on arduino (default)
const uint8_t LOW_LED_OUT = 3; //LED PIN for low sound levels
const uint8_t HIGH_LED_OUT = 4; //LED PIN for high sound levels
const uint8_t PIN_ANALOG = A0; //ANALOG PIN, gate signal
IncuTester myIncuTester;
void setup()
{
Serial.begin(115200);
mySerial.begin(9600); //Begin LCD serial
}
void loop()
{
myIncuTester.getTemp();
myIncuTester.getpH();
myIncuTester.getTempHumidity();
myIncuTester.analyzeSound();
myIncuTester.printToSerial(pHValue, temperature);
myIncuTester.printToLCD(pHValue, temperature);
delay(2000);
}
void soundISR() //Interupt function
{
int pin_val; //local variable of pin value
pin_val = digitalRead(PIN_ANALOG); //Setting pin value of PIN_A0
digitalWrite(PIN_LED_OUT, pin_val); //Allows to see if board recieving constant data stream
}
|
// C++ for the Windows Runtime vv1.0.170303.6
// Copyright (c) 2017 Microsoft Corporation. All rights reserved.
#pragma once
#include "Windows.Security.ExchangeActiveSyncProvisioning.2.h"
WINRT_EXPORT namespace winrt {
namespace Windows::Security::ExchangeActiveSyncProvisioning {
struct WINRT_EBO EasClientDeviceInformation :
Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation,
impl::require<EasClientDeviceInformation, Windows::Security::ExchangeActiveSyncProvisioning::IEasClientDeviceInformation2>
{
EasClientDeviceInformation(std::nullptr_t) noexcept {}
EasClientDeviceInformation();
};
struct WINRT_EBO EasClientSecurityPolicy :
Windows::Security::ExchangeActiveSyncProvisioning::IEasClientSecurityPolicy
{
EasClientSecurityPolicy(std::nullptr_t) noexcept {}
EasClientSecurityPolicy();
};
struct WINRT_EBO EasComplianceResults :
Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults,
impl::require<EasComplianceResults, Windows::Security::ExchangeActiveSyncProvisioning::IEasComplianceResults2>
{
EasComplianceResults(std::nullptr_t) noexcept {}
};
}
}
|
void setup() {
Serial.begin(9600);
pinMode(SEC_PIN, INPUT_PULLUP);
pinMode(RLS_PIN, OUTPUT);
//-----UDP-----
Ethernet.begin(mac, section);
Udp.begin(localPort);
//-----Leds-----
LED.begin();
//-----Boutons-----
pinMode(BTN_0, INPUT_PULLUP);
pinMode(BTN_1, INPUT_PULLUP);
pinMode(BTN_2, INPUT_PULLUP);
pinMode(BTN_3, INPUT_PULLUP);
Serial.println("Arduino pret.");
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll INF = (ll)(2e18);
struct LCASparse {
vector<vector<pair<int, int> > > dp;
vector<int> twos_power;
explicit LCASparse(vector<pair<int, int> > &a) {
size_t x = a.size() + 5;
twos_power.resize(x + 2);
for (size_t i = 1; i < x + 2; ++i) {
twos_power[i] = (int)(floor(log2(i)));
}
auto m = (size_t)(ceil(log2(x)));
dp.resize(m);
dp[0].resize(x);
for (size_t i = 0; i < x; ++i) {
dp[0][i] = a[i];
}
for (size_t i = 1; i < m; ++i) {
dp[i].resize(x);
for (size_t j = 0; j < x; ++j) {
dp[i][j] = dp[i - 1][j];
if (j + (1 << (i - 1)) < x)
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))]);
}
}
}
int min_(int l, int r) { // вхождения соответствующих вершин
int k = twos_power[r - l + 1];
return min(dp[k][l], dp[k][r - (1LL << k) + 1]).second;
}
};
vector<int> entry;
vector<int> dep;
vector<pair<int, int> > euler;
vector<vector<int> > children;
void dfs(int v, int d, int p) {
entry[v] = (int)euler.size();
dep[v] = d;
euler.emplace_back(d, v);
for (int u : children[v]) {
if (u == p) {
continue;
}
dfs(u, d + 1, v);
euler.emplace_back(d, v);
}
}
int lca(int v, int u, LCASparse &sparse) {
v = entry[v]; u = entry[u];
if (v > u) {
swap(v, u);
}
return sparse.min_(v, u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
// freopen("file.in", "r", stdin);
int n;
while (cin >> n) {
if (n == 0) {
break;
}
entry.clear();
euler.clear();
children.clear();
dep.clear();
int a, b, m;
dep.assign(n, 0);
entry.assign(n, 0);
children.assign((size_t)n, vector<int>());
for (int i = 1; i < n; ++i) {
cin >> a >> b; a--; b--;
children[b].push_back(a);
children[a].push_back(b);
}
dfs(0, 0, -1);
LCASparse sparse(euler);
//////////////////
string act;
int root = 0;
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> act;
if (act == "!") {
cin >> root; root--;
} else if (act == "?") {
cin >> a >> b; a--; b--;
int res = lca(a, b, sparse);
int L1 = lca(root, a, sparse);
int L2 = lca(root, b, sparse);
if (dep[L1] > dep[res]) {
res = L1;
}
if (dep[L2] > dep[res]) {
res = L2;
}
cout << res + 1 << " " << "\n";
}
}
}
return 0;
}
|
//
// Created by zanbo on 2020/3/5.
//
#include <vector>
#include <stdlib.h>
#include <iostream>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#include <stdio.h>
using namespace std;
struct ListNode
{
int val;
ListNode* next;
ListNode(int x): val(x),next(NULL){};
};
/**
* Definition for a binary tree node.
* */
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
//从0到n的最短路径问题 使用图的广度优先搜索 BFS ==== test case 7168 超时！
public:
int numSquares(int n) {
queue<int> q;
int step = 0;
int curlevelcount = 1; //队列中当前层级节点个数 pop后需要减1 为0表示全部为下一层
int nextlevelcount = 0; // next层个数 push后+1
q.push(n);
while(!q.empty())
{
int left = q.front();
if(left == 0)
return step;
q.pop();
curlevelcount--;
for(int i=0;i<=int(sqrt(n));i++)
{
q.push(left-i*i);
nextlevelcount++;
}
if(curlevelcount==0)
{
curlevelcount = nextlevelcount;
nextlevelcount = 0;
step++;
}
}
}
//动态规划
int numSquares2(int n) {
vector<int> dp(n + 1);
for (int i = 1; i <= n; ++i) {
dp[i] = i;
for (int j = 1; j * j <= i; ++j)
dp[i] = min(dp[i - j * j] + 1, dp[i]);
}
return dp[n];
}
};
int main()
{
Solution s;
int res = s.numSquares(7168);
cout<<res<<endl;
}
|
//
// Copyright (c) 2003--2009
// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
// Thomas Klimpel and Rutger ter Borg
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// THIS FILE IS AUTOMATICALLY GENERATED
// PLEASE DO NOT EDIT!
//
#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEIN_HPP
#define BOOST_NUMERIC_BINDINGS_LAPACK_COMPUTATIONAL_HSEIN_HPP
#include <boost/assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/numeric/bindings/lapack/detail/lapack.h>
#include <boost/numeric/bindings/lapack/workspace.hpp>
#include <boost/numeric/bindings/traits/detail/array.hpp>
#include <boost/numeric/bindings/traits/is_complex.hpp>
#include <boost/numeric/bindings/traits/is_real.hpp>
#include <boost/numeric/bindings/traits/traits.hpp>
#include <boost/numeric/bindings/traits/type_traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost {
namespace numeric {
namespace bindings {
namespace lapack {
//$DESCRIPTION
// overloaded functions to call lapack
namespace detail {
inline void hsein( char const side, char const eigsrc, char const initv,
logical_t* select, integer_t const n, float* h,
integer_t const ldh, float* wr, float* wi, float* vl,
integer_t const ldvl, float* vr, integer_t const ldvr,
integer_t const mm, integer_t& m, float* work, integer_t* ifaill,
integer_t* ifailr, integer_t& info ) {
LAPACK_SHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi,
vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
}
inline void hsein( char const side, char const eigsrc, char const initv,
logical_t* select, integer_t const n, double* h,
integer_t const ldh, double* wr, double* wi, double* vl,
integer_t const ldvl, double* vr, integer_t const ldvr,
integer_t const mm, integer_t& m, double* work, integer_t* ifaill,
integer_t* ifailr, integer_t& info ) {
LAPACK_DHSEIN( &side, &eigsrc, &initv, select, &n, h, &ldh, wr, wi,
vl, &ldvl, vr, &ldvr, &mm, &m, work, ifaill, ifailr, &info );
}
inline void hsein( char const side, char const eigsrc, char const initv,
logical_t* select, integer_t const n, traits::complex_f* h,
integer_t const ldh, traits::complex_f* w, traits::complex_f* vl,
integer_t const ldvl, traits::complex_f* vr, integer_t const ldvr,
integer_t const mm, integer_t& m, traits::complex_f* work,
float* rwork, integer_t* ifaill, integer_t* ifailr,
integer_t& info ) {
LAPACK_CHSEIN( &side, &eigsrc, &initv, select, &n,
traits::complex_ptr(h), &ldh, traits::complex_ptr(w),
traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
&ldvr, &mm, &m, traits::complex_ptr(work), rwork, ifaill,
ifailr, &info );
}
inline void hsein( char const side, char const eigsrc, char const initv,
logical_t* select, integer_t const n, traits::complex_d* h,
integer_t const ldh, traits::complex_d* w, traits::complex_d* vl,
integer_t const ldvl, traits::complex_d* vr, integer_t const ldvr,
integer_t const mm, integer_t& m, traits::complex_d* work,
double* rwork, integer_t* ifaill, integer_t* ifailr,
integer_t& info ) {
LAPACK_ZHSEIN( &side, &eigsrc, &initv, select, &n,
traits::complex_ptr(h), &ldh, traits::complex_ptr(w),
traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr),
&ldvr, &mm, &m, traits::complex_ptr(work), rwork, ifaill,
ifailr, &info );
}
}
// value-type based template
template< typename ValueType, typename Enable = void >
struct hsein_impl{};
// real specialization
template< typename ValueType >
struct hsein_impl< ValueType, typename boost::enable_if< traits::is_real<ValueType> >::type > {
typedef ValueType value_type;
typedef typename traits::type_traits<ValueType>::real_type real_type;
// user-defined workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorWR,
typename VectorWI, typename MatrixVL, typename MatrixVR,
typename VectorIFAILL, typename VectorIFAILR, typename WORK >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorWR& wr, VectorWI& wi,
MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
detail::workspace1< WORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::vector_traits<
VectorWR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::vector_traits<
VectorWI >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::matrix_traits<
MatrixVL >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::matrix_traits<
MatrixVR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
VectorIFAILL >::value_type, typename traits::vector_traits<
VectorIFAILR >::value_type >::value) );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
BOOST_ASSERT( initv == 'N' || initv == 'U' );
BOOST_ASSERT( traits::vector_size(select) >=
traits::matrix_num_columns(h) );
BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
BOOST_ASSERT( traits::leading_dimension(h) >= std::max(1,
traits::matrix_num_columns(h)) );
BOOST_ASSERT( traits::vector_size(wr) >=
traits::matrix_num_columns(h) );
BOOST_ASSERT( traits::vector_size(wi) >=
traits::matrix_num_columns(h) );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_work( traits::matrix_num_columns(h), ?2 ));
detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
traits::matrix_num_columns(h), traits::matrix_storage(h),
traits::leading_dimension(h), traits::vector_storage(wr),
traits::vector_storage(wi), traits::matrix_storage(vl),
traits::leading_dimension(vl), traits::matrix_storage(vr),
traits::leading_dimension(vr), mm, m,
traits::vector_storage(work.select(real_type())),
traits::vector_storage(ifaill),
traits::vector_storage(ifailr), info );
}
// minimal workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorWR,
typename VectorWI, typename MatrixVL, typename MatrixVR,
typename VectorIFAILL, typename VectorIFAILR >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorWR& wr, VectorWI& wi,
MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
minimal_workspace work ) {
traits::detail::array< real_type > tmp_work( min_size_work(
traits::matrix_num_columns(h), ?2 ) );
invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, ifaill,
ifailr, info, workspace( tmp_work ) );
}
// optimal workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorWR,
typename VectorWI, typename MatrixVL, typename MatrixVR,
typename VectorIFAILL, typename VectorIFAILR >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorWR& wr, VectorWI& wi,
MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
optimal_workspace work ) {
invoke( side, eigsrc, initv, select, h, wr, wi, vl, vr, mm, m, ifaill,
ifailr, info, minimal_workspace() );
}
static integer_t min_size_work( integer_t const n, ?? ) {
return (n+2)*n;
}
};
// complex specialization
template< typename ValueType >
struct hsein_impl< ValueType, typename boost::enable_if< traits::is_complex<ValueType> >::type > {
typedef ValueType value_type;
typedef typename traits::type_traits<ValueType>::real_type real_type;
// user-defined workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorW,
typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
typename VectorIFAILR, typename WORK, typename RWORK >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorW& w, MatrixVL& vl,
MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
detail::workspace2< WORK, RWORK > work ) {
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::vector_traits<
VectorIFAILL >::value_type, typename traits::vector_traits<
VectorIFAILR >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::vector_traits<
VectorW >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::matrix_traits<
MatrixVL >::value_type >::value) );
BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits<
MatrixH >::value_type, typename traits::matrix_traits<
MatrixVR >::value_type >::value) );
BOOST_ASSERT( side == 'R' || side == 'L' || side == 'B' );
BOOST_ASSERT( eigsrc == 'Q' || eigsrc == 'N' );
BOOST_ASSERT( initv == 'N' || initv == 'U' );
BOOST_ASSERT( traits::vector_size(select) >=
traits::matrix_num_columns(h) );
BOOST_ASSERT( traits::matrix_num_columns(h) >= 0 );
BOOST_ASSERT( traits::leading_dimension(h) >= std::max(1,
traits::matrix_num_columns(h)) );
BOOST_ASSERT( traits::vector_size(w) >=
traits::matrix_num_columns(h) );
BOOST_ASSERT( mm >= m );
BOOST_ASSERT( traits::vector_size(work.select(value_type())) >=
min_size_work( traits::matrix_num_columns(h) ));
BOOST_ASSERT( traits::vector_size(work.select(real_type())) >=
min_size_rwork( traits::matrix_num_columns(h) ));
detail::hsein( side, eigsrc, initv, traits::vector_storage(select),
traits::matrix_num_columns(h), traits::matrix_storage(h),
traits::leading_dimension(h), traits::vector_storage(w),
traits::matrix_storage(vl), traits::leading_dimension(vl),
traits::matrix_storage(vr), traits::leading_dimension(vr), mm,
m, traits::vector_storage(work.select(value_type())),
traits::vector_storage(work.select(real_type())),
traits::vector_storage(ifaill),
traits::vector_storage(ifailr), info );
}
// minimal workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorW,
typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
typename VectorIFAILR >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorW& w, MatrixVL& vl,
MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
minimal_workspace work ) {
traits::detail::array< value_type > tmp_work( min_size_work(
traits::matrix_num_columns(h) ) );
traits::detail::array< real_type > tmp_rwork( min_size_rwork(
traits::matrix_num_columns(h) ) );
invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
ifailr, info, workspace( tmp_work, tmp_rwork ) );
}
// optimal workspace specialization
template< typename VectorSELECT, typename MatrixH, typename VectorW,
typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
typename VectorIFAILR >
static void invoke( char const side, char const eigsrc, char const initv,
VectorSELECT& select, MatrixH& h, VectorW& w, MatrixVL& vl,
MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, integer_t& info,
optimal_workspace work ) {
invoke( side, eigsrc, initv, select, h, w, vl, vr, mm, m, ifaill,
ifailr, info, minimal_workspace() );
}
static integer_t min_size_work( integer_t const n ) {
return n*n;
}
static integer_t min_size_rwork( integer_t const n ) {
return n;
}
};
// template function to call hsein
template< typename VectorSELECT, typename MatrixH, typename VectorWR,
typename VectorWI, typename MatrixVL, typename MatrixVR,
typename VectorIFAILL, typename VectorIFAILR, typename Workspace >
inline integer_t hsein( char const side, char const eigsrc,
char const initv, VectorSELECT& select, MatrixH& h, VectorWR& wr,
VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t const mm,
integer_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr,
Workspace work ) {
typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
integer_t info(0);
hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, wr,
wi, vl, vr, mm, m, ifaill, ifailr, info, work );
return info;
}
// template function to call hsein, default workspace type
template< typename VectorSELECT, typename MatrixH, typename VectorWR,
typename VectorWI, typename MatrixVL, typename MatrixVR,
typename VectorIFAILL, typename VectorIFAILR >
inline integer_t hsein( char const side, char const eigsrc,
char const initv, VectorSELECT& select, MatrixH& h, VectorWR& wr,
VectorWI& wi, MatrixVL& vl, MatrixVR& vr, integer_t const mm,
integer_t& m, VectorIFAILL& ifaill, VectorIFAILR& ifailr ) {
typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
integer_t info(0);
hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, wr,
wi, vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
return info;
}
// template function to call hsein
template< typename VectorSELECT, typename MatrixH, typename VectorW,
typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
typename VectorIFAILR, typename Workspace >
inline integer_t hsein( char const side, char const eigsrc,
char const initv, VectorSELECT& select, MatrixH& h, VectorW& w,
MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr, Workspace work ) {
typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
integer_t info(0);
hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, w,
vl, vr, mm, m, ifaill, ifailr, info, work );
return info;
}
// template function to call hsein, default workspace type
template< typename VectorSELECT, typename MatrixH, typename VectorW,
typename MatrixVL, typename MatrixVR, typename VectorIFAILL,
typename VectorIFAILR >
inline integer_t hsein( char const side, char const eigsrc,
char const initv, VectorSELECT& select, MatrixH& h, VectorW& w,
MatrixVL& vl, MatrixVR& vr, integer_t const mm, integer_t& m,
VectorIFAILL& ifaill, VectorIFAILR& ifailr ) {
typedef typename traits::matrix_traits< MatrixH >::value_type value_type;
integer_t info(0);
hsein_impl< value_type >::invoke( side, eigsrc, initv, select, h, w,
vl, vr, mm, m, ifaill, ifailr, info, optimal_workspace() );
return info;
}
}}}} // namespace boost::numeric::bindings::lapack
#endif
|
//
// Copyright Toon Knapen, Karl Meerbergen
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
//#include <jflib/linalg/lapack/ublas.hpp>
//#include <jflib/linalg/lapack/eigen.hpp>
#include <jflib/tests/all.hpp>
#include <jflib/python/pyconfig.hpp>
#include <jflib/tests/ublas/random.hpp>
#include <jflib/linalg/lapack/eigen.hpp>
#include <jflib/linalg/lapack/ublas.hpp>
#include <boost/numeric/ublas/matrix.hpp>
/*
#include <boost/numeric/bindings/lapack/driver/syev.hpp>
#include <boost/numeric/bindings/traits/type_traits.hpp>
#include <boost/numeric/bindings/traits/ublas_symmetric.hpp>
#include <boost/numeric/bindings/traits/ublas_vector.hpp>
*/
//#include <jflib/linalg/traits/ublas_diagonal.hpp>
//#include <jflib/linalg/traits/ublas_symmetric.hpp>
namespace jflib { namespace tests {
// Randomize a matrix
template <typename M>
void randomize_upper(M& m) {
typedef typename M::size_type size_type ;
typedef typename M::value_type value_type ;
size_type size2 = m.size2() ;
for(size_type i=0; i<size2; ++i) {
for(size_type j=0; j<i; ++j) {
m(j,i) = random_value<value_type>();
}
}
}
template<typename T>
int syevectors(int N) {
namespace ublas = boost::numeric::ublas;
namespace lapack = jflib::linalg::lapack;
typedef ublas::matrix<T, ublas::column_major> matrix_type;
typedef ublas::vector<T> vector_type;
//typedef ublas::diagonal_matrix<T> vector_type;
// Set matrix
matrix_type a(N,N);
vector_type e1(N);
randomize_upper(a);
//ublas::symmetric_adaptor<matrix_type,ublas::upper> sym(a);
//lapack::syev('V',sym,e1);
//lapack::syev('V',ublas::upper(a),e1);
//lapack::syev('V','U',a,e1);
lapack::syevectors(a,e1);
return 0;
}
int TestHandle::eigenvectors(int size) {
syevectors<float>(size);
syevectors<double>(size);
return 0;
}
}}
/*
template <typename T, typename W>
int do_memory_type(int N, W workspace) {
typedef ublas::matrix<T, ublas::column_major> matrix_type;
//typedef ublas::symmetric_matrix<T,ublas::lower,ublas::column_major> matrix_type;
typedef ublas::vector<T> vector_type ;
// Set matrix
matrix_type a(N,N);
vector_type e1(N);
vector_type e2(N);
randomize(a);
lapack::syevectors(a,e1);
// Compute Schur decomposition.
//lapack::gees(&N, &N, a, e1, z) ;
//lapack::gees(&N, &N, a, e1, z, workspace ) ;
// Check Schur factorization
// if (norm_frobenius( prod( a2, z ) - prod( z, a ) )
// >= safety_factor*10.0* norm_frobenius( a2 ) * std::numeric_limits< real_type >::epsilon() ) return 255 ;
//lapack::gees( a2, e2, workspace ) ;
//if (norm_2( e1 - e2 ) > safety_factor*norm_2( e1 ) * std::numeric_limits< real_type >::epsilon()) return 255 ;
//if (norm_frobenius( a2 - a )
// >= safety_factor*10.0* norm_frobenius( a2 ) * std::numeric_limits< real_type >::epsilon() ) return 255 ;
return 0;
}
template <typename T>
struct Workspace {
typedef ublas::vector<T> array_type ;
typedef lapack::detail::workspace1< array_type > type ;
Workspace(size_t n)
: work_( 3*n )
{}
type operator() () {
return lapack::workspace(work_) ;
}
array_type work_ ;
};
template <typename T>
struct Workspace< std::complex<T> > {
typedef ublas::vector<T> real_array_type ;
typedef ublas::vector< std::complex<T> > complex_array_type ;
typedef lapack::detail::workspace2< complex_array_type,real_array_type > type ;
Workspace(size_t n)
: work_( 2*n )
, rwork_( n )
{}
type operator() () {
return lapack::workspace(work_, rwork_) ;
}
complex_array_type work_ ;
real_array_type rwork_ ;
};
template <typename T>
int do_value_type(unsigned N) {
if(do_memory_type<T,lapack::optimal_workspace>( N, lapack::optimal_workspace() ) ) return 255 ;
if(do_memory_type<T,lapack::minimal_workspace>( N, lapack::minimal_workspace() ) ) return 255 ;
Workspace<T> work(N);
do_memory_type<T,typename Workspace<T>::type >(N, work());
return 0;
}
*/
|
// { Driver Code Starts
#include<bits/stdc++.h>
using namespace std;
// } Driver Code Ends
vector<int> kLargest(int arr[], int n, int k)
{
priority_queue<int,vector<int>,greater<int>> min_heap;
for(int i=0;i<n;i++){
if(i<k)
min_heap.push(arr[i]);
else if(arr[i]>min_heap.top()){
min_heap.pop();
min_heap.push(arr[i]);
}
}
vector<int> res;
for(int i=0;i<k;i++){
res.push_back(min_heap.top());
min_heap.pop();
}
reverse(res.begin(),res.end());
return res;
}
// { Driver Code Starts.
vector<int> kLargest(int arr[], int n, int k);
int main(){
int t;
cin >> t;
while(t--){
int n, k;
cin >> n >> k;
int arr[n];
for(int i = 0; i < n;i++)
cin>>arr[i];
vector<int> result = kLargest(arr, n, k);
for (int i = 0; i < result.size(); ++i)
cout<<result[i]<<" ";
cout << endl;
}
return 0;
}
// } Driver Code Ends
|
#include <ESP8266WebServer.h>
#define SSID "FABLABKAMAKURA2_guest"
#define PASS "kamakura_1192"
#define LED_A 12
#define LED_B 13
ESP8266WebServer server(80);
char* html = "<!DOCTYPE html>\
<head>\
<meta charset='UTF-8'>\
<meta name='viewport' content='width=device-width'>\
</head>\
<body>\
<h1><a href='/both'>両方つける</a></h1>\
<h1><a href='/a'>LED_A</a></h1>\
<h1><a href='/b'>LED_B</a></h1>\
<h1><a href='/off'>OFF</a></h1>\
</body>\
</html>";
void connectWiFi(){
WiFi.begin(SSID, PASS);
Serial.println();
while(WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WiFi connected");
Serial.println(WiFi.localIP());
}
void handleRoot(){
server.send(200, "text/html", html);
}
void turnOnBoth(){
digitalWrite(LED_A, HIGH);
digitalWrite(LED_B, HIGH);
server.send(200, "text/html", html);
Serial.println("turn on both");
}
void turnOnA(){
digitalWrite(LED_A, HIGH);
digitalWrite(LED_B, LOW);
server.send(200, "text/html", html);
Serial.println("turn on a");
}
void turnOnB(){ // LED ON
digitalWrite(LED_A, LOW);
digitalWrite(LED_B, HIGH);
server.send(200, "text/html", html);
Serial.println("turn on b");
}
void turnOff(){ // LED OFF
digitalWrite(LED_A, LOW);
digitalWrite(LED_B, LOW);
server.send(200, "text/html", html);
Serial.println("turn off");
}
void setup(){
Serial.begin(9600);
pinMode(LED_A, OUTPUT);
pinMode(LED_B, OUTPUT);
digitalWrite(LED_A, LOW);
digitalWrite(LED_B, LOW);
connectWiFi();
server.on("/", handleRoot);
server.on("/both", turnOnBoth);
server.on("/a", turnOnA);
server.on("/b", turnOnB);
server.on("/off", turnOff);
server.begin();
Serial.println("HTTP server started");
}
void loop() {
server.handleClient();
}
|
#include "GPUOCLLayer.h"
#include "cl_scan_gpu.h"
void GPUOCLLayer::waitIfDebug(const char* file, int line) const
{
#ifdef _DEBUG
cl_int cErr = clFinish(m_globals.cmdQueue);
if (cErr != CL_SUCCESS)
{
const char* err = getOpenCLErrorString(cErr);
RUN_TIME_ERROR_AT(err, file, line);
}
#endif
}
void GPUOCLLayer::runKernel_MakeEyeSamplesOnly(size_t a_size, int a_passNumber,
cl_mem a_zindex, cl_mem a_samples)
{
cl_mem pssVector = a_samples;
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel makeSamples = m_progs.screen.kernel("MakeEyeRaysSamplesOnly");
CHECK_CL(clSetKernelArg(makeSamples, 0, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(makeSamples, 1, sizeof(cl_mem), (void*)&pssVector));
CHECK_CL(clSetKernelArg(makeSamples, 2, sizeof(cl_mem), (void*)&a_zindex));
CHECK_CL(clSetKernelArg(makeSamples, 3, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(makeSamples, 4, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(makeSamples, 5, sizeof(cl_mem), (void*)&m_globals.qmcTable));
CHECK_CL(clSetKernelArg(makeSamples, 6, sizeof(cl_int), (void*)&a_passNumber));
CHECK_CL(clSetKernelArg(makeSamples, 7, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(makeSamples, 8, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(makeSamples, 9, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeSamples, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
m_globals.m_passNumberQMC = a_passNumber;
}
void GPUOCLLayer::runKernel_MakeEyeRaysQMC(size_t a_size, int a_passNumber,
cl_mem a_zindex, cl_mem a_samples)
{
cl_mem pssVector = a_samples;
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel makeSamples = m_progs.screen.kernel("MakeEyeRaysQMC");
CHECK_CL(clSetKernelArg(makeSamples, 0, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(makeSamples, 1, sizeof(cl_mem), (void*)&pssVector));
CHECK_CL(clSetKernelArg(makeSamples, 2, sizeof(cl_mem), (void*)&a_zindex));
CHECK_CL(clSetKernelArg(makeSamples, 3, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(makeSamples, 4, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(makeSamples, 5, sizeof(cl_mem), (void*)&m_globals.qmcTable));
CHECK_CL(clSetKernelArg(makeSamples, 6, sizeof(cl_int), (void*)&a_passNumber));
CHECK_CL(clSetKernelArg(makeSamples, 7, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(makeSamples, 8, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(makeSamples, 9, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeSamples, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
m_globals.m_passNumberQMC = a_passNumber;
}
void GPUOCLLayer::runKernel_MakeRaysFromEyeSam(cl_mem a_zindex, cl_mem a_samples, size_t a_size, int a_passNumber,
cl_mem a_rpos, cl_mem a_rdir)
{
cl_mem pssVector = a_samples;
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
{
BitonicCLArgs sortArgs;
sortArgs.bitonicPassK = m_progs.sort.kernel("bitonic_pass_kernel");
sortArgs.bitonic512 = m_progs.sort.kernel("bitonic_512");
sortArgs.bitonic1024 = m_progs.sort.kernel("bitonic_1024");
sortArgs.bitonic2048 = m_progs.sort.kernel("bitonic_2048");
sortArgs.cmdQueue = m_globals.cmdQueue;
sortArgs.dev = m_globals.device;
bitonic_sort_gpu(a_zindex, int(a_size), sortArgs);
}
waitIfDebug(__FILE__, __LINE__);
cl_kernel makeRaysKern = m_progs.screen.kernel("MakeEyeRaysUnifiedSampling");
int packIndexForCPU = m_screen.m_cpuFrameBuffer ? 1 : 0;
CHECK_CL(clSetKernelArg(makeRaysKern, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(makeRaysKern, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(makeRaysKern, 2, sizeof(cl_mem), (void*)&m_rays.packedXY));
CHECK_CL(clSetKernelArg(makeRaysKern, 3, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(makeRaysKern, 4, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(makeRaysKern, 5, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clSetKernelArg(makeRaysKern, 6, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(makeRaysKern, 7, sizeof(cl_mem), (void*)&a_zindex));
CHECK_CL(clSetKernelArg(makeRaysKern, 8, sizeof(cl_mem), (void*)&pssVector));
CHECK_CL(clSetKernelArg(makeRaysKern, 9, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(makeRaysKern,10, sizeof(cl_mem), (void*)&m_globals.qmcTable));
CHECK_CL(clSetKernelArg(makeRaysKern,11, sizeof(cl_int), (void*)&a_passNumber));
CHECK_CL(clSetKernelArg(makeRaysKern,12, sizeof(cl_int), (void*)&packIndexForCPU));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeRaysKern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
m_globals.m_passNumberQMC = a_passNumber;
}
void GPUOCLLayer::runKernel_MakeEyeRays(cl_mem a_rpos, cl_mem a_rdir, cl_mem a_zindex, size_t a_size, int a_passNumber)
{
runKernel_MakeEyeSamplesOnly(a_size, a_passNumber,
a_zindex, m_rays.pathShadeColor);
runKernel_MakeRaysFromEyeSam(a_zindex, m_rays.pathShadeColor, a_size, a_passNumber,
a_rpos, a_rdir);
}
void GPUOCLLayer::runKernel_ClearAllInternalTempBuffers(size_t a_size)
{
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel makeRaysKern = m_progs.screen.kernel("ClearAllInternalTempBuffers");
CHECK_CL(clSetKernelArg(makeRaysKern, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern, 1, sizeof(cl_mem), (void*)&m_rays.pathAccColor)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern, 2, sizeof(cl_mem), (void*)&m_rays.pathThoroughput)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern, 3, sizeof(cl_mem), (void*)&m_rays.fogAtten)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern, 4, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern, 5, sizeof(cl_mem), (void*)&m_rays.accPdf));
CHECK_CL(clSetKernelArg(makeRaysKern, 6, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeRaysKern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_MakeEyeRaysSpp(int32_t a_blocksSize, int32_t yBegin, size_t a_size, cl_mem in_pixels,
cl_mem a_rpos, cl_mem a_rdir)
{
int isize = int(a_size);
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel kernX = nullptr;
if(a_blocksSize == GBUFFER_SAMPLES)
{
kernX = m_progs.screen.kernel("MakeEyeRaysSPP");
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_int), (void*)&a_blocksSize));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_int), (void*)&yBegin));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&m_globals.hammersley2DGBuff));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
}
else if(a_blocksSize == PMPIX_SAMPLES && in_pixels!= nullptr) // && input != nullptr
{
kernX = m_progs.screen.kernel("MakeEyeRaysSPPPixels");
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&m_rays.packedXY));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_mem), (void*)&in_pixels));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_globals.qmcTable));
CHECK_CL(clSetKernelArg(kernX, 8, sizeof(cl_int), (void*)&m_globals.m_passNumberQMC));
CHECK_CL(clSetKernelArg(kernX, 9, sizeof(cl_mem), (void*)&m_globals.hammersley2D256));
CHECK_CL(clSetKernelArg(kernX,10, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernX,11, sizeof(cl_int), (void*)&isize));
}
else
{
std::cerr << "bad SPP size for runKernel_MakeEyeRaysSpp = " << a_blocksSize << std::endl;
std::cerr << " in_pixels = " << in_pixels << std::endl;
return;
}
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_CopyLightSampleToSurfaceHit(cl_mem a_rayPos, size_t a_size,
cl_mem out_hitSurfaceAll)
{
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel makeSamKern = m_progs.lightp.kernel("CopyLightSampleToSurfaceHit");
CHECK_CL(clSetKernelArg(makeSamKern, 0, sizeof(cl_mem), (void*)&a_rayPos));
CHECK_CL(clSetKernelArg(makeSamKern, 1, sizeof(cl_mem), (void*)&out_hitSurfaceAll));
CHECK_CL(clSetKernelArg(makeSamKern, 2, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeSamKern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_MakeLightRays(cl_mem a_rpos, cl_mem a_rdir, cl_mem a_outColor, size_t a_size)
{
size_t localWorkSize = CMP_RESULTS_BLOCK_SIZE;
int iSize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
// (1) generate samples in primary space
//
cl_kernel makeSamKern = m_progs.lightp.kernel("LightSampleForwardCreate");
CHECK_CL(clSetKernelArg(makeSamKern, 0, sizeof(cl_mem), (void*)&m_rays.shadowRayPos));
CHECK_CL(clSetKernelArg(makeSamKern, 1, sizeof(cl_mem), (void*)&m_rays.shadowRayDir));
CHECK_CL(clSetKernelArg(makeSamKern, 2, sizeof(cl_mem), (void*)&m_rays.samZindex));
CHECK_CL(clSetKernelArg(makeSamKern, 3, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(makeSamKern, 4, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(makeSamKern, 5, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(makeSamKern, 6, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeSamKern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
// (2) sort them
//
BitonicCLArgs sortArgs;
sortArgs.bitonicPassK = m_progs.sort.kernel("bitonic_pass_kernel");
sortArgs.bitonic512 = m_progs.sort.kernel("bitonic_512");
sortArgs.bitonic1024 = m_progs.sort.kernel("bitonic_1024");
sortArgs.bitonic2048 = m_progs.sort.kernel("bitonic_2048");
sortArgs.cmdQueue = m_globals.cmdQueue;
sortArgs.dev = m_globals.device;
bitonic_sort_gpu(m_rays.samZindex, int(a_size), sortArgs);
runKernel_ClearAllInternalTempBuffers(a_size); // #TODO: opt this!
// (3) generate light sample
//
cl_kernel makeRaysKern = m_progs.lightp.kernel("LightSampleForwardKernel");
CHECK_CL(clSetKernelArg(makeRaysKern, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(makeRaysKern, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(makeRaysKern, 2, sizeof(cl_mem), (void*)&m_rays.shadowRayPos));
CHECK_CL(clSetKernelArg(makeRaysKern, 3, sizeof(cl_mem), (void*)&m_rays.shadowRayDir));
CHECK_CL(clSetKernelArg(makeRaysKern, 4, sizeof(cl_mem), (void*)&m_rays.samZindex));
CHECK_CL(clSetKernelArg(makeRaysKern, 5, sizeof(cl_mem), (void*)&m_rays.accPdf));
CHECK_CL(clSetKernelArg(makeRaysKern, 6, sizeof(cl_mem), (void*)&m_rays.pathMisDataPrev));
CHECK_CL(clSetKernelArg(makeRaysKern, 7, sizeof(cl_mem), (void*)&m_rays.lightOffsetBuff));
CHECK_CL(clSetKernelArg(makeRaysKern, 8, sizeof(cl_mem), (void*)&m_rays.lsamRev));
CHECK_CL(clSetKernelArg(makeRaysKern, 9, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(makeRaysKern,10, sizeof(cl_mem), (void*)&a_outColor));
CHECK_CL(clSetKernelArg(makeRaysKern,11, sizeof(cl_mem), (void*)&m_rays.pathThoroughput)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern,12, sizeof(cl_mem), (void*)&m_rays.fogAtten)); // pass this data to clear them only!
CHECK_CL(clSetKernelArg(makeRaysKern,13, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(makeRaysKern,14, sizeof(cl_mem), (void*)&m_scene.storagePdfs));
CHECK_CL(clSetKernelArg(makeRaysKern,15, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(makeRaysKern,16, sizeof(cl_int), (void*)&iSize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, makeRaysKern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void RoundBlocks2D(size_t global_item_size[2], size_t local_item_size[2])
{
global_item_size[0] = roundBlocks(global_item_size[0], int(local_item_size[0]));
global_item_size[1] = roundBlocks(global_item_size[1], int(local_item_size[1]));
}
void GPUOCLLayer::AddContributionToScreenGPU(cl_mem in_color, cl_mem in_indices, int a_size, int a_width, int a_height, int a_spp, bool a_copyToLDRNow,
cl_mem out_colorHDR, cl_mem out_colorLDR)
{
//// (3) sort references
////
//{
// BitonicCLArgs sortArgs;
// sortArgs.bitonicPassK = m_progs.sort.kernel("bitonic_pass_kernel");
// sortArgs.bitonic512 = m_progs.sort.kernel("bitonic_512");
// sortArgs.bitonic1024 = m_progs.sort.kernel("bitonic_1024");
// sortArgs.bitonic2048 = m_progs.sort.kernel("bitonic_2048");
// sortArgs.cmdQueue = m_globals.cmdQueue;
// sortArgs.dev = m_globals.device;
//
// bitonic_sort_gpu(in_indices, int(m_rays.MEGABLOCKSIZE), sortArgs);
//}
int alreadySorted = 1;
// (4) run contrib kernel
//
cl_kernel contribKern = m_progs.screen.kernel("ContribSampleToScreen");
size_t global_item_size[2] = { size_t(m_width), size_t(m_height) };
size_t local_item_size[2] = { 16, 16 };
RoundBlocks2D(global_item_size, local_item_size);
const float invGamma = 1.0f/m_globsBuffHeader.varsF[HRT_IMAGE_GAMMA];
CHECK_CL(clSetKernelArg(contribKern, 0, sizeof(cl_mem), (void*)&in_color));
CHECK_CL(clSetKernelArg(contribKern, 1, sizeof(cl_mem), (void*)&in_indices));
CHECK_CL(clSetKernelArg(contribKern, 2, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(contribKern, 3, sizeof(cl_int), (void*)&a_size));
CHECK_CL(clSetKernelArg(contribKern, 4, sizeof(cl_int), (void*)&a_width));
CHECK_CL(clSetKernelArg(contribKern, 5, sizeof(cl_int), (void*)&a_height));
CHECK_CL(clSetKernelArg(contribKern, 6, sizeof(cl_float), (void*)&m_spp));
CHECK_CL(clSetKernelArg(contribKern, 7, sizeof(cl_float), (void*)&invGamma));
CHECK_CL(clSetKernelArg(contribKern, 8, sizeof(cl_mem), (void*)&out_colorHDR));
CHECK_CL(clSetKernelArg(contribKern, 9, sizeof(cl_mem), (void*)&out_colorLDR));
CHECK_CL(clSetKernelArg(contribKern,10, sizeof(cl_int), (void*)&alreadySorted));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, contribKern, 2, NULL, global_item_size, local_item_size, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
// recalculate LDR image rely on normalisation constants
//
if((m_vars.m_flags & HRT_ENABLE_MMLT) != 0 && (m_vars.m_flags & HRT_ENABLE_SBPT) == 0 && a_copyToLDRNow)
{
ReduceCLArgs args;
args.cmdQueue = m_globals.cmdQueue;
args.reductionK = m_progs.screen.kernel("ReductionFloat4Avg256");
double avg[4] = {0,0,0,0};
reduce_average4f_gpu(out_colorHDR, m_width*m_height, avg, args);
const float avgBrightness = contribFunc(float3(avg[0], avg[1], avg[2]));
const float kScale = m_avgBrightness / fmax(avgBrightness, DEPSILON2);
runKernel_HDRToLDRWithScale(out_colorHDR, kScale, m_width, m_height,
out_colorLDR);
}
}
void GPUOCLLayer::runKernel_HDRToLDRWithScale(cl_mem in_colorHDR, float a_kScale, int a_width, int a_height,
cl_mem out_colorLDR)
{
cl_kernel contribKern = m_progs.screen.kernel("HDRToLDRWithScale");
size_t global_item_size[2] = { size_t(m_width), size_t(m_height) };
size_t local_item_size[2] = { 16, 16 };
RoundBlocks2D(global_item_size, local_item_size);
const float invGamma = 1.0f/m_globsBuffHeader.varsF[HRT_IMAGE_GAMMA];
CHECK_CL(clSetKernelArg(contribKern, 0, sizeof(cl_mem), (void*)&in_colorHDR));
CHECK_CL(clSetKernelArg(contribKern, 1, sizeof(cl_mem), (void*)&out_colorLDR));
CHECK_CL(clSetKernelArg(contribKern, 2, sizeof(cl_float), (void*)&invGamma));
CHECK_CL(clSetKernelArg(contribKern, 3, sizeof(cl_float), (void*)&a_kScale));
CHECK_CL(clSetKernelArg(contribKern, 4, sizeof(cl_int), (void*)&a_width));
CHECK_CL(clSetKernelArg(contribKern, 5, sizeof(cl_int), (void*)&a_height));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, contribKern, 2, NULL, global_item_size, local_item_size, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_Trace(cl_mem a_rpos, cl_mem a_rdir, size_t a_size,
cl_mem a_hits)
{
if (m_globals.cpuTrace)
{
runTraceCPU(a_rpos, a_rdir, m_rays.hits, a_size);
}
else
{
cl_kernel kernTrace1 = m_progs.trace.kernel("BVH4TraversalKernel");
cl_kernel kernTrace2 = m_progs.trace.kernel("BVH4TraversalInstKernel");
cl_kernel kernTrace3 = m_progs.trace.kernel("BVH4TraversalInstKernelA");
cl_kernel kernTrace4 = m_progs.trace.kernel("BVH4TraversalInstKernelAS");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
for(int runId = 0; runId < m_scene.bvhNumber; runId++)
{
bool smoothOpacity = m_bvhTrees[runId].smoothOpacity && ((m_vars.m_flags & HRT_ENABLE_MMLT) == 0);
cl_mem bvhBuff = m_scene.bvhBuff [runId];
cl_mem triBuff = m_scene.objListBuff[runId];
cl_mem triAlpha = m_scene.alphTstBuff[runId];
cl_kernel kernTrace = m_scene.bvhHaveInst[runId] ? kernTrace2 : kernTrace1;
if (triAlpha != nullptr)
{
if (smoothOpacity)
{
kernTrace = kernTrace4;
CHECK_CL(clSetKernelArg(kernTrace, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernTrace, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernTrace, 2, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernTrace, 3, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernTrace, 4, sizeof(cl_mem), (void*)&triAlpha));
CHECK_CL(clSetKernelArg(kernTrace, 5, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernTrace, 6, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernTrace, 7, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernTrace, 8, sizeof(cl_mem), (void*)&a_hits));
CHECK_CL(clSetKernelArg(kernTrace, 9, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernTrace, 10, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernTrace, 11, sizeof(cl_int), (void*)&isize));
}
else
{
kernTrace = kernTrace3;
CHECK_CL(clSetKernelArg(kernTrace, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernTrace, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernTrace, 2, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernTrace, 3, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernTrace, 4, sizeof(cl_mem), (void*)&triAlpha));
CHECK_CL(clSetKernelArg(kernTrace, 5, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernTrace, 6, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernTrace, 7, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernTrace, 8, sizeof(cl_mem), (void*)&a_hits));
CHECK_CL(clSetKernelArg(kernTrace, 9, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernTrace, 10, sizeof(cl_int), (void*)&isize));
}
}
else
{
CHECK_CL(clSetKernelArg(kernTrace, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernTrace, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernTrace, 2, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernTrace, 3, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernTrace, 4, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernTrace, 5, sizeof(cl_mem), (void*)&a_hits));
CHECK_CL(clSetKernelArg(kernTrace, 6, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernTrace, 7, sizeof(cl_int), (void*)&isize));
}
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernTrace, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
}
}
void GPUOCLLayer::runKernel_ComputeAO(cl_mem outCompressedAO, size_t a_size)
{
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
// (1) read AO params and put (rpos, tmax) to m_rays.shadowRayPos
// (2) create random vector in hemisphere and put it to m_rays.shadowRayDir
//
int numIters = 4;
for (int iter = 0; iter < numIters; iter++)
{
cl_kernel kernAO = m_progs.lightp.kernel("MakeAORays");
CHECK_CL(clSetKernelArg(kernAO, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernAO, 1, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernAO, 2, sizeof(cl_mem), (void*)&m_rays.hits));
CHECK_CL(clSetKernelArg(kernAO, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernAO, 4, sizeof(cl_mem), (void*)&m_rays.shadowRayPos));
CHECK_CL(clSetKernelArg(kernAO, 5, sizeof(cl_mem), (void*)&m_rays.shadowRayDir));
CHECK_CL(clSetKernelArg(kernAO, 6, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernAO, 7, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernAO, 8, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernAO, 9, sizeof(cl_int), (void*)&iter));
CHECK_CL(clSetKernelArg(kernAO,10, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernAO, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
// (3) calc shadows
//
runKernel_ShadowTrace(m_rays.rayFlags, m_rays.shadowRayPos, m_rays.shadowRayDir, a_size,
m_rays.lshadow);
// (4) pack them in outCompressedAO
//
cl_kernel kernAOPack = m_progs.lightp.kernel("PackAO");
CHECK_CL(clSetKernelArg(kernAOPack, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernAOPack, 1, sizeof(cl_mem), (void*)&m_rays.lshadow));
CHECK_CL(clSetKernelArg(kernAOPack, 2, sizeof(cl_mem), (void*)&outCompressedAO));
CHECK_CL(clSetKernelArg(kernAOPack, 3, sizeof(cl_int), (void*)&iter));
CHECK_CL(clSetKernelArg(kernAOPack, 4, sizeof(cl_int), (void*)&numIters));
CHECK_CL(clSetKernelArg(kernAOPack, 5, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernAOPack, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
}
void GPUOCLLayer::runKernel_ComputeAO2(cl_mem outCompressedAO, size_t a_size, int aoId) // #TODO: implement this! Both Up and down !!!
{
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
// (1) read AO params and put (rpos, tmax) to m_rays.shadowRayPos
// (2) create random vector in hemisphere and put it to m_rays.shadowRayDir
//
cl_kernel kernAO = m_progs.lightp.kernel("MakeAORaysPacked4");
CHECK_CL(clSetKernelArg(kernAO, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernAO, 1, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernAO, 2, sizeof(cl_mem), (void*)&m_rays.hits));
CHECK_CL(clSetKernelArg(kernAO, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernAO, 4, sizeof(cl_mem), (void*)&m_rays.shadowRayPos));
CHECK_CL(clSetKernelArg(kernAO, 5, sizeof(cl_mem), (void*)&m_rays.shadowRayDir));
CHECK_CL(clSetKernelArg(kernAO, 6, sizeof(cl_mem), (void*)&m_rays.shadowTemp1i)); // put target inst id to 'shadowTemp1i'
CHECK_CL(clSetKernelArg(kernAO, 7, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernAO, 8, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernAO, 9, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernAO, 10, sizeof(cl_int), (void*)&aoId));
CHECK_CL(clSetKernelArg(kernAO, 11, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernAO, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
// (3) calc shadows
//
runKernel_ShadowTraceAO(m_rays.rayFlags, m_rays.shadowRayPos, m_rays.shadowRayDir, m_rays.shadowTemp1i, // read target inst id from 'shadowTemp1i'
m_rays.lshadow, AO_RAYS_PACKED*a_size);
// (4) pack them in outCompressedAO
//
cl_kernel kernAOPack = m_progs.lightp.kernel("PackAO4");
CHECK_CL(clSetKernelArg(kernAOPack, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernAOPack, 1, sizeof(cl_mem), (void*)&m_rays.lshadow));
CHECK_CL(clSetKernelArg(kernAOPack, 2, sizeof(cl_mem), (void*)&outCompressedAO));
CHECK_CL(clSetKernelArg(kernAOPack, 3, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernAOPack, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_ComputeHit(cl_mem a_rpos, cl_mem a_rdir, cl_mem a_hits, size_t a_size, size_t a_sizeRun,
cl_mem out_hitSurface, cl_mem a_outProcTexData)
{
// eval common surface parameters
//
cl_kernel kernHit = m_progs.trace.kernel("ComputeHit");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
a_sizeRun = roundBlocks(a_sizeRun, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernHit, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernHit, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernHit, 2, sizeof(cl_mem), (void*)&a_hits));
CHECK_CL(clSetKernelArg(kernHit, 3, sizeof(cl_mem), (void*)&m_scene.matrices));
CHECK_CL(clSetKernelArg(kernHit, 4, sizeof(cl_mem), (void*)&m_scene.storageGeom));
CHECK_CL(clSetKernelArg(kernHit, 5, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernHit, 6, sizeof(cl_mem), (void*)&m_scene.remapLists));
CHECK_CL(clSetKernelArg(kernHit, 7, sizeof(cl_mem), (void*)&m_scene.remapTable));
CHECK_CL(clSetKernelArg(kernHit, 8, sizeof(cl_mem), (void*)&m_scene.remapInst));
CHECK_CL(clSetKernelArg(kernHit, 9, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernHit, 10, sizeof(cl_mem), (void*)&out_hitSurface));
CHECK_CL(clSetKernelArg(kernHit, 11, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernHit, 12, sizeof(cl_int), (void*)&m_scene.remapTableSize));
CHECK_CL(clSetKernelArg(kernHit, 13, sizeof(cl_int), (void*)&m_scene.totalInstanceNum));
CHECK_CL(clSetKernelArg(kernHit, 14, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernHit, 1, NULL, &a_sizeRun, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
//if (a_doNotEvaluateProcTex)
//return;
// eval AO
//
if (m_rays.aoCompressed != nullptr)
runKernel_ComputeAO2(m_rays.aoCompressed , a_sizeRun, 0);
if(m_rays.aoCompressed2 != nullptr)
runKernel_ComputeAO2(m_rays.aoCompressed2, a_sizeRun, 1);
// eval procedure textures
//
if (a_outProcTexData != nullptr)
{
cl_kernel kernProcT = m_progs.texproc.kernel("ProcTexExec");
CHECK_CL(clSetKernelArg(kernProcT, 0, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernProcT, 1, sizeof(cl_mem), (void*)&m_rays.rayDir));
CHECK_CL(clSetKernelArg(kernProcT, 2, sizeof(cl_mem), (void*)&out_hitSurface));
CHECK_CL(clSetKernelArg(kernProcT, 3, sizeof(cl_mem), (void*)&m_rays.aoCompressed));
CHECK_CL(clSetKernelArg(kernProcT, 4, sizeof(cl_mem), (void*)&m_rays.aoCompressed2));
CHECK_CL(clSetKernelArg(kernProcT, 5, sizeof(cl_mem), (void*)&m_rays.hits));
CHECK_CL(clSetKernelArg(kernProcT, 6, sizeof(cl_mem), (void*)&m_scene.matrices));
CHECK_CL(clSetKernelArg(kernProcT, 7, sizeof(cl_mem), (void*)&a_outProcTexData));
CHECK_CL(clSetKernelArg(kernProcT, 8, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernProcT, 9, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernProcT,10, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernProcT,11, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernProcT, 1, NULL, &a_sizeRun, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
}
void GPUOCLLayer::runKernel_GetGBufferSamples(cl_mem a_rdir, cl_mem a_gbuff1, cl_mem a_gbuff2, int a_blockSize, size_t a_size)
{
cl_kernel kernHit = m_progs.material.kernel("GetGBufferSample");
size_t localWorkSize = a_blockSize;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernHit, 0, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernHit, 1, sizeof(cl_mem), (void*)&m_rays.hits));
CHECK_CL(clSetKernelArg(kernHit, 2, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernHit, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernHit, 4, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kernHit, 5, sizeof(cl_mem), (void*)&a_gbuff1));
CHECK_CL(clSetKernelArg(kernHit, 6, sizeof(cl_mem), (void*)&a_gbuff2));
CHECK_CL(clSetKernelArg(kernHit, 7, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernHit, 8, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernHit, 9, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernHit,10, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernHit, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_PutAlphaToGBuffer(cl_mem a_inThoroughput, cl_mem a_gbuff1, size_t a_size)
{
cl_kernel kernHit = m_progs.material.kernel("PutAlphaToGBuffer");
size_t localWorkSize = GBUFFER_SAMPLES;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernHit, 0, sizeof(cl_mem), (void*)&a_inThoroughput));
CHECK_CL(clSetKernelArg(kernHit, 1, sizeof(cl_mem), (void*)&a_gbuff1));
CHECK_CL(clSetKernelArg(kernHit, 2, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernHit, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_GetShadowToAlpha(cl_mem a_color, cl_mem a_shadow, size_t a_size)
{
cl_kernel kernHit = m_progs.screen.kernel("GetShadowToAlpha");
size_t localWorkSize = GBUFFER_SAMPLES;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernHit, 0, sizeof(cl_mem), (void*)&a_color));
CHECK_CL(clSetKernelArg(kernHit, 1, sizeof(cl_mem), (void*)&a_shadow));
CHECK_CL(clSetKernelArg(kernHit, 2, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernHit, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_HitEnvOrLight(cl_mem a_rayFlags, cl_mem a_rpos, cl_mem a_rdir, cl_mem a_outColor, int a_currBounce, int a_minBounce, size_t a_size)
{
cl_kernel kernX = m_progs.material.kernel("HitEnvOrLightKernel");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_float mLightSubPathCount = cl_float(m_width*m_height); // cl_float(m_rays.MEGABLOCKSIZE);
cl_int currBounce = a_currBounce;
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_mem), (void*)&m_rays.packedXY));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&a_outColor));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_rays.pathThoroughput)); // a_thoroughput
CHECK_CL(clSetKernelArg(kernX, 8, sizeof(cl_mem), (void*)&m_rays.pathMisDataPrev)); // a_misDataPrev
CHECK_CL(clSetKernelArg(kernX, 9, sizeof(cl_mem), (void*)&m_rays.oldRayDir)); // when PT: use oldRayDir to store emission color
CHECK_CL(clSetKernelArg(kernX, 10, sizeof(cl_mem), (void*)&m_rays.pathShadow8B)); //
CHECK_CL(clSetKernelArg(kernX, 11, sizeof(cl_mem), (void*)&m_rays.pathMisDataPrev));
CHECK_CL(clSetKernelArg(kernX, 12, sizeof(cl_mem), (void*)&m_rays.accPdf));
CHECK_CL(clSetKernelArg(kernX, 13, sizeof(cl_mem), (void*)&m_rays.oldColor)); // when 3-Way PT pass run, it use unused 'oldColor' to store prevData that is a copy of m_rays.accPdf
CHECK_CL(clSetKernelArg(kernX, 14, sizeof(cl_mem), (void*)&m_rays.oldFlags)); // when 3-Way PT pass run, it use unused 'oldFlags' to store pdfCamA as single float (sizeof(int) == sizeof(float))
CHECK_CL(clSetKernelArg(kernX, 15, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernX, 16, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kernX, 17, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernX, 18, sizeof(cl_mem), (void*)&m_scene.storagePdfs));
CHECK_CL(clSetKernelArg(kernX, 19, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernX, 20, sizeof(cl_mem), (void*)&m_scene.instLightInst));
CHECK_CL(clSetKernelArg(kernX, 21, sizeof(cl_mem), (void*)&m_rays.hits));
CHECK_CL(clSetKernelArg(kernX, 22, sizeof(cl_float), (void*)&mLightSubPathCount)); // a_mLightSubPathCount
CHECK_CL(clSetKernelArg(kernX, 23, sizeof(cl_int), (void*)&currBounce)); // a_currDepth
CHECK_CL(clSetKernelArg(kernX, 24, sizeof(cl_int), (void*)&a_minBounce)); // a_currDepth
CHECK_CL(clSetKernelArg(kernX, 25, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_NextBounce(cl_mem a_rayFlags, cl_mem a_rpos, cl_mem a_rdir, cl_mem a_outColor, size_t a_size)
{
cl_kernel kernX = m_progs.material.kernel("NextBounce");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
if (true)
{
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&kmlt.currZind));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&kmlt.currVec));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kernX, 8, sizeof(cl_mem), (void*)&a_outColor));
CHECK_CL(clSetKernelArg(kernX, 9, sizeof(cl_mem), (void*)&m_rays.pathThoroughput)); // a_thoroughput
CHECK_CL(clSetKernelArg(kernX,10, sizeof(cl_mem), (void*)&m_rays.pathMisDataPrev)); // a_misDataPrev
CHECK_CL(clSetKernelArg(kernX,11, sizeof(cl_mem), (void*)&m_rays.lshadow)); // a_shadow
CHECK_CL(clSetKernelArg(kernX,12, sizeof(cl_mem), (void*)&m_rays.fogAtten)); // a_fog
CHECK_CL(clSetKernelArg(kernX,13, sizeof(cl_mem), (void*)&m_rays.pathShadeColor)); // in_shadeColor
if (m_vars.m_flags & HRT_FORWARD_TRACING)
{
CHECK_CL(clSetKernelArg(kernX, 14, sizeof(cl_mem), nullptr));
}
else
{
CHECK_CL(clSetKernelArg(kernX, 14, sizeof(cl_mem), (void*)&m_rays.oldRayDir)); // PT can use unused oldRays as input emission color from kernel HitEnvOrLight
}
CHECK_CL(clSetKernelArg(kernX, 15, sizeof(cl_mem), (void*)&m_rays.accPdf)); // a_pdfAcc
if (m_vars.m_flags & HRT_FORWARD_TRACING)
{
CHECK_CL(clSetKernelArg(kernX, 16, sizeof(cl_mem), nullptr));
}
else
{
CHECK_CL(clSetKernelArg(kernX, 16, sizeof(cl_mem), (void*)&m_rays.oldFlags)); // PT can use unused oldFlags to store camPdfA; require sizeof(int) == sizeof(float);
}
CHECK_CL(clSetKernelArg(kernX, 17, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernX, 18, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kernX, 19, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernX, 20, sizeof(cl_mem), (void*)&m_scene.storagePdfs));
CHECK_CL(clSetKernelArg(kernX, 21, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernX, 22, sizeof(cl_int), (void*)&isize));
}
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_NextTransparentBounce(cl_mem a_rpos, cl_mem a_rdir, cl_mem a_thoroughput, size_t a_size)
{
cl_kernel kernX = m_progs.material.kernel("NextTransparentBounce");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_mem), (void*)&a_thoroughput)); // a_thoroughput
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernX, 8, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernX, 9, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_ShadowTrace(cl_mem a_rayFlags, cl_mem a_rpos, cl_mem a_rdir, size_t a_size,
cl_mem a_outShadow)
{
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel kernTrace1 = m_progs.trace.kernel("BVH4TraversalShadowKenrel");
cl_kernel kernTrace2 = m_progs.trace.kernel("BVH4TraversalInstShadowKenrel");
cl_kernel kernTrace4 = m_progs.trace.kernel("BVH4TraversalInstShadowKenrelAS");
for (int runId = 0; runId < m_scene.bvhNumber; runId++)
{
cl_mem bvhBuff = m_scene.bvhBuff[runId];
cl_mem triBuff = m_scene.objListBuff[runId];
cl_mem triAlpha = m_scene.alphTstBuff[runId];
cl_kernel kernY = m_scene.bvhHaveInst[runId] ? kernTrace2 : kernTrace1;
if (triAlpha != nullptr)
{
kernY = kernTrace4;
CHECK_CL(clSetKernelArg(kernY, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernY, 1, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernY, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernY, 3, sizeof(cl_mem), (void*)&a_outShadow));
CHECK_CL(clSetKernelArg(kernY, 4, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernY, 5, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernY, 6, sizeof(cl_mem), (void*)&triAlpha));
CHECK_CL(clSetKernelArg(kernY, 7, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernY, 8, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernY, 9, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernY,10, sizeof(cl_int), (void*)&isize));
}
else
{
CHECK_CL(clSetKernelArg(kernY, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernY, 1, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernY, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernY, 3, sizeof(cl_mem), (void*)&a_outShadow));
CHECK_CL(clSetKernelArg(kernY, 4, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernY, 5, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernY, 6, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernY, 7, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernY, 8, sizeof(cl_int), (void*)&isize));
}
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernY, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
}
void GPUOCLLayer::runKernel_ShadowTraceAO(cl_mem a_rayFlags, cl_mem a_rpos, cl_mem a_rdir, cl_mem a_instId,
cl_mem a_outShadow, size_t a_size)
{
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_kernel kernTrace1 = m_progs.trace.kernel("BVH4TraversalShadowKenrel_Packed");
cl_kernel kernTrace2 = m_progs.trace.kernel("BVH4TraversalInstShadowKenrel_Packed");
cl_kernel kernTrace4 = m_progs.trace.kernel("BVH4TraversalInstShadowKenrelAS_Packed");
for (int runId = 0; runId < m_scene.bvhNumber; runId++)
{
cl_mem bvhBuff = m_scene.bvhBuff [runId];
cl_mem triBuff = m_scene.objListBuff[runId];
cl_mem triAlpha = m_scene.alphTstBuff[runId];
cl_kernel kernY = m_scene.bvhHaveInst[runId] ? kernTrace2 : kernTrace1;
if (triAlpha != nullptr)
{
kernY = kernTrace4;
CHECK_CL(clSetKernelArg(kernY, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernY, 1, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernY, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernY, 3, sizeof(cl_mem), (void*)&a_instId));
CHECK_CL(clSetKernelArg(kernY, 4, sizeof(cl_mem), (void*)&a_outShadow));
CHECK_CL(clSetKernelArg(kernY, 5, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernY, 6, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernY, 7, sizeof(cl_mem), (void*)&triAlpha));
CHECK_CL(clSetKernelArg(kernY, 8, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernY, 9, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernY,10, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernY,11, sizeof(cl_int), (void*)&isize));
}
else
{
CHECK_CL(clSetKernelArg(kernY, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernY, 1, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernY, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernY, 3, sizeof(cl_mem), (void*)&a_instId));
CHECK_CL(clSetKernelArg(kernY, 4, sizeof(cl_mem), (void*)&a_outShadow));
CHECK_CL(clSetKernelArg(kernY, 5, sizeof(cl_mem), (void*)&bvhBuff));
CHECK_CL(clSetKernelArg(kernY, 6, sizeof(cl_mem), (void*)&triBuff));
CHECK_CL(clSetKernelArg(kernY, 7, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernY, 8, sizeof(cl_int), (void*)&runId));
CHECK_CL(clSetKernelArg(kernY, 9, sizeof(cl_int), (void*)&isize));
}
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernY, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
}
void GPUOCLLayer::ShadePass(cl_mem a_rpos, cl_mem a_rdir, cl_mem a_outColor, size_t a_size, bool a_measureTime)
{
bool transparensyShadowEnabled = false; // !(m_vars.m_flags & HRT_ENABLE_PT_CAUSTICS);
cl_kernel kernX = m_progs.lightp.kernel("LightSample");
//cl_kernel kernT = m_progs.material.kernel("TransparentShadowKenrel");
cl_kernel kernZ = m_progs.material.kernel("Shade");
cl_kernel kernN = m_progs.trace.kernel("NoShadow");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
const bool traceShadows = (m_vars.m_flags & HRT_COMPUTE_SHADOWS);
if (true)
{
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&kmlt.currZind));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&kmlt.currVec));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&m_rays.randGenState));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_rays.lsamRev));
CHECK_CL(clSetKernelArg(kernX, 8, sizeof(cl_mem), (void*)&m_rays.shadowRayPos)); // float4
CHECK_CL(clSetKernelArg(kernX, 9, sizeof(cl_mem), (void*)&m_rays.shadowRayDir)); // float4
CHECK_CL(clSetKernelArg(kernX, 10, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernX, 11, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kernX, 12, sizeof(cl_mem), (void*)&m_scene.storagePdfs));
CHECK_CL(clSetKernelArg(kernX, 13, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernX, 14, sizeof(cl_int), (void*)&isize));
}
if (m_globals.cpuTrace)
{
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
runTraceShadowCPU(a_size);
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernZ, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
}
else
{
float timeBeginLightSample = 0.0f;
float timeLightSample = 0.0f;
float timeShadow = 0.0f;
if (m_vars.m_varsI[HRT_ENABLE_MRAYS_COUNTERS] && a_measureTime)
{
clFinish(m_globals.cmdQueue);
timeBeginLightSample = m_timer.getElapsed();
}
waitIfDebug(__FILE__, __LINE__);
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
if (m_vars.m_varsI[HRT_ENABLE_MRAYS_COUNTERS] && a_measureTime)
{
clFinish(m_globals.cmdQueue);
timeLightSample = m_timer.getElapsed();
m_stat.samLightTimeMs = 1000.0f*(timeLightSample - timeBeginLightSample);
}
if (traceShadows)
{
runKernel_ShadowTrace(m_rays.rayFlags, m_rays.shadowRayPos, m_rays.shadowRayDir, a_size,
m_rays.lshadow);
}
else
{
CHECK_CL(clSetKernelArg(kernN, 0, sizeof(cl_mem), (void*)&m_rays.lshadow));
CHECK_CL(clSetKernelArg(kernN, 1, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernN, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
}
if (m_vars.m_varsI[HRT_ENABLE_MRAYS_COUNTERS] && a_measureTime)
{
clFinish(m_globals.cmdQueue);
timeShadow = m_timer.getElapsed();
m_stat.shadowTimeMs = 1000.0f*(timeShadow - timeLightSample);
}
CHECK_CL(clSetKernelArg(kernZ, 0, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernZ, 1, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernZ, 2, sizeof(cl_mem), (void*)&m_rays.rayFlags));
CHECK_CL(clSetKernelArg(kernZ, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernZ, 4, sizeof(cl_mem), (void*)&m_rays.lshadow));
CHECK_CL(clSetKernelArg(kernZ, 5, sizeof(cl_mem), (void*)&m_rays.lsamRev));
CHECK_CL(clSetKernelArg(kernZ, 6, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kernZ, 7, sizeof(cl_mem), (void*)&m_rays.oldColor)); // pdfAccCopy
CHECK_CL(clSetKernelArg(kernZ, 8, sizeof(cl_mem), (void*)&m_rays.oldFlags)); // camPdfA
CHECK_CL(clSetKernelArg(kernZ, 9, sizeof(cl_mem), (void*)&a_outColor));
CHECK_CL(clSetKernelArg(kernZ, 10, sizeof(cl_mem), (void*)&m_rays.pathShadow8B));
CHECK_CL(clSetKernelArg(kernZ, 11, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kernZ, 12, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kernZ, 13, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernZ, 14, sizeof(cl_mem), (void*)&m_scene.storagePdfs));
CHECK_CL(clSetKernelArg(kernZ, 15, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernZ, 16, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernZ, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
if (m_vars.m_varsI[HRT_ENABLE_MRAYS_COUNTERS] && a_measureTime)
{
clFinish(m_globals.cmdQueue);
m_stat.shadeTimeMs = 1000.0f*(m_timer.getElapsed() - timeShadow);
}
}
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_EyeShadowRays(cl_mem a_rayFlags, cl_mem a_rdir2,
cl_mem a_rpos, cl_mem a_rdir, size_t a_size)
{
const int usematerials = (a_rdir2 == nullptr) ? 0 : 1;
cl_kernel kernMakeRays = m_progs.material.kernel("MakeEyeShadowRays");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernMakeRays, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kernMakeRays, 1, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kernMakeRays, 2, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kernMakeRays, 3, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kernMakeRays, 4, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernMakeRays, 5, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernMakeRays, 6, sizeof(cl_int), (void*)&isize));
CHECK_CL(clSetKernelArg(kernMakeRays, 7, sizeof(cl_int), (void*)&usematerials));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernMakeRays, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_ProjectSamplesToScreen(cl_mem a_rayFlags, cl_mem a_rdir, cl_mem a_rdir2, cl_mem a_colorsIn,
cl_mem a_colorsOut, cl_mem a_zindex, size_t a_size, int a_currBounce)
{
cl_kernel kern = m_progs.material.kernel("ConnectToEyeKernel");
size_t localWorkSize = 256;
cl_int isize = cl_int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
cl_float mLightSubPathCount = cl_float(m_width*m_height); //
cl_int currBounce = a_currBounce+1;
CHECK_CL(clSetKernelArg(kern, 0, sizeof(cl_mem), (void*)&a_rayFlags));
CHECK_CL(clSetKernelArg(kern, 1, sizeof(cl_mem), (void*)&a_rdir2));
CHECK_CL(clSetKernelArg(kern, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kern, 3, sizeof(cl_mem), (void*)&m_rays.lshadow));
CHECK_CL(clSetKernelArg(kern, 4, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kern, 5, sizeof(cl_mem), (void*)&m_rays.accPdf));
CHECK_CL(clSetKernelArg(kern, 6, sizeof(cl_mem), (void*)&m_rays.lightOffsetBuff)); //#TODO: remove this buffer, store it inside 'lsamRev'
CHECK_CL(clSetKernelArg(kern, 7, sizeof(cl_mem), (void*)&m_rays.lsamRev));
CHECK_CL(clSetKernelArg(kern, 8, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kern, 9, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kern, 10, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kern, 11, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kern, 12, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kern, 13, sizeof(cl_mem), (void*)&m_globals.cMortonTable));
CHECK_CL(clSetKernelArg(kern, 14, sizeof(cl_mem), (void*)&a_colorsIn));
CHECK_CL(clSetKernelArg(kern, 15, sizeof(cl_mem), (void*)&a_colorsOut));
CHECK_CL(clSetKernelArg(kern, 16, sizeof(cl_mem), (void*)&a_zindex));
CHECK_CL(clSetKernelArg(kern, 17, sizeof(cl_float), (void*)&mLightSubPathCount));
CHECK_CL(clSetKernelArg(kern, 18, sizeof(cl_int), (void*)&currBounce));
CHECK_CL(clSetKernelArg(kern, 19, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_UpdateForwardPdfFor3Way(cl_mem a_flags, cl_mem old_rayDir, cl_mem next_rayDir, cl_mem acc_pdf, size_t a_size)
{
cl_kernel kern = m_progs.material.kernel("UpdateForwardPdfFor3Way");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kern, 0, sizeof(cl_mem), (void*)&a_flags));
CHECK_CL(clSetKernelArg(kern, 1, sizeof(cl_mem), (void*)&old_rayDir));
CHECK_CL(clSetKernelArg(kern, 2, sizeof(cl_mem), (void*)&next_rayDir));
CHECK_CL(clSetKernelArg(kern, 3, sizeof(cl_mem), (void*)&m_rays.hitSurfaceAll));
CHECK_CL(clSetKernelArg(kern, 4, sizeof(cl_mem), (void*)&m_rays.hitProcTexData));
CHECK_CL(clSetKernelArg(kern, 5, sizeof(cl_mem), (void*)&m_rays.pathMisDataPrev));
CHECK_CL(clSetKernelArg(kern, 6, sizeof(cl_mem), (void*)&acc_pdf)); // m_rays.accPdf
CHECK_CL(clSetKernelArg(kern, 7, sizeof(cl_mem), (void*)&m_scene.storageTex));
CHECK_CL(clSetKernelArg(kern, 8, sizeof(cl_mem), (void*)&m_scene.storageTexAux));
CHECK_CL(clSetKernelArg(kern, 9, sizeof(cl_mem), (void*)&m_scene.storageMat));
CHECK_CL(clSetKernelArg(kern,10, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clSetKernelArg(kern,11, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kern, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_InitRandomGen(cl_mem a_buffer, size_t a_size, int a_seed)
{
cl_kernel kernInitR = m_progs.trace.kernel("InitRandomGen");
size_t localWorkSize = 256;
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
//std::cerr << "a_size = " << a_size << std::endl
CHECK_CL(clSetKernelArg(kernInitR, 0, sizeof(cl_mem), (void*)&a_buffer));
CHECK_CL(clSetKernelArg(kernInitR, 1, sizeof(cl_int), (void*)&a_seed));
CHECK_CL(clSetKernelArg(kernInitR, 2, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernInitR, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
//// ML Render
//
void GPUOCLLayer::runKernel_GenerateSPPRays(cl_mem a_pixels, cl_mem a_sppPos, cl_mem a_rpos, cl_mem a_rdir, size_t a_size, int a_blockSize)
{
cl_kernel kernX = m_progs.screen.kernel("MakeEyeRaysSPP");
int isize = int(a_size);
size_t localWorkSize = size_t(a_blockSize);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_pixels));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_rpos));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_mem), (void*)&a_rdir));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_int), (void*)&m_width));
CHECK_CL(clSetKernelArg(kernX, 4, sizeof(cl_int), (void*)&m_height));
CHECK_CL(clSetKernelArg(kernX, 5, sizeof(cl_int), (void*)&a_blockSize));
CHECK_CL(clSetKernelArg(kernX, 6, sizeof(cl_mem), (void*)&a_sppPos));
CHECK_CL(clSetKernelArg(kernX, 7, sizeof(cl_mem), (void*)&m_scene.allGlobsData));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
void GPUOCLLayer::runKernel_ReductionFloat4Average(cl_mem a_src, cl_mem a_dst, size_t a_size, int a_bsize)
{
if (a_bsize != 256 && a_bsize != 64 && a_bsize != 16)
RUN_TIME_ERROR("ReductionFloat4Avg256 not implemented for bsize != 256/64/16");
//ReductionFloat4Avg16
cl_kernel kernX = m_progs.screen.kernel("ReductionFloat4Avg256");
if (a_bsize == 64)
kernX = m_progs.screen.kernel("ReductionFloat4Avg64");
else if (a_bsize == 16)
kernX = m_progs.screen.kernel("ReductionFloat4Avg16");
size_t localWorkSize = size_t(a_bsize);
int isize = int(a_size);
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&a_src));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&a_dst));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
waitIfDebug(__FILE__, __LINE__);
}
bool GPUOCLLayer::testSimpleReduction()
{
int testData[256];
for (int i = 0; i < 256; i++)
testData[i] = rand() % 100;
int goldSumm = 0;
for (int i = 0; i < 256; i++)
goldSumm += testData[i];
cl_int ciErr1;
cl_mem testBuffer = clCreateBuffer(m_globals.ctx, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, 256*sizeof(int), (void*)(testData), &ciErr1);
if (ciErr1 != CL_SUCCESS)
RUN_TIME_ERROR("Error in clCreateBuffer");
cl_kernel kernX = m_progs.screen.kernel("SimpleReductionTest");
size_t a_size = 256;
int isize = 256;
size_t localWorkSize = 256;
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&testBuffer));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
int resSumm = 0;
CHECK_CL(clEnqueueReadBuffer(m_globals.cmdQueue, testBuffer, CL_TRUE, 0, sizeof(int), &resSumm, 0, NULL, NULL));
clReleaseMemObject(testBuffer);
return (resSumm == goldSumm);
}
void GPUOCLLayer::memsetu32(cl_mem buff, uint a_val, size_t a_size)
{
cl_kernel kern = m_progs.screen.kernel("MemSetu32");
size_t szLocalWorkSize = 256;
cl_int iNumElements = cl_int(a_size);
a_size = roundBlocks(a_size, int(szLocalWorkSize));
CHECK_CL(clSetKernelArg(kern, 0, sizeof(cl_mem), (void*)&buff));
CHECK_CL(clSetKernelArg(kern, 1, sizeof(cl_uint), (void*)&a_val));
CHECK_CL(clSetKernelArg(kern, 2, sizeof(cl_int), (void*)&iNumElements));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kern, 1, NULL, &a_size, &szLocalWorkSize, 0, NULL, NULL));
}
void GPUOCLLayer::memsetf4(cl_mem buff, float4 a_val, size_t a_size, size_t a_offset)
{
cl_kernel kern = m_progs.screen.kernel("MemSetf4");
size_t szLocalWorkSize = 256;
cl_int iNumElements = cl_int(a_size);
cl_int iOffset = cl_int(a_offset);
a_size = roundBlocks(a_size, int(szLocalWorkSize));
CHECK_CL(clSetKernelArg(kern, 0, sizeof(cl_mem), (void*)&buff));
CHECK_CL(clSetKernelArg(kern, 1, sizeof(cl_float4), (void*)&a_val));
CHECK_CL(clSetKernelArg(kern, 2, sizeof(cl_int), (void*)&iNumElements));
CHECK_CL(clSetKernelArg(kern, 3, sizeof(cl_int), (void*)&iOffset));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kern, 1, NULL, &a_size, &szLocalWorkSize, 0, NULL, NULL));
}
void GPUOCLLayer::memcpyu32(cl_mem buff1, uint a_offset1, cl_mem buff2, uint a_offset2, size_t a_size)
{
if (buff2 == 0 || buff1 == 0)
return;
cl_kernel kern = m_progs.screen.kernel("MemCopyu32");
size_t szLocalWorkSize = 256;
cl_int iNumElements = cl_int(a_size);
a_size = roundBlocks(a_size, int(szLocalWorkSize));
CHECK_CL(clSetKernelArg(kern, 0, sizeof(cl_mem), (void*)&buff2));
CHECK_CL(clSetKernelArg(kern, 1, sizeof(cl_uint), (void*)&a_offset2));
CHECK_CL(clSetKernelArg(kern, 2, sizeof(cl_mem), (void*)&buff1));
CHECK_CL(clSetKernelArg(kern, 3, sizeof(cl_uint), (void*)&a_offset1));
CHECK_CL(clSetKernelArg(kern, 4, sizeof(cl_int), (void*)&iNumElements));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kern, 1, NULL, &a_size, &szLocalWorkSize, 0, NULL, NULL));
}
void GPUOCLLayer::float2half(cl_mem tempFloatBuff, cl_mem tempHalfBuff, size_t a_size)
{
cl_kernel kernX = m_progs.screen.kernel("FloatToHalf");
int isize = int(a_size);
int iOffset = 0;
size_t localWorkSize = 256;
a_size = roundBlocks(a_size, int(localWorkSize));
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&tempFloatBuff));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_mem), (void*)&tempHalfBuff));
CHECK_CL(clSetKernelArg(kernX, 2, sizeof(cl_int), (void*)&isize));
CHECK_CL(clSetKernelArg(kernX, 3, sizeof(cl_int), (void*)&iOffset));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
}
void GPUOCLLayer::float2half(const float* a_inData, size_t a_size, std::vector<cl_half>& a_out)
{
if (a_size == 0)
return;
a_out.resize(a_size);
cl_int ciErr1;
cl_mem tempFloatBuff = clCreateBuffer(m_globals.ctx, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, a_size * sizeof(float), (float*)a_inData, &ciErr1); if (ciErr1 != CL_SUCCESS) RUN_TIME_ERROR("Error in clCreateBuffer");
cl_mem tempHalfBuff = clCreateBuffer(m_globals.ctx, CL_MEM_READ_WRITE, a_size*sizeof(cl_half), NULL, &ciErr1); if (ciErr1 != CL_SUCCESS) RUN_TIME_ERROR("Error in clCreateBuffer");
float2half(tempFloatBuff, tempHalfBuff, a_size);
CHECK_CL(clEnqueueReadBuffer(m_globals.cmdQueue, tempHalfBuff, CL_TRUE, 0, a_size*sizeof(cl_half), &a_out[0], 0, NULL, NULL));
clReleaseMemObject(tempFloatBuff);
clReleaseMemObject(tempHalfBuff);
}
void GPUOCLLayer::float2half(const std::vector<float>& a_in, std::vector<cl_half>& a_out)
{
if (a_in.size() == 0 || a_in.size() != a_out.size())
return;
float2half(&a_in[0], a_in.size(), a_out);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float2 GPUOCLLayer::runKernel_TestAtomicsPerf(size_t a_size)
{
// return make_float2(0, 0);
Timer myTimer;
cl_mem buff = m_screen.color0;
cl_kernel kernX = m_progs.screen.kernel("TestAtomicsInt");
cl_kernel kernY = m_progs.screen.kernel("TestAtomicsFloat");
int isize = int(a_size);
size_t localWorkSize = 256;
a_size = roundBlocks(a_size, int(localWorkSize));
memsetf4(buff, float4(0, 0, 0, 0), a_size);
clFinish(m_globals.cmdQueue);
myTimer.start();
CHECK_CL(clSetKernelArg(kernX, 0, sizeof(cl_mem), (void*)&buff));
CHECK_CL(clSetKernelArg(kernX, 1, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernX, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
clFinish(m_globals.cmdQueue);
float time1 = myTimer.getElapsed()*1000.0f;
memsetf4(buff, float4(0, 0, 0, 0), a_size);
clFinish(m_globals.cmdQueue);
myTimer.start();
CHECK_CL(clSetKernelArg(kernY, 0, sizeof(cl_mem), (void*)&buff));
CHECK_CL(clSetKernelArg(kernY, 1, sizeof(cl_int), (void*)&isize));
CHECK_CL(clEnqueueNDRangeKernel(m_globals.cmdQueue, kernY, 1, NULL, &a_size, &localWorkSize, 0, NULL, NULL));
clFinish(m_globals.cmdQueue);
float time2 = myTimer.getElapsed()*1000.0f;
if (0)
{
std::vector<float> testData(1024);
CHECK_CL(clEnqueueReadBuffer(m_globals.cmdQueue, buff, CL_TRUE, 0, testData.size()*sizeof(float), &testData[0], 0, NULL, NULL));
std::ofstream out("testAtomicsf2.txt");
for (int i = 0; i < testData.size(); i++)
out << testData[i] << std::endl;
out.close();
}
return make_float2(time1, time2);
}
|
/*
* Copyright (C) 2007-2015 Frank Mertens.
*
* Use of this source is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#ifndef FLUX_PROCESS_H
#define FLUX_PROCESS_H
#include <sys/types.h> // pid_t
#include <flux/Exception>
#include <flux/SignalSet>
#include <flux/String>
#include <flux/Map>
#include <flux/SystemStream>
#include <flux/LineSource>
namespace flux {
class ProcessFactory;
typedef Map<String, String> EnvMap;
/** \brief Child process control
*/
class Process: public Stream
{
// FIXME: split up into Process, CurrentProcess
// FIXME: add function to set/get process-wide signal mask
public:
static Ref<Process> start(String command, int ioPolicy = 0);
static Ref<Process> start(String command, ProcessFactory *factory);
// -- child process control interface
enum Type {
GroupMember,
GroupLeader,
SessionLeader
};
enum IoPolicy {
ForwardInput = 1,
ForwardOutput = 2,
ForwardError = 4,
ForwardByPseudoTerminal = 8,
CloseInput = 16,
CloseOutput = 32,
CloseError = 64,
ErrorToOutput = 128,
ForwardAll = ForwardInput|ForwardOutput|ForwardError,
CloseAll = CloseInput|CloseOutput|CloseError
};
int type() const;
int ioPolicy() const;
SystemStream *in() const;
SystemStream *out() const;
SystemStream *err() const;
LineSource *lineOut();
LineSource *lineErr();
pid_t id() const;
void kill(int signal = SIGTERM, bool *permissionDenied = 0);
bool isRunning() const;
int wait();
// -- stream interface
virtual bool readyRead(double interval) const;
virtual int read(ByteArray *data);
virtual void write(const ByteArray *data);
// -- query / modify the current process status
static void cd(String path);
static String cwd();
static String execPath();
static mode_t setFileCreationMask(mode_t mask);
static uid_t realUserId();
static gid_t realGroupId();
static uid_t effectiveUserId();
static gid_t effectiveGroupId();
static bool isSuperUser();
static void setUserId(uid_t uid);
static void setEffectiveUserId(uid_t uid);
static String env(String key);
static void setEnv(String key, String value);
static void unsetEnv(String key);
static char **&environ();
static Ref<EnvMap> envMap();
static pid_t currentId();
static pid_t parentId();
static void kill(pid_t processId, int signal, bool *permissionDenied = 0);
static void killGroup(pid_t processGroupId, int signal, bool *permissionDenied = 0);
static void raise(int signal);
static int alarm(int seconds);
static SignalSet *defaultSignalMask();
static void sleep(double duration);
static void exit(int exitCode);
static void daemonize();
static bool isDaemonized();
protected:
friend class ProcessFactory;
Process(
int type,
int ioPolicy,
SystemStream *rawInput,
SystemStream *rawOutput,
SystemStream *rawError,
pid_t processId,
String command // FIXME: StringList *arguments
);
~Process();
private:
static void forwardSignal(int signal);
int type_;
int ioPolicy_;
Ref<SystemStream> in_;
Ref<SystemStream> out_;
Ref<SystemStream> err_;
Ref<LineSource> lineOut_;
Ref<LineSource> lineErr_;
pid_t processId_;
String command_;
};
/** \brief Child process error
*/
class ProcessError: public Exception
{
public:
ProcessError(int status, String command)
: status_(status),
command_(command)
{}
~ProcessError() throw() {}
inline int status() const { return status_; }
inline String command() const { return command_; }
virtual String message() const;
private:
int status_;
String command_;
};
} // namespace flux
#endif // FLUX_PROCESS_H
|
/*
Copyright (c) 2005-2023, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the University of Oxford 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.
*/
#ifndef TESTSOLVINGCOUPLEDNONLINEARPDES_HPP_
#define TESTSOLVINGCOUPLEDNONLINEARPDES_HPP_
#include <cxxtest/TestSuite.h>
#include "TetrahedralMesh.hpp"
#include <petsc.h>
#include <vector>
#include <cmath>
#include "PetscSetupAndFinalize.hpp"
#include "SimpleNonlinearEllipticSolver.hpp"
#include "BoundaryConditionsContainer.hpp"
#include "ConstBoundaryCondition.hpp"
#include "TrianglesMeshReader.hpp"
#include "ReplicatableVector.hpp"
#include "NonlinearEquationPde.hpp"
#include "SimpleNewtonNonlinearSolver.hpp"
/* HOW_TO_TAG PDE
* Write a solver for coupled nonlinear PDEs (advanced)
*/
/**
* A solver to solve the 'coupled' 2-unknown problem
* div.(u grad u) + 1 = 0,
* div.(v grav v) + lambda = 0,
* where lambda is taken in in the constructor.
*/
template <int DIM>
class MySimpleNonlinearCoupledSolver : public AbstractNonlinearAssemblerSolverHybrid<DIM,DIM,2>
{
private:
double mLambda;
virtual c_matrix<double,2*(DIM+1),2*(DIM+1) > ComputeMatrixTerm(c_vector<double, DIM+1>& rPhi,
c_matrix<double, DIM, DIM+1>& rGradPhi,
ChastePoint<DIM>& rX,
c_vector<double,2>& rU,
c_matrix<double,2,DIM>& rGradU,
Element<DIM,DIM>* pElement)
{
c_matrix<double,2*(DIM+1),2*(DIM+1)> ret = zero_matrix<double>(2*(DIM+1), 2*(DIM+1));
for (unsigned i=0; i<DIM+1; i++)
{
for (unsigned j=0; j<DIM+1; j++)
{
matrix_column<c_matrix<double,DIM,DIM+1> > grad_phi_i(rGradPhi,i);
matrix_column<c_matrix<double,DIM,DIM+1> > grad_phi_j(rGradPhi,j);
matrix_row<c_matrix<double,2,DIM> > gradU0(rGradU, 0);
matrix_row<c_matrix<double,2,DIM> > gradU1(rGradU, 1);
ret(2*i, 2*j) = + rPhi(j)*inner_prod(gradU0,grad_phi_i) + rU(0)*inner_prod(grad_phi_j,grad_phi_i);
ret(2*i+1,2*j+1) = + rPhi(j)*inner_prod(gradU1,grad_phi_i) + rU(1)*inner_prod(grad_phi_j,grad_phi_i);
}
}
return ret;
}
virtual c_vector<double,2*(DIM+1)> ComputeVectorTerm(c_vector<double, DIM+1>& rPhi,
c_matrix<double, DIM, DIM+1>& rGradPhi,
ChastePoint<DIM>& rX,
c_vector<double,2>& rU,
c_matrix<double,2,DIM>& rGradU,
Element<DIM,DIM>* pElement)
{
c_vector<double,2*(DIM+1)> ret;
for (unsigned i=0; i<DIM+1; i++)
{
matrix_column<c_matrix<double,DIM,DIM+1> > grad_phi_i(rGradPhi, i);
matrix_row<c_matrix<double,2,DIM> > gradU0(rGradU, 0);
matrix_row<c_matrix<double,2,DIM> > gradU1(rGradU, 1);
ret(2*i) = rU(0)*inner_prod(gradU0,grad_phi_i) - rPhi(i);
ret(2*i+1) = rU(1)*inner_prod(gradU1,grad_phi_i) - mLambda*rPhi(i);
}
return ret;
}
public:
MySimpleNonlinearCoupledSolver(TetrahedralMesh<DIM,DIM>* pMesh,
BoundaryConditionsContainer<DIM,DIM,2>* pBoundaryConditions,
double lambda)
: AbstractNonlinearAssemblerSolverHybrid<DIM,DIM,2>(pMesh,pBoundaryConditions)
{
mLambda = lambda;
}
virtual ~MySimpleNonlinearCoupledSolver()
{
}
};
/**
* A solver to solve the coupled 2-unknown problem
* div.(v gradu) = f(x,y),
* div.(u gradv) = g(x,y),
* where f and g (and boundary conditions) are chosen such that the solution is
* u = x^2, v = y.
*/
class AnotherCoupledNonlinearAssembler : public AbstractNonlinearAssemblerSolverHybrid<2,2,2> // AnotherCoupledNonlinearAssembler>
{
private:
double f(double x,double y)
{
return 2*y;
}
double g(double x,double y)
{
return 0;
}
virtual c_matrix<double,2*(2+1),2*(2+1)> ComputeMatrixTerm(c_vector<double, 2+1>& rPhi,
c_matrix<double, 2, 2+1>& rGradPhi,
ChastePoint<2>& rX,
c_vector<double,2>& rU,
c_matrix<double,2,2>& rGradU,
Element<2,2>* pElement)
{
c_matrix<double,2*(2+1),2*(2+1)> ret;
for (unsigned i=0; i<2+1; i++)
{
for (unsigned j=0; j<2+1; j++)
{
matrix_column<c_matrix<double,2,2+1> > grad_phi_i(rGradPhi, i);
matrix_column<c_matrix<double,2,2+1> > grad_phi_j(rGradPhi, j);
matrix_row<c_matrix<double,2,2> > gradU0(rGradU, 0);
matrix_row<c_matrix<double,2,2> > gradU1(rGradU, 1);
ret(2*i, 2*j) = rU(1)*inner_prod(grad_phi_j, grad_phi_i);
ret(2*i, 2*j+1) = rPhi(j)*inner_prod(gradU0, grad_phi_i);
ret(2*i+1,2*j) = rPhi(j)*inner_prod(gradU1, grad_phi_i);
ret(2*i+1,2*j+1) = rU(0)*inner_prod(grad_phi_j, grad_phi_i);
}
}
return ret;
}
virtual c_vector<double,2*(2+1)> ComputeVectorTerm(c_vector<double, 2+1>& rPhi,
c_matrix<double, 2, 2+1>& rGradPhi,
ChastePoint<2>& rX,
c_vector<double,2>& rU,
c_matrix<double,2,2>& rGradU,
Element<2,2>* pElement)
{
c_vector<double,2*(2+1)> ret;
for (unsigned i=0; i<2+1; i++)
{
matrix_column<c_matrix<double,2,2+1> > grad_phi_i(rGradPhi,i);
matrix_row<c_matrix<double,2,2> > gradU0(rGradU, 0);
matrix_row<c_matrix<double,2,2> > gradU1(rGradU, 1);
ret(2*i) = rU(1)*inner_prod(gradU0,grad_phi_i) + f(rX[0], rX[1])*rPhi(i);
ret(2*i+1) = rU(0)*inner_prod(gradU1,grad_phi_i) + g(rX[0], rX[1])*rPhi(i);
}
return ret;
}
public:
AnotherCoupledNonlinearAssembler(TetrahedralMesh<2,2>* pMesh,
BoundaryConditionsContainer<2,2,2>* pBoundaryConditions)
: AbstractNonlinearAssemblerSolverHybrid<2,2,2>(pMesh,pBoundaryConditions)
{
}
};
//////////////////////////////////////////////////////////////////////////////
// Test class
//////////////////////////////////////////////////////////////////////////////
class TestSolvingCoupledNonlinearPdes : public CxxTest::TestSuite
{
private:
template<int DIM>
void runTestSimpleCoupledNonlinearPde()
{
std::string file;
if (DIM==1)
{
file = "mesh/test/data/1D_0_to_1_10_elements";
}
else if (DIM==2)
{
file = "mesh/test/data/disk_522_elements";
}
else
{
file = "mesh/test/data/slab_395_elements";
}
TrianglesMeshReader<DIM,DIM> mesh_reader(file);
TetrahedralMesh<DIM,DIM> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
////////////////////////////////////////////////////////////////
// Solve coupled system using solver defined above
////////////////////////////////////////////////////////////////
// Boundary conditions for 2-unknown problem
BoundaryConditionsContainer<DIM,DIM,2> bcc;
bcc.DefineZeroDirichletOnMeshBoundary(&mesh,0); // zero dirichlet for u
bcc.DefineZeroDirichletOnMeshBoundary(&mesh,1); // zero dirichlet for v
// For comparing residuals
MySimpleNonlinearCoupledSolver<DIM> solver_lam_1(&mesh, &bcc, 1);
// For comparing solutions
MySimpleNonlinearCoupledSolver<DIM> solver(&mesh, &bcc, 4);
////////////////////////////////////////////
// Store residual
////////////////////////////////////////////
// Initialize 'solution' vector
Vec guess = PetscTools::CreateAndSetVec(2*mesh.GetNumNodes(), 1.0);
// Solve as well
Vec result = solver.Solve(guess, true);
ReplicatableVector result_repl(result);
///////////////////////////////////////////////////////////////////////
// Now solve div.(u gradu) + 1 = 0 as an uncoupled 1-unknown problem
///////////////////////////////////////////////////////////////////////
// Instantiate PDE object
NonlinearEquationPde<DIM> pde; //defined above
// boundary conditions for 1-unknown problem
BoundaryConditionsContainer<DIM,DIM,1> bcc_1unknown;
bcc_1unknown.DefineZeroDirichletOnMeshBoundary(&mesh);
// Assembler
SimpleNonlinearEllipticSolver<DIM,DIM> solver_1unknown(&mesh,&pde,&bcc_1unknown);
////////////////////////////////////////////
// Store residual
////////////////////////////////////////////
Vec guess_1unknown = PetscTools::CreateAndSetVec(mesh.GetNumNodes(), 1.0);
// Solve as well
Vec result_1unknown = solver_1unknown.Solve(guess_1unknown, true);
ReplicatableVector result_1unknown_repl(result_1unknown);
/////////////////////////////////////////////////////////////////////////
// check the residuals and solutions agree
// (check the u solutions (result_repl[2*i]) is equal to the
// solution of the 1-unknown problem and the v solutions
// (result_repl[2*i+1]) equal to 2 times the 1-unknown
// solution (as lambda=4))
//////////////////////////////////////////////////////////////////////////
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(result_repl[2*i], result_1unknown_repl[i], 1e-4);
TS_ASSERT_DELTA(result_repl[2*i+1], 2*result_1unknown_repl[i], 1e-4);
}
}
public:
/*
* Solve:
* div.(u gradu) + 1 = 0,
* div.(v gradv) + 4 = 0,
* with zero dirichlet on boundary.
*
* This is obviously really just two virtually identical uncoupled
* problems
*/
void TestSimpleCoupledNonlinearPde()
{
// run 1d version
runTestSimpleCoupledNonlinearPde<1>();
// run 2d version
runTestSimpleCoupledNonlinearPde<2>();
// run 3d version
runTestSimpleCoupledNonlinearPde<3>();
}
/*
* Solve:
* div.(u gradu) + 1 = 0,
* div.(v gradv) + 1 = 0,
* with neumann boundary conditions (the same on both u and v)
* on part of the boundary
*
* This is obviously two identical uncoupled problems
*/
void TestSimpleCoupledNonlinearPdeWithNeumannBoundaryConditions()
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/disk_522_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
////////////////////////////////////////////////////////////////
// Solve coupled system using solver defined above
////////////////////////////////////////////////////////////////
// boundary conditions for 2-unknown problem
BoundaryConditionsContainer<2,2,2> bcc;
// du/dn = -0.5 on r=1
TetrahedralMesh<2,2>::BoundaryElementIterator iter = mesh.GetBoundaryElementIteratorBegin();
ConstBoundaryCondition<2>* p_boundary_condition = new ConstBoundaryCondition<2>(-0.5);
ConstBoundaryCondition<2>* p_boundary_condition1 = new ConstBoundaryCondition<2>(-0.5);
while (iter != mesh.GetBoundaryElementIteratorEnd())
{
bcc.AddNeumannBoundaryCondition(*iter, p_boundary_condition,0);
bcc.AddNeumannBoundaryCondition(*iter, p_boundary_condition1,1);
iter++;
}
// u = 2 at some point on the boundary, say node 1
p_boundary_condition = new ConstBoundaryCondition<2>(2.0);
p_boundary_condition1 = new ConstBoundaryCondition<2>(2.0);
bcc.AddDirichletBoundaryCondition(mesh.GetNode(1), p_boundary_condition,0);
bcc.AddDirichletBoundaryCondition(mesh.GetNode(1), p_boundary_condition1,1);
// Use solver to solve (with lambda = 1)
MySimpleNonlinearCoupledSolver<2> solver(&mesh,&bcc,1.0);
Vec result = solver.Solve(PetscTools::CreateAndSetVec(2*mesh.GetNumNodes(),1.0),true);
ReplicatableVector result_repl(result);
///////////////////////////////////////////////////////////////////////
// Now solve div.(u gradu) + 1 = 0 as an uncoupled 1-unknown problem
///////////////////////////////////////////////////////////////////////
// Instantiate PDE object
NonlinearEquationPde<2> pde;
// boundary conditions for 1-unknown problem
BoundaryConditionsContainer<2,2,1> bcc_1unknown;
iter = mesh.GetBoundaryElementIteratorBegin();
p_boundary_condition = new ConstBoundaryCondition<2>(-0.5);
while (iter != mesh.GetBoundaryElementIteratorEnd())
{
bcc_1unknown.AddNeumannBoundaryCondition(*iter, p_boundary_condition);
iter++;
}
// u = 2 at some point on the boundary, say node 1
p_boundary_condition = new ConstBoundaryCondition<2>(2.0);
bcc_1unknown.AddDirichletBoundaryCondition(mesh.GetNode(1), p_boundary_condition);
// Assembler
SimpleNonlinearEllipticSolver<2,2> solver_1unknown(&mesh,&pde,&bcc_1unknown);
Vec result_1unknown = solver_1unknown.Solve(PetscTools::CreateAndSetVec(mesh.GetNumNodes(),1.0), true);
ReplicatableVector result_1unknown_repl(result_1unknown);
// check the u solutions (result_repl[2*i]) is equal to the
// solution of the 1-unknown problem and the v solutions
// (result_repl[2*i+1]) are equal to the 1-unknown
// solution
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
TS_ASSERT_DELTA(result_repl[2*i] , result_1unknown_repl[i], 1e-6);
TS_ASSERT_DELTA(result_repl[2*i+1], result_1unknown_repl[i], 1e-6);
}
}
/* Solve the real coupled pde
*
* v (u_xx+u_yy) = f
* u (v_xx+v_yy) = g
*
* where f,g and boundary conditions are chosen given the solution
*
* u = x^2
* v = y
*/
void TestRealCoupledPde()
{
TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_128_elements");
// REPLACE ABOVE LINE WITH THIS AND THE ASSEMBLER SEEMS TO GET STUCK SOMEWHERE (applying
// boundary conditions maybe?) ///\todo: find out why..
//TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_4096_elements");
TetrahedralMesh<2,2> mesh;
mesh.ConstructFromMeshReader(mesh_reader);
// boundary conditions for 2-unknown problem
BoundaryConditionsContainer<2,2,2> bcc;
TetrahedralMesh<2,2>::BoundaryNodeIterator iter = mesh.GetBoundaryNodeIteratorBegin();
while (iter != mesh.GetBoundaryNodeIteratorEnd())
{
double x = (*iter)->GetPoint()[0];
double y = (*iter)->GetPoint()[1];
// apply bc u=x^2
ConstBoundaryCondition<2>* p_boundary_condition = new ConstBoundaryCondition<2>(x*x);
bcc.AddDirichletBoundaryCondition(*iter, p_boundary_condition, 0);
// apply bc v=x^2
ConstBoundaryCondition<2>* p_boundary_condition1 = new ConstBoundaryCondition<2>(y);
bcc.AddDirichletBoundaryCondition(*iter, p_boundary_condition1, 1);
iter++;
}
// purpose-made solver for this problem:
AnotherCoupledNonlinearAssembler solver(&mesh,&bcc);
// use the newton solver (for coverage)
SimpleNewtonNonlinearSolver newton_solver;
newton_solver.SetTolerance(1e-10);
newton_solver.SetWriteStats();
solver.SetNonlinearSolver(&newton_solver);
//// uncomment this to check whether ComputeMatrixTerm has been coded up correctly
//// (by seeing whether the resulting analytic Jacobian matches the numerical one).
//assert( solver.VerifyJacobian() );
// IMPORTANT NOTE: both the petsc nonlinear solver and the Newton solver will FAIL
// if an initial guess of zeroes is given.
Vec result = solver.Solve( PetscTools::CreateAndSetVec(2*mesh.GetNumNodes(),1.0), false);
int size;
VecGetSize(result,&size);
TS_ASSERT_EQUALS(size, (int)mesh.GetNumNodes()*2);
ReplicatableVector result_repl(result);
for (unsigned i=0; i<mesh.GetNumNodes(); i++)
{
double x = mesh.GetNode(i)->GetPoint()[0];
double y = mesh.GetNode(i)->GetPoint()[1];
double u = result_repl[2*i];
double v = result_repl[2*i+1];
TS_ASSERT_DELTA(u, x*x, 1e-2);
TS_ASSERT_DELTA(v, y, 1e-2);
}
PetscTools::Destroy(result);
}
};
#endif /*TESTSOLVINGCOUPLEDNONLINEARPDES_HPP_*/
|
#include<stdio.h>
#include<stdlib.h>
int bubble(int [],int);
int swap(int *,int *);
int printArray(int [],int);
int main(void){
int arr[]={55,2,6,12,3,1};
int n=sizeof(arr)/sizeof(arr[0]);
bubble(arr,n);
printArray(arr,n);
return 0;
}
int bubble(int arr[],int size){
int i,j;
for(i=0;i<size;i++)
for(j=0;j<size-1;j++)
if(arr[j]<arr[j+1]){ // decreasing order sort
swap(&arr[j],&arr[j+1]);
}
}
int swap(int *x,int *y){
int temp;
temp=*x;
*x=*y;
*y=temp;
}
int printArray(int arr[], int size){
int i;
for(i=0;i<size;i++)
printf(" %d",arr[i]);
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <map>
#include <sstream>
#include <cmath>
#include <unordered_set> // 需要c++ 11才能支持
#include <unordered_map> // 需要c++ 11才能支持
using namespace std;
class Distance {
public:
int getDistance(vector<string> article, int n, string x, string y) {
int xp = -n, yp = -n, res = n;
// 最大距离肯定是最两端的单词
// 最小距离肯定是相邻x与y的距离
for(int i = 0; i < n; ++i){
if(article[i] == x){
res = min(res, i-yp);
xp = i;
}
else if(article[i] == y){
res = min(res, i-xp);
yp = i;
}
} return res;
}
};
int main(){
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int arr[]={3,4,5,6,0,0,0,0,7,0,8,9};
int n=sizeof(arr)/sizeof(arr[0]);
//cout<<n<<endl;
for(int i=0;i<n;i++)
cout<<arr[i]<<"\t";
int left=0;
int right=n-1;
while(left<right){
int currentLeftElement=arr[left];
int currentRightElement=arr[right];
if(currentLeftElement>0)
left++;
if(currentRightElement==0)
right--;
if(currentLeftElement==0 && currentRightElement>0){
arr[left]=currentRightElement;
arr[right]=currentLeftElement;
left++;
right--;
}
}
cout<<endl;
for(int i=0;i<n;i++)
cout<<arr[i]<<"\t";
cout<<endl;
return 0;
}
|
/****************************************************
* RoseBin :: Binary Analysis for ROSE
* Author : tps
* Date : Sep26 07
* Decription : Visualization in DOT
****************************************************/
#ifndef __RoseBin_Graph__
#define __RoseBin_Graph__
//#include <mysql.h>
#include <stdio.h>
#include <iostream>
#include "SB_Graph.h"
//#include "RoseBin_support.h"
#include "MyAstAttribute.h"
//#include "RoseBin_unparse_visitor.h"
//#include "RoseBin.h"
class RoseBin_FlowAnalysis;
//class RoseBin_FlowAnalysis;
class RoseBin_Graph : public SB_DirectedGraph {
protected:
bool grouping;
// specifies that this node has no destination address
bool nodest_jmp ;
// specifies that there is a node that has a call error (calling itself)
bool error ;
// specifies a call to a unknown location
bool nodest_call;
// specifies where its an int instruction
bool interrupt;
// specifies wheather a node has been visited by the dfa successfully
bool checked;
bool dfa_standard ;
bool dfa_resolved_func;
bool dfa_unresolved_func;
bool dfa_conditional;
//rose_graph_node_edge_hash_multimap unique_edges;
rose_graph_integer_edge_hash_multimap unique_edges;
public:
//RoseBin_Graph(VirtualBinCFG::AuxiliaryInformation* info):SB_DirectedGraph(info) {grouping = true;}
RoseBin_Graph() {grouping = true;}
virtual ~RoseBin_Graph() {}
//RoseBin_unparse_visitor* unparser;
SgIncidenceDirectedGraph* graph;
void setGrouping(bool val) {grouping = val;}
virtual void printEdges( VirtualBinCFG::AuxiliaryInformation* info,
bool forward_analysis, std::ofstream& myfile, bool mergedEdges) =0;
virtual void printNodes( bool dfg, RoseBin_FlowAnalysis* flow, bool forward_analysis,
std::ofstream &myfile, std::string& recursiveFunctionName) =0;
virtual void printProlog( std::ofstream& myfile, std::string& fileType) =0;
virtual void printEpilog( std::ofstream& myfile) =0;
void createUniqueEdges();
};
#endif
|
//
// Created by Nitish Mohan Shandilya on 9/9/20.
//
// Given Student Id and the courses that he has taken
// Find the overlapping courses of two students
class Solution {
struct UserGroupNotFoundException : exception {
const char* what() noexcept {
return "Bad Input passed";
}
};
unordered_map<string, vector<string>> coursesToIdMap;
unordered_map<string, vector<string>> result;
void buildCoursesToIdMap(vector<string>& userIds, vector<vector<string>>& coursesList) {
for (int i=0; i<userIds.size(); ++i) {
string& user = userIds[i];
vector<string>& courses = coursesList[i];
for (string& course : courses) {
auto it = coursesToIdMap.find(course);
if (it == coursesToIdMap.end()) {
coursesToIdMap.emplace(course, initializer_list<string>{user});
} else {
coursesToIdMap[course].emplace_back(user);
}
}
}
}
void insertPairsIntoResultMap(vector<string>& userIds) {
for (int i=0; i<userIds.size()-1; ++i) {
for (int j=i+1; j<userIds.size(); ++j) {
string& firstUser = userIds[i];
string& secondUser = userIds[j];
result.emplace(firstUser+ ","+secondUser, (0));
}
}
}
public:
void getOverlappingCourses(vector<string>& userIds, vector<vector<string>>& coursesList) {
buildCoursesToIdMap(userIds, coursesList);
insertPairsIntoResultMap(userIds);
for (auto ele : coursesToIdMap) {
const string& course = ele.first;
vector<string>& userIds = ele.second;
if (userIds.size() <= 1) continue;
for (int i=0; i<userIds.size()-1; ++i) {
for (int j=i+1; j<userIds.size(); ++j) {
string& firstUser = userIds[i];
string& secondUser = userIds[j];
string group1 = firstUser+","+secondUser;
string group2 = secondUser+","+firstUser;
auto it1 = result.find(group1);
auto it2 = result.find(group2);
if (it1 == result.end() && it2 != result.end()) {
result[it2->first].emplace_back(course);
} else if (it2 == result.end() && it1 != result.end()) {
result[it1->first].emplace_back(course);
} else {
throw UserGroupNotFoundException();
}
}
}
}
}
void print() {
for (auto ele : result) {
const string& pairIds = ele.first;
vector<string>& courses = ele.second;
cout << pairIds << "->";
for (string& course : courses) {
cout << course << " : ";
}
cout << endl;
}
}
};
int main() {
vector<string> userIds = {"45", "54", "65", "34", "5566", "1"};
vector<vector<string>> coursesList = {{"Computer", "Electronics"}, {"Electronics"},
{"Social"}, {""}, {""}, {"Computer", "Electronics"}};
Solution s;
try {
s.getOverlappingCourses(userIds, coursesList);
s.print();
} catch (exception& e) {
cout << e.what();
}
}
|
/*
* FStream.h
*
* Created on: May 21, 2012
* Author: marchi
*/
#ifndef FSTREAM_H_
#define FSTREAM_H_
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <string>
using std::string;
using std::ios;
using std::ifstream;
using std::cout;
using std::endl;
#define _FILE_OFFSET_BITS 64
class Fstream {
protected:
int dStep;
int offStep;
int nframe;
public:
Fstream():dStep(1),offStep(0),nframe(0){};
Fstream(string & x): dStep(1),offStep(0),nframe(0){};
int gStep(){return dStep;}
int goffStep(){return offStep;}
int gFrame(){return nframe;};
virtual void seekg(off_t ,string)=0;
virtual bool CheckFrameNumber(int)=0;
virtual void nextFrame()=0;
virtual ios::pos_type tellg()=0;
virtual ~Fstream();
};
#endif /* FSTREAM_H_ */
|
/**
* Regular expression matcher.
* Based on the work of Russ Cox: https://swtch.com/~rsc/regexp/regexp1.html
*
* Implements a Thompson NFA based RegEx matcher.
* Ken Thompson, “Regular expression search algorithm,” Communications of the
* ACM 11(6) (June 1968), pp. 419–422. http://doi.acm.org/10.1145/363347.363387
* (PDF)
*/
#ifndef FISHY_REGEX_H
#define FISHY_REGEX_H
#include <CORE/types.h>
#include <string>
namespace core {
namespace util {
namespace parser {
/**
* Regular Expression pattern matcher
*/
class RegExPattern {
public:
/**
* Error codes from build process.
*/
struct eBuildError {
enum type {
NONE,
MISSING_ESCAPE,
BAD_ESCAPE,
MISSING_PEREN,
MISSING_BRACE,
PEREN_INSIDE_BRACE,
RANGE_OUTSIDE_BRACE,
MISSING_OPERAND
};
};
RegExPattern();
~RegExPattern();
RegExPattern(const RegExPattern &other);
RegExPattern &operator=(const RegExPattern &other);
/**
* Constructs a regex in place. Will die on error.
*
* @param pattern the regex pattern to build
*/
RegExPattern(const std::string &pattern);
/**
* Replaces the regex in this pattern.
*
* @param pattern the regex pattern to build
*/
eBuildError::type build(const std::string &pattern);
/**
* Scans a string for a match against this pattern.
* The pattern matching starts at {@code begin} and continues until the first
* of
* {@code end} or match rejection.
*
* @param begin start of string to match
* @param end end of string to match
* @return iterator at end of match, or begin if no match.
*/
std::string::const_iterator scan(
const std::string::const_iterator &begin,
const std::string::const_iterator &end) const;
/**
* Matches a full string against this pattern.
*
* @param begin start of string to match
* @param end end of string to match
* @return true if string is fully matched
*/
bool match(
const std::string::const_iterator &begin,
const std::string::const_iterator &end) const;
private:
class Nfa;
Nfa *m_machine;
};
} // namespace parser
} // namespace util
} // namespace core
#endif
|
#pragma once
#ifndef HTTPDISPATCHERFACTORY_H
#define HTTPDISPATCHERFACTORY_H
#include "IHTTPDispatcher.h"
#include "CURLDispatcher.h"
//Why this factory method? Although now it only returns an instance of the CURLDispatcher class, when in a typical factory there's at least some choices as to what instance to return,
//this design anticipates future extensions, say performing network requests with the QT framework classes instead of the CPR library.
class HTTPDispatcherFactory {
public:
static IHTTPDispatcher* createInstance() {
return new CURLDispatcher();
}
};
#endif
|
#ifndef __SHOWEVENTSAPP_HPP
#define __SHOWEVENTSAPP_HPP
#include <vector>
#include <TApplication.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TPaveText.h>
#include <TH1I.h>
#include "AxialShiftHook.hpp"
class AxialShiftApp: public TApplication
{
private:
TCanvas* main_canvas;
TPad* hist_pad;
TPaveText* title_text_widget;
unordered_map< chamber_id_t, TH1I* > shift_hist;
AxialShiftHook* hook;
void ParseCommandLine();
void init_hists( Geometry &geom );
public:
AxialShiftApp( const char* app_name, int &argc, char* argv[] );
~AxialShiftApp();
string data_filepath;
string geometry_filepath;
void Init();
};
#endif
|
#include "ProbabilityDistribution.h"
|
#ifndef user_hpp
#define user_hpp
#include "tstring.hpp"
using namespace std;
class user {
private:
tstring<20> name;
tstring<30> id;
tstring<30> pwd;
int purview = 0;
public:
void setName(const tstring<20> &_name) {
name = _name;
}
void setId(const tstring<30> &_id) {
id = _id;
}
void setPwd(const tstring<30> &_pwd) {
pwd = _pwd;
}
void setPurview(int _pur) {
purview = _pur;
}
tstring<20> getName() {return name;}
tstring<30> getId() {return id;}
tstring<30> getPwd() {return pwd;}
bool login(const tstring<30> &_pwd) {
return _pwd == pwd;
}
int getPurview() {return purview;}
operator bool() const {
return purview != 0;
}
};
#endif
|
/***********************************************************************
created: Sun, 6th April 2014
author: Lukas E Meindl
*************************************************************************/
/***************************************************************************
* Copyright (C) 2004 - 2014 Paul D Turner & The CEGUI Development Team
*
* 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 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 "CEGUI/RendererModules/Direct3D11/Shader.h"
#include "CEGUI/Logger.h"
#include "CEGUI/Exceptions.h"
#include <D3Dcompiler.h>
#include <sstream>
#include <iostream>
namespace CEGUI
{
//----------------------------------------------------------------------------//
static const size_t LOG_BUFFER_SIZE = 8096;
//----------------------------------------------------------------------------//
Direct3D11Shader::Direct3D11Shader(Direct3D11Renderer& owner,
const std::string& vertexShaderSource,
const std::string& pixelShaderSource)
: d_device(owner.getDirect3DDevice())
, d_deviceContext(owner.getDirect3DDeviceContext())
, d_vertShader(0)
, d_vertexShaderBuffer(0)
, d_vertexShaderReflection(0)
, d_pixelShader(0)
, d_pixelShaderBuffer(0)
, d_pixelShaderReflection(0)
{
createVertexShader(vertexShaderSource);
createPixelShader(pixelShaderSource);
}
//----------------------------------------------------------------------------//
Direct3D11Shader::~Direct3D11Shader()
{
if (d_vertShader)
d_vertShader->Release();
if (d_vertexShaderBuffer)
d_vertexShaderBuffer->Release();
if(d_vertexShaderReflection)
d_vertexShaderReflection->Release();
if (d_pixelShader)
d_pixelShader->Release();
if(d_pixelShaderBuffer)
d_pixelShaderBuffer->Release();
if(d_pixelShaderReflection)
d_pixelShaderReflection->Release();
}
//----------------------------------------------------------------------------//
void Direct3D11Shader::bind() const
{
//Set Vertex and Pixel Shaders
d_deviceContext->VSSetShader(d_vertShader, 0, 0);
d_deviceContext->PSSetShader(d_pixelShader, 0, 0);
d_deviceContext->CSSetShader(0, 0, 0);
d_deviceContext->DSSetShader(0, 0, 0);
d_deviceContext->GSSetShader(0, 0, 0);
}
//----------------------------------------------------------------------------//
void Direct3D11Shader::createVertexShader(const std::string& vertexShaderSource)
{
HRESULT result;
ID3D10Blob* errorMessage;
UINT flags1 = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR;
#if defined(DEBUG) || defined (_DEBUG)
flags1 |= D3DCOMPILE_DEBUG;
#else
flags1 |= 0;
#endif
result = D3DCompile(static_cast<LPCSTR>(vertexShaderSource.c_str()), vertexShaderSource.size(), "CEGUI Vertex Shader",
0, 0, "main", getVertexShaderVersion().c_str(), flags1, 0, &d_vertexShaderBuffer, &errorMessage);
if(FAILED(result))
{
std::string msg(static_cast<const char*>(errorMessage->GetBufferPointer()), errorMessage->GetBufferSize());
errorMessage->Release();
throw RendererException(msg);
}
result = d_device->CreateVertexShader(d_vertexShaderBuffer->GetBufferPointer(), d_vertexShaderBuffer->GetBufferSize(), 0, &d_vertShader);
if(FAILED(result))
{
std::string msg("Direct3D11Shader: Failed to create the vertex shader");
throw RendererException(msg);
}
result = D3DReflect(d_vertexShaderBuffer->GetBufferPointer(), d_vertexShaderBuffer->GetBufferSize(), IID_ID3D11ShaderReflection, reinterpret_cast<void**>(&d_vertexShaderReflection));
if(FAILED(result))
{
std::string msg("D3DReflect: Shader reflection failed");
throw RendererException(msg);
}
}
//----------------------------------------------------------------------------//
void Direct3D11Shader::createPixelShader(const std::string& pixelShaderSource)
{
HRESULT result;
ID3D10Blob* errorMessage;
UINT flags1 = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR;
#if defined(DEBUG) || defined (_DEBUG)
flags1 |= D3DCOMPILE_DEBUG;
#else
flags1 |= 0;
#endif
result = D3DCompile(static_cast<LPCSTR>(pixelShaderSource.c_str()), pixelShaderSource.size(), "D3D11 Pixel Shader",
0, 0, "main", getPixelShaderVersion().c_str(), flags1, 0, &d_pixelShaderBuffer, &errorMessage);
if(FAILED(result))
{
std::string msg(static_cast<const char*>(errorMessage->GetBufferPointer()), errorMessage->GetBufferSize());
errorMessage->Release();
throw RendererException(msg);
}
result = d_device->CreatePixelShader(d_pixelShaderBuffer->GetBufferPointer(), d_pixelShaderBuffer->GetBufferSize(), 0, &d_pixelShader);
if(FAILED(result))
{
std::string msg("Direct3D11Shader: Failed to create the pixel shader");
throw RendererException(msg);
}
result = D3DReflect(d_pixelShaderBuffer->GetBufferPointer(), d_pixelShaderBuffer->GetBufferSize(), IID_ID3D11ShaderReflection, reinterpret_cast<void**>(&d_pixelShaderReflection));
if(FAILED(result))
{
std::string msg("D3DReflect: Shader reflection failed");
throw RendererException(msg);
}
}
//----------------------------------------------------------------------------//
std::string Direct3D11Shader::getVertexShaderVersion() const
{
//Values taken from http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876%28v=vs.85%29.aspx
D3D_FEATURE_LEVEL featureLevel = d_device->GetFeatureLevel();
switch(featureLevel)
{
default:
case D3D_FEATURE_LEVEL_11_0:
return "vs_5_0";
break;
case D3D_FEATURE_LEVEL_10_1:
return "vs_4_0";
break;
case D3D_FEATURE_LEVEL_10_0:
return "vs_4_0";
break;
case D3D_FEATURE_LEVEL_9_3:
return "vs_4_0_level_9_3";
break;
case D3D_FEATURE_LEVEL_9_2:
return "vs_4_0_level_9_1";
break;
case D3D_FEATURE_LEVEL_9_1:
return "vs_4_0_level_9_1";
break;
}
}
//----------------------------------------------------------------------------//
std::string Direct3D11Shader::getPixelShaderVersion() const
{
//Values taken from http://msdn.microsoft.com/en-us/library/windows/desktop/ff476876%28v=vs.85%29.aspx
D3D_FEATURE_LEVEL featureLevel = d_device->GetFeatureLevel();
switch(featureLevel)
{
default:
case D3D_FEATURE_LEVEL_11_0:
return "ps_5_0";
break;
case D3D_FEATURE_LEVEL_10_1:
return "ps_4_0";
break;
case D3D_FEATURE_LEVEL_10_0:
return "ps_4_0";
break;
case D3D_FEATURE_LEVEL_9_3:
return "ps_4_0_level_9_3";
break;
case D3D_FEATURE_LEVEL_9_2:
return "ps_4_0_level_9_1";
break;
case D3D_FEATURE_LEVEL_9_1:
return "ps_4_0_level_9_1";
break;
}
}
//----------------------------------------------------------------------------//
D3D11_SHADER_INPUT_BIND_DESC Direct3D11Shader::getTextureBindingDesc(const std::string& variableName, ShaderType shaderType)
{
HRESULT result;
ID3D11ShaderReflection* shaderReflection = 0;
if(shaderType == ShaderType::VERTEX)
shaderReflection = d_vertexShaderReflection;
else if(shaderType == ShaderType::PIXEL)
shaderReflection = d_pixelShaderReflection;
D3D11_SHADER_DESC shaderDescription;
result = shaderReflection->GetDesc(&shaderDescription);
if(FAILED(result))
{
std::string errorMessage("ID3D11ShaderReflection::GetDesc() call failed. Could not retrieve shader description.");
throw RendererException(errorMessage);
}
UINT resourceCount = shaderDescription.BoundResources;
D3D11_SHADER_INPUT_BIND_DESC shaderInputBindDesc;
for(UINT i = 0; i < resourceCount; ++i)
{
result = shaderReflection->GetResourceBindingDesc(i, &shaderInputBindDesc);
if(SUCCEEDED(result))
{
int comparisonResult = variableName.compare(shaderInputBindDesc.Name);
if(comparisonResult == 0)
return shaderInputBindDesc;
}
}
std::string errorMessage = std::string("Variable was not found in shader for variable of name \"") + variableName + "\"";
throw RendererException(errorMessage);
return shaderInputBindDesc;
}
//----------------------------------------------------------------------------//
D3D11_SHADER_VARIABLE_DESC Direct3D11Shader::getUniformVariableDescription(const std::string& variableName, ShaderType shaderType)
{
HRESULT result;
ID3D11ShaderReflectionConstantBuffer* shaderReflectConstBuffer = getShaderReflectionConstBuffer(shaderType);
ID3D11ShaderReflectionVariable* shaderReflectVariable = shaderReflectConstBuffer->GetVariableByName(variableName.c_str());
D3D11_SHADER_VARIABLE_DESC varDesc;
result = shaderReflectVariable->GetDesc(&varDesc);
if(FAILED(result))
throw RendererException("Could not retrieve variable \"" + variableName + "\" from the buffer \"$Globals\"");
return varDesc;
}
//----------------------------------------------------------------------------//
ID3D11ShaderReflectionConstantBuffer* Direct3D11Shader::getShaderReflectionConstBuffer(ShaderType shaderType)
{
HRESULT result;
ID3D11ShaderReflection* shaderReflection = 0;
if(shaderType == ShaderType::VERTEX)
shaderReflection = d_vertexShaderReflection;
else if(shaderType == ShaderType::PIXEL)
shaderReflection = d_pixelShaderReflection;
D3D11_SHADER_DESC shaderDescription;
result = shaderReflection->GetDesc(&shaderDescription);
if(FAILED(result))
{
std::string errorMessage("ID3D11ShaderReflection::GetDesc() call failed. Could not retrieve shader description.");
throw RendererException(errorMessage);
}
ID3D11ShaderReflectionConstantBuffer* shaderReflectConstBufferGlobals = shaderReflection->GetConstantBufferByName("$Globals");
if(shaderReflectConstBufferGlobals == 0)
throw RendererException("Could not retrieve constant buffer \"$Globals\" from the shader");
return shaderReflectConstBufferGlobals;
}
//----------------------------------------------------------------------------//
ID3D10Blob* Direct3D11Shader::getVertexShaderBuffer() const
{
return d_vertexShaderBuffer;
}
//----------------------------------------------------------------------------//
}
|
#ifndef _H_GRID_
#define _H_GRID_
#include <list>
#include <vector>
class grid
{
public:
grid(int size, double resolution);
~grid();
void add_obstacle(double x, double y);
std::list<std::pair<double, double> > make_path(double x, double y, double px, double py) const;
private:
bool has_obstacle(int x, int y) const;
//FIXME: it's ugly
std::vector<std::vector<bool> > map;
double resolution_;
};
#endif //_H_GRID_
|
//------------------------------------------------------------------------------
// STKEphemerisFile
//------------------------------------------------------------------------------
// GMAT: General Mission Analysis Tool
//
// Copyright (c) 2002 - 2015 United States Government as represented by the
// Administrator of the National Aeronautics and Space Administration.
// All Other Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// You may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
// http://www.apache.org/licenses/LICENSE-2.0.
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language
// governing permissions and limitations under the License.
//
// Author: Linda Jun / NASA
// Created: 2016.01.13
//
/**
* Writes a spacecraft orbit ephemeris to a file in STK format.
*/
//------------------------------------------------------------------------------
#include "STKEphemerisFile.hpp"
#include "FileUtil.hpp"
#include "FileTypes.hpp"
#include "StringUtil.hpp"
#include "TimeTypes.hpp" // for FormatCurrentTime()
#include "UtilityException.hpp"
#include "MessageInterface.hpp"
#include "TimeSystemConverter.hpp" // for TimeConverterUtil::Convert()
#include "A1Mjd.hpp"
#include "Rvector6.hpp"
#include "GmatGlobal.hpp"
#include <sstream>
#include <limits>
// We want to use std::numeric_limits<std::streamsize>::max()
#ifdef _MSC_VER // if Microsoft Visual C++
#undef max
#endif
//#define DEBUG_STK_FILE
//#define DEBUG_INITIALIZE
//#define DEBUG_WRITE_DATA_SEGMENT
//#define DEBUG_FINALIZE
//#define DEBUG_INITIAL_FINAL
//----------------------------
// static data
//----------------------------
//----------------------------
// public methods
//----------------------------
//------------------------------------------------------------------------------
// default constructor
//------------------------------------------------------------------------------
STKEphemerisFile::STKEphemerisFile() :
stkFileNameForRead (""),
stkFileNameForWrite ("")
{
InitializeData();
}
//------------------------------------------------------------------------------
// copy constructor
//------------------------------------------------------------------------------
STKEphemerisFile::STKEphemerisFile(const STKEphemerisFile ©) :
stkFileNameForRead (copy.stkFileNameForRead),
stkFileNameForWrite (copy.stkFileNameForWrite)
{
InitializeData();
}
//------------------------------------------------------------------------------
// operator=
//------------------------------------------------------------------------------
STKEphemerisFile& STKEphemerisFile::operator=(const STKEphemerisFile ©)
{
if (© == this)
return *this;
stkFileNameForRead = copy.stkFileNameForRead;
stkFileNameForWrite = copy.stkFileNameForWrite;
InitializeData();
return *this;
}
//------------------------------------------------------------------------------
// destructor
//------------------------------------------------------------------------------
STKEphemerisFile::~STKEphemerisFile()
{
if (stkInStream.is_open())
stkInStream.close();
if (stkOutStream.is_open())
{
stkOutStream.flush();
stkOutStream.close();
}
}
//------------------------------------------------------------------------------
// void InitializeData()
//------------------------------------------------------------------------------
/**
* Clears header information.
*/
//------------------------------------------------------------------------------
void STKEphemerisFile::InitializeData()
{
#ifdef DEBUG_STK_EPHEMFILE_INIT
MessageInterface::ShowMessage("STKEphemerisFile::InitializeData() entered\n");
#endif
firstTimeWriting = true;
openForTempOutput = true;
scenarioEpochA1Mjd = 0.0;
coordinateSystemEpochA1Mjd = 0.0;
beginSegmentTime = 0.0;
lastEpochWrote = -999.999;
beginSegmentArray.clear();
numberOfEphemPoints = 0;
interpolationOrder = 0;
scenarioEpochUtcGreg = "";
interpolationMethod = "";
centralBody = "";
coordinateSystem = "";
coordinateSystemEpochStr = "";
distanceUnit = "";
ephemTypeForRead = "";
ephemTypeForWrite = "";
stkTempFileName = "";
numEphemPointsBegPos = 0;
initialSecsFromEpoch = 0.0;
finalSecsFromEpoch = 0.0;
}
//------------------------------------------------------------------------------
// bool OpenForRead(const std::string &filename, const std::string &ephemType)
//------------------------------------------------------------------------------
/**
* Opens STK ephemeris (.e) file for reading.
*
* @filename File name to open
* @ephemType Ephemeris type to read, at this time only "TimePos" or "TimePosVel"
* is allowed
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::OpenForRead(const std::string &filename,
const std::string &ephemType)
{
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
("STKEphemerisFile::OpenForRead() entered, filename='%s'\n", filename.c_str());
#endif
bool retval = false;
// Check ephem type
// Currently only TimePos and TimePosVel are allowed
if (ephemType != "TimePos" && ephemType != "TimePosVel")
{
UtilityException ue;
ue.SetDetails("STKEphemerisFile::OpenForRead() *** INTERNAL ERROR *** "
"Only TimePos or TimePosVel is valid for read on STK "
"ephemeris file '%s'.", stkFileNameForRead.c_str());
throw ue;
}
if (stkInStream.is_open())
stkInStream.close();
stkFileNameForRead = filename;
ephemTypeForRead = ephemType;
stkInStream.open(stkFileNameForRead.c_str());
if (stkInStream.is_open())
{
retval = true;
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
(" Successfully opened '%s' for reading\n", stkFileNameForRead.c_str());
#endif
}
else
{
retval = false;
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
(" Failed open '%s' for reading\n", stkFileNameForRead.c_str());
#endif
}
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
("STKEphemerisFile::OpenForRead() returning %d\n", retval);
#endif
return retval;
}
//------------------------------------------------------------------------------
// bool OpenForWrite(const std::string &filename, const std::string &ephemType)
//------------------------------------------------------------------------------
/**
* Opens STK ephemeris (.e) file for writing.
*
* @filename File name to open
* @ephemType Ephemeris type to write, at this time only "TimePos" or "TimePosVel"
* is allowed
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::OpenForWrite(const std::string &filename,
const std::string &ephemType)
{
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
("STKEphemerisFile::OpenForWrite() entered, filename='%s', openForTempOutput=%d\n",
filename.c_str(), openForTempOutput);
#endif
bool retval = false;
// Check ephem type
// Currently only TimePos and TimePosVel are allowed
if (ephemType != "TimePos" && ephemType != "TimePosVel")
{
UtilityException ue;
ue.SetDetails("STKEphemerisFile::OpenForWrite() *** INTERNAL ERROR *** "
"Only TimePos or TimePosVel is valid for writing to STK "
"ephemeris file '%s'.", stkFileNameForWrite.c_str());
throw ue;
}
if (stkOutStream.is_open())
stkOutStream.close();
stkFileNameForWrite = filename;
ephemTypeForWrite = ephemType;
stkOutStream.open(stkFileNameForWrite.c_str());
if (stkOutStream.is_open())
{
retval = true;
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
(" Successfully opened '%s' for writing\n", stkFileNameForWrite.c_str());
#endif
}
else
{
retval = false;
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
(" Failed open '%s' for writing\n", stkFileNameForWrite.c_str());
#endif
}
// Open temporary file to write STK ephemeris since header data needs to be
// updated after final data
if (openForTempOutput)
{
stkOutStream.close();
std::string tempPath = GmatFileUtil::GetTemporaryDirectory();
std::string fileNameNoPath = GmatFileUtil::ParseFileName(filename);
stkTempFileName = tempPath + fileNameNoPath;
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
(" tempPath='%s'\n stkTempFileName='%s'\n", tempPath.c_str(),
stkTempFileName.c_str());
#endif
stkOutStream.open(stkTempFileName.c_str());
}
#ifdef DEBUG_STK_FILE
MessageInterface::ShowMessage
("STKEphemerisFile::OpenForWrite() returning %d\n", retval);
#endif
return retval;
}
//------------------------------------------------------------------------------
// void CloseForRead()
//------------------------------------------------------------------------------
void STKEphemerisFile::CloseForRead()
{
if (stkInStream.is_open())
stkInStream.close();
}
//------------------------------------------------------------------------------
// void CloseForWrite()
//------------------------------------------------------------------------------
void STKEphemerisFile::CloseForWrite()
{
if (stkOutStream.is_open())
stkOutStream.close();
}
//------------------------------------------------------------------------------
// bool GetInitialAndFinalStates(Real &initialA1Mjd, Real &finalA1Mjd,
// Rvector6 &initialState, Rvector6 &finalState,
// std::string &cbName, std::string &csName)
//------------------------------------------------------------------------------
/**
* Retrieves initial and final state from STK ephem file. Assumes ephem file
* is successfully opened via OpenForRead()
*
* @param initialA1Mjd output initial epoch in a1mjd
* @param finalA1Mjd output final epoch in a1mjd
* @param initialState output initial cartesian state in MJ2000Eq
* @param finalState output final cartesian state in MJ2000Eq
* @param cbName output central body name
* @param csName output coordinate system name
*
* @return true if all output parameter values are assigned, false otherwise
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::GetInitialAndFinalStates(Real &initialA1Mjd, Real &finalA1Mjd,
Rvector6 &initialState, Rvector6 &finalState,
std::string &cbName, std::string &csName)
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
("STKEphemerisFile::GetInitialAndFinalState() entered\n");
#endif
// Set defaults for output
cbName = "Earth";
csName = "J2000";
// Read headers
std::string line1, line;
std::string stkVersionKeyword = "stk.v.";
std::string beginEphemKeyword = "BEGIN Ephemeris";
std::string numEphemPointsKeyword = "NumberOfEphemerisPoints";
std::string scenarioEpochKeyword = "ScenarioEpoch";
std::string centralBodyKeyword = "CentralBody";
std::string coordSystemKeyword = "CoordinateSystem";
std::string timePosVelKeyword = "EphemerisTimePosVel";
std::string distanceUnitKeyword = "DistanceUnit";
std::string item;
std::string::size_type index1;
// Required header fields
bool stkVersionFound = false;
bool beginEphemFound = false;
bool numEphemPointsFound = false;
bool scenarioEpochFound = false;
bool timePosVelFound = false;
while (!stkInStream.eof())
{
getline(stkInStream, line1);
#ifdef DEBUG_INITIAL_FINAL_MORE
MessageInterface::ShowMessage
(" ............... line = %s\n", line1.c_str());
#endif
line = GmatStringUtil::Strip(line1);
// Skip comment line
if ((line.size() > 1) && (line[0] == '#'))
continue;
// Now go through each keyword
if (line.find(stkVersionKeyword) != line.npos)
{
index1 = line.find(stkVersionKeyword);
item = line.substr(index1 + stkVersionKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s%s\n", stkVersionKeyword.c_str(), item.c_str());
#endif
if (item.size() > 0)
stkVersionFound = true;
}
else if (line.find(beginEphemKeyword) != line.npos)
{
index1 = line.find(beginEphemKeyword);
item = line.substr(index1 + beginEphemKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s%s\n", beginEphemKeyword.c_str(), item.c_str());
#endif
if (item == "")
beginEphemFound = true;
}
else if (line.find(numEphemPointsKeyword) != line.npos)
{
numEphemPointsFound = true;
index1 = line.find(numEphemPointsKeyword);
item = line.substr(index1 + numEphemPointsKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s : %s\n", numEphemPointsKeyword.c_str(), item.c_str());
#endif
}
else if (line.find(scenarioEpochKeyword) != line.npos)
{
scenarioEpochFound = true;
index1 = line.find(scenarioEpochKeyword);
item = line.substr(index1 + scenarioEpochKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s : %s\n", scenarioEpochKeyword.c_str(), item.c_str());
#endif
scenarioEpochUtcGreg = item;
// Convert epoch from UTCGregorian to A1Mjd
if (UTCGregorianToA1ModJulian(item, scenarioEpochA1Mjd))
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" scenarioEpochA1Mjd : %.12f\n", scenarioEpochA1Mjd);
#endif
}
else
{
MessageInterface::ShowMessage
("*** ERROR *** Cannot convet ScenarioEpoch '%s' to A1ModJulian read "
"from ephemeris file '%s'\n", item.c_str(), stkFileNameForRead.c_str());
return false;
// UtilityException ue;
// ue.SetDetails("STKEphemerisFile::GetInitialAndFinalStates() Error converting "
// "ScenarioEpoch: '%s' to A1ModJulian on input STK "
// "ephemeris file '%s'.", stkFileNameForRead.c_str());
// throw ue;
}
}
else if (line.find(centralBodyKeyword) != line.npos)
{
index1 = line.find(centralBodyKeyword);
item = line.substr(index1 + centralBodyKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s : %s\n", centralBodyKeyword.c_str(), item.c_str());
#endif
centralBody = item;
cbName = item;
}
else if (line.find(coordSystemKeyword) != line.npos)
{
index1 = line.find(coordSystemKeyword);
item = line.substr(index1 + coordSystemKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s : %s\n", coordSystemKeyword.c_str(), item.c_str());
#endif
coordinateSystem = item;
csName = item;
}
else if (line.find(distanceUnitKeyword) != line.npos)
{
index1 = line.find(distanceUnitKeyword);
item = line.substr(index1 + distanceUnitKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s : %s\n", distanceUnitKeyword.c_str(), item.c_str());
#endif
distanceUnit = item; // The reader will use this in propagation
}
// This field shoud be the last one before reading actual ephem states
else if (line.find(timePosVelKeyword) != line.npos)
{
index1 = line.find(timePosVelKeyword);
item = line.substr(index1 + timePosVelKeyword.size());
item = GmatStringUtil::Strip(item);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" %24s%s\n", timePosVelKeyword.c_str(), item.c_str());
#endif
if (item == "")
timePosVelFound = true;
break;
}
}
if (!stkVersionFound || !beginEphemFound || !numEphemPointsFound ||
!scenarioEpochFound || !timePosVelFound)
{
MessageInterface::ShowMessage
("*** ERROR *** Cannot find required header info from '%s'. "
"Missing one or more of the following keywords:\n "
"\" '%s' '%s' '%s' '%s' '%s' \"\n", stkFileNameForRead.c_str(),
stkVersionKeyword.c_str(), beginEphemKeyword.c_str(),
numEphemPointsKeyword.c_str(), scenarioEpochKeyword.c_str(),
timePosVelKeyword.c_str());
return false;
}
// Read initial TimePosVel
bool firstStateFound = false;
StringArray items;
while (!stkInStream.eof())
{
// Use cross-platform GetLine
//GmatFileUtil::GetLine(&stkInStream, line);
getline(stkInStream, line);
if (line != "")
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage(" first line =\n '%s'\n", line.c_str());
#endif
// Check if line has 7 items
items = GmatStringUtil::SeparateBy(line, " ");
if (items.size() != 7)
{
MessageInterface::ShowMessage
("*** ERROR *** Did not find correct number of elements in the first data\n");
break;
}
else
{
if (GetEpochAndState(line, initialSecsFromEpoch, initialState))
{
firstStateFound = true;
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" initialSecsFromEpoch = %.12f\n initialState = %s\n",
initialSecsFromEpoch, initialState.ToString().c_str());
#endif
}
break;
}
}
}
if (!firstStateFound)
{
MessageInterface::ShowMessage("*** ERROR *** There are no ephemeris data points\n");
return false;
}
// Read final TimePosVel
// Last line should be 'END Ephemeris', how can I read last non-blank line before this?
// This may not be efficient for huge file
std::string lastLine;
bool badDataFound = false;
bool lastStateFound = false;
while (!stkInStream.eof())
{
getline(stkInStream, line);
if (line != "")
{
#ifdef DEBUG_INITIAL_FINAL_MORE
MessageInterface::ShowMessage(" line =\n '%s'\n", line.c_str());
#endif
if (line.find("END Ephemeris") != line.npos)
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage(" 'END Ephemeris' found\n");
#endif
break;
}
else
{
// Check if line has 7 items
StringArray items = GmatStringUtil::SeparateBy(line, " ");
if (items.size() != 7)
{
// Has bad data points
badDataFound = true;
MessageInterface::ShowMessage
("*** ERROR *** Did not find correct number of elements in the data\n");
break;
}
else
{
lastLine = line;
lastStateFound = true;
}
}
}
}
if (!badDataFound)
{
if (lastStateFound)
{
GetEpochAndState(lastLine, finalSecsFromEpoch, finalState);
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
(" finalSecsFromEpoch = %.12f\n finalState = %s\n", finalSecsFromEpoch,
finalState.ToString().c_str());
#endif
}
else
{
// If there is only one line, set initial to final
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage("There are only one ephemeris data point\n");
#endif
finalSecsFromEpoch = initialSecsFromEpoch;
finalState = initialState;
lastStateFound = true;
}
}
// This code block looks more efficient, but how can I read backward so I can
// get good ephemeris data. There may be blank lines between data lines
#if 0
line = GetLastLine();
bool lastStateFound = false;
if (line != "")
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage(" last line =\n '%s'\n", line.c_str());
#endif
// Check if line has 7 items
StringArray items = GmatStringUtil::SeparateBy(line, " ");
if (items.size() != 7)
{
MessageInterface::ShowMessage
("*** ERROR *** Did not find correct number of elements in the last data\n");
}
else
{
if (GetEpochAndState(line, finalSecsFromEpoch, finalState))
lastStateFound = true;
}
}
#endif
// Convert initial and final epoch to A1ModJulian
initialA1Mjd = scenarioEpochA1Mjd + initialSecsFromEpoch/86400.0;
finalA1Mjd = scenarioEpochA1Mjd + finalSecsFromEpoch/86400.0;
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
("STKEphemerisFile::GetInitialAndFinalState() returning %d\n", lastStateFound);
#endif
return lastStateFound;
}
//------------------------------------------------------------------------------
// void SetVersion(const std::string &version)
//------------------------------------------------------------------------------
void STKEphemerisFile::SetVersion(const std::string &version)
{
#ifdef DEBUG_VERSION
MessageInterface::ShowMessage
("STKEphemerisFile::SetVersion() entered, stkVersion='%s'\n",
stkVersion.c_str());
#endif
stkVersion = version;
}
//------------------------------------------------------------------------------
// void SetInterpolationOrder(Integer order)
//------------------------------------------------------------------------------
void STKEphemerisFile::SetInterpolationOrder(Integer order)
{
interpolationOrder = order;
}
//------------------------------------------------------------------------------
// bool SetHeaderForWriting(const std::string &fieldName,
// const std::string &value)
//------------------------------------------------------------------------------
/**
* Sets STK header data for writing. It does not validate the input value.
*
* @param fieldName Header field name to be set
* @param value Value to set to the field
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::SetHeaderForWriting(const std::string &fieldName,
const std::string &value)
{
if (fieldName == "Version")
stkVersion = value;
else if (fieldName == "InterpolationMethod")
interpolationMethod = value;
else if (fieldName == "CentralBody")
centralBody = value;
else if (fieldName == "CoordinateSystem")
coordinateSystem = value;
else if (fieldName == "CoordinateSystemEpoch")
coordinateSystemEpochStr = value;
else
throw UtilityException
("The field \"" + fieldName + "\" is not valid STK header field.\n"
"Valid fields are: TBS");
return true;
}
//------------------------------------------------------------------------------
// bool WriteHeader()
//------------------------------------------------------------------------------
/**
* Formats and writes header to a file. If output stream is not opened,
* it just returns false.
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::WriteHeader()
{
#ifdef DEBUG_WRITE_HEADER
MessageInterface::ShowMessage
("STKEphemerisFile::WriteHeader() entered, stkVersion='%s'\n", stkVersion.c_str());
#endif
if (!stkOutStream.is_open())
{
#ifdef DEBUG_WRITE_HEADER
MessageInterface::ShowMessage
("STKEphemerisFile::WriteHeader() returning false, stkOutStream is not opened\n");
#endif
return false;
}
std::string ephemFormat = "Ephemeris" + ephemTypeForWrite;
scenarioEpochUtcGreg = A1ModJulianToUtcGregorian(scenarioEpochA1Mjd, 1);
std::stringstream ss("");
ss << stkVersion << std::endl;
ss << "# WrittenBy GMAT " << GmatGlobal::Instance()->GetGmatVersion() << std::endl;
ss << "BEGIN Ephemeris" << std::endl;
stkOutStream << ss.str();
numEphemPointsBegPos = stkOutStream.tellp();
#ifdef DEBUG_WRITE_HEADER
MessageInterface::ShowMessage("numEphemPointsBegPos=%ld\n", (long)numEphemPointsBegPos);
#endif
// Clear stream contents
ss.str("");
ss << "NumberOfEphemerisPoints " << numberOfEphemPoints << std::endl;
ss << "ScenarioEpoch " << scenarioEpochUtcGreg << std::endl;
// Write interpolation info if not blank
if (interpolationMethod != "")
{
// Figure out actual interpolation order
Integer actualInterpOrder = interpolationOrder;
if (numberOfEphemPoints <= interpolationOrder)
actualInterpOrder = numberOfEphemPoints - 1;
if (numberOfEphemPoints == 1)
actualInterpOrder = 1;
ss << "InterpolationMethod " << interpolationMethod << std::endl;
ss << "InterpolationOrder " << actualInterpOrder << std::endl;
}
ss << "CentralBody " << centralBody << std::endl;
ss << "CoordinateSystem " << coordinateSystem << std::endl;
// GMAT writes in km only for now
ss << "DistanceUnit Kilometers" << std::endl;
// Write begin segment times if not empty
if (!beginSegmentArray.empty())
{
char strBuff[200];
ss << "BEGIN SegmentBoundaryTimes" << std::endl;
for (unsigned int i = 0; i < beginSegmentArray.size(); i++)
{
sprintf(strBuff, " %1.15e\n", beginSegmentArray[i]);
ss << strBuff;
}
ss << "END SegmentBoundaryTimes" << std::endl;
}
ss << std::endl;
ss << ephemFormat << std::endl;
ss << std::endl;
stkOutStream << ss.str();
stkOutStream.flush();
#ifdef DEBUG_WRITE_HEADER
MessageInterface::ShowMessage
("STKEphemerisFile::WriteHeader() returning true\n");
#endif
return true;
}
//------------------------------------------------------------------------------
// bool WriteBlankLine()
//------------------------------------------------------------------------------
/**
* Writes blank line to a file.
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::WriteBlankLine()
{
if (!stkOutStream.is_open())
return false;
stkOutStream << std::endl;
stkOutStream.flush();
return true;
}
//------------------------------------------------------------------------------
// bool WriteString(const std::string &str)
//------------------------------------------------------------------------------
/**
* Writes input string to a file.
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::WriteString(const std::string &str)
{
#ifdef DEBUG_WRITE_STRING
MessageInterface::ShowMessage
("STKEphemerisFile::WriteString() entered, str='%s'\n", str.c_str());
#endif
if (!stkOutStream.is_open())
return false;
stkOutStream << str << std::endl;
stkOutStream.flush();
#ifdef DEBUG_WRITE_STRING
MessageInterface::ShowMessage
("STKEphemerisFile::WriteString() returning true\n");
#endif
return true;
}
//------------------------------------------------------------------------------
// bool WriteDataSegment(const EpochArray &epochArray, const StateArray &stateArray,
// bool canFinalize = false);
//------------------------------------------------------------------------------
bool STKEphemerisFile::WriteDataSegment(const EpochArray &epochArray,
const StateArray &stateArray,
bool canFinalize)
{
Integer numPoints = stateArray.size();
#ifdef DEBUG_WRITE_DATA_SEGMENT
MessageInterface::ShowMessage
("============================================================\n"
"STKEphemerisFile::WriteDataSegment() entered, numPoints=%d, canFinalize=%d\n",
numPoints, canFinalize);
#endif
if (numPoints == 0)
{
#ifdef DEBUG_WRITE_DATA_SEGMENT
MessageInterface::ShowMessage
("STKEphemerisFile::WriteDataSegment() just returning true, data size is zero\n");
#endif
return true;
}
else if (numPoints != stateArray.size())
{
UtilityException ue;
ue.SetDetails("STKEphemerisFile::WriteDataSegment() *** INTERNAL ERROR *** "
"Received different number of timeS and stateS. size of time "
"array: %d, size of state array: %d\n", epochArray.size(),
stateArray.size());
throw ue;
}
// If first time writing, save scenario epoch
if (firstTimeWriting)
{
scenarioEpochA1Mjd = (epochArray[0])->GetReal();
openForTempOutput = true;
}
if (ephemTypeForWrite == "TimePosVel")
WriteTimePosVel(epochArray, stateArray);
else if (ephemTypeForWrite == "TimePos")
WriteTimePos(epochArray, stateArray);
else
{
// ephemType has already validated in OpenFile but check anyway
UtilityException ue;
ue.SetDetails("STKEphemerisFile::WriteDataSegment() *** INTERNAL ERROR *** "
"Only TimePos or TimePosVel is valid for read on STK "
"ephemeris file '%s'.", stkFileNameForWrite.c_str());
throw ue;
}
// If final data segment received, write end ephemeris
if (canFinalize)
{
FinalizeEphemeris();
}
else
{
// Indicate new segment starting by writing blank line and the last data
WriteBlankLine();
#ifdef DEBUG_WRITE_DATA_SEGMENT
WriteString("# ============================== new segment");
#endif
Integer last = numPoints - 1;
Real lastEpoch = (epochArray[last])->GetReal();
WriteTimePosVel(lastEpoch, stateArray[last]);
if (firstTimeWriting)
beginSegmentArray.push_back(0.0);
beginSegmentTime = (lastEpoch - scenarioEpochA1Mjd) * 86400.0;
beginSegmentArray.push_back(beginSegmentTime);
}
firstTimeWriting = false;
#ifdef DEBUG_WRITE_DATA_SEGMENT
MessageInterface::ShowMessage("STKEphemerisFile::WriteDataSegment() leavng\n");
#endif
return true;
}
//----------------------------
// protected methods
//----------------------------
//------------------------------------------------------------------------------
// bool GetEpochAndState(const std::string &line, Real &epoch, Rvector6 &state)
//------------------------------------------------------------------------------
bool STKEphemerisFile::GetEpochAndState(const std::string &line, Real &epoch, Rvector6 &state)
{
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
("STKEphemerisFile::GetEpochAndState() entered\n line =\n '%s'\n", line.c_str());
#endif
// Parse line
bool retval = false;
StringArray items = GmatStringUtil::SeparateBy(line, " ", false, false, false);
if (items.size() == 7)
{
retval = true;
Real rval;
#ifdef DEBUG_INITIAL_FINAL
for (unsigned int i = 0; i < items.size(); i++)
MessageInterface::ShowMessage(" items[%d] = '%s'\n", i, items[i].c_str());
#endif
if (GmatStringUtil::ToReal(items[0], rval))
epoch = rval;
else
{
retval = false;
MessageInterface::ShowMessage("*** ERROR *** '%s' is not a valid real number\n", items[0].c_str());
}
for (unsigned int i = 1; i < items.size(); i++)
{
if (GmatStringUtil::ToReal(items[i], rval))
state[i-1] = rval;
else
{
retval = false;
MessageInterface::ShowMessage("*** ERROR *** '%s' is not a valid real number\n", items[i].c_str());
}
}
}
#ifdef DEBUG_INITIAL_FINAL
MessageInterface::ShowMessage
("STKEphemerisFile::GetEpochAndState() returing %d\n", retval);
#endif
return retval;
}
//------------------------------------------------------------------------------
// std::string GetLastLine()
//------------------------------------------------------------------------------
std::string STKEphemerisFile::GetLastLine()
{
std::ifstream::pos_type pos = stkInStream.tellg();
std::ifstream::pos_type lastPos;
while (stkInStream >> std::ws && IgnoreLine(lastPos))
pos = lastPos;
stkInStream.clear();
stkInStream.seekg(pos);
std::string line;
std::getline(stkInStream, line);
return line;
}
//------------------------------------------------------------------------------
// std::istream& IgnoreLine(std::ifstream::pos_type& pos)
//------------------------------------------------------------------------------
std::istream& STKEphemerisFile::IgnoreLine(std::ifstream::pos_type& pos)
{
pos = stkInStream.tellg();
return stkInStream.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
//------------------------------------------------------------------------------
// void WriteTimePosVel(const EpochArray &epochArray, const StateArray &stateArray)
//------------------------------------------------------------------------------
/**
* Writes STK ephemeris in EphemerisTimePosVel format
*/
//------------------------------------------------------------------------------
void STKEphemerisFile::WriteTimePosVel(const EpochArray &epochArray,
const StateArray &stateArray)
{
Integer numPoints = stateArray.size();
// Write out to stream
for (int i = 0; i < numPoints; i++)
{
// For multiple segments, end epoch of previous segment may be the same as
// beginning epoch of new segmnet, so check for duplicate epoch and use the
// state of new epoch since any maneuver or some spacecraft property update
// may happened.
Real epoch = (epochArray[i])->GetReal();
if (epoch == lastEpochWrote)
continue;
WriteTimePosVel(epoch, stateArray[i]);
// lastEpochWrote = epoch;
// numberOfEphemPoints++;
}
}
//------------------------------------------------------------------------------
// void WriteTimePosVel(Real epoch, const Rvector6 *state)
//------------------------------------------------------------------------------
void STKEphemerisFile::WriteTimePosVel(Real epoch, const Rvector6 *state)
{
// Format output using scientific notation
const Real *outState = state->GetDataVector();
Real timeIntervalInSecs = (epoch - scenarioEpochA1Mjd) * 86400.0;
char strBuff[200];
sprintf(strBuff, "%1.15e % 1.15e % 1.15e % 1.15e % 1.15e % 1.15e % 1.15e\n",
timeIntervalInSecs, outState[0], outState[1], outState[2], outState[3],
outState[4], outState[5]);
stkOutStream << strBuff;
lastEpochWrote = epoch;
numberOfEphemPoints++;
#ifdef DEBUG_WRITE_POSVEL
std::string epochStr = A1ModJulianToUtcGregorian(epochArray[i], 2);
MessageInterface::ShowMessage(" %s % 1.15e\n", epochStr, outState[0]);
#endif
}
//------------------------------------------------------------------------------
// void WriteTimePos(const EpochArray &epochArray, const StateArray &stateArray)
//------------------------------------------------------------------------------
/**
* Writes STK ephemeris in EphemerisTimePos format
*/
//------------------------------------------------------------------------------
void STKEphemerisFile::WriteTimePos(const EpochArray &epochArray,
const StateArray &stateArray)
{
Integer numPoints = stateArray.size();
// Write out to stream
for (int i = 0; i < numPoints; i++)
{
// For multiple segments, end epoch of previous segment may be the same as
// beginning epoch of new segmnet, so check for duplicate epoch and use the
// state of new epoch since any maneuver or some spacecraft property update
// may happened.
Real epoch = (epochArray[i])->GetReal();
if (epoch == lastEpochWrote)
continue;
WriteTimePos(epoch, stateArray[i]);
lastEpochWrote = epoch;
numberOfEphemPoints++;
}
}
//------------------------------------------------------------------------------
// void WriteTimePos(Real epoch, const Rvector6 *state)
//------------------------------------------------------------------------------
void STKEphemerisFile::WriteTimePos(Real epoch, const Rvector6 *state)
{
// Format output using scientific notation
const Real *outState = state->GetDataVector();
Real timeIntervalInSecs = (epoch - scenarioEpochA1Mjd) * 86400.0;
char strBuff[200];
sprintf(strBuff, "%1.15e % 1.15e % 1.15e % 1.15e\n",
timeIntervalInSecs, outState[0], outState[1], outState[2]);
stkOutStream << strBuff;
#ifdef DEBUG_WRITE_POSVEL
std::string epochStr = A1ModJulianToUtcGregorian(epochArray[i], 2);
MessageInterface::ShowMessage(" %s % 1.15e\n", epochStr, outState[0]);
#endif
}
//------------------------------------------------------------------------------
// void FinalizeEphemeris()
//------------------------------------------------------------------------------
/**
* Finalized ephemeris file. It writes number of data points and end ephemeris
* keyword.
*/
//------------------------------------------------------------------------------
void STKEphemerisFile::FinalizeEphemeris()
{
#ifdef DEBUG_FINALIZE
MessageInterface::ShowMessage
("STKEphemerisFile::FinalizeEphemeris() entered, numberOfEphemPoints=%d, "
"numEphemPointsBegPos=%ld\n stkTempFileName='%s'", numberOfEphemPoints,
(long)numEphemPointsBegPos, stkTempFileName.c_str());
#endif
// Write end ephemeris keyword
stkOutStream << "END Ephemeris" << std::endl << std::endl;
stkOutStream.flush();
// Close temp file and copy content to actual STK ephemeris file
// after writing header data
stkOutStream.close();
if (OpenForRead(stkTempFileName, "TimePosVel"))
{
openForTempOutput = false;
OpenForWrite(stkFileNameForWrite, "TimePosVel");
WriteHeader();
// Read lines
std::string line;
while (!stkInStream.eof())
{
// Use cross-platform GetLine
//GmatFileUtil::GetLine(&stkInStream, line);
getline(stkInStream, line);
stkOutStream << line << std::endl;
}
stkInStream.close();
stkOutStream.close();
// Delete temp file
remove(stkTempFileName.c_str());
}
else
{
MessageInterface::ShowMessage("Failed to open temp file\n");
}
#ifdef DEBUG_FINALIZE
MessageInterface::ShowMessage("There are %d segments\n", beginSegmentArray);
for (unsigned int i = 0; i < beginSegmentArray.size(); i++)
MessageInterface::ShowMessage(" %.12e\n", beginSegmentArray[i]);
MessageInterface::ShowMessage("STKEphemerisFile::FinalizeEphemeris() leaving\n");
#endif
}
//------------------------------------------------------------------------------
// std::string A1ModJulianToUtcGregorian(Real epochInDays, Integer format = 1)
//------------------------------------------------------------------------------
/**
* Formats epoch in either in days or seconds to desired format.
*
* @param epoch Epoch in A1 days
* @param format Desired output format [1]
* 1 = "01 Jan 2000 11:59:28.000"
* 2 = "2000-01-01T11:59:28.000"
*/
//------------------------------------------------------------------------------
std::string STKEphemerisFile::A1ModJulianToUtcGregorian(Real epochInDays, Integer format)
{
if (epochInDays == -999.999)
return "-999.999";
Real toMjd;
std::string epochStr;
std::string fromType = "A1ModJulian";
std::string toType = "UTCGregorian";
// Convert current epoch to specified format
TimeConverterUtil::Convert(fromType, epochInDays, "", toType, toMjd, epochStr, format);
if (epochStr == "")
{
MessageInterface::ShowMessage
("**** ERROR **** EphemerisWriter::ToUtcGregorian() Cannot convert epoch %.10f %s "
"to UTCGregorian\n", epochInDays, "days");
epochStr = "EpochError";
}
return epochStr;
}
//------------------------------------------------------------------------------
// bool UtcGregorianToA1ModJulian(const std::string &utcGreg, Real &a1Mjd)
//------------------------------------------------------------------------------
/**
* Converts epoch in UTCGregorian to A1ModJulian format. It uses UTCGregorian
* format of "01 Jan 2000 11:59:28.000."
*
* @param utcGreg Epoch in UTCGregorian
* @param a1Mjd output epoch in A1ModJulian
*/
//------------------------------------------------------------------------------
bool STKEphemerisFile::UTCGregorianToA1ModJulian(const std::string &utcGreg, Real &a1Mjd)
{
bool retval = true;
Real fromMjd = -999.999;
Real toMjd = -999.999;
std::string epochStr;
std::string fromType = "UTCGregorian";
std::string toType = "A1ModJulian";
// Convert current epoch to specified format
TimeConverterUtil::Convert(fromType, fromMjd, utcGreg, toType, toMjd, epochStr, 1);
if (epochStr == "")
{
MessageInterface::ShowMessage
("**** ERROR **** EphemerisWriter::ToUtcGregorian() Cannot convert epoch %s "
"to A1ModJulian\n", utcGreg.c_str());
retval = false;
}
a1Mjd = toMjd;
return retval;
}
|
#include "../include/homogeneous_matrix.h"
#include <math.h> /* sin, cos, abs */
#include <array>
#include <cassert> // assert
#include <cmath> // std::abs
#include <iostream>
#include <limits> // std::numeric_limits, std::epsilon
#include <ostream>
RotationMatrix::RotationMatrix() {
m_matrix[0] = {1.0, 0.0, 0.0};
m_matrix[1] = {0.0, 1.0, 0.0};
m_matrix[2] = {0.0, 0.0, 1.0};
}
RotationMatrix::RotationMatrix(const std::array<float, 3> &row_1, const std::array<float, 3> &row_2, const std::array<float, 3> &row_3) {
m_matrix[0] = row_1;
m_matrix[1] = row_2;
m_matrix[2] = row_3;
}
std::array<float, 3> &RotationMatrix::operator[](const int index) {
if (index >= 3) {
std::cout << "Array index out of bound, exiting." << std::endl;
exit(0);
}
return m_matrix[index];
}
std::array<float, 3> RotationMatrix::operator[](const int index) const {
if (index >= 3) {
std::cout << "Array index out of bound, exiting." << std::endl;
exit(0);
}
return m_matrix[index];
}
RotationMatrix RotationMatrix::operator*(const RotationMatrix &other) const {
RotationMatrix result;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
float res_ij = 0.;
for (int k = 0; k < 3; k++) {
res_ij += m_matrix[i][k] * other.m_matrix[k][j];
}
result.m_matrix[i][j] = res_ij;
}
}
return result;
}
void RotationMatrix::print() const {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
std::cout << m_matrix[i][j] << " ";
}
std::cout << std::endl;
}
}
bool RotationMatrix::isValid() const {
float aei = m_matrix[0][0] * m_matrix[1][1] * m_matrix[2][2];
float bfg = m_matrix[0][1] * m_matrix[1][2] * m_matrix[2][0];
float cdh = m_matrix[0][2] * m_matrix[1][0] * m_matrix[2][1];
float ceg = m_matrix[0][2] * m_matrix[1][1] * m_matrix[2][0];
float bdi = m_matrix[0][1] * m_matrix[1][0] * m_matrix[2][2];
float afh = m_matrix[0][0] * m_matrix[1][2] * m_matrix[2][1];
/* Rule of Sarrus */
float determinant = aei + bfg + cdh - ceg - bdi - afh;
return (std::abs(determinant - 1) < std::numeric_limits<float>::epsilon()) ? true : false;
}
/* Copied from GLM. Switched colom major to row major and placed the real part of the quaternion at the end. */
std::array<float, 4> RotationMatrix::toQuat() const {
float fourXSquaredMinus1 = m_matrix[0][0] - m_matrix[1][1] - m_matrix[2][2];
float fourYSquaredMinus1 = m_matrix[1][1] - m_matrix[0][0] - m_matrix[2][2];
float fourZSquaredMinus1 = m_matrix[2][2] - m_matrix[0][0] - m_matrix[1][1];
float fourWSquaredMinus1 = m_matrix[0][0] + m_matrix[1][1] + m_matrix[2][2];
int biggestIndex = 0;
float fourBiggestSquaredMinus1 = fourWSquaredMinus1;
if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) {
fourBiggestSquaredMinus1 = fourXSquaredMinus1;
biggestIndex = 1;
}
if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) {
fourBiggestSquaredMinus1 = fourYSquaredMinus1;
biggestIndex = 2;
}
if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) {
fourBiggestSquaredMinus1 = fourZSquaredMinus1;
biggestIndex = 3;
}
float biggestVal = sqrt(fourBiggestSquaredMinus1 + 1.) * 0.5;
float mult = 0.25 / biggestVal;
switch (biggestIndex) {
case 0:
return {(m_matrix[2][1] - m_matrix[1][2]) * mult, (m_matrix[0][2] - m_matrix[2][0]) * mult, (m_matrix[1][0] - m_matrix[0][1]) * mult, biggestVal};
case 1:
return {biggestVal, (m_matrix[1][0] + m_matrix[0][1]) * mult, (m_matrix[0][2] + m_matrix[2][0]) * mult, (m_matrix[2][1] - m_matrix[1][2]) * mult};
case 2:
return {(m_matrix[1][0] + m_matrix[0][1]) * mult, biggestVal, (m_matrix[2][1] + m_matrix[1][2]) * mult, (m_matrix[0][2] - m_matrix[2][0]) * mult};
case 3:
return {(m_matrix[0][2] + m_matrix[2][0]) * mult, (m_matrix[2][1] + m_matrix[1][2]) * mult, biggestVal, (m_matrix[1][0] - m_matrix[0][1]) * mult};
default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity.
assert(false);
return {0., 0., 0., 1.};
}
}
/* Constructors */
HomogeneousMatrix::HomogeneousMatrix(const RotationMatrix &rotation_matrix, const std::array<float, 3> &translation_vector)
: m_rotation_matrix(rotation_matrix), m_translation_vector(translation_vector) {}
HomogeneousMatrix::HomogeneousMatrix() {
m_rotation_matrix = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};
m_translation_vector = {0.0, 0.0, 0.0};
}
HomogeneousMatrix::HomogeneousMatrix(const std::array<float, 3> &rotation_angles,
const std::array<float, 3> &translation_vector,
const bool is_degree) {
m_rotation_matrix = eulerAngleXYZ(rotation_angles[0], rotation_angles[1], rotation_angles[2], is_degree);
m_translation_vector[0] = translation_vector[0];
m_translation_vector[1] = translation_vector[1];
m_translation_vector[2] = translation_vector[2];
}
/* Euler Angle Matrix */
RotationMatrix HomogeneousMatrix::eulerAngleXYZ(const float rotation_x, const float rotation_y, const float rotation_z, const bool is_degree) const {
float c1;
float c2;
float c3;
float s1;
float s2;
float s3;
if (is_degree) {
c1 = cos(-rotation_x * 0.01745329251994329576923690768489);
c2 = cos(-rotation_y * 0.01745329251994329576923690768489);
c3 = cos(-rotation_z * 0.01745329251994329576923690768489);
s1 = sin(-rotation_x * 0.01745329251994329576923690768489);
s2 = sin(-rotation_y * 0.01745329251994329576923690768489);
s3 = sin(-rotation_z * 0.01745329251994329576923690768489);
}
else {
c1 = cos(-rotation_x);
c2 = cos(-rotation_y);
c3 = cos(-rotation_z);
s1 = sin(-rotation_x);
s2 = sin(-rotation_y);
s3 = sin(-rotation_z);
}
RotationMatrix result;
result[0][0] = c2 * c3;
result[1][0] = -c1 * s3 + s1 * s2 * c3;
result[2][0] = s1 * s3 + c1 * s2 * c3;
result[0][1] = c2 * s3;
result[1][1] = c1 * c3 + s1 * s2 * s3;
result[2][1] = -s1 * c3 + c1 * s2 * s3;
result[0][2] = -s2;
result[1][2] = s1 * c2;
result[2][2] = c1 * c2;
return result;
}
/* Rotations */
void HomogeneousMatrix::rotate(const float rotation_x, const float rotation_y, const float rotation_z, const bool is_degree) {
RotationMatrix rotation_matrix = eulerAngleXYZ(rotation_x, rotation_y, rotation_z, is_degree);
m_rotation_matrix = m_rotation_matrix * rotation_matrix;
}
void HomogeneousMatrix::rotate(const std::array<float, 3> &rotation_angles, const bool is_degree) {
RotationMatrix rotation_matrix = eulerAngleXYZ(rotation_angles[0], rotation_angles[1], rotation_angles[2], is_degree);
m_rotation_matrix = m_rotation_matrix * rotation_matrix;
}
/* Translations */
void HomogeneousMatrix::translate(const float x, const float y, const float z) {
m_translation_vector[0] = m_translation_vector[0] + x;
m_translation_vector[1] = m_translation_vector[1] + y;
m_translation_vector[2] = m_translation_vector[2] + z;
}
void HomogeneousMatrix::translate(const std::array<float, 3> &translation_vector) {
m_translation_vector[0] = m_translation_vector[0] + translation_vector[0];
m_translation_vector[1] = m_translation_vector[1] + translation_vector[1];
m_translation_vector[2] = m_translation_vector[2] + translation_vector[2];
}
/* Print */
void HomogeneousMatrix::print() const {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
std::cout << m_rotation_matrix[i][j] << " ";
}
std::cout << m_translation_vector[i];
std::cout << std::endl;
}
}
/* Reset */
void HomogeneousMatrix::resetToIdentity() {
m_rotation_matrix = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};
m_translation_vector = {0.0, 0.0, 0.0};
}
/* Sanity Check */
bool HomogeneousMatrix::rotationMatrixIsValid() const {
return m_rotation_matrix.isValid();
}
/* Getter */
RotationMatrix HomogeneousMatrix::getRotationMatrix() const { return m_rotation_matrix; }
std::array<float, 3> HomogeneousMatrix::getTranslationVector() const { return m_translation_vector; }
std::array<float, 7> HomogeneousMatrix::toPoseArray() const {
std::array<float, 4> quaternion = m_rotation_matrix.toQuat();
std::array<float, 7> result;
for (int i = 0; i < 3; i++) {
result[i] = m_translation_vector[i];
}
for (int i = 3; i < 7; i++) {
result[i] = quaternion[i - 3];
}
return result;
}
/* Multiplication */
HomogeneousMatrix HomogeneousMatrix::operator*(const HomogeneousMatrix &b) const {
HomogeneousMatrix result;
std::array<float, 3> translation;
for (int i = 0; i < 3; i++) {
float dot = 0.;
for (int j = 0; j < 3; j++) {
dot += m_rotation_matrix[i][j] * b.m_translation_vector[j];
float res_ij = 0.;
for (int k = 0; k < 3; k++) {
res_ij += m_rotation_matrix[i][k] * b.m_rotation_matrix[k][j];
}
result.m_rotation_matrix[i][j] = res_ij;
}
dot += m_translation_vector[i];
translation[i] = dot;
}
result.m_translation_vector = translation;
return result;
}
|
#include "util.h"
#include "Poco.h"
void D_TRANSFORMATIONSETTING::Jsonize(JsonIO & json)
{
json
("ID",data.ID )
("USERID",data.USERID)
("TRANSFORMTYPE",data.TRANSFORMTYPE)
("DELETEDORIGINALFILE",data.DELETEDORIGINALFILE)
("PROCCESSORDER",data.PROCCESSORDER)
;
}
D_TRANSFORMATIONSETTING D_TRANSFORMATIONSETTING::Create(Http& http){
S_TRANSFORMATIONSETTING pObj; // params container
try{
//pObj.ID=atoi((String)http["ID"]);
pObj.USERID=atoi((String)http["USERID"]);
pObj.TRANSFORMTYPE=atoi((String)http["TRANSFORMTYPE"]);
pObj.DELETEDORIGINALFILE=atoi((String)http["DELETEDORIGINALFILE"]);
pObj.PROCCESSORDER=atoi((String)http["PROCCESSORDER"]);
}
catch(...)
{
Cout() << "Error D_TRANSFORMATIONSETTING::Create";
}
return Create(pObj);
}
D_TRANSFORMATIONSETTING D_TRANSFORMATIONSETTING::Create(S_TRANSFORMATIONSETTING& pObj){
D_TRANSFORMATIONSETTING tObj = GetById(pObj.ID);
if(tObj.data.ID < 0)
{
SQL * Insert( TRANSFORMATIONSETTING )
//(ID,pObj.ID)
(USERID,pObj.USERID)
(TRANSFORMTYPE,pObj.TRANSFORMTYPE)
(DELETEDORIGINALFILE,pObj.DELETEDORIGINALFILE)
(PROCCESSORDER,pObj.PROCCESSORDER)
;
//----------------------------------------
Cout()<<"\nCreated Transformation Setting:"<<tObj<<"\n";
}
else
{
Cout()<<"\nTransformation Setting existed:"<<tObj.data.ID<<"\n";
}
return tObj;
}
/*
update user information based on ID
ex:
http://127.0.0.1:8001/tis/api/user/update?ID=3&EMAIL=user23@simaget.com&PASSWORD=12345&FULLNAME=user2%20simaget&PHONE=987654321&DATEOFBIRTH=2000/03/01
*/
D_TRANSFORMATIONSETTING D_TRANSFORMATIONSETTING::Edit(Http& http){
S_TRANSFORMATIONSETTING pObj; // params container
try{
pObj.ID=atoi((String)http["ID"]);
pObj.USERID=atoi((String)http["USERID"]);
pObj.TRANSFORMTYPE=atoi((String)http["TRANSFORMTYPE"]);
pObj.DELETEDORIGINALFILE=atoi((String)http["DELETEDORIGINALFILE"]);
pObj.PROCCESSORDER=atoi((String)http["PROCCESSORDER"]);
}
catch(...)
{
Cout() << "Error D_TRANSFORMATIONSETTING::Update";
}
return Edit(pObj);
}
D_TRANSFORMATIONSETTING D_TRANSFORMATIONSETTING::Edit(S_TRANSFORMATIONSETTING& pObj){
D_TRANSFORMATIONSETTING tObj = GetById(pObj.ID);
if(tObj.data.ID > 0)
{
SQL * Update( TRANSFORMATIONSETTING )
(USERID,pObj.USERID)
(TRANSFORMTYPE,pObj.TRANSFORMTYPE)
(DELETEDORIGINALFILE,pObj.DELETEDORIGINALFILE)
(PROCCESSORDER,pObj.PROCCESSORDER)
.Where( ID == pObj.ID);
//----------------------------------------
tObj = GetById(pObj.ID);
Cout()<<"\n Daily Summary Update:"<<tObj<<"\n";
}
else
{
Cout()<<"\n Daily Summary did not exist:"<<tObj.data.ID<<"\n";
tObj = Create(pObj);
}
return tObj;
}
void D_TRANSFORMATIONSETTING::Delete(Http& http){
// do not delete setting?
}
Vector<D_TRANSFORMATIONSETTING> D_TRANSFORMATIONSETTING::Retrieve(Http& http){
S_TRANSFORMATIONSETTING pObj; // params container
PAGINATION pager(http); // extract pager
try{
pObj.ID=atoi((String)http["ID"]);
pObj.USERID=atoi((String)http["USERID"]);
pObj.TRANSFORMTYPE=atoi((String)http["TRANSFORMTYPE"]);
pObj.DELETEDORIGINALFILE=atoi((String)http["DELETEDORIGINALFILE"]);
pObj.PROCCESSORDER=atoi((String)http["PROCCESSORDER"]);
}
catch(...)
{
Cout() << "Error get params";
}
int row =0;
//------------------------
SqlBool where;
if(pObj.ID>0) where = ID == pObj.ID;
if(pObj.USERID>0) where =where && USERID == pObj.USERID;
if(pObj.TRANSFORMTYPE>0) where =where && TRANSFORMTYPE == pObj.TRANSFORMTYPE;
if(pObj.DELETEDORIGINALFILE>0) where =where && DELETEDORIGINALFILE == pObj.DELETEDORIGINALFILE;
if(pObj.PROCCESSORDER>0) where =where && PROCCESSORDER == pObj.PROCCESSORDER;
//------------------------
Cout()<<pObj<<"\n";
SQL * Select ( SqlAll() ).From ( TRANSFORMATIONSETTING ).Where(where).OrderBy ( ID ).Limit(pager.OFFSET, pager.SIZE);
Vector<D_TRANSFORMATIONSETTING> vector;
S_TRANSFORMATIONSETTING x;
while ( SQL.Fetch ( x ) ){
vector.Add ( D_TRANSFORMATIONSETTING(x) );
row++;
if(row >= pager.SIZE) break;
}
//--------------------------------------------------------
return vector;
}
String D_TRANSFORMATIONSETTING::RetrieveAsJson(Http& http){
return StoreAsJson(Retrieve(http),true);
}
/*
get user setting by id
*/
D_TRANSFORMATIONSETTING D_TRANSFORMATIONSETTING::GetById(int id){
D_TRANSFORMATIONSETTING rs;
S_TRANSFORMATIONSETTING x;
try{
SqlBool where;
where = ID == id;// condition
SQL * Select ( SqlAll() ).From ( TRANSFORMATIONSETTING ).Where(where).Limit(1);
while ( SQL.Fetch ( x ) ){
rs = D_TRANSFORMATIONSETTING(x);
break;
}
}
catch(...){
Cout() << "Error D_TRANSFORMATIONSETTING::Get(String id)";
}
return rs;
}
|
//
// designConstants.cpp
// Nexus
//
// Created by Nick potts on 1/27/18.
// Copyright © 2018 Matthew Foote. All rights reserved.
//
/*
For labels at the top of a VC describing the VC make it this
FONT: System bold 20 point
Height: 40
WIDTH: Width of the safe area
ERROR LABELS:
TEXT COLOR: RED
HEIGHT: 40
FONT: SYSTEM 17
BUTTONS:
COLOR: GRAY
TEXTCOLOR: BLACK
CORNERRADIUS: 7.0
SHADOW COLOR: GRAY
SHADOW RADIUS: 2.5
SHADOW OPACITY: .4
SHADOW OFFSET: (0,0)
TEXTFIELD LINE LAYER
let bottomLayer = CALayer()
bottomLayer.frame = CGRect(x: 0, y: 28, width: emailTextField.frame.width, height: 0.6)
bottomLayer.backgroundColor = UIColor.white.cgColor
emailTextField.layer.addSublayer(bottomLayer)
emailTextField.attributedPlaceholder = NSAttributedString(string: emailTextField.placeholder!, attributes: [NSAttributedStringKey.foregroundColor: UIColor(white: 1.0, alpha: 1.0)])
TEXT FONTS AND STYLES
ALL USE PINGFANG HK
BUTTONS:
Semibold size 18
SCENE LABELS:
Semibold size 20
ERROR LABELS and bottom scene buttons:
Medium Size 16
REGULAR LABELS(Labels for an object)
Regular size 17
*/
|
//h
#include "tic_tac_toe.h"
#include <fstream>
#include <string>
#include <vector>
#ifndef TIC_TAC_TOE_DATA_H
#define TIC_TAC_TOE_DATA_H
using std::vector;
class TicTacToeData
{
public:
void save_games(const std::vector<std::unique_ptr<TicTacToe>>& games);
std::vector<std::unique_ptr<TicTacToe>> get_games() const;
private:
const std::string file_name{ "tic_tac_toe.dat" };
};
#endif
|
//
// Created by engineer on 2020/5/7.
//
#ifndef PROJ_ANDROID_ACTOR_H
#define PROJ_ANDROID_ACTOR_H
#include "cocos2d.h"
USING_NS_CC;
class GlobalEnv {
public:
static void load();
};
class Actor {
public:
// Actor();
virtual void init() = 0;
virtual void collide(cocos2d::Rect &rect);
virtual cocos2d::Sprite *actor();
virtual void setPosition(float x, float y);
virtual void release();
virtual cocos2d::Sprite *operator->();
virtual operator Sprite *();
virtual operator Sprite &();
protected:
cocos2d::Sprite *sprite;
};
//2D move
class Hero : public Actor {
public:
void init();
void move(float time, int x, int y);
private:
};
class Enemy : public Actor {
public:
void init();
void move(float time, int x, int y);
private:
};
#endif //PROJ_ANDROID_ACTOR_H
|
//@@author A0112218W
#pragma once
#include "Command.h"
//Feedback message for different add operation result
const std::string MESSAGE_ADD_SUCCESS = "\"%s\" have been added succesfully.\nStart Date Time: %s\nEnd Date Time: %s";
const std::string MESSAGE_ADD_EMPTY = "Task text cannot be empty. New task is not added.";
//Feedback message when add operation is undoed
const std::string MESSAGE_UNDO_ADD = "Previous add operation is undoed succesfully";
/**
* Command sub class responsible for adding task
*/
class AddCommand: public Command {
private:
/**
* Task to be added.
*/
Task _task;
public:
/**
* Constructor
* @param type2 SecondaryCommandType which corresponding to the type of task added.
* @param task Task to be added.
*/
AddCommand (CommandTokens::SecondaryCommandType type2, Task task);
/**
* Execution method of AddCommand.
* _task will be added to RunTimeStorage* provided.
*/
UIFeedback execute(RunTimeStorage*);
/**
* Undo method of AddCommand.
* Will remove the task added to RunTimeStorage.
*
*/
UIFeedback undo(void);
/**
* Return true all the time.
*/
bool canUndo();
virtual ~AddCommand(void);
#ifdef TESTMODE
Task getTask() {
return _task;
}
#endif
};
|
//MouseActionCreator.cpp
#include "MouseActionCreator.h"
MouseActionCreator::MouseActionCreator() {
}
MouseActionCreator::MouseActionCreator(const MouseActionCreator& source) {
}
MouseActionCreator::~MouseActionCreator() {
}
MouseActionCreator& MouseActionCreator::operator=(const MouseActionCreator& source) {
return *this;
}
#include "MouseAction.h"
#include "MouseLButtonDown.h"
#include "MouseRButtonDown.h"
#include "MouseOnMove.h"
#include "PageFormMouseLButtonDown.h"
#include "MemoForm.h"
#include "PageForm.h"
#include "Form.h"
#include "OtherNoteFormMouseLButtonDblClk.h"
#include "FindingForm.h"
#include "MouseLButtonDoubleClicked.h"
MouseAction* MouseActionCreator::Create(Form *form, UINT nFlags, CPoint point, Long message) {
//1121 찾은 index 해제 하기
OtherNoteForm *otherNoteForm = (OtherNoteForm*)(CFrameWnd::FindWindow("OtherNote", NULL));
FindingForm *findingForm = otherNoteForm->GetFindingForm();
if (findingForm != NULL) {
findingForm->ResetIndexes();
}
if (dynamic_cast<MemoForm*>(form)) {
if (message == WM_LBUTTONDOWN && nFlags == MK_LBUTTON) {
return new MouseLButtonDown(form);
}
else if (message == WM_RBUTTONDOWN && nFlags == MK_RBUTTON) {
return new MouseRButtonDown(form);
}
else if (message == WM_LBUTTONDBLCLK && nFlags == MK_LBUTTON) {
return new MouseLButtonDoubleClicked(form);
}
else if (message == WM_MOUSEMOVE && nFlags & MK_LBUTTON) {
return new MouseOnMove(form);//mouse drag to select
}
}
else if (dynamic_cast<PageForm*>(form)) {
if (message == WM_LBUTTONDOWN && nFlags == MK_LBUTTON) {
return new PageFormMouseLButtonDown(form);
}
}
else if (dynamic_cast<OtherNoteForm*>(form)) {
if (message == WM_LBUTTONDBLCLK && nFlags == MK_LBUTTON) {
return new OtherNoteFormMouseLButtonDblClk(form);
}
}
return 0;
}
#include "MouseMove.h"
MouseAction* MouseActionCreator::Create(Form *form, int x, int y, Long message) {
return new MouseMove(form);//mouse move to other memoForm for hovering
}
#include "OtherNoteForm.h"
#include "MouseScrollingToLeft.h"
#include "MouseScrollingToRight.h"
#include "MouseScrollingToBottom.h"
#include "MouseScrollingToTop.h"
#include "MouseMovingToLeft.h"
#include "MouseMovingToRight.h"
#include "MouseMovingToTop.h"
#include "MouseMovingToBottom.h"
MouseAction* MouseActionCreator::Create(Form *form, UINT nSide, LPRECT lpRect, Long message) {//메모폼이동중
OtherNoteForm *otherNoteForm = (OtherNoteForm*)(CFrameWnd::FindWindow("OtherNote", NULL));
//1. Moving : 별도로 분리가 필요함 0904
// bounce 동작
CRect pageFormWndRect;
static_cast<MemoForm*>(form)->GetParent()->GetWindowRect(&pageFormWndRect);
if (lpRect->left <= pageFormWndRect.left) {//메모지를 페이지 제일 왼쪽으로 이동했을 경우
return new MouseMovingToLeft(form);
}
if (lpRect->right > pageFormWndRect.right) {
return new MouseMovingToRight(form);
}
if (lpRect->top <= pageFormWndRect.top) {
return new MouseMovingToTop(form);
}
if (lpRect->bottom > pageFormWndRect.bottom) {
return new MouseMovingToBottom(form);
}
//2. Scrolling
CRect docWndRect;
otherNoteForm->GetDocumentWnd()->GetWindowRect(&docWndRect);
CPoint point;
GetCursorPos(&point);
if (point.x - 5 <= docWndRect.left) {
return new MouseScrollingToLeft(form);
}
else if (point.x + 10 >= docWndRect.right) {
return new MouseScrollingToRight(form);
}
else if (point.y + 15 >= docWndRect.bottom) {
return new MouseScrollingToBottom(form);
}
else if (point.y - 5 <= docWndRect.top) {
return new MouseScrollingToTop(form);
}
return 0;
}
#include "TabCtrl.h"
#include "TabCtrlMouseLButtonDown.h"
#include "TabCtrlMouseRButtonDown.h"
#include "TabCtrlMouseLButtonDoubleClicked.h"
MouseAction* MouseActionCreator::Create(TabCtrl *tabCtrl, UINT nFlags, CPoint point, Long message) {
if (nFlags == MK_LBUTTON && message == WM_LBUTTONDOWN) {
return new TabCtrlMouseLButtonDown(tabCtrl);
}
else if (nFlags == MK_RBUTTON && message == WM_RBUTTONDOWN) {
return new TabCtrlMouseRButtonDown(tabCtrl);
}
else if (nFlags == MK_LBUTTON && message == WM_LBUTTONDBLCLK) {
//1121 찾은 index 해제 하기
OtherNoteForm *otherNoteForm = (OtherNoteForm*)(CFrameWnd::FindWindow("OtherNote", NULL));
FindingForm *findingForm = otherNoteForm->GetFindingForm();
if (findingForm != NULL) {
findingForm->ResetIndexes();
}
return new TabCtrlMouseLButtonDoubleClicked(tabCtrl);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int edges;
cin>>edges;
//int src;
//cin>>src;
int arr[n];
int adj[n][n];
for(int i=0;i<n;i++)
{
arr[i]=0;
for(int j=0;j<n;j++)
{
adj[i][j]=0;
}
}
for(int i=0;i<edges;i++)
{
int x;
int y;
cin>>x;
cin>>y;
adj[x][y]=1;
adj[y][x]=1;
}
cout<<endl;
cout<<"ENTER THE K-CORE LIMIT"<<endl;
int k;
cin>>k;
vector<int> pt;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cout<<adj[i][j];
}
cout<<endl;
}
for(int i=0;i<n;i++)
{
int sum=0;
for(int j=0;j<n;j++)
{
sum+=adj[i][j];
}
if(sum<k)
{
pt.push_back(i);
}
}
for(int i=0;i<pt.size();i++)
{
cout<<pt[i]<<" ";
for(int j=0;j<n;j++)
{
adj[pt[i]][j]=0;
adj[j][pt[i]]=0;
}
}
cout<<endl;
int mark[n];
for(int i=0;i<n;i++)
{
mark[i]=0;
}
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cout<<adj[i][j]<<" ";
if(adj[i][j]==1)
{
if(mark[i]==0)
{
mark[i]=i;
mark[j]=i;
}
else
{
mark[j]=i;
}
}
}
cout<<endl;
}
cout<<endl;
for(int i=0;i<n;i++)
{
cout<<mark[i]<<" ";
}
}
|
class Global_Clock
{
int counter;
};
|
#include <Windows.h>
#include <iostream>
using namespace std;
namespace thread_mutex
{
int tickets=100;
HANDLE mutex;//会记录拥有者的线程ID 和 拥有次数
DWORD WINAPI threadFunc1(LPVOID lpParam)//函数形式
{
while(TRUE)
{
WaitForSingleObject(mutex,INFINITE);//一直等待到可用,对Mutex,已经是拥有者线程,可以多次调用,计数器加1,
//如果没有ReleaseMutex线程退出,操作系统会自动为Mutex计数器清0,拥有者的线程ID清0
if(tickets>0)
{
Sleep(5);
cout<<"threadFunc1 sale tickets:"<<tickets--<<endl;
}else
{
break;
}
ReleaseMutex(mutex);//只对拥有者的线程调用才有效,其它线程调用无效,计数器减1,直到为0,其它线程可用
}
return 0;
}
DWORD WINAPI threadFunc2(LPVOID lpParam)
{
while(TRUE)
{
WaitForSingleObject(mutex,INFINITE);
if(tickets>0)
{
Sleep(5);
cout<<"threadFunc2 sale tickets:"<<tickets--<<endl;
}else
{
break;
}
ReleaseMutex(mutex);
}
return 0;
}
int main(int argc,char* argv[] )
{
mutex=CreateMutex(NULL,FALSE,L"myTicks");//互斥对象,FALSE其它线程可用,如为TRUE,计数器加1
if(mutex)
{
if(ERROR_ALREADY_EXISTS==GetLastError())// 对有名字的,对一个软件只一个进程运行
{
cout<<"only one instance can run!"<<endl;
getchar();
return 1;
}
}
HANDLE myThread1,myThread2;
myThread1=CreateThread(NULL,0,threadFunc1,0,0,NULL);
myThread2=CreateThread(NULL,0,threadFunc2,0,0,NULL);
CloseHandle(myThread1);//当线程执行完成会清资源
CloseHandle(myThread2);
cout<<"main Thread runing"<<endl;
Sleep(5*1000);//放弃时间片
getchar();
return 1;
}
};
|
#include "Student.hpp"
#include <fstream>
#include <cstdlib>
int main()
{
Student *S=new Student[11];
ifstream F("Studenti.txt");
for(int i=0;i<11;i++)
F>>S[i];
cout<<"Datele pentru fiecare student:\n\n";
for(int i=0;i<11;i++)
cout<<S[i]<<endl;
Student St;
cout<<endl;
for(int i=0;i<10;i++)
for(int j=i+1;j<11;j++)
if(S[i].getMedie()>S[j].getMedie())
{
St=S[i];
S[i]=S[j];
S[j]=St;
}
cout<<"\n\nDatele pentru fiecare student dupa ordonarea in functie de medie:\n\n";
for(int i=0;i<11;i++)
cout<<S[i]<<endl;
char nume_dirig_nou[40];
cout<<"Cititi numele noului diriginte (fara spatiu intre nume si prenume si intre prenume) si modificati pentru fiecare student numele vechi in acesta: "<<endl;
cin>>nume_dirig_nou;
for(int i=0;i<11;i++)
Dirig_nou(S[i],nume_dirig_nou);
cout<<"Datele pentru fiecare student actualizate dupa schimbarea dirigintelui:\n\n";
for(int i=0;i<11;i++)
cout<<S[i]<<endl;
Student *V=new Student[12];
for(int i=0;i<11;i++)
{
V[i]=S[i];
Update_Nr(V[i],1);
}
int X;
cout<<"Pozitia pe care se adauga noul elevul: ";
cin>>X;
int note[3]={8,8,8};
Student Z(note,3,nume_dirig_nou,"4236BN",12,"IlaoiTania");
for(int i=11;i>=X+1;i--)
V[i]=V[i-1];
V[X]=Z;
cout<<"\n\nDatele pentru fiecare student in urma venirii noului student: \n\n";
for(int i=0;i<12;i++)
cout<<V[i]<<endl;
return 76;
}
|
/* File: primes.cpp
* Name: Paulo Lemus
* Date: 1/26/2017
*/
/* This program will promp user for input, and then find all primes between
* 2 and n.
*
* USE SIEVE OF ERATOSTHENES
* * FINISHED
*/
#include <cmath>
#include <iostream>
using namespace std;
// Function that ensures the input is valid
void getInput(int* n){
cout << "\n\nThis program will find all the primes between 2 and n, inclusive.\n";
do{
cout << "\nEnter n: ";
cin >> *n;
cin.clear();
cin.ignore(100, '\n');
} while(cin.fail() || *n < 2);
}
// Function that sets all primes from 2 to n
void setPrimes(bool* list, int maxNum){
// set all values to true
for(int i = 0; i < maxNum-1; i++) list[i] = true;
int bound = (int)ceil(sqrt(maxNum));
// Main loop to set primes
for(int i = 2; i <= bound; i++){
if(list[i-2]){
for(int j = i*i; j <= maxNum; j += i){
list[j-2] = false;
}
}
}
}
// Function to print all the prime indices on the list
void printPrimes(bool* list, int maxNum){
cout << "\nList of primes from 2 to " << maxNum << ":\n\n";
for(int i = 0; i < maxNum-1; i++){
if(list[i]){
cout << i + 2 << endl;
}
}
}
int main(){
int maxNum; // number to calculate primes up to
bool* list; // trues will be primes while false is not prime.
getInput(&maxNum); // Get a valid input from user
try{
list = new bool[maxNum-1]; // Init list to correct size
}
catch(...){
cout << "Caught an error: memory allocation. Exiting" << endl;
exit(1);
}
setPrimes(list, maxNum); // Sets all prime indices to true, others to false
printPrimes(list, maxNum); // Just loops through and prints the true indices
delete[] list;
return 0;
}
|
#ifndef FUZZYCORE_ENUMS_HPP
#define FUZZYCORE_ENUMS_HPP
enum InputTermTypes {
TRIANGLE = 1, TRAPEZOID = 2, GAUSSIAN = 3
};
enum OutputTermTypes {
CONSTANT = 1, LINEAR = 2
};
#endif
|
// app.cpp - application base class
// (c) 2020 Michael Fink
// https://github.com/vividos/OldStuff/
// This file contains reconstructed classes from lost source files that
// couldn't be recovered.
#include "app.h"
#include "keyboard.h"
app::app()
{
ende = false;
}
void app::init()
{
// nothing to do
}
void app::show_screen()
{
// nothing to do
}
void app::idle()
{
// nothing to do
}
void app::handle_key(keycode kc)
{
if (kc == kbQ && keyboard::is_special_key(skAlt))
ende = true;
}
#pragma argsused
void app::arg_option(const string& opt)
{
// nothing to do
}
void app::run(int argc, char** argv)
{
// start from second argument; first one is the executable
for (int arg = 1; arg < argc; arg++)
{
string s(argv[arg]);
arg_option(s);
}
run();
}
void app::run()
{
init();
while (!ende)
{
while (!ende && !keyboard::key_pressed())
idle();
handle_key(keyboard::wait_key());
show_screen();
}
}
|
#ifndef FRIENDWIDGETITEM_H
#define FRIENDWIDGETITEM_H
#include <QListWidgetItem>
#include "Widget_Name_Mood.h"
#include "Struct/PersonalInfoStruct.h"
#include "CompleteLineEdit.h"
class FriendInfoDetailDialog;
class FriendWidgetItem:public QListWidgetItem
{
public:
explicit FriendWidgetItem(PersonalInfoStruct &infor, CompleteLineEdit &completeLineEdit);
Widget_Name_Mood widgetNameMood;
PersonalInfoStruct friendInfor;
};
#endif // FRIENDWIDGETITEM_H
|
/*
(6 kyu)
Date: 1/15/20
Objective: Create a "tribonacci" sequence, like fibonacci but instead of the previous 2 integers sums its the previous 3
*/
std::vector<int> tribonacci(std::vector<int> signature, int n){
std::vector<int> result;
int z =0;
std::cout<<n<<std::endl;
for(int i = 0; i < (signature.size() > n ? n : signature.size()); i++) result.push_back(signature[i]);
while(result.size() < n){
std::cout << result[z] + result[z+1] + result[z+2]<< " " << z << std::endl;
result.push_back(result[z] + result[z+1] + result[z+2]);
z++;
}
return result;
}
|
#pragma once
#include <cassert>
#include <vector>
#include <limits>
#include "../../hlt/location.hpp"
class Path
{
public:
std::vector<hlt::Location> waypoints;
std::size_t length;
Path ()
: waypoints()
, length(0)
{ }
public:
void add (hlt::Location const location)
{
if (!waypoints.empty())
length += waypoints.front().get_distance_to(location);
waypoints.push_back(location);
}
void insert (std::size_t index, hlt::Location const location)
{
assert(index < waypoints.size());
if (index == waypoints.size() - 1)
{
if (!waypoints.empty())
length += waypoints.front().get_distance_to(location);
waypoints.push_back(location);
return;
}
length -= waypoints[index].get_distance_to(waypoints[index + 1]);
length += waypoints[index].get_distance_to(location);
length += waypoints[index + 1].get_distance_to(location);
waypoints.insert(waypoints.begin() + index, location);
}
};
|
class Solution {
public:
int divide(int dividend, int divisor) {
if(divisor == 0 || (dividend == INT_MIN && divisor == -1))
return INT_MAX;
int sign = (dividend < 0 && divisor < 0) || (dividend > 0 && divisor > 0)? 1 : -1;
long long did = labs(dividend), div = labs(divisor);
int res = 0;
while(did >= div)
{
long long tmp = div;
long long mul = 1;
while(did >= tmp)
{
tmp = tmp << 1;
mul = mul << 1;
}
res += mul >> 1;
did = did - (tmp >> 1);
}
return res * sign;
}
};
// Really tricky question. We need to consider two special cases 1) divisor == 0 2) dividend = INT_MIN and divisor == -1
// We use labs instead of abs, because abs return int but l abs return long int.
// abs => int, labs => long int, llabs => long long abs.
|
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
bool dfs(
const std::vector < std::vector < int > >&g,
int src, int dest,
int x)
{
visited[x] = true;
if (x == dest)
return true;
bool visit = false;
for (const auto &next: g[x]){
if (!visited[next])
visit = visit || dfs(g, src, dest, next);
}
return visit;
}
bool bfs(
const std::vector < std::vetor < int > > &g,
int src, int dest)
{
queue < int > q;
q.push(src);
visited[src] = true;
bool visit = false;
while(!q.empty()){
int now = q.front(); q.pop();
for(const auto &next: g[now]){
if (!visited[next]){
visited[next] = true;
q.push(next);
}
}
}
q.clear();
return visit;
}
int main(void){
return 0;
}
|
template <int b>
int sigP(double Ps)
{
return Ps>b ? 1 : -1;
}
class NOperators;
class TBath{
public:
int ifl,bind;
TBath(int ifl_=-1, int bind_=0): ifl(ifl_), bind(bind_) {}
};
class Njj{
public:
function2D<double> M;
int istate, i_m_state;
int ifl1, ifl2, ii;
};
class ClusterData{
function2D<int> F_i; //yes
function2D<function2D<double> > F_M; //yes
public:
function2D<double> Ene; //yes
private:
function2D<double> Ene0; //yes
function2D<double> Spin; //yes
function1D<int> Ks; //yes
function1D<int> msize_; //yes
function2D<double> Patom_; //no
function1D<double> Patom; //no
vector<function2D<double> > Ma; //no
vector<int> gflip_index; //yes
public:
int Nm, nsize, N_ifl, N_flavors, Nvfl;//yes
int max_size, Osize; //yes
function1D<double> Sz; //yes
function1D<int> ifl_dim; //yes
function1D<int> ifl_from_fl; //yes
function1D<int> bfl_from_fl; //yes
function2D<int> fl_from_ifl; //yes
vector<function2D<int> > tfl_index; //yes
vector<function2D<int> > vfl_index; //yes
vector<deque<int> > v2fl_index; //yes
vector<TBath> vfli_index; //yes
vector<deque<int> > sign; //yes
vector<deque<int> > conjg; //yes
vector<deque<int> > bfl_index; //yes
Number Zatom; //no
function1D<function2D<function2D<double> > > HF_M; //yes
function1D<double> natom; //no
int N_unique_fl; //yes
function1D<int> fl_deg; //yes
function1D<int> Ns; //yes
function1D<double> epsk; //yes
string RealSigma, ImagSigma; //yes
map<int,double> Id; //yes
function2D<int> gflip_fl; //yes
function1D<pair<int,int> > gflip_ifl; //yes
function2D<bool> ifl_equivalent; //yes
function1D<int> gs_ind; //no
bool QHB1; //yes
int cnsize; //no
function1D<int> cNs; //no
function1D<int> cmsize_; //no
function2D<int> cF_i; //no
function1D<int> cindx; //no
vector<vector<double> > cEne; //no
function2D<function2D<double> > cF_M; //no
//function2D<function2D<double> > Nj; //yes
function1D<function2D<double> > Uc; //yes
vector<deque<Njj> > Njjs; // no
function2D<double> Njs; // for segment
deque<pair<int,int> > fl_fl;
public:
void ParsInput(ifstream& gout);
void EvaluateMa(double beta, double mu, double U);
int size() const {return nsize;}
int msize(int i) const {return msize_[i];}
int praState(int i) const {return i+1;}
int Fi(int iop, int ist) const {return F_i(iop,ist);}
const funProxy<int>& Fi(int iop) const {return F_i[iop];}
const function2D<double>& FM(int op, int st) const { return F_M(op,st);}
const funProxy<function2D<double> >& FM(int op) const {return F_M[op];}
double patom(int i) const {return Patom[i];}
int N_baths(int ifl) const {return bfl_index[ifl].size();}
void RecomputeCix(function2D<double>& AProb, double asign, double treshold, function1D<NState>& praStates);
friend class NOperators;
void Read_for_HB1(ifstream& gout, double mu, double U);
void HB1(double beta, double mu, const mesh1D& iom, const function2D<double>& AProb, int nom, int aom, const function2D<dcomplex>& Delta, function2D<dcomplex>& Sigma, const function1D<bool>& nonzero, const function1D<bool>& nonzerou, double sderiv, int nom_small);
double P_atom(int i, int m) const {return Patom_(i+1,m);}
int BcastClusterData(int my_rank, int Master);
void Compute_Nmatrices();
//void Fill_fl_fl();
};
void ClusterData::ParsInput(ifstream& gout)
{//*****************************************************************************//
// Many arrays defined in the following routine are explained in the example of
// 2x2 cluster DMFT for superconductings state. In the latter case, the following
// input is read from the input 'cix' file:
//
// ifl ifl_dim bfl_index gflip_index
// 0 1 0 0
// 1 1 -0* 1
// 2 2 1 3 3 -1* 2
// 3 2 1 -3 -3 -1* 3
// 4 1 2 4
// 5 1 -2* 5
//
// The following arrays and variables are subsequently defined in this routine:
// N_ifl = 6 : number of blocks of block-diagonal hybridization
// N_unique_fl = 4 : number of columns read from the file
// N_flavors = 8 : size of the actual matrix of hybridization N_flavors x N_flavors
// ifl_dim[N_ifl] = [1,1,2,2,1,1] : dimension of each block in block-diagonal hybridization
// bfl_index[N_ifl][nbfl] = [[ 0],[ 0],[ 1, 3, 3, 1],[ 1, 3, 3, 1],[ 2], [2]] : stores information how to construct matrix of hybridizations
// sign[N_ifl][nbfl] = [[ 1],[ 1],[ 1, 1, 1,-1],[ 1,-1,-1,-1],[ 1],[-1]] : stores information how to construct matrix of hybridizations
// conjg[N_ifl][nbfl] = [[ 0],[ 1],[ 0, 0, 0, 1],[ 0, 0, 0, 1],[ 0],[ 1]] : stores information how to construct matrix of hybridizations
// gflip_index[N_ifl] = [0,1,2,3,4,5] : instructions for global flips
//
//
// tfl_index[N_ifl][b1,b2] = (ifl=0 : [0] : index array for matrix of hybridizations
// (ifl=1 : [0]
// (ifl=2 : [[0,1],[2,3]]
// (ifl=3 : [[0,1],[2,3]]
// (ifl=4 : [0]
// (ifl=5 : [0]
//
// vfl_index[N_ifl][b1,b2] = (ifl=0 : [[0]]
// (ifl=1 : [[1]]
// (ifl=2 : [[2,3],[4,5]]
// (ifl=3 : [[6,7],[8,9]]
// (ifl=4 : [[10]]
// (ifl=5 : [[11]]
//
// v2fl_index[N_ifl][index] = (ifl=0 : [0]
// (ifl=1 : [1]
// (ifl=2 : [2,3,4,5]
// (ifl=3 : [6,7,8,9]
// (ifl=4 : [10]
// (ifl=5 : [11]
//
// Nvfl = 12
// vfli_index[Nvfl] = [(0,0),
// (1,0),
// (2,0),
// (2,1),
// (2,2),
// (2,3),
// (3,0),
// (3,1),
// (3,2),
// (3,3),
// (4,0),
// (5,0)]
//
//
// fl_deg[N_unique_fl] = [2,4,2,4]
//
// ifl_from_fl[N_flavors] = (fl=0 : 0 bfl_from_fl[N_flavors] = (fl=0 : 0
// (fl=1 : 1 (fl=1 : 0
// (fl=2 : 2 (fl=2 : 0
// (fl=3 : 2 (fl=3 : 1
// (fl=4 : 3 (fl=4 : 0
// (fl=5 : 3 (fl=5 : 1
// (fl=6 : 4 (fl=6 : 0
// (fl=7 : 5 (fl=7 : 0
//
// fl_from_ifl[N_ifl][nbfl] = (ifl=0 : [0]
// (ifl=1 : [1]
// (ifl=2 : [2, 3]
// (ifl=3 : [4, 5]
// (ifl=4 : [6]
// (ifl=5 : [7]
//
// ifl_equivalent[N_ifl][N_ifl] = ( 1 1 0 0 0 0
// ( 1 1 0 0 0 0
// ( 0 0 1 1 0 0
// ( 0 0 1 1 0 0
// ( 0 0 0 0 1 1
// ( 0 0 0 0 1 1
//
//**************************************************************************************//
//**************************************************************************************//
// The second example if given for the f-shell in tetragonal crystal field where mixing
// between Jz=5/2 and Jz=-3/2 occurs.
//**************************************************************************************//
// J Jz ifl ifl_dim bfl_index gflip_index fl_from_ifl
// 5/2 -5/2, 3/2 2 0,7,7,1 0 0 4
// 5/2 5/2,-3/2 2 0,7,7,1 0 5 1
// 5/2 -1/2 1 2 1 2
// 5/2 1/2 1 2 1 3
// 7/2 -7/2 1 3 2 6
// 7/2 -5/2 1 4 3 7
// 7/2 -3/2 1 5 4 8
// 7/2 -1/2 1 6 5 9
// 7/2 1/2 1 6 5 10
// 7/2 3/2 1 5 4 11
// 7/2 5/2 1 4 3 12
// 7/2 7/2 1 3 2 13
//
// Note that hybridization is given in block form in different order than the electron operators.
// The order of orbitals in the hybridization matrix is (-5/2,3/2,5/2,-3/2,-1/2,1/2,....)
// while the order of electron operators is (-5/2,-3/2,-1/2,1/2,3/5,5/2,....)
// therefore fl_from_ifl index is not equal to identity.
//
// fl_from_ifl= [[0,4],[5,1],[2],[3],[6],[7],[8],[9],[10],[11],[12],[13]]
// -5/2 -3/2 -1/2 1/2 3/2 5/2
// ifl_from_fl= [ 0, 1, 2, 3, 0, 1, 4, 5, 6, 7, 8, 9, 10, 11]
// bfl_from_fl= [ 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
//
// fl_deg = [2,2,2,2,2,2,2,4]
// N_unique_fl = 8
// N_ifl = 12
// N_flavors = 14
// tfl_index= [[[0,1],[2,3]],[[0,1],[2,3]],[0],[0],[0],[0],[0],[0],[0],[0],[0],[0]]
// vfl_index= [[[0,1],[2,3]],[[4,5],[6,7]],[8],[9],[10],[11],[12],[13],[14],[15],[16],[17]]
// v2fl_index=[[0,1,2,3],[4,5,6,7],[8],[9],[10],[11],[12],[13],[14],[15],[16],[17]]
// vfli_index=[(0,0),(0,1),(0,2),(0,3),(1,0),(1,1),(1,2),(1,3),(2,0),(3,0),(4,0),(5,0),(6,0),(7,0),(8,0),(9,0),(10,0),(11,0)]
//*****************************************************************************//
gout.ignore(1000,'\n');
gout.ignore(1000,'\n');
gout>>Nm>>nsize>>N_ifl>>max_size;
if (!gout || Nm<0 || nsize<0 || N_ifl<0 || max_size<0){cerr<<"Something wrong reading cix file!"<<endl; exit(1);}
gout.ignore(1000,'\n');
gout.ignore(1000,'\n');
ifl_dim.resize(N_ifl);
sign.resize(N_ifl);
conjg.resize(N_ifl);
tfl_index.resize(N_ifl);
vfl_index.resize(N_ifl);
bfl_index.resize(N_ifl);
gflip_index.resize(N_ifl);
v2fl_index.resize(N_ifl);
N_flavors=0;
int max_dim=0;
Nvfl=0;
for (int i=0; i<N_ifl; i++){
int it;
gout>>it>>ifl_dim[i];
if (it!=i) {cerr<<"Something wrong in reading symmetries of baths in cix file!"<<endl; exit(1);}
tfl_index[i].resize(ifl_dim[i],ifl_dim[i]);
vfl_index[i].resize(ifl_dim[i],ifl_dim[i]);
int ii=0;
string str;
for (int i1=0; i1<ifl_dim[i]; i1++){
for (int i2=0; i2<ifl_dim[i]; i2++){
int sgn=1; int cgn=0;
gout>>str;
size_t im = str.find("-");
if (im != string::npos){
sgn=-1;
str.replace(im,1,"");
}
size_t ic = str.find("*");
if (ic != string::npos){
cgn=1;
str.replace(ic,1,"");
}
int ind = atoi(str.c_str());
bfl_index[i].push_back(ind);
sign[i].push_back(sgn);
conjg[i].push_back(cgn);
Id[ind] = (i1==i2) ? 1 : 0;
tfl_index[i][i1][i2] = ii++;
vfl_index[i][i1][i2] = Nvfl;
v2fl_index[i].push_back(Nvfl);
Nvfl++;
}
}
if (ifl_dim[i]>max_dim) max_dim = ifl_dim[i];
N_flavors += ifl_dim[i];
{
int is;
gout>>is;
gflip_index[i]=is;
}
gout.ignore(1000,'\n');
}
gout.ignore(1000,'\n');
N_unique_fl = 0;
for (int ifl=0; ifl<N_ifl; ifl++)
for (size_t b=0; b<bfl_index[ifl].size(); b++)
if (bfl_index[ifl][b]>N_unique_fl) N_unique_fl = bfl_index[ifl][b];
N_unique_fl++;
fl_deg.resize(N_unique_fl);
fl_deg=0;
for (int ifl=0; ifl<N_ifl; ifl++)
for (size_t b=0; b<bfl_index[ifl].size(); b++) fl_deg[bfl_index[ifl][b]]++;
//// START NEW CHANGE 4.10.2008
if (!gout){cerr<<"Something wrong in reading cix file! Exiting 0! "<<endl; exit(1);}
string str0;
getline(gout,str0); // reading word "FL_FROM_IFL" or epsk[N_unique_fl]
// The order of psi_i operators is not necessary simply connected with the index in hybridization Delta.
// The index fl_from_ifl connects electron operator psi_i with the index in hybridization matrix.
fl_from_ifl.resize(N_ifl,max_dim);
if (str0.find("FL_FROM_IFL",0)!=string::npos){
deque<int> check_fl_from_ifl;
int n_flavors=0;
for (int ifl=0; ifl<N_ifl; ifl++){
for (int ib=0; ib<ifl_dim[ifl]; ib++){
gout>>n_flavors;
if (!gout){cerr<<"Something wrong in reading IFL_FROM_FL in cix file! Exiting! "<<endl; exit(1);}
fl_from_ifl(ifl,ib) = n_flavors;
check_fl_from_ifl.push_back(n_flavors);
}
gout.ignore(1000,'\n');
}
sort(check_fl_from_ifl.begin(), check_fl_from_ifl.end());
for (int i=0; i<check_fl_from_ifl.size(); i++){
if (i!=check_fl_from_ifl[i]) {cerr<<"FL_FROM_IFL is wrong! Must be index array 0...N-1!"<<endl; exit(1);}
}
gout.ignore(1000,'\n');
getline(gout,str0);
}else{
int n_flavors=0;
for (int ifl=0; ifl<N_ifl; ifl++){
for (int ib=0; ib<ifl_dim[ifl]; ib++){
fl_from_ifl(ifl,ib) = n_flavors;
n_flavors++;
}
}
}
if (!gout){cerr<<"Something wrong in reading cix file! Exiting! "<<endl; exit(1);}
gout.ignore(1000,'\n'); // comment
// reading from stringstream because we have epsk in string form
std::istringstream sstr0(str0);
epsk.resize(N_unique_fl);
epsk=0;
for (int ik=0; ik<N_unique_fl; ik++) sstr0>>epsk[ik];
ifl_from_fl.resize(N_flavors);
bfl_from_fl.resize(N_flavors);
for (int ifl=0; ifl<N_ifl; ifl++){
for (int jb=0; jb<ifl_dim[ifl]; jb++){
int tfl = fl_from_ifl(ifl,jb);
ifl_from_fl[tfl] = ifl;
bfl_from_fl[tfl] = jb;
}
}
//// END NEW CHANGE 4.10.2008
vfli_index.resize(Nvfl);
for (int i=0; i<N_ifl; i++){
int ii=0;
for (int i1=0; i1<ifl_dim[i]; i1++){
for (int i2=0; i2<ifl_dim[i]; i2++){
int jj = vfl_index[i][i1][i2];
vfli_index[jj] = TBath(i,ii);
ii++;
}
}
}
map<int,deque<int> > gfl_tmp;
for (int ifl=0; ifl<N_ifl; ifl++){
int ii = gflip_index[ifl];
gfl_tmp[ii].push_back(ifl);
}
int sz=0;
for (map<int,deque<int> >::iterator ia=gfl_tmp.begin(); ia!=gfl_tmp.end(); ia++){
deque<int>& d = ia->second;
sz += d.size()*(d.size()-1)/2;
}
gflip_fl.resize(sz+1,N_flavors);
gflip_ifl.resize(sz);
for (int iu=0; iu<sz; iu++){
for (int j=0; j<gflip_fl.size_Nd(); j++) gflip_fl[iu][j] = j;
}
int iu=0;
for (map<int,deque<int> >::iterator ia=gfl_tmp.begin(); ia!=gfl_tmp.end(); ia++){
deque<int>& d = ia->second;
for (size_t j1=0; j1<d.size(); j1++){
for (size_t j2=j1+1; j2<d.size(); j2++){
int ifa = d[j1];
int ifb = d[j2];
if (ifl_dim[ifa]!=ifl_dim[ifb]){cerr<<"Dimensions of similar baths have to be the same!"<<endl; exit(1);}
gflip_ifl[iu] = make_pair(ifa,ifb);
for (int ib=0; ib<ifl_dim[ifa]; ib++){
int fa = fl_from_ifl[ifa][ib];
int fb = fl_from_ifl[ifb][ib];
gflip_fl[iu][fa] = fb;
gflip_fl[iu][fb] = fa;
gflip_fl[sz][fa] = fb;
gflip_fl[sz][fb] = fa;
}
iu++;
}
}
}
ifl_equivalent.resize(N_ifl,N_ifl);
for (int ifl=0; ifl<N_ifl; ifl++){
for (int jfl=0; jfl<N_ifl; jfl++){
ifl_equivalent[ifl][jfl] = bfl_index[ifl]==bfl_index[jfl];
}
}
F_i.resize(2*N_flavors,nsize+1);
F_M.resize(2*N_flavors,nsize+1);
Ene.resize(nsize+1,max_size);
Ene0.resize(nsize+1,max_size);
Spin.resize(nsize+1,max_size);
Ns.resize(nsize+1);
Ks.resize(nsize+1);
Sz.resize(nsize+1);
msize_.resize(nsize+1);
msize_=0;
F_i=0;
int tsize=0;
for (int i=1; i<=nsize; i++){
int it1, in, ik, isize; double dsz;
gout>>it1>>in>>ik>>dsz>>isize;
if (it1!=i){cerr<<"Something wrong in parsing cix file!"<<endl;}
Ns[i] = in;
Ks[i] = ik;
Sz[i] = dsz;
msize_[i] = isize;
for (int ib=0; ib<N_flavors; ib++){
int ist;
gout>>ist;
if (ist!=0){
F_i(2*ib,i)=ist;
F_i(2*ib+1,ist)=i;
}
}
for (int is=0; is<isize; is++) gout>>Ene(i,is);
Ene[i].resize(isize);
for (int is=0; is<isize; is++) gout>>Spin(i,is);
Spin[i].resize(isize);
gout.ignore(1000,'\n');
tsize += isize;
}
gout.ignore(1000,'\n');
Ene0 = Ene;
for (int i=1; i<=nsize; i++){
for (int ib=0; ib<N_flavors; ib++){
int it, jt, size1, size2;
gout>>it>>jt>>size1>>size2;
if (it!=i || jt!=F_i(2*ib,i)) cerr<<"Something wrong reading cix file"<<endl;
F_M(2*ib,i).resize(size2,size1); // constructor changes i->ii
int ii = F_i(2*ib,i);
F_M(2*ib+1,ii).resize(size1,size2);// destructor changes ii->i
for (int i1=0; i1<size1; i1++){
for (int i2=0; i2<size2; i2++){
double m;
gout>>m;
F_M(2*ib,i)(i2,i1)=m; // constructor
F_M(2*ib+1,ii)(i1,i2)=m; // destructor
}
}
gout.ignore(1000,'\n');
}
}
string str;
QHB1=false;
getline(gout,str);
common::QHB2=false;
if (str.find("HB1",0)!=string::npos){
clog<<"Have HB1"<<endl;
QHB1=true;
}else if(str.find("HB2",0)!=string::npos){
clog<<"Have HB2"<<endl;
QHB1=true;
common::QHB2=true;
getline(gout,str); // # Uc = U[ifl,j1,j2,ifl]-U[ifl,j1,ifl,j2]:
Uc.resize(N_ifl);
for (int ifl=0; ifl<N_ifl; ifl++) Uc[ifl].resize(N_ifl,N_ifl);
for (int ifl=0; ifl<N_ifl; ifl++)
for (int j1=0; j1<N_ifl; j1++)
for (int j2=0; j2<N_ifl; j2++)
gout>>Uc[ifl](j1,j2);
getline(gout,str); // newline
}else{
// high frequency expansion, the first few moments of self-energy
if (gout){
getline(gout,str);
RealSigma = str;
getline(gout,str);
ImagSigma = str;
}
}
getline(gout,str); // # number of operators needed
gout>>Osize;
cout<<"Number of operators needed "<<Osize<<endl;
gout.ignore(1000,'\n');
getline(gout,str);
HF_M.resize(Osize);
//Nj.resize(nsize+1,N_ifl);
//cout<<"N_unique_fl="<<N_unique_fl<<endl;
//????
for (int op=0; op<Osize; op++){// Operator for the high frequency moments, called Op in the string above
if (!gout.good()) cerr<<"Something wrong in reading cix file high frequency expansion"<<endl;
HF_M[op].resize(N_unique_fl,nsize+1);
streampos pos1 = gout.tellg();
int in=0;
int im=0;
int it;
for (int ib=0; ib<N_unique_fl; ib++){
gout>>it;
gout.ignore(1000,'\n');
if (it==1) in++;
if (Id[ib]==1) im++;
}
bool off_diagonal=true;
if (in==im){
off_diagonal=false;
}else if (in==N_unique_fl){
off_diagonal=true;
}else{
cerr<<"Something wrong reading cix: Number of entries for Operator is not correct"<<endl;
}
cout<<"off_diagonal="<<off_diagonal<<endl;
gout.seekg(pos1);
for (int i=1; i<=nsize; i++){
for (int ib=0; ib<N_unique_fl; ib++){
int it=i;
int size1 = msize_[i];
int size2 = msize_[i];
if (Id[ib]==1 || off_diagonal){ // Only diagonal baths need this. Otherwise just set it to zero!
gout>>it>>size1>>size2;
if (it!=i) cerr<<"Something wrong reading cix file reading Operators: i="<< i<<" it="<<it<<" size="<<size1<<endl;
if (size1!=msize_[i] || size2!=msize_[i]) cerr<<"Sizes of HFM are wrong! "<<i<<" "<<size1<<" "<<size2<<" "<<msize_[i]<<endl;
}
HF_M[op](ib,i).resize(size2,size1); // constructor changes i->ii
for (int i1=0; i1<size1; i1++){
for (int i2=0; i2<size2; i2++){
double m=0.0;
if (Id[ib]==1 || off_diagonal) gout>>m;
HF_M[op](ib,i)(i2,i1)=m;
}
}
if (Id[ib]==1 || off_diagonal) gout.ignore(1000,'\n');
}
}
getline(gout,str);
}
}
void ClusterData::EvaluateMa(double beta, double mu, double U)
{
Ma.resize(N_flavors);
for (size_t i=0; i<Ma.size(); i++) Ma[i].resize(size()+1,max_size);
function2D<double> D(max_size,max_size);
for (int i=1; i<=size(); i++){
for (int op=0; op<N_flavors; op++){
int inew = F_i(2*op+1,i);
if (inew==0) continue;
D.MProduct(F_M(2*op,inew),F_M(2*op+1,i));
for (int m=0; m<D.size_N(); m++) Ma[op](i,m) = D(m,m);
}
}
for (int i=1; i<=nsize; i++){
double dE = -Ns[i]*mu + 0.5*Ns[i]*(Ns[i]-1)*U;
for (int m=0; m<Ene[i].size(); m++) Ene(i,m) += dE;
}
if (common::QHB2){
for (int ifl=0; ifl<N_ifl; ifl++)
for (int j1=0; j1<N_ifl; j1++)
for (int j2=0; j2<N_ifl; j2++)
if (j1==j2 && ifl!=j1) Uc[ifl](j1,j2) += U;
/*
cout<<"Uc="<<endl;
cout.precision(2);
for (int ifl=0; ifl<N_ifl; ifl++){
for (int j1=0; j1<N_ifl; j1++){
for (int j2=0; j2<N_ifl; j2++)
cout<<setw(6)<<Uc[ifl](j1,j2)<<" ";
cout<<endl;
}
}
cout<<endl;
*/
}
// cout<<"GS are:"<<endl;
gs_ind.resize(nsize+1);
for (int i=1; i<=nsize; i++){
int imin = 0;
for (int m=1; m<Ene[i].size(); m++)
if (Ene(i,m)<Ene(i,imin)) imin = m;
gs_ind[i] = imin;
// cout<<setw(3)<<i<<" "<<setw(4)<<gs_ind[i]<<endl;
}
Zatom=0;
for (int i=1; i<=size(); i++)
for (int m=0; m<msize(i); m++)
Zatom += Number(1,-Ene[i][m]*beta);
Patom.resize(size());
Patom_.resize(size()+1,max_size);
for (int i=1; i<=size(); i++){
double sum=0;
for (int m=0; m<msize(i); m++){
Patom_(i,m) = divide(Number(1,-Ene[i][m]*beta),Zatom);
sum += Patom_(i,m);
}
Patom[i-1] = sum;
}
natom.resize(N_flavors);
for (int b=0; b<N_flavors; b++){
double sum=0;
for (int i=1; i<=size(); i++)
for (int m=0; m<msize(i); m++)
sum += Patom_(i,m)*Ma[b](i,m);
natom[b] = sum;
}
}
bool CheckStream(istream& inputf, int& n, int& m)
{
istream input(inputf.rdbuf());
input.seekg(0,ios::beg);
n=0;
string str;
bool begincomment = false;
getline(input,str);
if (!input.good()) {
cerr << "ERROR: Wrong file format for input stream or no data!" << endl;
return false;
}
if (str.find('#')<string::npos){
begincomment = true;
}else n++;
getline(input,str); n++;
stringstream oneline(str);
m=0; double t;
while (oneline){oneline>>t; m++;}
m--;
while (input){ getline(input,str); n++;}
n--;
// clog << " Number of entries: "<< n <<endl;
// clog << " Number of columns: "<< m <<endl;
inputf.seekg(0,ios::beg);
if (begincomment) getline(inputf, str);
if (!inputf){ cerr<<"Reopening didn't suceeded!"<<endl; return false;}
return true;
}
bool ReadData(istream& input, mesh1D& om, function2D<dcomplex>& fi, int mdata, int baths)
{
clog<<"Reading data with "<<om.size()<<" entries"<<endl;
if (mdata<2*baths+1) {cerr<<"Not enough columns in input Delta file!"<<endl; return false;}
vector<double> data(mdata);
int i=-1;
while (input && ++i<om.size()){
for (int j=0; j<mdata; j++) input>>data[j];
input.ignore(500,'\n');
for (int j=0; j<baths; j++) fi[j][i] = dcomplex(data[2*j+1],data[2*j+2]);
om[i] = data[0];
}
input.clear(); // forget we hit the end of file
input.seekg(0, ios::beg); // move to the start of the file
string str;
getline(input, str); // read comment
return true;
}
vector<pair<double,double> > FindHighFrequencyExp_original(int Nf, const mesh1D& omi, const function2D<dcomplex>& fi)
{
vector<pair<double,double> > ah(fi.size_N());
for (int b=0; b<fi.size_N(); b++){
double S=0, Sx=0, Sy=0, Sxx=0, Sxy=0;
double Sz=0, Sxz=0;
for (int j=omi.size()-Nf; j<omi.size(); j++){
double y = fi[b][j].imag()*omi[j]; // 1/omega term
double z = fi[b][j].real()*omi[j]*omi[j]; // 1/omega^2 term
double x = omi[j];
Sy += y;
Sz += z;
Sx += 1/(x*x);
Sxx += 1/(x*x*x*x);
Sxy += y/(x*x);
Sxz += z/(x*x);
S++;
}
double dd = S*Sxx-Sx*Sx;
double ax = (Sxx*Sy-Sx*Sxy)/dd;
double bx = (Sxx*Sz-Sx*Sxz)/dd;
// double bx = (S*Sxy-Sx*Sy)/dd;
// clog<<a<<" "<<bx<<endl;
ah[b].first = -ax;
ah[b].second = bx/ax;
}
return ah;
}
vector<pair<double,double> > FindHighFrequencyExp(int Nf, const mesh1D& omi, const function2D<dcomplex>& fi)
{// Looking for the form : a/(iom-eps). We will determine a and eps and store into ah.first=a and ah.second=eps
cout.precision(16);
vector<pair<double,double> > ah(fi.size_N());
for (int b=0; b<fi.size_N(); b++){
double S=0, Sy=0, Sz=0;
for (int j=omi.size()-Nf; j<omi.size(); j++){
double y = fi[b][j].imag()*omi[j]; // 1/omega term
double z = fi[b][j].real()*omi[j]*omi[j]; // 1/omega^2 term
Sy += y;
Sz += z;
S++;
}
double ax = Sy/S;
double bx = Sz/S;
//cout<<"b="<<b<<" got ax="<<ax<<" got bx="<<bx<<endl;
ah[b].first = -ax; // a
ah[b].second = bx/ax; // eps
}
return ah;
}
void CreateLogMesh(int M1, int M2, double T, const mesh1D& omi, mesh1D& oms)
{
if (M1+M2+1>=omi.size()){
oms = omi;
return;
}
oms.resize(M1+M2+1);
double small=0.1;
for (int i=0; i<M1; i++) oms[i] = omi[i];
double alpha = log((omi.size()-1.)/M1)/(M2-1.);
int inp = static_cast<int>(0.5*(oms[M1-1]/(M_PI*T)-1)+small);
int l=0;
for (int i=0; i<M2; i++){
int in = static_cast<int>(M1*exp(alpha*i)+0.5);
if (in!=inp) oms[M1+(l++)] = (2*in+1)*M_PI*T;
inp = in;
}
int last = static_cast<int>(0.5*(omi.last()/(M_PI*T)-1)+small);
if (inp!=last) oms[M1+(l++)] = (2*last+1)*M_PI*T;
oms.resize(M1+l);
oms.SetUp(0.0);
}
void InverseFourier(const functionb<dcomplex>& Giom, const mesh& iom, functionb<double>& Gtau, const mesh& tau, const pair<double,double>& ah, double beta)
{
function1D<dcomplex> dG(iom.size());
for (int n=0; n<iom.size(); n++){
dcomplex g_infty = ah.first/(dcomplex(0,iom[n])-ah.second);
dG[n] = Giom[n]-g_infty;
}
for (int t=0; t<tau.size(); t++){
double tau_ = tau[t];
double dsum=0;
for (int n=0; n<iom.size(); n++)
dsum += cos(iom[n]*tau_)*dG[n].real()+sin(iom[n]*tau_)*dG[n].imag();
Gtau[t] = 2*dsum/beta;
if (ah.second>0)
Gtau[t] -= ah.first*exp(-ah.second*tau[t])/(1.+exp(-ah.second*beta));
else
Gtau[t] -= ah.first*exp(ah.second*(beta-tau[t]))/(1.+exp(ah.second*beta));
}
}
bool ReadDelta(int Ns, istream& input, int n, int m, mesh1D& omi, function2D<dcomplex>& Deltaw, vector<pair<double,double> >& ah, double beta, int Nhigh=40)
{
mesh1D tomi(n);
function2D<dcomplex> tDeltaw(Ns,tomi.size());
if (!ReadData(input, tomi, tDeltaw, m, Ns)) return false;
tomi.SetUp(0);
int Nhighf = min(Nhigh, static_cast<int>(tomi.size()*0.4)); // correction 21.4.2008 : Shuld not compute high frequency from low frequency points
ah = FindHighFrequencyExp(Nhighf, tomi, tDeltaw);
//int imax = static_cast<int>((tomi.last()*beta/M_PI-1)/2. + 0.5);
int imax = static_cast<int>((tomi.last()*beta/M_PI+1)/2. + 1e-6); // correction, Jun 2015
omi.resize(imax); // Matsubara mesh for this temperature
for (int i=0; i<omi.size(); i++)
omi[i] = (2*i+1)*M_PI/beta;
// Is the mesh iom from file Delta.inp correct for this temperature?
double mesh_diff=0;
for (int i=0; i<min(omi.size(),tomi.size()); i++) mesh_diff += fabs(omi[i]-tomi[i]);
//cout<<"mesh_diff="<<mesh_diff<<endl;
Deltaw.resize(Ns,omi.size());
for (int ib=0; ib<Ns; ib++){
//cout<<"ah="<<ah[ib].first<<","<<ah[ib].second<<endl;
if (mesh_diff>1.){ // The mesh of Matsubara points is not good enough
spline1D<double> tDeltaw_r(tomi.size());
spline1D<double> tDeltaw_i(tomi.size());
for (int i=0; i<tomi.size(); i++){
tDeltaw_r[i]=tDeltaw[ib][i].real();
tDeltaw_i[i]=tDeltaw[ib][i].imag();
}
tDeltaw_r.splineIt(tomi,0,0);
tDeltaw_i.splineIt(tomi,0,0);
for (int i=0; i<omi.size(); i++)
if (omi[i]<tomi.last()){
intpar pw = tomi.Interp(omi[i]);
Deltaw[ib][i] = dcomplex( tDeltaw_r(pw) , tDeltaw_i(pw) );
} else{
Deltaw[ib][i] = ah[ib].first/( dcomplex(0,omi[i]) - ah[ib].second);
}
}else{
for (int i=0; i<omi.size(); i++){
if (omi[i]<tomi.last()+M_PI/beta) // correction 16.12.2006
Deltaw[ib][i] = tDeltaw[ib](tomi.Interp(omi[i]));
else
Deltaw[ib][i] = ah[ib].first/( dcomplex(0,omi[i]) - ah[ib].second);
}
}
}
return true;
}
void DeltaFourier(int Ntau, double beta, mesh1D& tau, vector<spline1D<double> >& Delta, const mesh1D& omi, const function2D<dcomplex>& Deltaw, const vector<pair<double,double> >& ah)
{
tau.MakeEquidistantMesh(Ntau,0,beta);
for (size_t ib=0; ib<Delta.size(); ib++) Delta[ib].resize(tau.size());
for (size_t ib=0; ib<Delta.size(); ib++){
InverseFourier(Deltaw[ib], omi, Delta[ib], tau, ah[ib], beta); // Here needs to be corrected!
/*
ofstream check(NameOfFile("check.dat",ib).c_str());
check<<"# ah = "<<ah[ib].first<<" "<<ah[ib].second<<endl;
for (int i=0; i<tau.size(); i++) check<<tau[i]<<" "<<Delta[ib][i]<<endl;
*/
double df0 = (Delta[ib][1]-Delta[ib][0])/(tau[1]-tau[0]); // If Delta[ib][itau]>0 set it to something negative
int n = tau.size();
double dfn = (Delta[ib][n-1]-Delta[ib][n-2])/(tau[n-1]-tau[n-2]);
Delta[ib].splineIt(tau,df0,dfn);
}
}
// void ClusterData::Fill_fl_fl()
// {
// for (int ii=0; ii<N_ifl; ii++) fl_fl.push_back(make_pair(ii,ii));
// }
void ClusterData::Compute_Nmatrices()
{
if (common::Segment){
Njs.resize(size()+1,N_flavors);
Njs=0.0;
for (int ist=0; ist<size(); ist++){
int istate = praState(ist);
for (int fl=0; fl<N_flavors; fl++){
int op_dagg = 2*fl;
int op_nodag = 2*fl+1;
int i_m_state = Fi(op_nodag)[istate];
if (i_m_state==0) continue;
double nn=FM(op_dagg)[i_m_state](0,0)*FM(op_nodag)[istate](0,0);
Njs(istate,fl) = nn;
}
}
for (int ifl=0; ifl<N_ifl; ifl++) fl_fl.push_back(make_pair(ifl,ifl));
}else{
Njjs.resize(size()+1);
Njj nj;
nj.M.resize(max_size,max_size);
for (int ist=0; ist<size(); ist++){
int istate = praState(ist);
for (int ifl1=0; ifl1<N_ifl; ifl1++){
int fl1 = fl_from_ifl[ifl1][0];
int op_nodag = 2*fl1+1;
int i_m_state = Fi(op_nodag)[istate];
if (i_m_state==0) continue;
for (int ifl2=0; ifl2<N_ifl; ifl2++){
int fl2 = fl_from_ifl[ifl2][0];
int op_dagg = 2*fl2;
int istate_new = Fi(op_dagg)[i_m_state];
if (istate_new!=istate) continue;
Multiply(nj.M,FM(op_dagg)[i_m_state],FM(op_nodag)[istate]);
int ii=0; // searching for correct compact index for (ifl1,ifl2)
for (; ii<fl_fl.size(); ii++) // We want to have fl_fl[ii] = (ifl1,ifl2)
if (fl_fl[ii].first==ifl1 && fl_fl[ii].second==ifl2) break;
if (ii==fl_fl.size()) fl_fl.push_back(make_pair(ifl1,ifl2));
nj.istate = istate; // state |state> with N electrons
nj.i_m_state = i_m_state; // state |m_state> with N-1 electrons
nj.ifl1 = ifl1; // which baths are involved
nj.ifl2 = ifl2; // which two baths are involved
nj.ii = ii; // the compact index for (ifl1,ifl2)
Njjs[istate].push_back(nj);
}
}
}
}
/*
cout<<"fl_fl="<<endl;
for (int ii=0; ii<fl_fl.size(); ii++){
cout<<ii<<" "<<fl_fl[ii].first<<" "<<fl_fl[ii].second<<endl;
}
cout<<endl;
*/
/*
for (int istate=1; istate<=size(); istate++){
cout<<"istate="<<istate<<endl;
for (int fl=0; fl<Njs[istate].size(); fl++){
cout<<" fl="<<fl<<" : "<<Njs(istate,fl)<<endl;
}
}
*/
/*
for (int istate=1; istate<=size(); istate++){
for (int i=0; i<Njjs[istate].size(); i++){
cout<<istate<<" istate="<<setw(2)<<Njjs[istate][i].istate<<" (ifl1,ifl2)="<<setw(2)<<Njjs[istate][i].ifl1<<setw(2)<<Njjs[istate][i].ifl2<<" ii(fl1,fl2)="<<Njjs[istate][i].ii<<" i_m_state="<<setw(2)<<Njjs[istate][i].i_m_state<<" sizes="<<Njjs[istate][i].M.size_N()<<","<<Njjs[istate][i].M.size_Nd()<<endl;
for (int j1=0; j1<Njjs[istate][i].M.size_N(); j1++){
for (int j2=0; j2<Njjs[istate][i].M.size_Nd(); j2++)
cout<<Njjs[istate][i].M(j1,j2)<<" ";
}
cout<<endl;
int ii=Njjs[istate][i].ii;
//cout<<Njjs[istate][i].ifl1<<"="<<fl_fl[ii].first<<" "<<Njjs[istate][i].ifl2<<"="<<fl_fl[ii].second<<endl;
if (Njjs[istate][i].ifl1!=fl_fl[ii].first || Njjs[istate][i].ifl2!=fl_fl[ii].second) cerr<<"ERROR: ifl1,ifl2="<<Njjs[istate][i].ifl1<<" "<<Njjs[istate][i].ifl2<<" while fl_fl gives ifl1,ifl2="<<fl_fl[ii].first<<" "<<fl_fl[ii].second<<endl;
}
}
*/
}
void ClusterData::RecomputeCix(function2D<double>& AProb, double asign, double treshold, function1D<NState>& praStates)
{
for (int i=0; i<nsize; i++) for (int j=0; j<msize_[i+1]; j++) AProb[i][j]/=asign;
ofstream out("Probability.dat"); out.precision(16);
out<<"# asign="<<asign<<endl;
for (int j=0; j<AProb.size_N(); j++)
for (int k=0; k<AProb[j].size(); k++)
out<<setw(3)<<j+1<<" "<<setw(3)<<k<<" "<<setw(20)<<AProb[j][k]<<endl;
vector<deque<int> > redundant(nsize);
function1D<int> new_msize_(msize_);
// deque<int> remove;
for (int ist=0; ist<nsize; ist++){
int ii = ist+1;
deque<int> redun;
for (int m=0; m<msize_[ii]; m++)
if (fabs(AProb(ist,m))<treshold) redun.push_back(m); // this state should be eliminated
redundant[ist] = redun;
// if (redun.size()==msize_[ist+1]) remove.push_back(ist);
new_msize_[ii] = msize_[ii] - redun.size();
}
for (int ist=0; ist<nsize; ist++){
int ii = ist+1;
if (new_msize_[ii]==0) praStates[ist].SetIstate(0);
for (int ib=0; ib<N_flavors; ib++){
int jj = F_i(2*ib,ii);
if (jj==0) continue;
int size1 = msize_[ii];
int size2 = msize_[jj];
for (int k=redundant[ii-1].size()-1; k>=0; k--){
int ik = redundant[ii-1][k];
for (int m1=0; m1<size2; m1++)
for (int l=ik+1; l<size1; l++){
F_M(2*ib,ii)(m1,l-1) = F_M(2*ib,ii)(m1,l);
F_M(2*ib+1,jj)(l-1,m1) = F_M(2*ib+1,jj)(l,m1);
}
size1--;
}
for (int k=redundant[jj-1].size()-1; k>=0; k--){
int ik = redundant[jj-1][k];
for (int m2=0; m2<size1; m2++)
for (int l=ik+1; l<size2; l++){
F_M(2*ib,ii)(l-1,m2) = F_M(2*ib,ii)(l,m2);
F_M(2*ib+1,jj)(m2,l-1) = F_M(2*ib+1,jj)(m2,l);
}
size2--;
}
if (size1==0 || size2==0){
F_i[2*ib][ii]=0;
F_i[2*ib+1][jj]=0;
size1=0;
size2=0;
}
double sum=0;
for (int m1=0; m1<size2; m1++)
for (int m2=0; m2<size1; m2++)
sum += fabs(F_M(2*ib,ii)(m1,m2));
if (sum<treshold){
F_i[2*ib][ii]=0;
F_i[2*ib+1][jj]=0;
size1=0;
size2=0;
}
F_M(2*ib,ii).resize(size2,size1);
F_M(2*ib+1,jj).resize(size1,size2);
}
}
for (int ist=0; ist<nsize; ist++){
int ii = ist+1;
for (int k=redundant[ii-1].size()-1; k>=0; k--){
int ik = redundant[ii-1][k];
for (int l=ik+1; l<msize_[ii]; l++){
Ene0[ii][l-1] = Ene0[ii][l];
Spin[ii][l-1] = Spin[ii][l];
}
}
Ene0[ii].resize(new_msize_[ii]);
Spin[ii].resize(new_msize_[ii]);
}
for (int op=0; op<Osize; op++){
for (int ist=0; ist<nsize; ist++){
int ii = ist+1;
for (int ib=0; ib<N_unique_fl; ib++){
function2D<double>& hf = HF_M[op](ib,ii);
int size = msize_[ii];
for (int k=redundant[ii-1].size()-1; k>=0; k--){
int ik = redundant[ii-1][k];
for (int m1=0; m1<size; m1++) for (int l=ik+1; l<size; l++) hf(m1,l-1) = hf(m1,l);
for (int m1=0; m1<size; m1++) for (int l=ik+1; l<size; l++) hf(l-1,m1) = hf(l,m1);
}
hf.resize(new_msize_[ii],new_msize_[ii]);
}
}
}
msize_ = new_msize_;
ofstream gout("new.cix"); gout.precision(12);
gout<<"# Updated Cix file for cluster DMFT with CTQMC"<<endl;
gout<<"# cluster_size, number of states, number of baths, maximum_matrix_size"<<endl;
gout<<Nm<<" "<<nsize<<" "<<N_ifl<<" "<<max_size<<endl;
gout<<"# baths, dimension, symmetry"<<endl;
for (int i=0; i<N_ifl; i++){
gout<<left<<setw(3)<<i<<" "<<setw(4)<<ifl_dim[i]<<" ";
for (int b=0; b<sqr(ifl_dim[i]); b++){
if (sign[i][b]<0) gout<<"-";
gout<<bfl_index[i][b];
if (conjg[i][b]) gout<<"*";
gout<<" ";
}
gout<<" "<<setw(3)<<gflip_index[i]<<endl;
}
gout<<"# cluster energies for non-equivalent baths, eps[k]"<<endl;
for (int ik=0; ik<epsk.size(); ik++) gout<<epsk[ik]<<" ";
gout<<endl;
gout<<right;
gout<<" # N K Sz size"<<endl;
for (int ist=0; ist<nsize; ist++){
int ii = ist+1;
gout<<setw(2)<<ii<<" "<<setw(3)<<Ns[ii]<<" "<<setw(3)<<Ks[ii]<<" "<<setw(4)<<right<<Sz[ii]<<" "<<setw(3)<<msize_[ii]<<" ";
for (int ib=0; ib<N_flavors; ib++) gout<<setw(3)<<F_i(2*ib,ist+1)<<" ";
// gout<<" ";
for (int is=0; is<Ene0[ii].size(); is++) gout<<setw(18)<<Ene0(ii,is)<<" ";
for (int is=0; is<Spin[ii].size(); is++) gout<<setw(18)<<Spin(ii,is)<<" ";
gout<<endl;
}
gout<<"# matrix elements"<<endl;
for (int ist=0; ist<nsize; ist++){
for (int ib=0; ib<N_flavors; ib++){
gout<<setw(2)<<ist+1<<" "<<setw(3)<<F_i(2*ib,ist+1)<<" ";
function2D<double>& fm = F_M(2*ib,ist+1);
gout<<setw(3)<<fm.size_Nd()<<" "<<setw(3)<<fm.size_N()<<" ";
for (int im1=0; im1<fm.size_Nd(); im1++)
for (int im2=0; im2<fm.size_N(); im2++)
gout<<setw(20)<<fm[im2][im1]<<" ";
gout<<endl;
}
}
gout<<"# high frequency expansion (Real and Imaginary part of Sigma)"<<endl;
gout<<RealSigma<<endl;
gout<<ImagSigma<<endl;
gout<<"# number of operators needed"<<endl;
gout<<Osize<<endl;
for (int op=0; op<Osize; op++){
gout<<"# high frequency moment matrix elements, called Op"<<op+1<<" above"<<endl;
for (int i=1; i<=nsize; i++){
for (int ib=0; ib<N_unique_fl; ib++){
int size = msize_[i];
gout<<setw(2)<<i<<" "<<setw(3)<<size<<" "<<setw(3)<<size<<" ";
function2D<double>& hf = HF_M[op](ib,i);
for (int i1=0; i1<size; i1++)
for (int i2=0; i2<size; i2++)
gout<<setw(20)<<hf(i2,i1)<<" ";
gout<<endl;
}
}
}
Ene = Ene0;
for (int i=1; i<=nsize; i++){
double dE = -Ns[i]*common::mu + 0.5*Ns[i]*(Ns[i]-1)*common::U;
for (int m=0; m<Ene[i].size(); m++) Ene(i,m) += dE;
}
}
void Inverse_Gf(int dim, int N_unique_fl, const deque<int>& bfl_index, const deque<int>& sign, const deque<int>& conjg, int im, const function2D<dcomplex>& Gf, function2D<dcomplex>& Gf_1)
{
static function2D<dcomplex> g(dim,dim), gi(dim,dim);
if (dim==1){
Gf_1[bfl_index[0]][im] += 1/Gf[bfl_index[0]][im];
return;
}
g.resize(dim,dim);
gi.resize(dim,dim);
int ib=0;
for (int i1=0; i1<dim; i1++){
for (int i2=0; i2<dim; i2++){
dcomplex gf = Gf(bfl_index[ib],im);
if (sign[ib]==-1) gf*=-1;
if (conjg[ib]) gf = gf.conj();
g[i1][i2] = gf;
ib++;
}
}
gi.Inverse(g);
ib=0;
for (int i1=0; i1<dim; i1++){
for (int i2=0; i2<dim; i2++){
dcomplex gf = gi[i1][i2];
if (sign[ib]==-1) gf*=-1;
if (conjg[ib]) gf = gf.conj();
Gf_1(bfl_index[ib], im) += gf;
ib++;
}
}
}
#ifdef AS
template <>
int sigP<0>(double Ps){
return Ps>0 ? 1 : 1;
}
#endif
|
#ifndef GUN_H_INCLUDED
#define GUN_H_INCLUDED
#include "rendering/renderlist.h"
#include "bullet.h"
#include <memory>
#include <gameobjects/gameobject.h>
class Gun : public GameObject{
public:
void render(RenderList& list) const;
void render_aim(RenderList& list, double gun_angle) const;
void update() {};
double grip1_x(double gun_angle) const;
double grip1_y(double gun_angle) const;
double grip2_x(double gun_angle) const;
double grip2_y(double gun_angle) const;
Point get_barrel_position(double gun_angle) const;
virtual const char* shoot_sound() {
return "../assets/sound/shoot.wav";
}
virtual const char* holding_shoot_sound() {
return nullptr;
}
virtual bool in_front() const = 0;
virtual std::vector<std::unique_ptr<Bullet>> spawn_bullets(double gun_angle) const;
virtual int ticks_between_shots() const {
return 20;
}
virtual int initial_ammo() const = 0;
virtual ~Gun();
virtual const char* gun_image_name() const = 0;
private:
virtual double gun_rotation_x() const = 0;
virtual double gun_rotation_y() const = 0;
virtual double gun_offset_x() const = 0;
virtual double gun_offset_y() const = 0;
virtual double barrel_offset_x() const = 0;
virtual double barrel_offset_y() const = 0;
virtual double grip1_dx() const = 0;
virtual double grip1_dy() const = 0;
virtual double grip2_dx() const = 0;
virtual double grip2_dy() const = 0;
virtual double barrel_length() const {
return 20;
}
virtual std::unique_ptr<Bullet> create_initial_bullet() const = 0;
};
std::unique_ptr<Gun> create_gun(const std::string& gun_name);
#endif
|
#pragma once
#include "MacroHelper.h"
class CRTTI{
public:
CRTTI( const char* name, const CRTTI& parent ) : m_name(name), m_parent(parent) {}
const char* GetType(){
return m_name;
}
private:
const char* m_name;
const CRTTI& m_parent;
};
#define DEFINE_RTTI(CLASS_NAME) \
public:\
static CRTTI m_rtti;\
static const char* GetType(){ return m_rtti.GetType(); }
#define IMPLEMENT_RTTI(...) OVERLOADED_MACRO(IMPLEMENT_RTTI, __VA_ARGS__)
#define IMPLEMENT_RTTI1(CLASS_NAME)\
CRTTI CLASS_NAME::m_rtti(#CLASS_NAME, CLASS_NAME::m_rtti)
#define IMPLEMENT_RTTI2(CLASS_NAME, PARENT_CLASS)\
CRTTI CLASS_NAME::m_rtti(#CLASS_NAME, PARENT_CLASS::m_rtti)
|
#include "WindowX.hpp"
#include "Logger.hpp"
#include "Utility.hpp"
#include "IJob.hpp"
namespace engine
{
enum Events
{
WM_SHUTDOWN,
WM_WAKE_UP
};
WindowX::WindowX()
: m_initialized(false)
, m_fullscreen(false)
, m_show(false)
, m_terminal(false)
, m_display(nullptr)
, m_window(0)
, m_screen(0)
, m_width(0)
, m_height(0)
{}
WindowX::~WindowX()
{
Finalize();
}
Int32 WindowX::Initialize( Uint32 poxX, Uint32 posY, Uint32 wndWidth, Uint32 wndHeight)
{
m_display = XOpenDisplay(NULL);
if (m_display == nullptr)
{
LOGE("Cound not create connection to XServer");
return -1;
}
m_screen = DefaultScreen(m_display);
m_window = XCreateSimpleWindow(m_display, DefaultRootWindow(m_display), 0, 0,
800, 600, 0, BlackPixel(m_display, m_screen),
WhitePixel(m_display, m_screen));
Atom m_shutdownAtom = XInternAtom( m_display, "WM_DELETE_WINDOW", 0 );
XSetWMProtocols(m_display , m_window, &m_shutdownAtom, 1);
XSelectInput(m_display, m_window, ExposureMask);
m_fileDescriptor = ConnectionNumber(m_display);
m_width = wndWidth;
m_height = wndHeight;
XSync(m_display, false);
m_initialized = true;
return 0;
}
void WindowX::RegisterEventCallback(IWindowEventHandler*) {}
void WindowX::Show()
{
XMapWindow(m_display, m_window);
XFlush(m_display);
m_show = true;
for(auto& listener: m_surfaceEventListeners)
{
listener->OnShow();
}
}
void WindowX::Hide()
{
XUnmapWindow(m_display, m_window);
XFlush(m_display);
m_show = false;
for(auto& listener: m_surfaceEventListeners)
{
listener->OnHide();
}
}
Bool WindowX::HandleEvents()
{
fd_set fds;
struct timeval tv;
XEvent event;
FD_ZERO(&fds);
FD_SET(m_fileDescriptor, &fds);
tv.tv_usec = 60000;
tv.tv_sec = 0;
Int32 numReadsFds = select(m_fileDescriptor + 1, &fds, 0, 0, &tv);
if (numReadsFds)
{
while(XPending(m_display))
{
XNextEvent(m_display, &event);
switch(event.type)
{
case Expose:
break;
case ClientMessage:
m_terminal = true;
return false;
}
}
}
if (IsShutdown()) // not sure about this
{
m_terminal = true;
return false;
}
return true;
}
void WindowX::Finalize()
{
// TO check thread this should be run from main thread
if (!m_initialized)
{
return;
}
if (m_show)
{
Hide();
}
Shutdown();
while(IsRunning())
{
Sleep(TimeUnits::MakeMiliseconds(200));
}
XDestroyWindow(m_display, m_window);
XCloseDisplay(m_display);
m_initialized = false;
}
void WindowX::OnStart() {}
void WindowX::OnResize( Uint32 width, Uint32 height)
{
for (auto& listener: m_surfaceEventListeners)
{
listener->OnResize(width, height);
}
}
void WindowX::OnReposition( Uint32 x, Uint32 y)
{
for (auto& listener: m_surfaceEventListeners)
{
listener->OnReposition(x, y);
}
}
void WindowX::OnShutdown()
{
for (auto& listener: m_surfaceEventListeners)
{
listener->OnShutdown();
}
}
void WindowX::OnFullscreen()
{
for (auto& listener: m_surfaceEventListeners)
{
listener->OnFullscreen();
}
}
Bool WindowX::IsFullscreen() { return m_fullscreen; }
Bool WindowX::IsShow() { return m_show; }
Bool WindowX::IsTerminal() { return m_terminal; }
void WindowX::RegisterEventListener(ObjectRef<ISurfaceEventListener>& surfaceEventListener)
{
m_surfaceEventListeners.push_back(surfaceEventListener);
}
void WindowX::UnregisterEventListener(ObjectRef<ISurfaceEventListener>& surfaceEventListener)
{
m_surfaceEventListeners.remove(surfaceEventListener);
}
} // namespace engine
|
#include "Background.h"
Background::Background(sf::Texture* background_texture, sf::Texture* overlay_texture,
sf::Texture* inactive_overlay_texture)
{
setUpBody(background_body, background_texture, sf::Vector2f(settings.window_size.x, settings.window_size.y),
sf::Vector2f(0.0f, 0.0f));
setUpBody(overlay_body, overlay_texture, sf::Vector2f(450.0f, 164.0f),
sf::Vector2f(0.0f, settings.window_size.y - 164.0f));
setUpBody(inactive_overlay_body, inactive_overlay_texture,
sf::Vector2f(settings.window_size.x, settings.window_size.y), sf::Vector2f(0.0f, 0.0f));
}
Background::~Background()
{
}
void Background::setUpBody(sf::RectangleShape& shape, sf::Texture* texture, sf::Vector2f size, sf::Vector2f position)
{
shape.setSize(size);
shape.setPosition(position);
shape.setTexture(texture);
}
void Background::drawOverlay(sf::RenderWindow& window)
{
window.draw(overlay_body);
}
void Background::drawBgr(sf::RenderWindow& window)
{
window.draw(background_body);
}
void Background::drawInactiveOverlay(sf::RenderWindow& window)
{
window.draw(inactive_overlay_body);
}
|
//
// SelectorGroup.hpp
// DDCSSParser
//
// Created by 1m0nster on 2018/8/7.
// Copyright © 2018 1m0nster. All rights reserved.
//
#ifndef SelectorGroup_hpp
#define SelectorGroup_hpp
#include <stdio.h>
#include <iostream>
#include <list>
#include "Selector.hpp"
namespace future {
class GroupSelector: public Selector {
public:
GroupSelector()
{
m_selectorType = Selector::SelectorGroup;
}
~GroupSelector();
void addSelector(Selector *);
std::list<Selector *>getAllSelectors()
{
return m_selectors;
}
bool isBaseSelector();
int weight();
virtual std::string description();
private:
std::list<Selector *> m_selectors;
};
}
#endif /* SelectorGroup_hpp */
|
//
// Created by Peter Eichinger on 04.10.18.
//
#pragma once
#include <cmath>
#include <vulkan/vulkan.hpp>
vk::DeviceSize nextPowerOfTwo(vk::DeviceSize value) {
return static_cast<vk::DeviceSize>(std::pow(2, std::ceil(std::log2(value))));
}
|
#pragma once
/* Disable Screen Shake
* PATCHES: Renderer2.dll
*/
#include "../Main.h"
#include "../Singleton.h"
#include "GenericPatcher.h"
class CPatcher_DisableScreenShake : public IGenericPatcher {
public:
CPatcher_DisableScreenShake();
bool ReadINI(void);
bool WriteINI(void);
private:
// Hook functions
// Variables for hook functions
};
typedef Singleton<CPatcher_DisableScreenShake> SngPatcher_DisableScreenShake;
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#define MAXSIZE 1000
typedef struct Node {
int val;
Node *left, *right;
}Node, *Tree;
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
Tree CreateTreeBST(int a[], int start, int end); // 创建完全二叉查找树
int FindRoot(int start, int end); // 给定首尾，确定该树的根节点
Node* CreateNode(int val); // 创建新结点
void TravelLevelOrder(Tree); // 层序遍历并输出
int main() {
freopen("CBSinput.txt", "r", stdin);
int N;
int a[MAXSIZE];
Tree t;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", a+i);
}
qsort(a, N, sizeof(int), compare);
t = CreateTreeBST(a, 0, N-1);
TravelLevelOrder(t);
return 0;
}
// 给定首尾，确定该树的根节点
int FindRoot(int start, int end) {
int n = end - start + 1; // 总结点数
int height = (int)log2(n+1); // 该完全二叉树除去最后一层的满二叉树的高度
int maxsize = pow(2, height) - 1; // 满二叉树的结点总数
int remains = n - maxsize; // 计算出最后一层的结点数
int half = pow(2, height-1); // 最后一层的总容量的一半
remains = remains < half ? remains : half;
return start + remains + (maxsize+1)/2 - 1; // 确定根节点的index
}
// 创建完全二叉搜索树
Tree CreateTreeBST(int a[], int start, int end) {
if (start > end) {
return NULL;
}
Tree t;
int index = FindRoot(start, end); // 找到根节点的位置
t = CreateNode(a[index]); // 创建根节点
t->left = CreateTreeBST(a, start, index-1); // 绑定左子树
t->right = CreateTreeBST(a, index+1, end); // 绑定右子树
return t;
}
Node* CreateNode(int val) {
Node* n = (Node*)malloc(sizeof(Node));
n->val = val;
n->left = NULL;
n->right = NULL;
return n;
}
// 层序遍历并输出
void TravelLevelOrder(Tree t) {
if (!t) return;
Node* a[MAXSIZE]; // 用作队列存储结点
a[0] = t; // 存入第一个结点
int front = 0, rear = 1; // 队首和队尾
while (front < rear) { // 如果队列不空
t = a[front++]; // 获取第一个结点
if (t->left) a[rear++] = t->left; // 存入该结点的左孩子
if (t->right) a[rear++] = t->right; // 存入该结点的右孩子
if (front == 1) printf("%d", t->val); // 打印该结点的值
else printf(" %d", t->val);
}
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// #define DEBUG
const int maxn = 20;
int n, cnt[maxn] = { 0 }, ans = 0;
string word[maxn];
char startChar;
struct Candidate {
int idx, len;
Candidate() {}
Candidate(int _idx, int _len)
: idx(_idx)
, len(_len) {}
};
vector<Candidate> cadidate[maxn];
int getCommonLen(string& a, string& b) {
int len = min(a.size(), b.size());
for (int i = 1; i <= len - 1; ++i)
if (a.substr(a.size() - i) == b.substr(0, i))
return i;
return 0;
}
void getCandidate(int a, int b) {
int tmp;
if (tmp = getCommonLen(word[a], word[b]))
cadidate[a].push_back(Candidate(b, tmp));
if (a != b && (tmp = getCommonLen(word[b], word[a])))
cadidate[b].push_back(Candidate(a, tmp));
}
void dfs(int idx, int len) {
bool flag = false;
for (int i = 0; i < cadidate[idx].size(); ++i) {
Candidate next = cadidate[idx][i];
if (cnt[next.idx] < 2) {
flag = true;
cnt[next.idx]++;
dfs(next.idx, len + word[next.idx].size() - next.len);
cnt[next.idx]--;
}
}
if (!flag)
ans = max(ans, len);
}
int main() {
#ifdef DEBUG
freopen("d:\\input.txt", "r", stdin);
freopen("d:\\output.txt", "w", stdout);
#endif
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> word[i];
for (int j = 0; j <= i; ++j)
getCandidate(i, j);
}
cin >> startChar;
for (int i = 0; i < n; ++i)
if (word[i][0] == startChar) {
// 这里不要漏了计数
cnt[i]++;
dfs(i, word[i].size());
cnt[i]--;
}
cout << ans;
return 0;
}
|
#ifndef _token_h__
#define _token_h__
#include <string>
class Tokenizer {
public:
Tokenizer();
double evaluate(std::string parsee) const;
};
#endif // ifndef _token_h__
|
#pragma once
#include <iostream>
//Main Shape class
class DrawShape {
public:
DrawShape();
private:
std::string shape_type;
int shape_count;
int shape_height;
int shape_length;
int shape_radius;
public:
DrawShape(const std::string, const int, const int, const int, const int);
~DrawShape();
std::string get_shape() const;
int get_count() const;
int get_height() const;
int get_length() const;
int get_radius() const;
void set_count(int varcount);
void set_height(int varheight);
void set_length(int varlength);
void set_shape(std::string varshape);
void set_radius(int varradius);
void Draw();
void DrawStars();
void Info();
};
|
/******************************************************************************
* Copyright (c) 2018, Xilinx, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION). HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
/*****************************************************************************
*
* Author: Kristof Denolf <kristof@xilinx.com>
* Date: 2016/06/02
*
*****************************************************************************/
#include "HRTimer.h"
HRTimer::HRTimer() {
#if defined(WIN32)
QueryPerformanceFrequency(&frequency);
clks_per_us = (float)frequency.QuadPart/float(1000000.0);
#else
start = 0;
stop = 0;
#endif
us = 0;
}
HRTimer::~HRTimer() {
}
void HRTimer::StartTimer() {
#if defined(WIN32)
DWORD_PTR oldmask = SetThreadAffinityMask(GetCurrentThread(), 0);
QueryPerformanceCounter(&start);
SetThreadAffinityMask(::GetCurrentThread(),oldmask);
#else
start = getCurrent();
#endif
}
void HRTimer::StopTimer() {
#if defined(WIN32)
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
QueryPerformanceCounter(&stop);
SetThreadAffinityMask(::GetCurrentThread(), oldmask);
us = (US_TYPE)((stop.QuadPart - start.QuadPart)/clks_per_us);
#else
stop = getCurrent();
us = stop - start;
#endif
}
void HRTimer::RestartTimer() {
StopTimer();
StartTimer();
}
US_TYPE HRTimer::GetElapsedUs() {
return us;
}
US_TYPE HRTimer::GetCurrentTime() {
#if defined(WIN32)
LARGE_INTEGER now;
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
QueryPerformanceCounter(&now);
SetThreadAffinityMask(::GetCurrentThread(), oldmask);
return (US_TYPE)((now.QuadPart - start.QuadPart)/clks_per_us);
#else
US_TYPE now = getCurrent();
US_TYPE time = now - start;
return time;
#endif
}
|
class Solution {
public:
int nthUglyNumber(int n) {
// 三个指针
int a = 0;
int b = 0;
int c = 0;
vector<int> dp;
dp.push_back(1);
if(n == 1) return 1;
n--;
int min_num;
while(n)
{
min_num = min(dp[b]*3,dp[a]*2);
min_num = min(min_num,dp[c]*5);
if(min_num%2==0) a++;
if(min_num%3==0) b++;
if(min_num%5==0) c++;
dp.push_back(min_num);
n--;
}
return min_num;
}
};
|
#include "widget.h"
#include "gridreport.h"
#include <QtGui/QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
widget *w=new widget;
QTextCodec::setCodecForTr( QTextCodec::codecForName("GBK") );
w->resize(820,850);
w->show();
return a.exec();
}
|
// C++ for the Windows Runtime vv1.0.170303.6
// Copyright (c) 2017 Microsoft Corporation. All rights reserved.
#pragma once
WINRT_EXPORT namespace winrt {
namespace ABI::Windows::Media::Devices::Core {
struct ICameraIntrinsics;
struct ICameraIntrinsics2;
struct ICameraIntrinsicsFactory;
struct IDepthCorrelatedCoordinateMapper;
struct IFrameControlCapabilities;
struct IFrameControlCapabilities2;
struct IFrameController;
struct IFrameController2;
struct IFrameExposureCapabilities;
struct IFrameExposureCompensationCapabilities;
struct IFrameExposureCompensationControl;
struct IFrameExposureControl;
struct IFrameFlashCapabilities;
struct IFrameFlashControl;
struct IFrameFocusCapabilities;
struct IFrameFocusControl;
struct IFrameIsoSpeedCapabilities;
struct IFrameIsoSpeedControl;
struct IVariablePhotoSequenceController;
struct CameraIntrinsics;
struct DepthCorrelatedCoordinateMapper;
struct FrameControlCapabilities;
struct FrameController;
struct FrameExposureCapabilities;
struct FrameExposureCompensationCapabilities;
struct FrameExposureCompensationControl;
struct FrameExposureControl;
struct FrameFlashCapabilities;
struct FrameFlashControl;
struct FrameFocusCapabilities;
struct FrameFocusControl;
struct FrameIsoSpeedCapabilities;
struct FrameIsoSpeedControl;
struct VariablePhotoSequenceController;
}
namespace Windows::Media::Devices::Core {
struct ICameraIntrinsics;
struct ICameraIntrinsics2;
struct ICameraIntrinsicsFactory;
struct IDepthCorrelatedCoordinateMapper;
struct IFrameControlCapabilities;
struct IFrameControlCapabilities2;
struct IFrameController;
struct IFrameController2;
struct IFrameExposureCapabilities;
struct IFrameExposureCompensationCapabilities;
struct IFrameExposureCompensationControl;
struct IFrameExposureControl;
struct IFrameFlashCapabilities;
struct IFrameFlashControl;
struct IFrameFocusCapabilities;
struct IFrameFocusControl;
struct IFrameIsoSpeedCapabilities;
struct IFrameIsoSpeedControl;
struct IVariablePhotoSequenceController;
struct CameraIntrinsics;
struct DepthCorrelatedCoordinateMapper;
struct FrameControlCapabilities;
struct FrameController;
struct FrameExposureCapabilities;
struct FrameExposureCompensationCapabilities;
struct FrameExposureCompensationControl;
struct FrameExposureControl;
struct FrameFlashCapabilities;
struct FrameFlashControl;
struct FrameFocusCapabilities;
struct FrameFocusControl;
struct FrameIsoSpeedCapabilities;
struct FrameIsoSpeedControl;
struct VariablePhotoSequenceController;
}
namespace Windows::Media::Devices::Core {
template <typename T> struct impl_ICameraIntrinsics;
template <typename T> struct impl_ICameraIntrinsics2;
template <typename T> struct impl_ICameraIntrinsicsFactory;
template <typename T> struct impl_IDepthCorrelatedCoordinateMapper;
template <typename T> struct impl_IFrameControlCapabilities;
template <typename T> struct impl_IFrameControlCapabilities2;
template <typename T> struct impl_IFrameController;
template <typename T> struct impl_IFrameController2;
template <typename T> struct impl_IFrameExposureCapabilities;
template <typename T> struct impl_IFrameExposureCompensationCapabilities;
template <typename T> struct impl_IFrameExposureCompensationControl;
template <typename T> struct impl_IFrameExposureControl;
template <typename T> struct impl_IFrameFlashCapabilities;
template <typename T> struct impl_IFrameFlashControl;
template <typename T> struct impl_IFrameFocusCapabilities;
template <typename T> struct impl_IFrameFocusControl;
template <typename T> struct impl_IFrameIsoSpeedCapabilities;
template <typename T> struct impl_IFrameIsoSpeedControl;
template <typename T> struct impl_IVariablePhotoSequenceController;
}
namespace Windows::Media::Devices::Core {
enum class FrameFlashMode
{
Disable = 0,
Enable = 1,
Global = 2,
};
}
}
|
#include "TriMesh.h"
#include "meshFIM.h"
#include "math.h"
#include "tinyxml.h"
#include <iostream>
#include <sstream>
#include <string>
#include "vnl/vnl_vector.h"
#define _USE_MATH_DEFINES
int main(int argc, char *argv[])
{
if(argc != 2)
{
std::cout << "-------------------------------" << std::endl;
std::cout << "ComputeGeodesicDistanceToLandmark " << std::endl;
std::cout << "-------------------------------" << std::endl;
std::cout << "Compute geodesic distances on given triangular meshes (ply format) to a set of given landmarks " << std::endl;
std::cout << "It uses a parameter file with the following tags" << std::endl;
std::cout << "\t - with_fids: a flag to indicate whether to use fids to generate the geodesics, if 0, kdtree will be used instead (filenames will be affected), if true, we need to provide" << std::endl;
std::cout << "\t the spacing, size and origin of their distance transforms that generated those fids files" << std::endl;
std::cout << "\t - mesh: a list of ply file names for meshes to be processed" << std::endl;
std::cout << "\t - fids: a list of corresponding fids files (in case with_fids = 1)" << std::endl;
std::cerr << "\t - origin_x, origin_t, origin_z: the origin in physical units of the resulting distance transform" << std::endl;
std::cerr << "\t - spacing_x, spacing_y, spacing_z: voxel spacing of the resulting distance transform" << std::endl;
std::cerr << "\t - size_x, size_y, size_z: the size (rows,cols,slices) of the resulting distance transform" << std::endl;
std::cout << "\t - landmark_files: a list of text files containing the 3d point locations of the landmarks associated with each mesh (a single file for each mesh with each row a different landmark xyz)" << std::endl;
std::cout << "\t - landmark_labels: the name of each landmark specified in landmark files, this will be used in the naming of the output feature files (fea)" << std::endl;
std::cout << "\t - apply_log: 0 (default) or 1 if need log of geodesic distance as feature" << std::endl;
std::cout << "Usage: " << argv[0] << " parameter file" << std::endl;
return EXIT_FAILURE;
}
typedef vnl_vector< double > PointVectorType;
TiXmlDocument doc(argv[1]);
bool loadOkay = doc.LoadFile();
if (!loadOkay)
{
std::cerr << "Error in loading xml file..." << std::endl;
return EXIT_FAILURE;
}
TiXmlHandle docHandle( &doc );
TiXmlElement *elem;
std::istringstream inputsBuffer;
// Collect a list of point file names and output file names
std::vector< std::string > meshFilename;
std::vector< std::string > landmarkFilename;
std::vector< std::string > landmarkLabels;
bool withFids = false; // if false use kdtree instead, note that filenames with be affected
std::vector< std::string > fidsFilename; // save name as mesh but with fids extension, ONLY will be used if with_fids is triggered
// in case of fids since image origin, size and spacing is needed that generated the fids files
int size_x, size_y, size_z;
float origin_x, origin_y, origin_z;
float spacing_x, spacing_y, spacing_z;
bool apply_log = false;
std::string tmpString;
elem = docHandle.FirstChild( "apply_log" ).Element();
if (elem)
{
atoi(elem->GetText()) > 0 ? apply_log = true : apply_log = false;
}
elem = docHandle.FirstChild( "with_fids" ).Element();
if (elem)
{
atoi(elem->GetText()) > 0 ? withFids = true : withFids = false;
}
if(withFids)
{
elem = docHandle.FirstChild( "fids" ).Element();
if (!elem)
{
std::cerr << "No fids files have been specified and with_fids is triggered" << std::endl;
throw 1;
}
else
{
fidsFilename.clear();
inputsBuffer.str(elem->GetText());
while (inputsBuffer >> tmpString)
{
fidsFilename.push_back(tmpString);
}
inputsBuffer.clear();
inputsBuffer.str("");
}
// voxel spacing in the x-direction
elem = docHandle.FirstChild( "spacing_x" ).Element();
if (elem)
{
spacing_x = atof( elem->GetText() );
}
else
{
std::cerr << "No spacing_x specified!" << std::endl;
return EXIT_FAILURE;
}
// voxel spacing in the y-direction
elem = docHandle.FirstChild( "spacing_y" ).Element();
if (elem)
{
spacing_y = atof( elem->GetText() );
}
else
{
std::cerr << "No spacing_y specified!" << std::endl;
return EXIT_FAILURE;
}
// voxel spacing in the z-direction
elem = docHandle.FirstChild( "spacing_z" ).Element();
if (elem)
{
spacing_z = atof( elem->GetText() );
}
else
{
std::cerr << "No spacing_z specified!" << std::endl;
return EXIT_FAILURE;
}
// volume size in the x-direction
elem = docHandle.FirstChild( "size_x" ).Element();
if (elem)
{
size_x = atoi( elem->GetText() );
}
else
{
std::cerr << "No size_x specified!" << std::endl;
return EXIT_FAILURE;
}
// volume size in the y-direction
elem = docHandle.FirstChild( "size_y" ).Element();
if (elem)
{
size_y = atoi( elem->GetText() );
}
else
{
std::cerr << "No size_y specified!" << std::endl;
return EXIT_FAILURE;
}
// volume size in the z-direction
elem = docHandle.FirstChild( "size_z" ).Element();
if (elem)
{
size_z = atoi( elem->GetText() );
}
else
{
std::cerr << "No size_z specified!" << std::endl;
return EXIT_FAILURE;
}
// volume orign in the x-direction
elem = docHandle.FirstChild( "origin_x" ).Element();
if (elem)
{
origin_x = atof( elem->GetText() );
}
else
{
std::cerr << "No origin_x specified!" << std::endl;
return EXIT_FAILURE;
}
// volume orign in the y-direction
elem = docHandle.FirstChild( "origin_y" ).Element();
if (elem)
{
origin_y = atof( elem->GetText() );
}
else
{
std::cerr << "No origin_y specified!" << std::endl;
return EXIT_FAILURE;
}
// volume orign in the z-direction
elem = docHandle.FirstChild( "origin_z" ).Element();
if (elem)
{
origin_z = atof( elem->GetText() );
}
else
{
std::cerr << "No origin_z specified!" << std::endl;
return EXIT_FAILURE;
}
}
elem = docHandle.FirstChild( "mesh" ).Element();
if (!elem)
{
std::cerr << "No mesh files have been specified" << std::endl;
throw 1;
}
else
{
meshFilename.clear();
inputsBuffer.str(elem->GetText());
while (inputsBuffer >> tmpString)
{
meshFilename.push_back(tmpString);
}
inputsBuffer.clear();
inputsBuffer.str("");
}
elem = docHandle.FirstChild( "landmark_files" ).Element();
if (!elem)
{
std::cerr << "No landmark files have been specified" << std::endl;
throw 1;
}
else
{
inputsBuffer.str(elem->GetText());
while (inputsBuffer >> tmpString)
{
landmarkFilename.push_back(tmpString);
}
inputsBuffer.clear();
inputsBuffer.str("");
}
elem = docHandle.FirstChild( "landmark_labels" ).Element();
if (!elem)
{
std::cerr << "No landmark labels have been specified" << std::endl;
throw 1;
}
else
{
landmarkLabels.clear();
inputsBuffer.str(elem->GetText());
while (inputsBuffer >> tmpString)
{
landmarkLabels.push_back(tmpString);
}
inputsBuffer.clear();
inputsBuffer.str("");
}
for (int s = 0; s < meshFilename.size(); s++)
{
// read mesh
std::cout << "Reading mesh file: " << meshFilename[s] << std::endl;
TriMesh *mesh = TriMesh::read( meshFilename[s].c_str() );
orient(mesh);
if (mesh->neighbors.empty()) mesh->need_neighbors();
if (mesh->adjacentfaces.empty()) mesh->need_adjacentfaces();
if (mesh->normals.empty()) mesh->need_normals();
if(withFids)
{
mesh->ReadFaceIndexMap(fidsFilename[s].c_str());
mesh->imageOrigin[0] = origin_x;
mesh->imageOrigin[1] = origin_y;
mesh->imageOrigin[2] = origin_z;
// Store spacing of image domain
mesh->imageSpacing[0] = spacing_x;
mesh->imageSpacing[1] = spacing_y;
mesh->imageSpacing[2] = spacing_z;
// Store size of image domain
mesh->imageSize[0] = size_x;
mesh->imageSize[1] = size_y;
mesh->imageSize[2] = size_z;
}
// read landmark points
std::cout << std::endl << "Reading landmarks file: " << landmarkFilename[s] << std::endl;
std::ifstream landmarkFile(landmarkFilename[s].c_str());
std::vector< point > landmarkPts;
if (!landmarkFile)
{
std::cout << "landmark file not found: " << landmarkFilename[s] << std::endl;
return EXIT_FAILURE;
}
while (landmarkFile)
{
point tmpPt; tmpPt.clear();
for (int d = 0; d < 3; d++)
{
landmarkFile >> tmpPt[d];
}
landmarkPts.push_back(tmpPt);
}
landmarkPts.pop_back();
// loop over landmarks to compute distance feature
for (int lm = 0; lm < landmarkLabels.size(); lm++)
{
std::cout << "Computing geodesics to " << landmarkLabels[lm] << " landmark ..." << std::endl;
// get name of output file
std::string feaFilename;
// SHIREEN: save fea files where we find the landmarks not the meshes, similar to compute distance to curves tool
int index = landmarkFilename[s].rfind("/");
std::string path = landmarkFilename[s].substr(0, index+1);
//std::string file = landmarkFilename[s].substr(index+1, landmarkFilename[s].length()-1);
int index_m = meshFilename[s].rfind("/");
// fea file will take its prefix from mesh file in case we use different meshs with different decimations
std::string file = meshFilename[s].substr(index_m+1, meshFilename[s].length()-1);
index = file.rfind(".");
if (index == std::string::npos)
{
if(withFids)
{
if (apply_log)
feaFilename = path + file + ".geoTo_" + landmarkLabels[lm] + "_withFids_withLog.fea";
else
feaFilename = path + file + ".geoTo_" + landmarkLabels[lm] + "_withFids.fea";
}
else
{
if (apply_log)
feaFilename = path + file + ".geoTo_" + landmarkLabels[lm] + "_withLog.fea";
else
feaFilename = path + file + ".geoTo_" + landmarkLabels[lm] + ".fea";
}
}
else
{
if(withFids)
{
if (apply_log)
feaFilename = path + file.substr(0, index) + ".geoTo_" + landmarkLabels[lm] + "_withFids_withLog.fea";
else
feaFilename = path + file.substr(0, index) + ".geoTo_" + landmarkLabels[lm] + "_withFids.fea";
}
else
{
if (apply_log)
feaFilename = path + file.substr(0, index) + ".geoTo_" + landmarkLabels[lm] + "_withLog.fea";
else
feaFilename = path + file.substr(0, index) + ".geoTo_" + landmarkLabels[lm] + ".fea";
}
}
std::cout << "fea filename to be saved : " << feaFilename << std::endl;
// SHIREEN: computing geodesics to landmarks based on geodesic approximation
meshFIM *fim = new meshFIM;
fim->SetMesh(mesh);
fim->ComputeDistanceToLandmark(mesh, landmarkPts[lm], apply_log, feaFilename.c_str());
}
}
return EXIT_SUCCESS;
}
|
#include <iostream>
#include "Menu.h"
using namespace std;
Menu::Menu()
{
selection = 0;
}
void Menu::displayMainMenu()
{
cout << "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
cout << "@ @\n";
cout << "@ T E X T E X P L O R E R @\n";
cout << "@ @\n";
cout << "@ 1. Aesop's Fables @\n";
cout << "@ 2. A Tale of Two Cites @\n";
cout << "@ 3. White Fange @\n";
cout << "@ 4. Through the Looking Glass @\n";
cout << "@ 5. The Time Machine @\n";
cout << "@ 6. Candide @\n";
cout << "@ 7. Sherlock Holmes @\n";
cout << "@ 8. Tarzan of the Apes @\n";
cout << "@ 9. Common Sense @\n";
cout << "@ 10. The Masque of Red Death @\n";
cout << "@ 11. Exit @\n";
cout << "@ @\n";
cout << "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
}
int Menu::getSelection()
{
int choice;
bool valid = false;
do
{
cout << "Choose a book to explore: " << flush;
cin >> choice;
if (cin.good() && choice > 0 && choice < 12)
{
valid = true;
}
else
{
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(),'\n');
cout << "Invalid input; Please select 1-10." << endl;
}
} while (!valid);
return choice;
}
|
#include "plot/HistogramFactories.h"
#include "base/std_ext/string.h"
#include "TMath.h"
#include "TDirectory.h"
#include "TTree.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TH3D.h"
#include <iomanip>
using namespace ant;
using namespace ant::analysis;
using namespace ant::std_ext;
using namespace std;
void HistogramFactory::goto_dir() const
{
if(my_directory)
my_directory->cd();
}
string HistogramFactory::MakeTitle(const string& title) const
{
if(title_prefix.empty())
return title;
return std_ext::formatter() << title_prefix << ": " << title;
}
TDirectory *HistogramFactory::mkDirNumbered(const string &name, TDirectory *rootdir)
{
TDirectory* dir = nullptr;
unsigned n=0;
do {
const string dn = (n!=0) ? name+to_string(n) : name;
++n;
rootdir->GetObject(dn.c_str(), dir);
if(!dir) {
dir = rootdir->mkdir(dn.c_str());
if(!dir)
throw("Can't create output directory \"" + dn +"\"");
} else {
dir = nullptr;
}
} while(dir==nullptr);
return dir;
}
string HistogramFactory::GetNextHistName(const string &name) const
{
if(name.empty()) {
return formatter() << "hist" << setfill('0') << setw(3) << n_unnamed++;
} else
return name;
}
HistogramFactory::HistogramFactory(const string &directory_name, TDirectory* root, const string& title_prefix_):
title_prefix(title_prefix_)
{
if(!root)
root=gDirectory;
my_directory = mkDirNumbered(directory_name, root);
}
HistogramFactory::HistogramFactory(const string& directory_name, const HistogramFactory& parent, const string& title_prefix_)
: my_directory(),
title_prefix
(
parent.title_prefix.empty() ?
title_prefix_ :
(title_prefix_.empty() ? parent.title_prefix :
std_ext::formatter() << parent.title_prefix << ": " << title_prefix_)
)
{
my_directory = parent.my_directory->mkdir(directory_name.c_str());
if(!my_directory)
my_directory=gDirectory;
}
void HistogramFactory::SetTitlePrefix(const string& title_prefix_)
{
title_prefix = title_prefix_;
}
string HistogramFactory::GetTitlePrefix() const
{
return title_prefix;
}
void HistogramFactory::SetDirDescription(const string &desc)
{
my_directory->SetTitle(desc.c_str());
}
TH1D *HistogramFactory::makeTH1D(const string &title, const string &xlabel, const string &ylabel, const BinSettings &bins, const string &name) const
{
auto r = make<TH1D>(GetNextHistName(name).c_str(), MakeTitle(title).c_str(),
bins.Bins(), bins.Start(), bins.Stop());
r->SetXTitle(xlabel.c_str());
r->SetYTitle(ylabel.c_str());
return r;
}
TH2D *HistogramFactory::makeTH2D(const string &title,
const string &xlabel,
const string &ylabel,
const BinSettings &xbins,
const BinSettings &ybins,
const string &name) const
{
auto h = make<TH2D>(GetNextHistName(name).c_str(), MakeTitle(title).c_str(),
xbins.Bins(), xbins.Start(), xbins.Stop(),
ybins.Bins(), ybins.Start(), ybins.Stop());
h->SetXTitle(xlabel.c_str());
h->SetYTitle(ylabel.c_str());
return h;
}
TH3D *HistogramFactory::makeTH3D(const string &title,
const string &xlabel,
const string &ylabel,
const string &zlabel,
const BinSettings &xbins,
const BinSettings &ybins,
const BinSettings &zbins,
const string &name) const
{
auto h = make<TH3D>(GetNextHistName(name).c_str(), MakeTitle(title).c_str(),
xbins.Bins(), xbins.Start(), xbins.Stop(),
ybins.Bins(), ybins.Start(), ybins.Stop(),
zbins.Bins(), zbins.Start(), zbins.Stop());
h->SetXTitle(xlabel.c_str());
h->SetYTitle(ylabel.c_str());
h->SetZTitle(zlabel.c_str());
return h;
}
TTree*HistogramFactory::makeTTree(const string& name)
{
TTree* t = make<TTree>(name.c_str(), MakeTitle(name.c_str()).c_str());
return t;
}
HistogramFactory::DirStackPush::DirStackPush(): dir(gDirectory)
{}
HistogramFactory::DirStackPush::~DirStackPush()
{
dir->cd();
}
|
#include "Fixed.hpp"
Fixed::Fixed(void) {
std::cout << "Default constructor called" << std::endl;
this->_fpValue = 0;
return;
}
Fixed::~Fixed(void) {
std::cout << "Destructor called" << std::endl;
return;
}
Fixed::Fixed(Fixed& cop) {
std::cout << "Copy constructor called" << std::endl;
*this = cop;
}
int Fixed::getRawBits() const {
std::cout << "Get raw bits function called" << std::endl;
return this->_fpValue;
}
Fixed & Fixed::operator=(Fixed const & rhs) {
std::cout << "Assignation operator called" << std::endl;
if (this != &rhs)
this->_fpValue = rhs.getRawBits();
return *this;
}
void Fixed::setRawBits(int const raw) {
this->_fpValue = raw;
}
const int Fixed::_bits = 8;
|
//
// main.cpp
// hw6
//
// Created by Christopher Chandler on 3/21/16.
// Copyright © 2016 Christopher Chandler. All rights reserved.
//
#include <iostream>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream> // string streams
#include <stdlib.h> /* atoi */
using namespace std;
//std::vector<std::vector<bool>> make_vector(int rows, int cols){
// std::vector<std::vector<bool>> game;
//}
int main(int argc, const char * argv[]) {
// Open and test the input file.
ifstream istr(argv[1]);
if (!istr) {
cerr << "Could not open " << argv[1] << " to read\n";
return 1;
}
// Open and test the output file.
ofstream ostr(argv[2]);
if (!ostr) {
cerr << "Could not open " << argv[2] << " to write\n";
return 1;
}
// data processing
int row; // the number of rows in the board
int col; // the number of columns in the board
string str;
vector<string> ships;
vector<int> num_in_row;
vector<int> num_in_col;
vector<string> process;
while(istr >> str){
process.push_back(str);
}
bool checked_rows = false;
bool checked_cols = false;
for(int i = 0; i < process.size(); i++){
cout << process[i] << endl;
if(process[i] == "rows"){
checked_rows = true;
}
if(process[i] == "cols"){
checked_cols = true;
}
if(process[i] == "cols" && checked_rows == true){
checked_rows = false;
}
if(process[i] == "board"){
row = stoi(process[i+1]);
col = stoi(process[i+2]);
}
cout << process[i] << endl;
if ( checked_rows == true && checked_cols == false){
num_in_row.push_back(stoi(process[i+1]));
}
}
// for(int i =0; i < ships.size(); ++i){
// cout << "ships: "<<ships[i] << endl;
// }
for(int i =0; i < num_in_row.size(); ++i){
cout <<"num in rows: "<< num_in_row[i];
}
// insert code here...
//make a 2d vector that is a temporary holder vector filled with
//false booleans that represent water
//information given: board sizes, how many things are in each row,
//how many things are in each colum
//go through temporary vector created that has size row and column
//cross reference rows and columns
//if you are in the row specified and that number of things in row
//is greater than 0, loop through the column at that row
//and add to that row, column index a true boolean
//then pass in the vector to board class to change these values to ship types
//make a test to pass in a vector to the board class that couts a solution
return 0;
//make a board class
//contains rows and columns vector
//make a ship class
}
|
/*
Copyright (c) 2005-2023, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the University of Oxford 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.
*/
#ifndef CELLDIVISIONLOCATIONSWRITER_HPP_
#define CELLDIVISIONLOCATIONSWRITER_HPP_
#include <boost/serialization/base_object.hpp>
#include "AbstractCellPopulationEventWriter.hpp"
#include "ChasteSerialization.hpp"
/**
* A writer class to output the time, locations and cell id info of cell divisions to a file.
*
* The output file is called divisions.dat by default.
*/
template <unsigned ELEMENT_DIM, unsigned SPACE_DIM>
class CellDivisionLocationsWriter : public AbstractCellPopulationEventWriter<ELEMENT_DIM, SPACE_DIM>
{
private:
/** Needed for serialization. */
friend class boost::serialization::access;
/**
* Serialize the object and its member variables.
*
* @param archive the archive
* @param version the current version of this class
*/
template <class Archive>
void serialize(Archive& archive, const unsigned int version)
{
archive& boost::serialization::base_object<AbstractCellPopulationEventWriter<ELEMENT_DIM, SPACE_DIM> >(*this);
}
public:
/**
* Default constructor.
*/
CellDivisionLocationsWriter();
/**
* Visit the population and write the data.
*
* Outputs [num divisions] lines of tab-separated values of the form:
* [Div time 0] [Div 0 x-pos] [Div 0 y-pos] [Div 0 z-pos] [Parent 0 Age] [Parent 0 ID] [Child 0 ID]
* [Div time 1] [Div 1 x-pos] ...
*
* where [num divisions] denotes the number of Divisions since the previous output step
* with other imformation about each division event.
*
* This line is appended to the output written by AbstractCellBasedEventWriter, which is nothing.
*
* @param pCellPopulation a pointer to the population to visit.
*/
void VisitAnyPopulation(AbstractCellPopulation<SPACE_DIM, SPACE_DIM>* pCellPopulation);
/**
* Visit the population and write the data.
*
* Just passes through to VisitAnyPopulation
*
* @param pCellPopulation a pointer to the MeshBasedCellPopulation to visit.
*/
virtual void Visit(MeshBasedCellPopulation<ELEMENT_DIM, SPACE_DIM>* pCellPopulation);
/**
* Visit the population and write the data.
*
* Just passes through to VisitAnyPopulation
*
* @param pCellPopulation a pointer to the CaBasedCellPopulation to visit.
*/
virtual void Visit(CaBasedCellPopulation<SPACE_DIM>* pCellPopulation);
/**
* Visit the population and write the data.
*
* Just passes through to VisitAnyPopulation
*
* @param pCellPopulation a pointer to the NodeBasedCellPopulation to visit.
*/
virtual void Visit(NodeBasedCellPopulation<SPACE_DIM>* pCellPopulation);
/**
* Visit the population and write the data.
*
* Just passes through to VisitAnyPopulation
*
* @param pCellPopulation a pointer to the PottsBasedCellPopulation to visit.
*/
virtual void Visit(PottsBasedCellPopulation<SPACE_DIM>* pCellPopulation);
/**
* Visit the population and write the data.
*
* Just passes through to VisitAnyPopulation
*
* @param pCellPopulation a pointer to the VertexBasedCellPopulation to visit.
*/
virtual void Visit(VertexBasedCellPopulation<SPACE_DIM>* pCellPopulation);
};
#include "SerializationExportWrapper.hpp"
// Declare identifier for the serializer
EXPORT_TEMPLATE_CLASS_ALL_DIMS(CellDivisionLocationsWriter)
#endif /* CELLDIVISIONLOCATIONSWRITER_HPP_ */
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include<cmath>
using namespace std;
/* 对比计算二叉树的深度 */
class Solution {
public:
int helper(TreeNode* r){
if(r == NULL) return 0;
int left = helper(r->left);
int right = helper(r->right);
if(left == -1 || right == -1) return -1;
if(abs(left-right) > 1) return -1;
return max(left, right)+1;
}
bool IsBalanced_Solution(TreeNode* root) {
if(root == NULL) return true;
return helper(root) != -1;
}
};
int main(){
return 0;
}
|
#include "Spool.h"
#include "Bullet.h"
void ABullet::OnProjectileHit(class AActor * OtherActor, UPrimitiveComponent * OtherComp, FVector NormalImpulse, const FHitResult & Hit)
{
if (Hit.GetActor())
{
FDamageEvent DamageEvent;
Hit.Actor->TakeDamage(BaseDamage, DamageEvent, GetInstigatorController(), this);
}
Destroy();
}
|
#include "sound.h"
SoundSystem::SoundSystem()
{
m_DirectSound = NULL;
m_PrimaryBuffer = NULL;
m_SecondaryBuffer1 = NULL;
}
SoundSystem::SoundSystem(const SoundSystem& other)
{
}
SoundSystem::~SoundSystem()
{
}
bool SoundSystem::Initialize(HWND window)
{
bool result = InitializeDirectSound(window);
if (!result) return false;
//char *testWaveFile = (char*)"data/air_raid.wav";
//result = LoadWaveFile(testWaveFile, &m_SecondaryBuffer1);
//if (!result) return false;
//result = PlayWaveFile();
//if (!result) return false;
return true;
}
void SoundSystem::Shutdown()
{
ShutdownWaveFile(&m_SecondaryBuffer1);
ShutdownDirectSound();
}
bool SoundSystem::InitializeDirectSound(HWND window)
{
if (FAILED(DirectSoundCreate8(NULL, &m_DirectSound, NULL))) return false;
if (FAILED(m_DirectSound->SetCooperativeLevel(window, DSSCL_PRIORITY))) return false;
DSBUFFERDESC bufferDesc = {};
bufferDesc.dwSize = sizeof(DSBUFFERDESC);
bufferDesc.dwFlags = DSBCAPS_PRIMARYBUFFER | DSBCAPS_CTRLVOLUME;
bufferDesc.dwBufferBytes = 0;
bufferDesc.dwReserved = 0;
bufferDesc.lpwfxFormat = NULL;
bufferDesc.guid3DAlgorithm = GUID_NULL;
if (FAILED(m_DirectSound->CreateSoundBuffer(&bufferDesc, &m_PrimaryBuffer, NULL))) return false;
WAVEFORMATEX waveFormat = {};
waveFormat.wFormatTag = WAVE_FORMAT_PCM;
waveFormat.nSamplesPerSec = 44100;
waveFormat.wBitsPerSample = 16;
waveFormat.nChannels = 2;
waveFormat.nBlockAlign = (waveFormat.wBitsPerSample / 8) * waveFormat.nChannels;
waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
waveFormat.cbSize = 0;
if (FAILED(m_PrimaryBuffer->SetFormat(&waveFormat))) return false;
return true;
}
void SoundSystem::ShutdownDirectSound()
{
if (m_PrimaryBuffer)
{
m_PrimaryBuffer->Release();
m_PrimaryBuffer = NULL;
}
if (m_DirectSound)
{
m_DirectSound->Release();
m_DirectSound = NULL;
}
}
bool SoundSystem::LoadWaveFile(char *filename, IDirectSoundBuffer8** secondaryBuffer)
{
FILE* filePtr;
int error = fopen_s(&filePtr, filename, "rb");
if (error != 0) return false;
WaveHeaderType waveFileHeader;
size_t count = fread(&waveFileHeader, sizeof(waveFileHeader), 1, filePtr);
if (count != 1) return false;
if ((waveFileHeader.chunkId[0] != 'R')
|| (waveFileHeader.chunkId[1] != 'I')
|| (waveFileHeader.chunkId[2] != 'F')
|| (waveFileHeader.chunkId[3] != 'F'))
return false;
if ((waveFileHeader.format[0] != 'W')
|| (waveFileHeader.format[1] != 'A')
|| (waveFileHeader.format[2] != 'V')
|| (waveFileHeader.format[3] != 'E'))
return false;
if ((waveFileHeader.subChunkId[0] != 'f')
|| (waveFileHeader.subChunkId[1] != 'm')
|| (waveFileHeader.subChunkId[2] != 't')
|| (waveFileHeader.subChunkId[3] != ' '))
return false;
if ((waveFileHeader.dataChunkId[0] != 'd') || (waveFileHeader.dataChunkId[1] != 'a') ||
(waveFileHeader.dataChunkId[2] != 't') || (waveFileHeader.dataChunkId[3] != 'a'))
return false;
WAVEFORMATEX waveFormat = {};
waveFormat.wFormatTag = waveFileHeader.audioFormat;
waveFormat.nSamplesPerSec = waveFileHeader.sampleRate;
waveFormat.wBitsPerSample = waveFileHeader.bitsPerSample;
waveFormat.nChannels = waveFileHeader.numChannels;
waveFormat.nBlockAlign = (waveFormat.wBitsPerSample / 8) * waveFormat.nChannels;
waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
waveFormat.cbSize = 0;
DSBUFFERDESC bufferDesc;
bufferDesc.dwSize = sizeof(DSBUFFERDESC);
bufferDesc.dwFlags = DSBCAPS_CTRLVOLUME;
bufferDesc.dwBufferBytes = waveFileHeader.dataSize;
bufferDesc.dwReserved = 0;
bufferDesc.lpwfxFormat = &waveFormat;
bufferDesc.guid3DAlgorithm = GUID_NULL;
IDirectSoundBuffer* tempBuffer;
if (FAILED(m_DirectSound->CreateSoundBuffer(&bufferDesc, &tempBuffer, NULL)))
return false;
if (FAILED(tempBuffer->QueryInterface(IID_IDirectSoundBuffer8, (void**)&*secondaryBuffer)))
return false;
tempBuffer->Release();
tempBuffer = NULL;
fseek(filePtr, sizeof(WaveHeaderType), SEEK_SET);
unsigned char* waveData = new unsigned char[waveFileHeader.dataSize];
if (!waveData) return false;
count = fread(waveData, 1, waveFileHeader.dataSize, filePtr);
if (count != waveFileHeader.dataSize) return false;
if (fclose(filePtr) != 0) return false;
unsigned char *bufferPtr;
unsigned long bufferSize;
if (FAILED((*secondaryBuffer)->Lock(0, waveFileHeader.dataSize, (void**)&bufferPtr, (DWORD*)&bufferSize, NULL, 0, 0)))
return false;
memcpy(bufferPtr, waveData, waveFileHeader.dataSize);
if (FAILED((*secondaryBuffer)->Unlock((void*)bufferPtr, bufferSize, NULL, 0)))
return false;
delete[] waveData;
waveData = NULL;
return true;
}
void SoundSystem::ShutdownWaveFile(IDirectSoundBuffer8** secondaryBuffer)
{
if (*secondaryBuffer)
{
(*secondaryBuffer)->Release();
*secondaryBuffer = NULL;
}
}
bool SoundSystem::PlayWaveFile()
{
if (FAILED(m_SecondaryBuffer1->SetCurrentPosition(0)))
return false;
if (FAILED(m_SecondaryBuffer1->SetVolume(DSBVOLUME_MAX)))
return false;
if (FAILED(m_SecondaryBuffer1->Play(0, 0, 0)))
return false;
return true;
}
|
#include <gtest/gtest.h>
#include <ostream>
#include <istream>
#include <sstream>
#include <vector>
#include <elements/element.h>
#include <elements/simple_text_element.h>
TEST(sample_test_case, sample_test)
{
EXPECT_EQ(1, 1);
}
TEST(simple_text_element, can_add_tags)
{
const std::vector<core::UID> tag_ids {
core::UID::generateRandom(),
core::UID::generateRandom(),
core::UID::generateRandom(),
core::UID::generateRandom()
};
const core::UID id = core::UID::generateRandom();
SimpleTextElement e1(id);
EXPECT_FALSE(e1.hasTagID(tag_ids[0]));
e1.addTagID(tag_ids[0]);
EXPECT_TRUE(e1.hasTagID(tag_ids[0]));
EXPECT_FALSE(e1.hasTagID(tag_ids[1]));
e1.addTagID(tag_ids[1]);
EXPECT_TRUE(e1.hasTagID(tag_ids[1]));
EXPECT_FALSE(e1.hasTagID(tag_ids[2]));
e1.addTagID(tag_ids[2]);
EXPECT_TRUE(e1.hasTagID(tag_ids[2]));
e1.removeTagID(tag_ids[1]);
EXPECT_FALSE(e1.hasTagID(tag_ids[1]));
EXPECT_TRUE(e1.hasTagID(tag_ids[0]));
EXPECT_TRUE(e1.hasTagID(tag_ids[2]));
}
TEST(simple_text_element, can_serialize_deserialize)
{
const core::UID id = core::UID::generateRandom();
const std::string test_text = "hola!";
const std::vector<core::UID> tag_ids {
core::UID::generateRandom(),
core::UID::generateRandom(),
core::UID::generateRandom(),
core::UID::generateRandom()
};
SimpleTextElement e1(id);
e1.setText(test_text);
for (auto& uid : tag_ids) {
e1.addTagID(uid);
}
std::stringstream ss;
EXPECT_TRUE(e1.serialize(ss));
SimpleTextElement e2, e3;
EXPECT_TRUE(e2.deserialize(ss));
EXPECT_EQ(e1, e2);
EXPECT_EQ(test_text, e2.text());
EXPECT_EQ(id, e2.id());
for (auto& uid : tag_ids) {
EXPECT_TRUE(e2.hasTagID(uid));
}
}
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
|
#include <limits.h>
#include <iostream>
#include <ctime>
#include "data_region_2d_bare_base.h"
#include "gtest/gtest.h"
using namespace std;
const int kRowCount = 32;
const int kColCount = 1024*1024;
const int kRepetition = 10;
void Setup2DArray(DataRegion2DBareBase<float> ®ion2d_obj){
for(int i=0; i<kRowCount; i++)
for(int j=0; j<kColCount; j++)
region2d_obj[i][j] = (i*kColCount)+j;
}
TEST(DataRegion2DTest, Create){
clock_t begin = clock();
/* Initiate local 2d array */
float **array2d = new float* [kRowCount];
for(int i=0; i<kRowCount; i++){
array2d[i] = new float[kColCount];
}
clock_t orig_alloc_clk = clock() - begin;
begin = clock();
unique_ptr<DataRegion2DBareBase<float>> region_p(new DataRegion2DBareBase<float>(kRowCount, kColCount));
clock_t my_alloc_clk = clock() - begin;
auto ®ion2d = *region_p;
ASSERT_EQ(region2d.size(), kRowCount*kColCount*sizeof(float)) <<
"Size of 2d region data and original differ";
for(int i=0; i<kRowCount; i++){
delete [] array2d[i];
}
delete [] array2d;
std::cout << "Orig. 2D array allocation time: " << orig_alloc_clk << std::endl;
std::cout << "2D data region allocation time: " << my_alloc_clk << std::endl;
}
TEST(DataRegion2DTest, AccessorsMutators){
unique_ptr<DataRegion2DBareBase<float>> region_p(new DataRegion2DBareBase<float>(kRowCount, kColCount));
auto ®ion2d_obj = *region_p;
Setup2DArray(region2d_obj);
ASSERT_EQ(region2d_obj.num_rows(), kRowCount);
ASSERT_EQ(region2d_obj.num_cols(), kColCount);
ASSERT_EQ(region2d_obj.count(), kRowCount*kColCount);
ASSERT_EQ(region2d_obj.item(0, kColCount-1), kColCount-1);
ASSERT_EQ(region2d_obj.item(0, 0), 0);
float val = 13.;
region2d_obj.item(0, 0, val);
ASSERT_EQ(region2d_obj[0][0], val);
val = 14.;
region2d_obj.item(1, 1, val);
ASSERT_EQ(region2d_obj[1][1], val);
}
TEST(DataRegion2DTest, Destructor){
unique_ptr<DataRegion2DBareBase<float>> region_p(new DataRegion2DBareBase<float>(kRowCount, kColCount));
auto ®ion2d_obj = *region_p;
Setup2DArray(region2d_obj);
DataRegion2DBareBase<float> copy_reg(kRowCount, kColCount);
}
TEST(DataRegion2DTest, Copy){
unique_ptr<DataRegion2DBareBase<float>> region_p(new DataRegion2DBareBase<float>(kRowCount, kColCount));
auto ®ion2d_obj = *region_p;
Setup2DArray(region2d_obj);
auto dr = new DataRegion2DBareBase<float>(kRowCount-1, kColCount);
ASSERT_THROW(region2d_obj.copy(*dr), std::out_of_range);
delete dr;
dr = new DataRegion2DBareBase<float>(kRowCount, kColCount-1);
ASSERT_THROW(region2d_obj.copy(*dr), std::out_of_range);
delete dr;
dr = new DataRegion2DBareBase<float>(kRowCount-1, kColCount-1);
ASSERT_THROW(region2d_obj.copy(*dr), std::out_of_range);
delete dr;
/* Copy function */
DataRegion2DBareBase<float> copy_reg(kRowCount, kColCount);
region2d_obj.copy(copy_reg);
for(size_t i=0; i<region2d_obj.num_rows(); i++)
for(size_t j=0; j<region2d_obj.num_cols(); j++)
ASSERT_EQ(region2d_obj[i][j], copy_reg[i][j]);
/* Copy assignment */
for(size_t i=0; i<region2d_obj.num_rows(); i++)
for(size_t j=0; j<region2d_obj.num_cols(); j++){
region2d_obj[i][j] = 0.5;
ASSERT_NE(region2d_obj[i][j], copy_reg[i][j]);
}
copy_reg = region2d_obj;
for(size_t i=0; i<region2d_obj.num_rows(); i++)
for(size_t j=0; j<region2d_obj.num_cols(); j++)
ASSERT_EQ(region2d_obj[i][j], copy_reg[i][j]);
/* Copy constructor */
DataRegion2DBareBase<float> copy_reg1(region2d_obj);
for(size_t i=0; i<region2d_obj.num_rows(); i++)
for(size_t j=0; j<region2d_obj.num_cols(); j++)
ASSERT_EQ(region2d_obj[i][j], copy_reg1[i][j]);
}
TEST(DataRegion2DTest, WriteReadTest){
unique_ptr<DataRegion2DBareBase<float>> region_p(new DataRegion2DBareBase<float>(kRowCount, kColCount));
auto ®ion2d_obj = *region_p;
Setup2DArray(region2d_obj);
/* Initiate local 2d array */
float **array2d = new float* [kRowCount];
for(int i=0; i<kRowCount; i++)
array2d[i] = new float[kColCount];
clock_t begin = clock();
for(int r=0; r<kRepetition; r++)
for(int i=0; i<kRowCount; i++)
for(int j=0; j<kColCount; j++)
array2d[i][j] = 2*i+j;
clock_t orig_write_clk = clock() - begin;
float sum_o =0.0;
begin = clock();
for(int r=0; r<kRepetition; r++)
for(int i=0; i<kRowCount; i++)
for(int j=1; j<kColCount; j++)
sum_o += array2d[i][j]+array2d[i][j-1];
clock_t orig_read_clk = clock() - begin;
std::cout << "2D array avg. write time: " << 1.*orig_write_clk/kRepetition << std::endl;
std::cout << "2D array avg. read time: " << 1.*orig_read_clk/kRepetition << std::endl;
float sum_m =0.0;
begin = clock();
for(int r=0; r<kRepetition; r++)
for(size_t i=0; i<kRowCount; i++)
for(size_t j=0; j<kColCount; j++)
region2d_obj[i][j] = 2*i+j;
clock_t my_write_clk = clock() - begin;
begin = clock();
for(int r=0; r<kRepetition; r++)
for(size_t i=0; i<kRowCount; i++)
for(size_t j=1; j<kColCount; j++)
sum_m += region2d_obj[i][j]+region2d_obj[i][j-1];
clock_t my_read_clk = clock() - begin;
ASSERT_EQ(sum_o, sum_m);
std::cout << "2D region avg. write time: " << 1.*my_write_clk/kRepetition << std::endl;
std::cout << "2D region avg. read time: " << 1.*my_read_clk/kRepetition << std::endl;
sum_m=0.0;
begin = clock();
for(int r=0; r<kRepetition; r++)
for(size_t i=0; i<kRowCount; i++)
for(size_t j=1; j<kColCount; j++)
sum_m += region2d_obj.item(i, j) + region2d_obj.item(i, j-1);
clock_t my_read_func_clk = clock() - begin;
ASSERT_EQ(sum_m, sum_o);
sum_m=0.0;
for(int i=0; i<kRowCount; i++)
for(int j=0; j<kColCount; j++)
region2d_obj[i][j] = (i*kColCount)+j;
for(size_t i=0; i<kRowCount; i++)
for(size_t j=0; j<kColCount; j++)
sum_m += region2d_obj[i][j];
float tot = (1.*kRowCount*kColCount)*((kRowCount*kColCount)-1)/2.0;
ASSERT_EQ(sum_m, tot);
for(int i=0; i<kRowCount; i++)
delete array2d[i];
delete array2d;
std::cout << "2D region avg. read time using func.: " << 1.*my_read_func_clk/kRepetition << std::endl;
}
|
//Jason Strange
//CS222-01-13W
//This is the header file for my node object.
#ifndef _NODE_
#define _NODE_
#include <string>
#include <cstdio>
#include <cstdlib>
#include "Comparable.h"
#include "Item.h"
#include "DRT.h"
#include "TitleKey.h"
#include "TitleData.h"
#include "BinaryDataBase.h"
using namespace std;
class BinaryDataBase;
class Comparable;
class Item;
class DRT;
class Node{
private:
BinaryDataBase* tree;
Node* left;
Node* right;
Node* parent;
bool redOrBlack;//True if black, false if red.
Comparable* key;
Item* data;
public:
Node(BinaryDataBase* t, Comparable* k, Item* d, Node* p);
//red/black set and get:
bool isBlack();
void setColor(bool color);
//Sets/gets:
Node* getLeft();
Node* getRight();
Node* getParent();
Comparable* getKey();
Item* getData();
void setLeft(Node* l);
void setRight(Node* r);
void setParent(Node* p);
void setKey(Comparable* k);
void setData(Item* d);
//Utility functions:
DRT* returnDRT();
int Node::isValid();
bool getColor(Node* n);
Node* getSibling (Node *n, Node *p);
Node* getDirect();
bool isDirect();
void rotateUp();
Node* findNode(Comparable* k);
void addNewNode(Comparable* k, Item* d);
void delNode(Node* n);
void ruleFourOn(Node* x, Node* p);
bool bothChildrenBlack(Node* l, Node* r);
Comparable* getNext();
Comparable* getPrev();
//Helper functions:
void addNode(Node* n);
void addProcess(Node* x);
void delSelf();
Node* getLeftDecendent();
Node* getRightDecendent();
void print();
int count();
};
#endif
|
#include <bits/stdc++.h>
#define MAX 1000001
#define M 1000000007
#define ll long long
#define ld long double
#define ESP 0.0001
using namespace std;
int main() {
int t;
cin >> t;
while(t--) {
int n, k;
cin >> n >> k;
int a[n];
for (int i=0;i<n;i++) cin >> a[i];
sort(a, a+n);
int mn = INT_MAX;
for (int i=0;i<=n-k;i++) {
mn = min(mn, a[i+k-1]-a[i]);
}
cout << mn << endl;
}
return 0;
}
|
#include "config.h"
#include "src/Common/debug.h"
#include "src/Common/config.h"
#include "src/Common/rtc.h"
#include "src/Common/radio_common.h"
#include "src/Common/accel.h"
#include "src/Common/rom.h"
#include "src/Common/command.h"
#include "src/Common/battery.h"
#include <SimbleeCOM.h>
#include "src/Common/Wire/Wire.h"
#include "shoe_rom.h"
// TODO: If after 4pm, set an alarm for the next morning at 9am and sleep until then
// Use RTC alarm to wake up at the beginning of START_HOUR:START_MINUTE
// Lesson tracker & region tracker may be able to get away without storing any data
// Boolean on whether to collect data
volatile bool collectData;
volatile bool afterSchool;
volatile uint8_t lastCollectionPeriod = 0;
bool longSleep = false;
// Used to track a mode where we avoid sleep so we can hear
// requests for additional page downloads.
volatile unsigned long lastDownloadRequest = 0;
// BOARD_TYPE_STUDENT_SENSOR
// BOARD_TYPE_LESSON_TRACKER
// BOARD_TYPE_REGION_TRACKER
extern BoardType boardType = BOARD_TYPE_STUDENT_SENSOR;
void setup()
{
pinMode(RTC_INTERRUPT_PIN, INPUT_PULLUP);
SimbleeCOM.txPowerLevel = TX_POWER_LEVEL;
// nRF provides an internal source of randomness
RandomSeed();
// Set I2C to 400KHz
Wire.speed = 400;
Wire.beginOnPins(14, 13);
Serial.begin(BAUD_RATE);
romManager = new PrNetRomManager();
delay(200);
Serial.print(" Sensei ");
switch (boardType) {
case BOARD_TYPE_STUDENT_SENSOR:
Serial.print("StudentSensor");
break;
case BOARD_TYPE_LESSON_TRACKER:
Serial.print("LessonTracker");
break;
case BOARD_TYPE_REGION_TRACKER:
Serial.print("RegionTracker");
break;
}
Serial.println(" shoe firmware v0.1");
if (romManager->config.deviceID == 0x00) {
Serial.println("DEVICE ID NOT SET, WAITING");
while (romManager->config.deviceID == 0x00) {
delay(5);
InterpretCommand();
}
} else {
Serial.print("Sensor ID: ");
PrintHexByte(romManager->config.deviceID);
Serial.println("");
}
// Put a mark in ROM (TODO: do we care?)
resetROM();
// Clear rtc alarm
DS3231_clear_a1f();
// Run a small window where we accept commands, to change id, etc.
long start = millis();
while (millis() - start < 3000) {
delay(5);
InterpretCommand();
}
// See if the RTC has the time
synchronizeTime();
// If the timer doesn't have the time, this is a hard reset. Don't do anything after powerup until we receive a time.
// Sleeps an odd number of MS to ensure time will be picked up after a few cycles
if (!timer.isTimeSet) {
d("Waiting for time");
startRadioListening();
while (!timer.isTimeSet) {
delay(5);
InterpretCommand();
// Don't try to sleep if the deviceID isn't set
// (going to sleep may mess up the serial console; fresh devices need console access to set the ID)
if (romManager->config.deviceID != 0x00) {
delay(600); // TODO may want to loop InterpretCommand during this
Simblee_ULPDelay(MILLISECONDS(800));
}
}
stopRadioListening();
}
d("Time set.");
if (boardType != BOARD_TYPE_REGION_TRACKER) {
setupAccelerometer();
}
#ifndef DEBUG
Serial.end();
#endif
EnableRTCInterrupt();
Simblee_pinWakeCallback(RTC_INTERRUPT_PIN, HIGH, RTC_Interrupt);
}
void SendPing()
{
char payload[] = {RADIO_PROX_PING, romManager->config.deviceID};
bool success = false;
while (!success) {
success = SimbleeCOM.send(payload, sizeof(payload));
}
}
void SendDeviceStatus()
{
// Currently, only the student tracker hardware is capable of performing battery measurements
uint8_t bat = 0;
if (boardType == BOARD_TYPE_STUDENT_SENSOR) {
bat = get_battery_adc();
d("Battery level = " + String(bat));
}
uint8_t numPages = STORAGE_FLASH_PAGE - romManager->config.pageCounter + 1; // total page count
char payload[] = {RADIO_DEVICE_STATUS, romManager->config.deviceID, bat, numPages, boardType, timer.t.day, timer.t.hours, longSleep ? 1 : 0};
bool success = false;
while (!success) {
success = SimbleeCOM.send(payload, sizeof(payload));
}
}
void SendBatteryLevel()
{
// Currently, only the student tracker hardware is capable of performing battery measurements
if (boardType != BOARD_TYPE_STUDENT_SENSOR) {
return;
}
uint8_t bat = get_battery_adc();
d("Battery level = " + String(bat));
char payload[] = {RADIO_RESPONSE_BATTERY, romManager->config.deviceID, bat};
bool success = false;
while (!success) {
success = SimbleeCOM.send(payload, sizeof(payload));
}
}
void SleepUntilNine()
{
d("Going to sleep");
longSleep = true;
SetAlarmAtNine();
Simblee_resetPinWake(RTC_INTERRUPT_PIN);
// GH: I suspect this call lets go of the RTC_INTERRUPT_PIN pullup; we would need an external pullup to use it
//Simblee_systemOff();
// Simblee_ULPDelay(INFINITE) dies and never wakes up
Simblee_ULPDelay(SECONDS(5));
}
void loop()
{
uint8_t random_transmit_offset;
bool inPostDownloadListenWindow = (millis() - lastDownloadRequest) < 5000;
// Even in longSleep we listen, but it's for a tiny window once a minute
bool shouldListen = collectData || afterSchool || inPostDownloadListenWindow || longSleep;
if (shouldListen) {
startRadioListening();
}
if (collectData) {
collectData = false;
d("Collect");
synchronizeTime();
if (boardType == BOARD_TYPE_STUDENT_SENSOR) {
enableAccelerometer();
delay(10);
readAcc();
disableAccelerometer();
}
random_transmit_offset = random(MS_SEND_DELAY_MIN, MS_SEND_DELAY_MAX);
delay(random_transmit_offset);
SendPing();
delay(MS_TO_COLLECT - random_transmit_offset);
writeData();
d("Collected");
} else if (afterSchool) {
afterSchool = false;
random_transmit_offset = random(MS_SEND_DELAY_MIN, MS_SEND_DELAY_MAX);
delay(random_transmit_offset);
SendDeviceStatus();
delay(MS_TO_COLLECT - random_transmit_offset);
d("End of day mode.");
} else if (longSleep) {
// Looping once a minute during longSleep
synchronizeTime();
if (timer.inDataCollectionPeriod(START_HOUR, START_MINUTE, END_HOUR, END_MINUTE)) {
// Waking up from a night long sleep
d("It's a new day");
// Give up on any old data from yesterday.
remoteEraseROM();
// Time to start collecting data
longSleep = false;
EnableRTCInterrupt();
return;
} else {
d("Still night");
SendDeviceStatus();
delay(50); // We listen for 50 ms each minute during night sleep
stopRadioListening();
// it's possible that we've been woken; skip the sleep if so.
if (longSleep) {
Simblee_ULPDelay(MINUTES(1));
}
return;
}
}
dn("_");
#ifdef DEBUG
Serial.flush();
#endif
if (!inPostDownloadListenWindow) {
stopRadioListening();
Simblee_ULPDelay(MILLISECONDS(100));
}
}
int RTC_Interrupt(uint32_t ulPin)
{
Simblee_resetPinWake(ulPin);
timer.NextSecond();
if (longSleep) {
return 0;
}
// Collect data every few seconds if we're in the data collection period
if (timer.t.seconds % 10 == 0 && timer.t.seconds != lastCollectionPeriod ) {
if (timer.inDataCollectionPeriod(START_HOUR, START_MINUTE, END_HOUR, END_MINUTE)) {
lastCollectionPeriod = timer.t.seconds;
collectData = true;
dn("." + String(timer.t.seconds));
} else if (timer.afterSchool(END_HOUR, END_MINUTE)) {
afterSchool = true;
dn("x");
} else {
// Past midnight, or weekend, should be sleeping
SleepUntilNine();
}
} else {
dn("-");
}
return 0;
}
void SimbleeCOM_onReceive(unsigned int esn, const char *payload, int len, int rssi)
{
// dn("Msg ");
// dn(len);
// dn(" ");
// dn(esn);
// dn("(");
// dn(rssi);
// dn(") ");
// for (int i = 0; i < len; i++)
// PrintByteDebug(payload[i]);
// d("");
if (len < 2) {
dn("Invalid payload");
dn(esn);
dn("(");
dn(rssi);
dn(") ");
for (int i = 0; i < len; i++)
PrintByteDebug(payload[i]);
d("");
return;
}
// The only 15B long messages are RADIO_RESPONSE_ROWS messages, which we should ignore
if (len == 15) {
d("Ignoring 15B message");
return;
}
uint8_t command = payload[0];
uint8_t id = payload[1];
bool id_match = (id == romManager->config.deviceID);
// Over the air protocol, bytes:
// 0: Command
// 1: Device ID, if applicable
// n: Data
switch (command) {
case RADIO_PROX_PING:
// Proximity beacon
// Recording RSSI data
dn("Device online: ");
PrintByteDebug(id);
dn(" RSSI ");
dn(rssi);
// TODO: Move data collection period out to a flag
if (timer.inDataCollectionPeriod(START_HOUR, START_MINUTE, END_HOUR, END_MINUTE)) {
rssiTotal[id] += rssi;
rssiCount[id]++;
newData = true;
}
break;
case RADIO_SHARED_TIME:
// Time sharing
d("Time received");
noInterrupts();
//delay(450);
setRTCTime((int)payload[1], (int)payload[2], (int)payload[3], (int)payload[4], (int)payload[5], (int)payload[6], (int)payload[7]);
timer.secondsElapsed = 1;
synchronizeTime();
interrupts();
d("Done");
break;
case RADIO_REQUEST_PAGEINFO:
if (!id_match) {
return;
}
sendPageInfo();
break;
case RADIO_REQUEST_SINGLE_PAGE:
if (!id_match) {
return;
}
lastDownloadRequest = millis();
sendROMPage(payload[2]);
break;
case RADIO_REQUEST_COMPRESSED:
dn("Compressed data transfer");
PrintByteDebug(id);
if (!id_match) {
return;
}
lastDownloadRequest = millis();
sendROM_heatshrink();
break;
case RADIO_REQUEST_PARTIAL:
if (!id_match) {
return;
}
//transferPage = (uint8_t)payload[1];
//transferRow = (uint8_t)payload[2];
//transferRowsLeft = (uint8_t) payload[3];
// length
lastDownloadRequest = millis();
sendROMPage((uint8_t)payload[1]);
break;
case RADIO_REQUEST_ERASE:
if (!id_match) {
return;
}
remoteEraseROM();
break;
case RADIO_REQUEST_SLEEP_ERASE:
if (!id_match) {
return;
}
stopRadioListening();
remoteEraseROM();
SleepUntilNine();
break;
case RADIO_REQUEST_SLEEP:
if (!id_match) {
return;
}
SleepUntilNine();
break;
case RADIO_REQUEST_WAKE:
if (!id_match) {
return;
}
longSleep = false;
EnableRTCInterrupt();
break;
case RADIO_ENTER_OTA_MODE:
if (!id_match) {
return;
}
// WARNING: Simblee OTA stomps all over user flash pages
// See http://forum.rfduino.com/index.php?topic=1273.25
//
// Note: there are some reports that activity on pin 5 at boot can trigger OTA
//ota_bootloader_start();
break;
case RADIO_REQUEST_BATTERY:
if (!id_match) {
return;
}
dn("Battery level requested");
SendBatteryLevel();
break;
// Ignore other devices' responses
case RADIO_RESPONSE_ROWS:
case RADIO_RESPONSE_COMPLETE:
break;
default:
#ifdef DEBUG
dn("Invalid payload");
dn(esn);
dn("(");
dn(rssi);
dn(") ");
for (int i = 0; i < len; i++)
PrintByteDebug(payload[i]);
d("");
#endif
break;
}
}
/*
* Synchronizes the node's time with the RTC time
*/
void synchronizeTime()
{
DS3231_get(&rtcTime);
// DS3231 reset time is: 01/01/00 01 00:00:00 (DD/MM/YY DOW HH:MM:SS
if (rtcTime.year_s != 00) {
timer.setInitialTime(rtcTime.mon, rtcTime.mday, rtcTime.year_s,
rtcTime.wday, rtcTime.hour, rtcTime.min, rtcTime.sec);
#ifdef DEBUG
Serial.print("RTC Time: ");
timer.displayDateTime();
#endif
} else {
d("RTC is not set");
}
}
|
#include <iostream>
int main()
{
int n;
std::cout << "Enter a number >";
std::cin >> n;
while ( n>0 )
{
std::cout << n << ","; --n;
}
std::cout << "(FIRE!)\n";
std::cin.get();
std::cin.get();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fr(i,n) for (ll i=0;i<n;i++)
#define fr1(i,n) for(ll i=1;i<=n;i++)
bool isprime(ll n)
{
for(ll i=2; i*i<=n; i++)
{
if(n%i==0)return 0;
}
return 1;
}
int main()
{
ll m,n,i,j,k ,t;
while( cin>>n)
{
ll x, y;
x=2*n;
y=n;
if( n%2==0 and n!=2)cout<<x<<" "<<n<<endl;
else if(n==1)cout<<"10 9"<<endl;
else if(n==2)cout<<"10 8"<<endl;
else
{
// if(isprime(y))x++, y++;
while( isprime(x) or isprime(y))x++, y++;
cout<<x<<" "<<y<<endl;
}
}
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
struct data
{
string v1,v2;
int w1;
};
map<string,string>bap;
bool comp(data u,data u1)
{
return u.w1<u1.w1;
}
string bapke(string x)
{
if(bap[x]==x)return x;
return bap[x]=bapke(bap[x]);
}
int main()
{
int n,m,t;scanf("%d",&t);
for(int a=1;a<=t;a++)
{
scanf("%d %d",&n,&m);
char x[20],y[20];
ll res=0;
int w,cnt=0;
vector<data>v;
map<string,int>seen;
for(int i=0;i<m;i++)
{
scanf("%s%s%d",x,y,&w);
v.push_back({x,y,w});
if(seen[x]==0){
bap[x]=x;seen[x]=1;
}
if(seen[y]==0){
seen[y]=1;bap[y]=y;
}
}
sort(v.begin(),v.end(),comp);
for(int i=0;i<m;i++)
{
string A=bapke(v[i].v1);
string B=bapke(v[i].v2);
if(A!=B)
{
cnt++;
res+=v[i].w1;
bap[B]=A;
if(cnt==n-1)break;
}
}
printf("%lld\n",res);
seen.clear();
if(a!=t)printf("\n");
}
return 0;
}
|
// exponential search
// _ ____ __ _ _ __
// (_/_(_(_(_)(__ / (_(_/_(_(_(_/__(/_/ (_
// /( .-/ .-/
// (_) (_/ (_/
#include "../_library_search_.h"
// Độ phức tạp:
// Time: O(logn) | Memory: O(1)
// Ưu điểm:
// - Phiên bản kết hợp giữa BS và tìm khoảng chứa phần tử (k * 2)
// - Hữu dụng với loại tìm kiếm số lượng phần tử vô hạn
// Nhược điểm:
// - Cần mảng đã sắp xếp
template<class T> lli ExponentialSearch(T *arr, lli n, T target)
{
// Kiểm tra phần tử đầu tiên
if (arr[0] == target) {
return 0;
}
// Tìm khoảng chứ target theo cấp số nhân (Exponential)
lli index = 1;
while (index < n && arr[index] < target)
{
index *= 2;
}
// Bước tìm kiếm nhị phân trong đoạn chứa target
lli left = index / 2;
lli right = Min(index, n - 1);
lli mid;
do
{
mid = (left + right) / 2;
if (arr[mid] == target) {
return mid;
}
if (arr[mid] > target) {
right = mid - 1;
}
else {
left = mid + 1;
}
} while (left <= right);
return -1;
}
int main() {
lli *arr;
lli n{}, target{};
Input(arr, n, target);
target = ExponentialSearch(arr, n, target);
Output(arr, n, target);
return 0;
}
|
#ifndef FASTCG_OPENGL_TEXTURE_H
#define FASTCG_OPENGL_TEXTURE_H
#ifdef FASTCG_OPENGL
#include <FastCG/Graphics/OpenGL/OpenGL.h>
#include <FastCG/Graphics/BaseTexture.h>
namespace FastCG
{
class OpenGLGraphicsSystem;
class OpenGLTexture : public BaseTexture
{
public:
inline operator GLuint() const
{
return mTextureId;
}
OpenGLTexture(const Args &rArgs);
OpenGLTexture(const OpenGLTexture &rOther) = delete;
OpenGLTexture(const OpenGLTexture &&rOther) = delete;
virtual ~OpenGLTexture();
private:
GLuint mTextureId{~0u};
OpenGLTexture operator=(const OpenGLTexture &rOther) = delete;
friend class OpenGLGraphicsSystem;
};
}
#endif
#endif
|
//string::npos作为find函数失配后的返回值
#include<iostream>
#include<string>
using namespace std;
int main()
{
if(string::npos==-1)
cout<<"-1 is string::npos"<<endl;
if(string::npos==4294967295)//看编译器警告提示
cout<<"4294967295 is also string::npos"<<endl;
return 0;
}
|
#pragma once
#include "Ms2ScanWithSpecificMass.h"
namespace EngineLayer
{
class ScanWithIndexAndNotchInfo
{
public:
Ms2ScanWithSpecificMass *TheScan;
int Notch = 0;
int ScanIndex = 0;
virtual ~ScanWithIndexAndNotchInfo()
{
//delete TheScan;
}
ScanWithIndexAndNotchInfo(Ms2ScanWithSpecificMass *theScan, int notch, int scanIndex);
};
}
|
//
// Created by nickolay on 20.02.2021.
//
#include "Settings.h"
|
#ifndef TURTLENODEEDITOR_H
#define TURTLENODEEDITOR_H
#include <QLineEdit>
#include <QTableView>
#include <QWidget>
#include <Presenter/Elements/Nodes/TurtleNodePresenter.h>
constexpr float FU_GEN_PI = 3.14159265359;
#include <iostream>
class ProductionModel : public QAbstractTableModel
{
Q_OBJECT
//
signals:
//
void editCompleted(const QString &);
//
private:
//
TurtleNodePresenter &Turtle;
//
std::vector<char> IndexingArray;
//
void RefreshIndexingArray()
{
IndexingArray.resize(Turtle.GetProductions().size());
int i=0;
for(auto &I : Turtle.GetProductions())
{
IndexingArray[i] = I.first;
i++;
}
}
//
public:
//
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override
{
return IndexingArray.size() + 1;
}
//
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const override
{
return 2;
}
//
virtual Qt::ItemFlags flags(const QModelIndex &index) const override
{
return Qt::ItemIsEditable | QAbstractTableModel::flags(index);
}
//
virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override
{
if (role == Qt::DisplayRole)
{
if (orientation == Qt::Horizontal)
{
switch (section)
{
case 0:
return QString("Predecessor");
case 1:
return QString("Successor");
}
}
}
return QVariant();
}
//
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override
{
if(role == Qt::DisplayRole || role == Qt::EditRole)
{
if(index.row() < IndexingArray.size())
{
if(index.column() == 0)
{
return QString(IndexingArray[index.row()]);
}
if(index.column() == 1)
{
return QString::fromStdString(Turtle.GetProductions().find(IndexingArray[index.row()])->second.GetSuccessor());
}
}
}
//
return QVariant();
}
//
virtual bool setData(const QModelIndex &index, const QVariant &value, int role) override
{
if (role == Qt::EditRole)
{
if(index.row() < IndexingArray.size())
{
if(index.column() == 0 && value.toString().size() == 1)
{
std::string SuccessorValue = Turtle.GetProductions().find(IndexingArray[index.row()])->second.GetSuccessor();
Turtle.DeleteProduction(IndexingArray[index.row()]);
IndexingArray[index.row()] = value.toString().at(0).toLatin1();
Turtle.AddProduction(IndexingArray[index.row()],SuccessorValue);
//
emit editCompleted(value.toString());
}
else if (index.column() == 1)
{
Turtle.AddProduction(IndexingArray[index.row()],value.toString().toStdString());
//
emit editCompleted(value.toString());
}
}
else
{
if(index.column() == 0 && value.toString().size() == 1)
{
char Predecessor = value.toString().at(0).toLatin1();
if(!Turtle.HasProduction(Predecessor))
{
beginInsertRows(QModelIndex(),IndexingArray.size() + 2,IndexingArray.size() + 2);
Turtle.AddProduction(value.toString().at(0).toLatin1(),"");
RefreshIndexingArray();
//
emit editCompleted(value.toString());
endInsertRows();
}
}
}
}
return true;
}
//
ProductionModel(TurtleNodePresenter &turtle)
:Turtle(turtle)
{
RefreshIndexingArray();
}
};
class TurtleNodeEditor : public QWidget
{
Q_OBJECT
private:
QLineEdit *DeltaDistance;
QLineEdit *DeltaAngle;
QLineEdit *Axiom;
QLineEdit *RecursionDepth;
QTableView *Productions;
//
TurtleNodePresenter *TurtleNode;
//
ProductionModel TableModel;
//
private slots:
//
void DeltaDistanceChanged()
{
std::cout << "New distance " << DeltaDistance->text().toDouble() << std::endl;
TurtleNode->SetDeltaDistance(DeltaDistance->text().toDouble());
}
//
void DeltaAngleChanged()
{
std::cout << "New angle: " << DeltaAngle->text().toDouble() << std::endl;
TurtleNode->SetDeltaAngle(DeltaAngle->text().toDouble() * FU_GEN_PI / 180.0);
}
//
void AxiomChanged()
{
std::cout << "New axiom" << Axiom->text().toStdString() << std::endl;
TurtleNode->SetAxiom(Axiom->text().toStdString());
}
//
void RecursionDepthChanged()
{
std::cout << "New recursion depth" << RecursionDepth->text().toStdString() << std::endl;
TurtleNode->SetRecursionDepth(RecursionDepth->text().toInt());
}
//
public:
//
TurtleNodeEditor(TurtleNodePresenter *turtle_node);
//
virtual ~TurtleNodeEditor() override;
};
#endif // TURTLENODEEDITOR_H
|
/*
* Copyright (c) 2015-2016 Kees Bakker. All rights reserved.
*
* This file is part of GPRSbee.
*
* GPRSbee 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.
*
* GPRSbee is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with GPRSbee. If not, see
* <http://www.gnu.org/licenses/>.
*/
#ifndef _SIMCOM_MODEM_h
#define _SIMCOM_MODEM_h
#include <Arduino.h>
#include <stdint.h>
#include <Stream.h>
#include "SIMCOM_Datetime.h"
#include "SIMCOM_Modem_OnOff.h"
// callback for changing the baudrate of the modem stream.
typedef void (*BaudRateChangeCallbackPtr)(uint32_t newBaudrate);
#define SIMCOM_MODEM_DEFAULT_BUFFER_SIZE 64
#define DEFAULT_READ_MS 5000 // Used in readResponse()
class SIMCOM_Modem {
public:
// Constructor
SIMCOM_Modem();
virtual ~SIMCOM_Modem() {}
// Sets the onoff instance
void setOnOff(SIMCOM_Modem_OnOff & onoff) { _onoff = &onoff; }
// Turns the modem on and returns true if successful.
bool on();
// Turns the modem off and returns true if successful.
bool off();
// Sets the optional "Diagnostics and Debug" stream.
void setDiag(Stream &stream) { _diagStream = &stream; }
void setDiag(Stream *stream) { _diagStream = stream; }
// Sets the size of the input buffer.
// Needs to be called before init().
void setInputBufferSize(size_t value) { this->_inputBufferSize = value; };
// Store APN and user and password
void setApn(const char *apn, const char *user = NULL, const char *pass = NULL);
void setApnUser(const char *user);
void setApnPass(const char *pass);
// Store PIN
void setPin(const char *pin);
// Returns the default baud rate of the modem.
// To be used when initializing the modem stream for the first time.
//virtual uint32_t getDefaultBaudrate() = 0;
// Enables the change of the baud rate to a higher speed when the modem is ready to do so.
// Needs a callback in the main application to re-initialize the stream.
void enableBaudrateChange(BaudRateChangeCallbackPtr callback) { _baudRateChangeCallbackPtr = callback; };
void setMinSignalQuality(int q);
uint8_t getCSQtime() const { return _CSQtime; }
uint8_t getLastRSSI() const { return _lastRSSI; }
// Gets the Received Signal Strength Indication in dBm and Bit Error Rate.
// Returns true if successful.
virtual bool getRSSIAndBER(int8_t* rssi, uint8_t* ber) = 0;
// Gets the Operator Name.
// Returns true if successful.
//virtual bool getOperatorName(char* buffer, size_t size) = 0;
// Gets Mobile Directory Number.
// Returns true if successful.
//virtual bool getMobileDirectoryNumber(char* buffer, size_t size) = 0;
// Gets International Mobile Equipment Identity.
// Should be provided with a buffer of at least 16 bytes.
// Returns true if successful.
virtual bool getIMEI(char* buffer, size_t size) = 0;
// Gets Integrated Circuit Card ID.
// Should be provided with a buffer of at least 21 bytes.
// Returns true if successful.
virtual bool getCCID(char* buffer, size_t size) = 0;
// Gets the International Mobile Station Identity.
// Should be provided with a buffer of at least 16 bytes.
// Returns true if successful.
//virtual bool getIMSI(char* buffer, size_t size) = 0;
bool sendCommandWaitForOK(const char *cmd, uint16_t timeout=4000);
bool sendCommandWaitForOK(const String & cmd, uint16_t timeout=4000);
bool sendCommandWaitForOK_P(const char *cmd, uint16_t timeout=4000);
protected:
// The stream that communicates with the device.
Stream* _modemStream;
// The (optional) stream to show debug information.
Stream* _diagStream;
// The size of the input buffer. Equals SODAQ_GSM_MODEM_DEFAULT_INPUT_BUFFER_SIZE
// by default or (optionally) a user-defined value when using USE_DYNAMIC_BUFFER.
size_t _inputBufferSize;
// Flag to make sure the buffers are not allocated more than once.
bool _isBufferInitialized;
// The buffer used when reading from the modem. The space is allocated during init() via initBuffer().
char* _inputBuffer;
char * _pin;
// The on-off pin power controller object.
SIMCOM_Modem_OnOff * _onoff;
// The callback for requesting baudrate change of the modem stream.
BaudRateChangeCallbackPtr _baudRateChangeCallbackPtr;
// This flag keeps track if the next write is the continuation of the current command
// A Carriage Return will reset this flag.
bool _appendCommand;
// This is the value of the most recent CSQ
// Notice that CSQ is somewhat standard. SIM800/SIM900 and Ublox
// compute to comparable numbers. With minor deviations.
// For example SIM800
// 1 -111 dBm
// 2...30 -110... -54 dBm
// For example UBlox
// 1 -111 dBm
// 2..30 -109 to -53 dBm
int8_t _lastRSSI; // 0 not known or not detectable
// This is the number of second it took when CSQ was record last
uint8_t _CSQtime;
// This is the minimum required CSQ to continue making the connection
int _minSignalQuality;
// Keep track if ATE0 was sent
bool _echoOff;
// Keep track when connect started. Use this to record various status changes.
uint32_t _startOn;
// Initializes the input buffer and makes sure it is only initialized once.
// Safe to call multiple times.
void initBuffer();
void mydelay(uint32_t nrMillis);
// Returns true if the modem is ON (and replies to "AT" commands without timing out)
virtual bool isAlive() = 0;
// Returns true if the modem is on.
bool isOn() const;
virtual void switchEchoOff() = 0;
// Sets the modem stream.
void setModemStream(Stream& stream);
// Small utility to see if we timed out
bool isTimedOut(uint32_t ts) { return (long)(millis() - ts) >= 0; }
void flushInput();
int readLine(uint32_t ts_max);
int readBytes(size_t len, uint8_t *buffer, size_t buflen, uint32_t ts_max);
bool waitForOK(uint16_t timeout=4000);
bool waitForMessage(const char *msg, uint32_t ts_max);
bool waitForMessage_P(const char *msg, uint32_t ts_max);
int waitForMessages(const char *msgs[], size_t nrMsgs, uint32_t ts_max);
bool waitForPrompt(const char *prompt, uint32_t ts_max);
void sendCommandProlog();
void sendCommandAdd(char c);
void sendCommandAdd(int i);
void sendCommandAdd(const char *cmd);
void sendCommandAdd(const String & cmd);
void sendCommandAdd_P(const char *cmd);
void sendCommandEpilog();
void sendCommand(const char *cmd);
void sendCommand_P(const char *cmd);
bool getIntValue(const char *cmd, const char *reply, int * value, uint32_t ts_max);
bool getIntValue_P(const char *cmd, const char *reply, int * value, uint32_t ts_max);
bool getStrValue(const char *cmd, const char *reply, char * str, size_t size, uint32_t ts_max);
bool getStrValue_P(const char *cmd, const char *reply, char * str, size_t size, uint32_t ts_max);
bool getStrValue(const char *cmd, char * str, size_t size, uint32_t ts_max);
// Write a byte
size_t writeByte(uint8_t value);
// Write the command prolog (just for debugging
void writeProlog();
size_t print(const __FlashStringHelper *);
size_t print(const String &);
size_t print(const char[]);
size_t print(char);
size_t print(unsigned char, int = DEC);
size_t print(int, int = DEC);
size_t print(unsigned int, int = DEC);
size_t print(long, int = DEC);
size_t print(unsigned long, int = DEC);
size_t print(double, int = 2);
size_t print(const Printable&);
size_t println(const __FlashStringHelper *);
size_t println(const String &s);
size_t println(const char[]);
size_t println(char);
size_t println(unsigned char, int = DEC);
size_t println(int, int = DEC);
size_t println(unsigned int, int = DEC);
size_t println(long, int = DEC);
size_t println(unsigned long, int = DEC);
size_t println(double, int = 2);
size_t println(const Printable&);
size_t println(void);
};
#endif
|
/*********************************************************************
Matt Marchant 2014 - 2016
http://trederia.blogspot.com
xygine - Zlib license.
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.
*********************************************************************/
//abstract base class for full screen post process effects
#ifndef XY_POST_PROCESS_HPP_
#define XY_POST_PROCESS_HPP_
#include <xygine/Config.hpp>
#include <xygine/MessageBus.hpp>
#include <memory>
#include <functional>
namespace sf
{
class RenderTarget;
class RenderTexture;
class Shader;
}
#include <SFML/Graphics/VertexArray.hpp>
#include <SFML/System/Vector2.hpp>
namespace xy
{
/*!
\brief Abstract base class for full screen post processes
Post processes can be added to a scene so that they are applied
after a scene is rendered. Multiple post processes can be chained
but be aware that too many will affect performance.
*/
class XY_EXPORT_API PostProcess
{
public:
/*!
\brief Post Process Message Handler
Allows callback behaviour for post process effects when
message events are raised on the message bus. Message
handlers can be added to a post process via addMessageHandler
*/
struct MessageHandler final
{
using Action = std::function<void(const Message&)>;
Message::ID id; //< Message ID for this handler to respond to
Action action; //< Executed when message with ID is received
};
using Ptr = std::unique_ptr<PostProcess>;
PostProcess() = default;
virtual ~PostProcess() = default;
PostProcess(const PostProcess&) = delete;
const PostProcess& operator = (const PostProcess&) = delete;
/*!
\brief Applies the effect
\param RenderTexture A render Texture containing the scene to which the
effect should be applied.
\param RenderTarget The target to which the effected scene is rendered.
This may be the current render window, or another RenderTexture when
chaining multiple effects together.
The source and destinations are handled automatically by xygine when
a post process effect is added to a scene, but must be specified
maunally when using the effect outside the scene rendering.
*/
virtual void apply(const sf::RenderTexture&, sf::RenderTarget&) = 0;
/*!
\brief Updates the effect
Some effects may require shader parameters to be updated over time.
This optionally overridable function passes in the current frame time
and allows updating those parameters. This is called automatically
when the effect is added to a Scene, but will need to be called manually
when using the effect on its own.
*/
virtual void update(float) {}
/*!
\brief Utility function for creating post process effects
*/
template <typename T, typename... Args>
static Ptr create(Args&&... args)
{
static_assert(std::is_base_of<PostProcess, T>::value, "Can only create post process types");
return std::move(std::make_unique<T>(std::forward<Args>(args)...));
}
/*!
\brief Used internally by xygine to call any message handler
callbacks associated with a post process effect when an effect
is added to a Scene. This should be called manually when explicitly
applying post process effects and message handling is required.
\param Message Reference to message passed to callbacks
*/
void handleMessage(const Message&);
/*!
\brief Adds a message handler to the list of message handling
callbacks for this effect.
Custom message handlers can be added to any instance of a post
process via the MessageHandler struct.
\see MessageHandler
*/
void addMessageHandler(const MessageHandler&);
protected:
static void applyShader(const sf::Shader&, sf::RenderTarget&);
private:
std::vector<MessageHandler> m_messageHandlers;
};
}
#endif //XY_POST_PROCESS_HPP_
|
#ifndef __MODULE_IMPORT_MESH_H__
#define __MODULE_IMPORT_MESH_H__
#include "Module.h"
#include <vector>
class ResourceMesh;
struct aiMesh;
class ModuleImportMesh : public Module
{
public:
ModuleImportMesh(const char * name);
ResourceMesh * ImportAssimpMesh(aiMesh *assimp_mesh, UID uid, std::vector<UID> & bones_uid, const char * asset_path);
//ResourceMesh * ImportParShapeMesh(par_shapes_mesh *mesh);
};
#endif
|
//
// Created by Josh on 4/25/2020.
//
#ifndef FINALPROJECT_PROJECTILE_H
#define FINALPROJECT_PROJECTILE_H
#include "location.h"
namespace space_invader {
class Projectile {
public:
explicit Projectile(const Location& location);
Location GetLocation() const;
Location SetLocation(const Location&);
void SetVisibility(bool visible);
bool IsVisibile() const;
private:
Location location_;
bool visible_;
};
}
#endif // FINALPROJECT_PROJECTILE_H
|
#ifndef Lista_Index_Indexada_Mia2
#define Lista_Index_Indexada_Mia2
#include <iostream>
class Lista_Index{
private:
struct Celda{
Celda(int);
Celda * siguiente;
~Celda();
int elemento;
};
int contador;
int primerIndex;
int ultimoIndex;
Celda * primera;
Celda * ultima;
public:
Lista_Index();
// Lista_Index(int);
void iniciar();
void iniciar(int);
void vaciar();
int vacia();
void destruir();
~Lista_Index();
void agregarAlFinal(int);
void agregarAlInicio(int);
void agregar(int, int);
void borrar(int);
int recuperar(int);
void modificar(int, int);
void intercambiar(int indice1, int indice2);
int numElem();
void imprimirLista();
int primerIndice();
int ultimoIndice();
int siguiente(int);
int anterior(int);
};
#endif
|
#pragma once
#include "Module.h"
#include "Globals.h"
#include "Box2D/Box2D/Box2D.h"
#include "p2Point.h"
#define GRAVITY_X 0.0f
#define GRAVITY_Y -7.0f
#define PIXELS_PER_METER 50.0f // if touched change METER_PER_PIXEL too
#define METER_PER_PIXEL 0.02f // this is 1 / PIXELS_PER_METER !
#define METERS_TO_PIXELS(m) ((int) floor(PIXELS_PER_METER * m))
#define PIXEL_TO_METERS(p) ((float) METER_PER_PIXEL * p)
enum body_type{b_dynamic,b_static,b_kinematic};
// Small class to return to other modules to track position and rotation of physics bodies
class PhysBody
{
public:
PhysBody() : listener(NULL), body(NULL)
{}
PhysBody::PhysBody(b2Body* body, const SDL_Rect& rect, body_type type) : body(body), rect(rect), type(type), listener(NULL)
{}
void GetPosition(int& x, int &y) const;
float GetRotation() const;
bool Contains(int x, int y) const;
int RayCast(int x1, int y1, int x2, int y2, float& normal_x, float& normal_y) const;
void Push(float x, float y);
public:
int width, height;
b2Body* body;
Module* listener;
SDL_Rect rect;
private:
body_type type;
};
// Module --------------------------------------
class ModulePhysics : public Module, public b2ContactListener // TODO
{
public:
ModulePhysics(Application* app, bool start_enabled = true);
~ModulePhysics();
bool Start();
update_status PreUpdate();
update_status PostUpdate();
bool CleanUp();
PhysBody* CreateCircle(int x, int y, int radius, b2BodyType type);
PhysBody* CreateCircleSensor(int x, int y, int radius, b2BodyType type);
PhysBody* CreateRectangle(int x, int y, int width, int height, b2BodyType type);
PhysBody* CreateRectangleSensor(int x, int y, int width, int height);
PhysBody* CreateChain(int x, int y, int* points, int size);
PhysBody* CreateStaticChain(int x, int y, int* points, int size);
PhysBody* AddBody(int x, int y, int* points, uint count, float density, float restitution, b2BodyType type);
PhysBody* CreateFlipper(int x, int y, int* points, uint count, float density, float restitution, bool isSensor);
PhysBody* AddCircularBody(int x, int y, int diameter, body_type type, float density, float restitution, bool ccd, bool isSensor);
void CreateRevoluteJoint(PhysBody* body_1, PhysBody* body_2, int x_pivot_1, int y_pivot_1, int x_pivot_2, int y_pivot_2, int max_angle, int min_angle);
void CreateLineJoint(PhysBody* body_1, PhysBody* body_2, int x_pivot_1, int y_pivot_1, int x_pivot_2, int y_pivot_2, float frequency, float damping);
void CreateJoint(PhysBody* flipbody, PhysBody* circlbody);
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
// b2ContactListener ---
//void BeginContact(b2Contact* contact);
private:
bool debug;
b2World* world;
b2MouseJoint* mouse_joint;
b2Body* ground;
p2List<PhysBody*> bodies;
};
|
#pragma once
#include <ft2build.h>
#include FT_FREETYPE_H
#include <iostream>
#include <cmath>
using namespace std;
typedef struct {
unsigned char* buffer;
unsigned int width;
unsigned int height;
float bearing_x;
float bearing_y;
} Glyph;
class FreeTypeLib {
public:
FreeTypeLib();
~FreeTypeLib();
FT_Face* loadFace(const string& fontName, int ptSize, int deviceHDPI, int deviceVDPI);
void freeFace(FT_Face* face);
Glyph* rasterize(FT_Face* face, uint32_t glyphIndex) const;
void freeGlyph(Glyph* glyph);
private:
FT_Library lib;
int force_ucs2_charmap(FT_Face ftf);
};
|
// ==============================================================
// RTL generated by Vivado(TM) HLS - High-Level Synthesis from C, C++ and OpenCL
// Version: 2019.2
// Copyright (C) 1986-2019 Xilinx, Inc. All Rights Reserved.
//
// ===========================================================
#ifndef _checkAxis_1_HH_
#define _checkAxis_1_HH_
#include "systemc.h"
#include "AESL_pkg.h"
#include "lineIntersectsPlane.h"
#include "pointOnSegment.h"
#include "p_hls_fptosi_float_i.h"
#include "checkAxis_2_collihbi.h"
namespace ap_rtl {
struct checkAxis_1 : public sc_module {
// Port declarations 13
sc_in_clk ap_clk;
sc_in< sc_logic > ap_rst;
sc_in< sc_logic > ap_start;
sc_out< sc_logic > ap_done;
sc_out< sc_logic > ap_idle;
sc_out< sc_logic > ap_ready;
sc_in< sc_lv<32> > edge_p1_x;
sc_in< sc_lv<32> > edge_p1_y;
sc_in< sc_lv<32> > edge_p1_z;
sc_in< sc_lv<32> > edge_p2_x;
sc_in< sc_lv<32> > edge_p2_y;
sc_in< sc_lv<32> > edge_p2_z;
sc_out< sc_lv<64> > ap_return;
// Module declarations
checkAxis_1(sc_module_name name);
SC_HAS_PROCESS(checkAxis_1);
~checkAxis_1();
sc_trace_file* mVcdFile;
checkAxis_2_collihbi* collisions_U;
lineIntersectsPlane* grp_lineIntersectsPlane_fu_192;
pointOnSegment* grp_pointOnSegment_fu_207;
p_hls_fptosi_float_i* grp_p_hls_fptosi_float_i_fu_220;
p_hls_fptosi_float_i* grp_p_hls_fptosi_float_i_fu_225;
sc_signal< sc_lv<20> > ap_CS_fsm;
sc_signal< sc_logic > ap_CS_fsm_state1;
sc_signal< sc_lv<32> > reg_242;
sc_signal< sc_logic > ap_CS_fsm_state3;
sc_signal< sc_logic > grp_lineIntersectsPlane_fu_192_ap_ready;
sc_signal< sc_logic > grp_lineIntersectsPlane_fu_192_ap_done;
sc_signal< sc_logic > ap_CS_fsm_state7;
sc_signal< sc_logic > ap_CS_fsm_state11;
sc_signal< sc_logic > ap_CS_fsm_state15;
sc_signal< sc_lv<32> > reg_248;
sc_signal< sc_lv<32> > reg_254;
sc_signal< sc_lv<32> > grp_p_hls_fptosi_float_i_fu_220_ap_return;
sc_signal< sc_lv<32> > reg_259;
sc_signal< sc_logic > ap_CS_fsm_state5;
sc_signal< sc_logic > grp_pointOnSegment_fu_207_ap_ready;
sc_signal< sc_logic > grp_pointOnSegment_fu_207_ap_done;
sc_signal< sc_lv<1> > grp_pointOnSegment_fu_207_ap_return;
sc_signal< sc_logic > ap_CS_fsm_state9;
sc_signal< sc_logic > ap_CS_fsm_state13;
sc_signal< sc_logic > ap_CS_fsm_state17;
sc_signal< sc_lv<32> > grp_p_hls_fptosi_float_i_fu_225_ap_return;
sc_signal< sc_lv<32> > reg_263;
sc_signal< sc_lv<2> > add_ln84_fu_267_p2;
sc_signal< sc_logic > ap_CS_fsm_state2;
sc_signal< sc_lv<1> > tmp_s_reg_591;
sc_signal< sc_lv<1> > tmp_45_1_reg_595;
sc_signal< sc_lv<1> > tmp_45_2_reg_599;
sc_signal< sc_lv<1> > tmp_45_3_reg_603;
sc_signal< sc_lv<3> > i_fu_530_p2;
sc_signal< sc_lv<3> > i_reg_610;
sc_signal< sc_logic > ap_CS_fsm_state19;
sc_signal< sc_lv<1> > icmp_ln138_fu_524_p2;
sc_signal< sc_lv<64> > returnCollisions_fu_541_p2;
sc_signal< sc_logic > ap_CS_fsm_state20;
sc_signal< sc_lv<2> > collisions_address0;
sc_signal< sc_logic > collisions_ce0;
sc_signal< sc_logic > collisions_we0;
sc_signal< sc_lv<64> > collisions_d0;
sc_signal< sc_lv<64> > collisions_q0;
sc_signal< sc_logic > grp_lineIntersectsPlane_fu_192_ap_start;
sc_signal< sc_logic > grp_lineIntersectsPlane_fu_192_ap_idle;
sc_signal< sc_lv<32> > grp_lineIntersectsPlane_fu_192_plane;
sc_signal< sc_lv<32> > grp_lineIntersectsPlane_fu_192_ap_return_0;
sc_signal< sc_lv<32> > grp_lineIntersectsPlane_fu_192_ap_return_1;
sc_signal< sc_lv<32> > grp_lineIntersectsPlane_fu_192_ap_return_2;
sc_signal< sc_logic > grp_pointOnSegment_fu_207_ap_start;
sc_signal< sc_logic > grp_pointOnSegment_fu_207_ap_idle;
sc_signal< sc_logic > grp_p_hls_fptosi_float_i_fu_220_ap_ready;
sc_signal< sc_logic > grp_p_hls_fptosi_float_i_fu_225_ap_ready;
sc_signal< sc_lv<2> > phi_ln84_reg_158;
sc_signal< sc_lv<1> > icmp_ln84_fu_278_p2;
sc_signal< sc_lv<64> > returnCollisions_0_reg_169;
sc_signal< sc_logic > ap_CS_fsm_state18;
sc_signal< sc_lv<3> > i_1_reg_181;
sc_signal< sc_logic > grp_lineIntersectsPlane_fu_192_ap_start_reg;
sc_signal< sc_logic > ap_CS_fsm_state6;
sc_signal< sc_logic > ap_CS_fsm_state10;
sc_signal< sc_logic > ap_CS_fsm_state14;
sc_signal< sc_logic > grp_pointOnSegment_fu_207_ap_start_reg;
sc_signal< sc_logic > ap_CS_fsm_state4;
sc_signal< sc_logic > ap_CS_fsm_state8;
sc_signal< sc_logic > ap_CS_fsm_state12;
sc_signal< sc_logic > ap_CS_fsm_state16;
sc_signal< sc_lv<64> > zext_ln84_fu_273_p1;
sc_signal< sc_lv<64> > zext_ln139_fu_536_p1;
sc_signal< sc_lv<64> > or_ln133_fu_334_p2;
sc_signal< sc_lv<64> > or_ln133_1_fu_391_p2;
sc_signal< sc_lv<64> > or_ln133_2_fu_454_p2;
sc_signal< sc_lv<64> > or_ln133_3_fu_517_p2;
sc_signal< sc_lv<32> > shl_ln80_fu_284_p2;
sc_signal< sc_lv<32> > shl_ln80_4_fu_290_p2;
sc_signal< sc_lv<32> > add_ln80_fu_296_p2;
sc_signal< sc_lv<64> > zext_ln132_fu_302_p1;
sc_signal< sc_lv<32> > add_ln80_10_fu_312_p2;
sc_signal< sc_lv<32> > add_ln80_11_fu_318_p2;
sc_signal< sc_lv<64> > zext_ln133_fu_324_p1;
sc_signal< sc_lv<64> > shl_ln133_fu_328_p2;
sc_signal< sc_lv<64> > shl_ln132_fu_306_p2;
sc_signal< sc_lv<32> > shl_ln80_5_fu_341_p2;
sc_signal< sc_lv<32> > or_ln80_fu_353_p2;
sc_signal< sc_lv<32> > shl_ln80_6_fu_347_p2;
sc_signal< sc_lv<32> > add_ln80_12_fu_359_p2;
sc_signal< sc_lv<64> > zext_ln132_1_fu_365_p1;
sc_signal< sc_lv<32> > add_ln80_13_fu_375_p2;
sc_signal< sc_lv<64> > zext_ln133_1_fu_381_p1;
sc_signal< sc_lv<64> > shl_ln133_1_fu_385_p2;
sc_signal< sc_lv<64> > shl_ln132_1_fu_369_p2;
sc_signal< sc_lv<32> > shl_ln80_7_fu_398_p2;
sc_signal< sc_lv<32> > or_ln80_1_fu_410_p2;
sc_signal< sc_lv<32> > shl_ln80_8_fu_404_p2;
sc_signal< sc_lv<32> > add_ln80_14_fu_416_p2;
sc_signal< sc_lv<64> > zext_ln132_2_fu_422_p1;
sc_signal< sc_lv<32> > or_ln80_2_fu_432_p2;
sc_signal< sc_lv<32> > add_ln80_15_fu_438_p2;
sc_signal< sc_lv<64> > zext_ln133_2_fu_444_p1;
sc_signal< sc_lv<64> > shl_ln133_2_fu_448_p2;
sc_signal< sc_lv<64> > shl_ln132_2_fu_426_p2;
sc_signal< sc_lv<32> > shl_ln80_9_fu_461_p2;
sc_signal< sc_lv<32> > or_ln80_3_fu_473_p2;
sc_signal< sc_lv<32> > shl_ln80_10_fu_467_p2;
sc_signal< sc_lv<32> > add_ln80_16_fu_479_p2;
sc_signal< sc_lv<64> > zext_ln132_3_fu_485_p1;
sc_signal< sc_lv<32> > or_ln80_4_fu_495_p2;
sc_signal< sc_lv<32> > add_ln80_17_fu_501_p2;
sc_signal< sc_lv<64> > zext_ln133_3_fu_507_p1;
sc_signal< sc_lv<64> > shl_ln133_3_fu_511_p2;
sc_signal< sc_lv<64> > shl_ln132_3_fu_489_p2;
sc_signal< sc_lv<64> > ap_return_preg;
sc_signal< sc_lv<20> > ap_NS_fsm;
static const sc_logic ap_const_logic_1;
static const sc_logic ap_const_logic_0;
static const sc_lv<20> ap_ST_fsm_state1;
static const sc_lv<20> ap_ST_fsm_state2;
static const sc_lv<20> ap_ST_fsm_state3;
static const sc_lv<20> ap_ST_fsm_state4;
static const sc_lv<20> ap_ST_fsm_state5;
static const sc_lv<20> ap_ST_fsm_state6;
static const sc_lv<20> ap_ST_fsm_state7;
static const sc_lv<20> ap_ST_fsm_state8;
static const sc_lv<20> ap_ST_fsm_state9;
static const sc_lv<20> ap_ST_fsm_state10;
static const sc_lv<20> ap_ST_fsm_state11;
static const sc_lv<20> ap_ST_fsm_state12;
static const sc_lv<20> ap_ST_fsm_state13;
static const sc_lv<20> ap_ST_fsm_state14;
static const sc_lv<20> ap_ST_fsm_state15;
static const sc_lv<20> ap_ST_fsm_state16;
static const sc_lv<20> ap_ST_fsm_state17;
static const sc_lv<20> ap_ST_fsm_state18;
static const sc_lv<20> ap_ST_fsm_state19;
static const sc_lv<20> ap_ST_fsm_state20;
static const sc_lv<32> ap_const_lv32_0;
static const sc_lv<32> ap_const_lv32_2;
static const sc_lv<32> ap_const_lv32_6;
static const sc_lv<32> ap_const_lv32_A;
static const sc_lv<32> ap_const_lv32_E;
static const sc_lv<32> ap_const_lv32_4;
static const sc_lv<1> ap_const_lv1_1;
static const sc_lv<32> ap_const_lv32_8;
static const sc_lv<32> ap_const_lv32_C;
static const sc_lv<32> ap_const_lv32_10;
static const sc_lv<32> ap_const_lv32_1;
static const sc_lv<32> ap_const_lv32_12;
static const sc_lv<1> ap_const_lv1_0;
static const sc_lv<32> ap_const_lv32_13;
static const sc_lv<2> ap_const_lv2_0;
static const sc_lv<64> ap_const_lv64_0;
static const sc_lv<32> ap_const_lv32_11;
static const sc_lv<3> ap_const_lv3_0;
static const sc_lv<32> ap_const_lv32_5;
static const sc_lv<32> ap_const_lv32_9;
static const sc_lv<32> ap_const_lv32_D;
static const sc_lv<32> ap_const_lv32_3F800000;
static const sc_lv<32> ap_const_lv32_40000000;
static const sc_lv<32> ap_const_lv32_40400000;
static const sc_lv<32> ap_const_lv32_3;
static const sc_lv<32> ap_const_lv32_7;
static const sc_lv<32> ap_const_lv32_B;
static const sc_lv<32> ap_const_lv32_F;
static const sc_lv<64> ap_const_lv64_1;
static const sc_lv<64> ap_const_lv64_2;
static const sc_lv<64> ap_const_lv64_3;
static const sc_lv<2> ap_const_lv2_1;
static const sc_lv<2> ap_const_lv2_3;
static const sc_lv<32> ap_const_lv32_FFFFFFFF;
static const sc_lv<3> ap_const_lv3_4;
static const sc_lv<3> ap_const_lv3_1;
static const bool ap_const_boolean_1;
// Thread declarations
void thread_ap_clk_no_reset_();
void thread_add_ln80_10_fu_312_p2();
void thread_add_ln80_11_fu_318_p2();
void thread_add_ln80_12_fu_359_p2();
void thread_add_ln80_13_fu_375_p2();
void thread_add_ln80_14_fu_416_p2();
void thread_add_ln80_15_fu_438_p2();
void thread_add_ln80_16_fu_479_p2();
void thread_add_ln80_17_fu_501_p2();
void thread_add_ln80_fu_296_p2();
void thread_add_ln84_fu_267_p2();
void thread_ap_CS_fsm_state1();
void thread_ap_CS_fsm_state10();
void thread_ap_CS_fsm_state11();
void thread_ap_CS_fsm_state12();
void thread_ap_CS_fsm_state13();
void thread_ap_CS_fsm_state14();
void thread_ap_CS_fsm_state15();
void thread_ap_CS_fsm_state16();
void thread_ap_CS_fsm_state17();
void thread_ap_CS_fsm_state18();
void thread_ap_CS_fsm_state19();
void thread_ap_CS_fsm_state2();
void thread_ap_CS_fsm_state20();
void thread_ap_CS_fsm_state3();
void thread_ap_CS_fsm_state4();
void thread_ap_CS_fsm_state5();
void thread_ap_CS_fsm_state6();
void thread_ap_CS_fsm_state7();
void thread_ap_CS_fsm_state8();
void thread_ap_CS_fsm_state9();
void thread_ap_done();
void thread_ap_idle();
void thread_ap_ready();
void thread_ap_return();
void thread_collisions_address0();
void thread_collisions_ce0();
void thread_collisions_d0();
void thread_collisions_we0();
void thread_grp_lineIntersectsPlane_fu_192_ap_start();
void thread_grp_lineIntersectsPlane_fu_192_plane();
void thread_grp_pointOnSegment_fu_207_ap_start();
void thread_i_fu_530_p2();
void thread_icmp_ln138_fu_524_p2();
void thread_icmp_ln84_fu_278_p2();
void thread_or_ln133_1_fu_391_p2();
void thread_or_ln133_2_fu_454_p2();
void thread_or_ln133_3_fu_517_p2();
void thread_or_ln133_fu_334_p2();
void thread_or_ln80_1_fu_410_p2();
void thread_or_ln80_2_fu_432_p2();
void thread_or_ln80_3_fu_473_p2();
void thread_or_ln80_4_fu_495_p2();
void thread_or_ln80_fu_353_p2();
void thread_returnCollisions_fu_541_p2();
void thread_shl_ln132_1_fu_369_p2();
void thread_shl_ln132_2_fu_426_p2();
void thread_shl_ln132_3_fu_489_p2();
void thread_shl_ln132_fu_306_p2();
void thread_shl_ln133_1_fu_385_p2();
void thread_shl_ln133_2_fu_448_p2();
void thread_shl_ln133_3_fu_511_p2();
void thread_shl_ln133_fu_328_p2();
void thread_shl_ln80_10_fu_467_p2();
void thread_shl_ln80_4_fu_290_p2();
void thread_shl_ln80_5_fu_341_p2();
void thread_shl_ln80_6_fu_347_p2();
void thread_shl_ln80_7_fu_398_p2();
void thread_shl_ln80_8_fu_404_p2();
void thread_shl_ln80_9_fu_461_p2();
void thread_shl_ln80_fu_284_p2();
void thread_zext_ln132_1_fu_365_p1();
void thread_zext_ln132_2_fu_422_p1();
void thread_zext_ln132_3_fu_485_p1();
void thread_zext_ln132_fu_302_p1();
void thread_zext_ln133_1_fu_381_p1();
void thread_zext_ln133_2_fu_444_p1();
void thread_zext_ln133_3_fu_507_p1();
void thread_zext_ln133_fu_324_p1();
void thread_zext_ln139_fu_536_p1();
void thread_zext_ln84_fu_273_p1();
void thread_ap_NS_fsm();
};
}
using namespace ap_rtl;
#endif
|
/*
* SPDX-FileCopyrightText: (C) 2017 Daniel Nicoletti <dantti12@gmail.com>
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef EVENTDISPATCHER_EPOLL_H
#define EVENTDISPATCHER_EPOLL_H
#include <QtCore/QAbstractEventDispatcher>
class EventDispatcherEPollPrivate;
#if defined(cutelyst_qt_eventloop_epoll_EXPORTS)
# define CUTELYST_EVENTLOOP_EPOLL_EXPORT Q_DECL_EXPORT
#else
# define CUTELYST_EVENTLOOP_EPOLL_EXPORT Q_DECL_IMPORT
#endif
class CUTELYST_EVENTLOOP_EPOLL_EXPORT EventDispatcherEPoll final : public QAbstractEventDispatcher
{
Q_OBJECT
public:
explicit EventDispatcherEPoll(QObject *parent = nullptr);
virtual ~EventDispatcherEPoll() override;
void reinstall();
virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) override;
virtual void registerSocketNotifier(QSocketNotifier *notifier) override;
virtual void unregisterSocketNotifier(QSocketNotifier *notifier) override;
virtual bool unregisterTimer(int timerId) override;
virtual bool unregisterTimers(QObject *object) override;
virtual QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject *object) const override;
virtual int remainingTime(int timerId) override;
virtual void wakeUp() override;
virtual void interrupt() override;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
virtual bool hasPendingEvents() override;
virtual void registerTimer(
int timerId,
int interval,
Qt::TimerType timerType,
QObject *object) override;
virtual void flush() override;
#else
virtual void registerTimer(int timerId, qint64 interval, Qt::TimerType timerType, QObject *object) override;
#endif
private:
Q_DISABLE_COPY(EventDispatcherEPoll)
Q_DECLARE_PRIVATE(EventDispatcherEPoll)
EventDispatcherEPollPrivate *d_ptr;
};
#endif // EVENTDISPATCHER_EPOLL_H
|
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
namespace p1 {
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int,int> m;
vector<int> res;
for (int i = 0; i < nums.size(); ++i) {
if (m.find(nums[i])!=m.end()){
res.push_back(m[nums[i]]);
res.push_back(i);
return res;
}
m[target-nums[i]]=i;
}
}
};
}
|
#include "spool_helper.h"
void show_file(result_map::iterator it, uid_t p_runner){
sHelper sHelp;
std::string id = sHelp.extract_number(it->second.filename().string());
std::string time = sHelp.format_time(TIME_FORMAT, it->first);
sHelp.restore_priv();
uid_t owner = sHelp.get_file_owner(it->second.string());
sHelp.drop_priv_temp(p_runner);
if(it->second.filename().string() != "meta"){
std::cout << it->second.filename() << " " << owner << " " <<
time << " " << id << std::endl;
}
}
//This gets the path/time of creation for a given directory
void fill_directory_map(fs::path dir_path, result_map &map){
fs::directory_iterator end_iter;
for(fs::directory_iterator dir_iter(dir_path); dir_iter != end_iter ; ++dir_iter){
if(fs::is_regular_file(dir_iter->status()) && dir_iter->path().filename().string() != METADATA){
map.insert(result_map::value_type(fs::last_write_time(dir_iter->path()), *dir_iter));
}
}
}
int list_dir(std::string src, uid_t p_runner){
result_map map;
fs::path p (src);
std::time_t last_write;
sHelper sHelp;
try{
if(exists(p)){
if(is_directory(p)){
sHelp.restore_priv();
fill_directory_map(p, map);
sHelp.drop_priv_temp(p_runner);
for(result_map::iterator it = map.begin(); it != map.end(); ++it){
show_file(it, p_runner);
}
}
}
} catch(const fs::filesystem_error& ex){
std::cout << ex.what() << '\n';
}
return 0;
}
int main(int argc, char *argv[]){
sHelper sHelp;
uid_t p_runner = getuid();
sHelp.drop_priv_temp(p_runner);
if(argc > 1){
std::cout << "This command takes no arguments. Please run as '$ showqueue'." << std::endl;
}else{
list_dir(SPOOL, p_runner);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.