text
stringlengths 8
6.88M
|
|---|
#include "Warlock.h"
Warlock::Warlock(const std::string& name, const std::string& type, int health, int damage, int mana) : SpellCaster(type, new WarlockState(name, health, damage, mana), new WarlockAttack(), new Fireball(static_cast<int>(FIREBALL::WARLOCK)), new Healing(static_cast<int>(HEALING::WARLOCK)), new DemonSummon()) {
std::cout << " creating Warlock " << std::endl;
this->demonBook = new std::set<Demon*>();
// this->demonBook->reserve(warlockMaxDemons);
this->lastDemon = nullptr;
// this->hasDemon = false;
}
Warlock::~Warlock() {
std::cout << " deleting Warlock " << std::endl;
// deleting Demons?
delete(this->demonBook);
std::cout << " deleted Warlock " << std::endl;
}
std::set<Demon*>* Warlock::getDemonBook() const { //const?
return this->demonBook;
}
void Warlock::castSpell(Unit* receiver) {
if ( !alterEgoOn ) {
if ( this->Unit::getState().outOfHp() ) { return; }
if ( this->getState().getMana() >= this->getActiveSpell()->getCost() ) {
if ( this->getActiveSpell()->getFormula() == "ds" ) {
if ( this->lastDemon ) {
std::cout << "You already have a Demon, summon it!" << std::endl;
return;
}
if ( this->demonBook->size() == warlockMaxDemons ) {
std::cout << "You already have max amount of demons!" << std::endl;
return;
}
}
this->getState().useMana(this->getActiveSpell()->getCost());
this->getActiveSpell()->action(receiver, this, this->getActiveSpell()->getMagicDmg());
} else {
std::cout << "Not enough mana" << '\n';
}
}
}
void Warlock::addDemon(Demon* demon) {
this->demonBook->insert(demon);
this->lastDemon = demon;
// this->lastDemon = true;
}
Demon* Warlock::summonDemon() {
if ( !this->lastDemon ) {
std::cout << "You have to cast Demon before summon it" << std::endl;
Demon* bubbleDemon = new Demon(this);
this->demonBook->insert(bubbleDemon);
bubbleDemon->takeDamage(bubbleDemon->getState().getMaxHp() * 2);
return bubbleDemon;
}
Demon* demon = this->lastDemon;
this->lastDemon = nullptr;
return demon;
}
void Warlock::notifyObservers(Unit* observable) {
Demon* demon = dynamic_cast<Demon*>(observable);
if ( !demon ) { return; }
demon->demonIsDestroyed();
this->demonBook->erase(demon);
}
void Warlock::notifyObservable(Unit* observer) {
for ( std::set<Demon*>::iterator it = this->demonBook->begin(); it != this->demonBook->end(); ) {
Demon* demon = (*it);
++it;
std::cout << "kiling Demon" << demon->getState().getName() << std::endl;
demon->takeDamage(demon->getState().getMaxHp() * 2);
}
}
std::ostream& operator<<(std::ostream& out, const Warlock& warlock) {
out << warlock.getUnitType() << " [";
if ( warlock.alterEgoOn ) {
out << warlock.Unit::getState() << "] AlterEgo: [" << static_cast<WarlockState&>(warlock.Unit::getAlterState()) << ", active spell: " << warlock.getActiveSpell()->getFormula() << ']';
} else {
out << static_cast<WarlockState&>(warlock.Unit::getState()) << ", active spell: " << warlock.getActiveSpell()->getFormula() << ']';
if ( &warlock.Unit::getAlterState() != nullptr ) {
out << " AlterEgo: [" << warlock.Unit::getAlterState() << ']';
}
}
out << " Mutation: [" << warlock.getUnitMutation() << "]\n";
out << "List of demons: ";
if ( warlock.getDemonBook()->empty() ) {
out << " is empty." << "\n";
} else {
out << "\n";
for ( Demon* demon : *warlock.getDemonBook() ) {
out << demon->getState().getName() << "\n";
}
}
return out;
}
|
#pragma warning (disable:4996)
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <string>
#include <cctype>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const double EPS = 1e-9;
const double PI = 2 * asin(1);
const int INF = 0x7fffffff;
const LL LINF = 0x7fffffffffffffff;
int n,i,j,t,ans;
map<string,int> mp;
queue<int> q;
char str[90],first[90];
char STGD[1005][90];
int vis[1005],len[1005];
vector<int> G[1005];
bool IsNext(char *s1,char *s2){
bool flag=false;
int step1=0;
int step2=0;
while(s1[step1]!='\0'&&s2[step2]!='\0'){
if(s1[step1]==s2[step2]){
step1++;
step2++;
}
if(s1[step1]!=s2[step2]&&!flag){
step2++;
flag=true;
}
if(s1[step1]!=s2[step2]&&flag){
return false;
}
}
return true;
}
int main(){
scanf("%d%s",&n,first);
for(i=0;i<n;i++){
scanf("%s",STGD[i]);
mp[STGD[i]]=i;
len[i]=strlen(STGD[i]);
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(i==j)
continue;
if(len[i]+1==len[j]){
if(IsNext(STGD[i],STGD[j])){
G[i].push_back(j);
}
}
}
}
memset(vis,0,sizeof(vis));
while (!q.empty())
q.pop();
ans=mp[first];
q.push(ans);
while(!q.empty()){
int t=q.front();
q.pop();
for(i=0;i<G[t].size();i++){
if(vis[G[t][i]]==0) {
vis[G[t][i]]=1;
q.push(G[t][i]);
if (len[G[t][i]] > len[ans])
ans=G[t][i];
}
}
}
printf("%s\n",STGD[ans]);
}
|
#include"conio.h"
#include"stdio.h"
void main(void)
{
clrscr();
int feet;
float meter;
printf("Enter Feets = ");
scanf("%d",&feet);
meter=feet*0.3084;
printf("\n\n%.2f Meters",meter);
getch();
}
|
//Напишите функцию, которая принимает вектор строк и возвращает число строк, начинающихся на большую или маленькую букву "a".
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
bool IsFirstLetterA(const string& s) {
return !s.empty() && (s[0] == 'a' || s[0] == 'A');
}
int CountStartsWithA(const vector<string>& xs) {
return count_if(xs.begin(), xs.end(), IsFirstLetterA);
}
int main() {
cout << CountStartsWithA({ "And"s, "another"s, "one"s, "gone"s, "another"s, "one"s "bites"s, "the"s, "dust"s });
return 0;
}
|
/**
* File: World.hpp
*/
#include "Universe.hpp"
Universe::Universe() {
myCamera = new Camera();
orbsPassed = 0;
/**
* opengl only supports 8 lights in the way we use them. Need to keep track of which are already taken so we dont take them again.
*/
for (int i = 0; i < 9; i++) {
lightsAvailable.push_back(8 - i);
}
collision = false;
}
Universe::~Universe() {
delete myCamera;
}
void Universe::draw_world() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//materials for the ship
GLfloat matAmb[] = { 0.1, .1, .1, 1.0 }; //ambient
GLfloat matDif[] = { 0.8, .8, 0.8, 1.0 }; //diffuse
GLfloat matSpec[] = { 0.3, 0.3, 0.3, 1.0 }; //specular
GLfloat matEm[] = { 0, 0, 0, 1 }; //emission, make the axis always bright
glMaterialfv(GL_FRONT, GL_AMBIENT, matAmb);
glMaterialfv(GL_FRONT, GL_DIFFUSE, matDif);
glMaterialfv(GL_FRONT, GL_SPECULAR, matSpec);
glMaterialfv(GL_FRONT, GL_EMISSION, matEm);
glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 125);
ship.draw();
for (std::list<LightOrb*>::const_iterator iterator = orbs.begin(), end = orbs.end(); iterator != end; ++iterator) {
(*iterator)->draw();
}
glFlush();
glutSwapBuffers();
}
void Universe::normalizeAll() {
ship.normalize();
}
void clockHelper(int pointerToWorld) {
((Universe*) pointerToWorld)->clock();
}
void Universe::clock() {
static DWORD start, end;
start = GetTickCount();
DWORD ticks = end - start;
keys();
if (orbs.size() < sqrt(orbsPassed) || orbs.size() == 0) {
//create a new orb
GLfloat startx = -5.0f + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX / (10.0f)));
GLfloat starty = -5.0f + static_cast<float>(rand()) / (static_cast<float>(RAND_MAX / (10.0f)));
//choose a color
int c = rand() % 5;
GLfloat r=0, g=0, b=0;
switch (c) {
case 0:
r = 1, g = 0, b = 0;
break;
case 1:
r = 0, g = 1, b = 0;
break;
case 2:
r = 0, g = 0, b = 1;
break;
case 3:
r = 1, g = 1, b = 0;
break;
case 4:
r = 0, g = 1, b = 1;
break;
case 5:
r = 1, g = 0, b = 1;
}
float speedFactor = 1.0
+ static_cast<float>(rand()) / (static_cast<float>(RAND_MAX / (1.0f + sqrt(orbsPassed))));
orbs.push_back(new LightOrb(startx, starty, r, g, b, &lightsAvailable, speedFactor));
//cout << "new orb" << endl;
}
for (std::list<LightOrb*>::const_iterator iterator = orbs.begin(), end = orbs.end(); iterator != end; ++iterator) {
(*iterator)->tick(ticks);
}
for (std::list<LightOrb*>::const_iterator iterator = orbs.begin(), end = orbs.end(); iterator != end; ++iterator) {
(*iterator)->tick(ticks);
if (checkCollision(*iterator)) {
collision = true;
}
if ((*iterator)->getMC().mat[0][3] < -10) {
//it has passed, delete
delete *iterator;
orbs.remove(*iterator);
orbsPassed++;
}
}
ship.tick(ticks);
keys();
if (!collision) {
glutTimerFunc(10, clockHelper, (int) this);
}
end = GetTickCount();
glutPostRedisplay();
}
bool Universe::checkCollision(LightOrb* o) {
Vector ov = o->getMC().getPosVect();
Vector sv = ship.getMC().getPosVect();
float radius = 0.5;
if (ov.x < 1.5 && ov.x > 0) { // if its too far or too close it could not have hit the ship
//check the body first, it has a radius of 1 and the orbs have .5
if (sqrt(pow(sv.y - ov.y, 2) + pow(sv.z - ov.z, 2) < 1 + radius)) {
//hit the body
return true;
}
Vector bodyToCircle = Vector(0, ov.y - sv.y, ov.z - sv.z); // vector from the body of the plane to the circle, 2d
GLfloat angle = bodyToCircle.angleFromPosZinYZPlane();
//cout << angle << endl;
float angleTolerance = 10;
float tilt = 0;
if (ship.vz > 0){
tilt = 20;
}else if (ship.vz < 0){
tilt = -20;
}
if (((angle > 20 - angleTolerance+tilt && angle < 20 + angleTolerance+tilt)
|| (angle > -20 - angleTolerance+tilt && angle < -20 + angleTolerance+tilt)) &&bodyToCircle.magnitude() <=2) {
//hit a wing, aproximately
return true;
}
}
return false;
}
void Universe::keys() {
BYTE mask = 0b10000000;
bool u, d, l, r;
u = (GetAsyncKeyState('W') && mask) || (GetAsyncKeyState(VK_UP) && mask);
d = (GetAsyncKeyState('S') && mask) || (GetAsyncKeyState(VK_DOWN) && mask);
l = (GetAsyncKeyState('A') && mask) || (GetAsyncKeyState(VK_LEFT) && mask);
r = (GetAsyncKeyState('D') && mask) || (GetAsyncKeyState(VK_RIGHT) && mask);
if (u && !d) {
ship.vert(1);
} else if (d && !u) {
ship.vert(-1);
} else {
ship.vert(0);
}
if (l && !r) {
ship.horiz(1);
} else if (r && !l) {
ship.horiz(-1);
} else {
ship.horiz(0);
}
}
|
#include <cmath>
#include <cstdio>
#include "Circle.h"
#include "Polygon.h"
#include "Reuleaux.h"
#include "Geom.h"
// =======================================
// Constructor ========== Getter Functions ==========
// =======================================
Polygon::Polygon(const vector<Point>vec) {
vertices = vec;
vertices_ = vertices.size();
}
int Polygon::Vertices() {
return vertices_;
}
Point Polygon::Vertex(int indx) {
return vertices.at(indx);
}
vector<Point> Polygon::GetPoints() {
return vertices;
}
// =======================================
// Main Class Functions===============================
// =======================================
bool Polygon::ContainedBy(Circle &circle) {
for (int i = 0; i < Vertices(); i++) {
if ( Geom::DistanceBetween(circle.Center(), this->Vertex(i))
> circle.Radius()) {
return false;
}
}
return true;
}
bool Polygon::ContainedBy(Polygon &polygon) {
bool ret = true;
int len;
if (polygon.Vertices() <= Vertices()) {
len = polygon.Vertices();
}
else {
len = Vertices();
}
//checks intersections
for (int i = 0; i < len-1; i++) {
Polygon *inner = this;
Point in = Geom::PolygonCenter(*inner);
Point out = Geom::PolygonCenter(polygon);
Point v0 = polygon.Vertex(i);
Point v1 = polygon.Vertex(i+1);
if (Geom::SegmentIntersect(out, in, v0, v1)) {
ret = false;
}
}
int contained = 0;
//checks inner vertices are contained within outer polygon
for (int i = 0; i < Vertices(); i++) {
Point point = Vertex(i);
if (Geom::PointInPolygon(point, polygon)) {
contained++;
}
}
if (contained < polygon.Vertices()) {
ret = false;
}
return ret;
}
bool Polygon::ContainedBy(ReuleauxTriangle &rt) {
//checks contained from within using vertices only not the arch radius
for (int i = 0; i < 3; i++) {
if (Vertex(i).x == rt.Vertex(i).x && Vertex(i).y == rt.Vertex(i).y) {
return true;
}
}
for (int i = 0; i < Vertices(); i++) {
if ( Geom::DistanceBetween(rt.Center(), Vertex(i))
> rt.RadiusFromCenter()) {
return false;
}
}
return true;
}
|
/* -*- Mode: c++; tab-width: 4; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2011 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*/
#include "core/pch.h"
# ifndef POSIX_INTERNAL
#define POSIX_INTERNAL(X) X
# endif // Defined here because this file is first in posix_jumbo.cpp
#ifdef POSIX_OK_SELECT
#include "platforms/posix/net/posix_base_socket.h"
bool PosixBaseSocket::SetSocketFlags(int fd, int *err)
{
// Set suitable options on a socket:
errno = 0;
int flags = fcntl(fd, F_GETFD, 0);
int res = flags + 1 ? fcntl(fd, F_SETFD, flags | FD_CLOEXEC) : -1;
if (res != -1)
{
#if FD_CLOEXEC
OP_ASSERT(errno == 0 && fcntl(fd, F_GETFD, 0) & FD_CLOEXEC);
#elif defined(__GNUC__)
# warning "FD_CLOEXEC is zero: close-on-exec may be unsupported"
#endif // but might simply be on-by-default
flags = fcntl(fd, F_GETFL, 0);
res = flags + 1 ? fcntl(fd, F_SETFL, flags | O_NONBLOCK) : -1;
}
if (res == -1)
{
*err = errno;
Log(TERSE, "%010p: Failed to configure socket flags: %s\n",
this, strerror(*err));
return false;
}
#if O_NONBLOCK
OP_ASSERT(errno == 0 && fcntl(fd, F_GETFL, 0) & O_NONBLOCK);
#elif defined(__GNUC__)
# warning "O_NONBLOCK is zero: non-blocking I/O may be unsupported"
#endif // or it might simply be on by default
return true;
}
#endif // POSIX_OK_SELECT
|
#include <EEPROM.h>
#ifdef __AVR_ATtiny85__
#define SWITCH_PIN 0
#define RED_PIN 1
#define GREEN_PIN 2
#define BLUE_PIN 3
#else
#define SWITCH_PIN 2
#define LED_PIN 3
// TODO
#endif
#define COLORS 7
#define STATE_IDLE 0
#define STATE_BUTTON_DOWN 1
#define STATE_BUTTON_RELEASED 2
#define STATE_TRANSITION 3
#define STATE_SHOW_COLOR 4
#define WHITE 0
#define YELLOW 1
#define RED 2
#define PURPLE 3
#define BLUE 4
#define CYAN 5
#define GREEN 6
#define COLOR_SETTING 0
#define LOOP_DELAY_MILLIS 40
int state = STATE_SHOW_COLOR;
int debounce = 0;
int color = 0;
int next_color = 0;
int write_settings = 0;
int clampColor(int color) {
return color >= COLORS? 0 : color;
}
void setup() {
pinMode(SWITCH_PIN, INPUT);
digitalWrite(SWITCH_PIN, HIGH);
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
color = clampColor(EEPROM.read(COLOR_SETTING));
}
void showColor(int color) {
switch(color) {
case WHITE: {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
}
break;
case YELLOW: {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
}
break;
case RED: {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
}
break;
case PURPLE: {
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
}
break;
case BLUE: {
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
}
break;
case CYAN: {
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
}
break;
case GREEN: {
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
}
break;
}
}
void blendColors(int percentage, int color1, int color2) {
for ( int i = 0; i < 100; i++ ) {
showColor(i > percentage? color1 : color2);
delayMicroseconds(1);
}
}
void loop() {
switch(state) {
case STATE_IDLE: {
if ( digitalRead(SWITCH_PIN) == LOW ) {
state = STATE_BUTTON_DOWN;
debounce = 0;
}
else if ( write_settings > 0 ) {
write_settings--;
if ( write_settings == 0 ) {
if ( clampColor(EEPROM.read(COLOR_SETTING)) != color ) {
EEPROM.write(COLOR_SETTING, color);
}
}
}
}
break;
case STATE_BUTTON_DOWN: {
// make sure button held down for long enough
if ( digitalRead(SWITCH_PIN) == LOW ) {
debounce++;
}
else if ( debounce >= 2 ) {
state = STATE_BUTTON_RELEASED;
}
else {
state = STATE_IDLE;
}
}
break;
case STATE_BUTTON_RELEASED: {
next_color = clampColor(color + 1);
state = STATE_TRANSITION;
}
break;
case STATE_TRANSITION: {
state = STATE_SHOW_COLOR;
for ( int i = 0; i < 33; i++ ) {
blendColors(3*(i+1), color, next_color);
}
color = next_color;
// wait a bit before we write settings away
write_settings = 800/LOOP_DELAY_MILLIS;
}
break;
case STATE_SHOW_COLOR: {
showColor(color);
state = STATE_IDLE;
}
break;
}
delay(LOOP_DELAY_MILLIS);
}
|
//
// Core.cpp
// GLFW3
//
// Created by William Meaton on 08/12/2015.
// Copyright © 2015 WillMeaton.uk. All rights reserved.
//
#include "Core.hpp"
//for graphics
using namespace Graphics;
Core::~Core(){
}
void Core::setup(){
Graphics::setBackground(255, 255, 255, 255);
}
void Core::update(){
}
void Core::draw(){
}
void Core::exitCalled(){
}
void Core::keyPressed(int key){
}
void Core::keyReleased(int key){
}
void Core::mousePressed(int button){
}
void Core::mouseReleased(int button){
}
|
//
// GStartBackgroundLayer.h
// Core
//
// Created by Max Yoon on 11. 7. 25..
// Copyright 2011년 __MyCompanyName__. All rights reserved.
//
#ifndef Core_GStartBackgroundLayer_h
#define Core_GStartBackgroundLayer_h
class GStartBackgroundLayer : public GLayer
{
enum
{
NUM_CLOUD = 5,
};
private:
GnReal2DMesh* mpBackground;
GnReal2DMesh* mpCloudsMeshs[NUM_CLOUD];
public:
static GStartBackgroundLayer* CreateBackground();
void CloudActionCallback(CCNode* pSender);
protected:
bool InitBackground();
bool InitClouds();
};
#endif
|
#include "chunkshader.h"
ChunkShader::ChunkShader(const std::string &vertexFile, const std::string &fragmentFile) :
AbstractShader(vertexFile, fragmentFile)
{
getUniforms();
}
void ChunkShader::loadProjectionViewMatrix(const Matrix4 &matrix)
{
loadMatrix(_locationProjectionViewMatrix, matrix);
}
void ChunkShader::getUniforms()
{
useProgram();
auto locationProjectionViewMatrix = glGetUniformLocation(_id, "projectionViewMatrix");
if (locationProjectionViewMatrix == -1) {
throw std::runtime_error("Unable to get uniform location: projectionViewMatrix");
}
_locationProjectionViewMatrix = static_cast<GLuint>(locationProjectionViewMatrix);
}
|
#pragma once
#include <memory>
#include <glm/glm.hpp>
class ComputeShader;
class TextureCubeMap;
class TimeQuery;
class SkyboxGenerator
{
public:
SkyboxGenerator(glm::ivec2 cubemapFaceDims);
~SkyboxGenerator();
/*
Generates the cubemap texture
*/
std::shared_ptr<TextureCubeMap> Generate(glm::vec3 sunDir, float sunPower, bool debug = false);
/*
Get the skybox cubemap texture
*/
std::shared_ptr<TextureCubeMap> GetCubemapTexture();
private:
std::shared_ptr<ComputeShader> _skyboxGenShader;
std::shared_ptr<TextureCubeMap> _cubemapTex;
std::shared_ptr<TextureCubeMap> _starsTex;
glm::ivec2 _cubemapFaceDimensions;
glm::ivec3 _groupDims;
std::shared_ptr<TimeQuery> _timer;
glm::vec3 _lastSunDir;
float _lastSunPower;
};
|
#pragma once
#include <glm/ext.hpp>
using namespace glm;
enum class PrimitiveID
{
NONE = 0,
Plane,
Sphere,
AABB,
Box,
TOTAL
};
class Primitive
{
public:
inline PrimitiveID GetID() { return m_ID; };
protected:
inline Primitive(PrimitiveID id) { m_ID = id; };
virtual ~Primitive() = 0;
PrimitiveID m_ID;
};
|
#include<iostream>
#include<cstdlib>
#include<conio.h>
using namespace std;
// prototipo funcion
int EncontrarMaximo(int x,int y);
int main () {
int n1,n2,mayor;
cout<<"digite 2 numeros ; ";
cin>>n1>>n2;
EncontrarMaximo(n1,n2);
getch();
return 0;
}
//definicion de funcion
int EncontrarMaximo(int x,int y){
int numMax;
if(x>y){
numMax=x;
}
else{
numMax=y;
}
cout<<"El mayor de los 2 numeros es "<<numMax;
}
|
// Created on: 1996-03-08
// Created by: Jacques GOUSSARD
// Copyright (c) 1996-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepFeat_Gluer_HeaderFile
#define _BRepFeat_Gluer_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <LocOpe_Gluer.hxx>
#include <BRepBuilderAPI_MakeShape.hxx>
#include <LocOpe_Operation.hxx>
#include <TopTools_ListOfShape.hxx>
class TopoDS_Shape;
class TopoDS_Face;
class TopoDS_Edge;
//! One of the most significant aspects
//! of BRepFeat functionality is the use of local operations as opposed
//! to global ones. In a global operation, you would first
//! construct a form of the type you wanted in your final feature, and
//! then remove matter so that it could fit into your initial basis object.
//! In a local operation, however, you specify the domain of the feature
//! construction with aspects of the shape on which the feature is being
//! created. These semantics are expressed in terms of a member
//! shape of the basis shape from which - or up to which - matter will be
//! added or removed. As a result, local operations make calculations
//! simpler and faster than global operations.
//! Glueing uses wires or edges of a face in the basis shape. These are
//! to become a part of the feature. They are first cut out and then
//! projected to a plane outside or inside the basis shape. By
//! rebuilding the initial shape incorporating the edges and the
//! faces of the tool, protrusion features can be constructed.
class BRepFeat_Gluer : public BRepBuilderAPI_MakeShape
{
public:
DEFINE_STANDARD_ALLOC
//! Initializes an empty constructor
BRepFeat_Gluer();
//! Initializes the shapes to be glued, the new shape
//! Snew and the basis shape Sbase.
BRepFeat_Gluer(const TopoDS_Shape& Snew, const TopoDS_Shape& Sbase);
//! Initializes the new shape Snew and the basis shape
//! Sbase for the local glueing operation.
void Init (const TopoDS_Shape& Snew, const TopoDS_Shape& Sbase);
//! Defines a contact between Fnew on the new shape
//! Snew and Fbase on the basis shape Sbase. Informs
//! other methods that Fnew in the new shape Snew is
//! connected to the face Fbase in the basis shape Sbase.
//! The contact faces of the glued shape must not have
//! parts outside the contact faces of the basis shape.
//! This indicates that glueing is possible.
void Bind (const TopoDS_Face& Fnew, const TopoDS_Face& Fbase);
//! nforms other methods that the edge Enew in the new
//! shape is the same as the edge Ebase in the basis
//! shape and is therefore attached to the basis shape. This
//! indicates that glueing is possible.
void Bind (const TopoDS_Edge& Enew, const TopoDS_Edge& Ebase);
//! Determine which operation type to use glueing or sliding.
LocOpe_Operation OpeType() const;
//! Returns the basis shape of the compound shape.
const TopoDS_Shape& BasisShape() const;
//! Returns the resulting compound shape.
const TopoDS_Shape& GluedShape() const;
//! This is called by Shape(). It does nothing but
//! may be redefined.
Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! returns the status of the Face after
//! the shape creation.
Standard_EXPORT virtual Standard_Boolean IsDeleted (const TopoDS_Shape& F) Standard_OVERRIDE;
//! returns the list of generated Faces.
Standard_EXPORT virtual const TopTools_ListOfShape& Modified (const TopoDS_Shape& F) Standard_OVERRIDE;
protected:
private:
LocOpe_Gluer myGluer;
};
#include <BRepFeat_Gluer.lxx>
#endif // _BRepFeat_Gluer_HeaderFile
|
#include <assert.h>
#include <algorithm>
#include <climits>
#include <functional>
#include <iostream>
#include <numeric>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
using namespace std;
int n, k;
struct Solution {
void solve() {
int pairs = n / 2;
if (n == 1 && k == 0) {
cout << "1" << endl;
return;
}
if (pairs > k || n == 1) {
cout << "-1" << endl; // going to exceed
return;
}
pairs = (n - 2) / 2;
int rem = k - pairs, odd = 1;
cout << rem << " " << rem * 2 << " ";
for (int i = 2; i + 1 < n; i += 2) {
int even = odd + 1;
while (rem == even || rem * 2 == even || rem == odd) {
odd += 2;
even = odd + 1;
}
cout << even << " " << odd << " ";
odd += 2;
}
if (odd == rem) odd += 2;
if (n & 1) cout << odd;
cout << endl;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
Solution test;
test.solve();
}
|
#include <iostream>
using namespace std;
//内联函数inline 1类内实现 2用inline关键字类内声明，实现可以写在类外
//public protected private
class Clock
{
public:
void ShowTime();
void SetTime(int h,int m,int s);
private:
int hour;
int minute;
int second;
};
void Clock::ShowTime()
{ cout << hour << ":" << this->minute << ":" << second << endl; }
void Clock::SetTime(int h,int m,int s)
{ this->hour = h; this->minute = m; second = s; }
int main()
{
Clock c1,c2;
// cout << sizeof(c1) << endl;
c2.SetTime(10,10,10);
c1.ShowTime();
return 0;
}
|
/*********************************************************\
* Copyright (c) 2012-2018 The Unrimp 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 OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\*********************************************************/
//[-------------------------------------------------------]
//[ Includes ]
//[-------------------------------------------------------]
#include "Direct3D9Renderer/Mapping.h"
#include "Direct3D9Renderer/d3d9.h"
#include <Renderer/Context.h>
#include <Renderer/IAssert.h>
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
namespace Direct3D9Renderer
{
//[-------------------------------------------------------]
//[ Public static methods ]
//[-------------------------------------------------------]
uint32_t Mapping::getDirect3D9MagFilterMode(const Renderer::Context& context, Renderer::FilterMode filterMode)
{
switch (filterMode)
{
case Renderer::FilterMode::MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::ANISOTROPIC:
return D3DTEXF_ANISOTROPIC;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_ANISOTROPIC:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::UNKNOWN:
RENDERER_ASSERT(context, false, "Direct3D 9 filter mode must not be unknown")
return D3DTEXF_POINT;
default:
return D3DTEXF_POINT; // We should never be in here
}
}
uint32_t Mapping::getDirect3D9MinFilterMode(const Renderer::Context& context, Renderer::FilterMode filterMode)
{
switch (filterMode)
{
case Renderer::FilterMode::MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::ANISOTROPIC:
return D3DTEXF_ANISOTROPIC;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_ANISOTROPIC:
return D3DTEXF_ANISOTROPIC;
case Renderer::FilterMode::UNKNOWN:
RENDERER_ASSERT(context, false, "Direct3D 9 filter mode must not be unknown")
return D3DTEXF_POINT;
default:
return D3DTEXF_POINT; // We should never be in here
}
}
uint32_t Mapping::getDirect3D9MipFilterMode(const Renderer::Context& context, Renderer::FilterMode filterMode)
{
switch (filterMode)
{
case Renderer::FilterMode::MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::ANISOTROPIC:
return D3DTEXF_ANISOTROPIC;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3DTEXF_POINT;
case Renderer::FilterMode::COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_MIN_MAG_MIP_LINEAR:
return D3DTEXF_LINEAR;
case Renderer::FilterMode::COMPARISON_ANISOTROPIC:
return D3DTEXF_ANISOTROPIC;
case Renderer::FilterMode::UNKNOWN:
RENDERER_ASSERT(context, false, "Direct3D 9 filter mode must not be unknown")
return D3DTEXF_POINT;
default:
return D3DTEXF_POINT; // We should never be in here
}
}
uint32_t Mapping::getDirect3D9TextureAddressMode(Renderer::TextureAddressMode textureAddressMode)
{
static const uint32_t MAPPING[] =
{
D3DTADDRESS_WRAP, // Renderer::TextureAddressMode::WRAP
D3DTADDRESS_MIRROR, // Renderer::TextureAddressMode::MIRROR
D3DTADDRESS_CLAMP, // Renderer::TextureAddressMode::CLAMP
D3DTADDRESS_BORDER, // Renderer::TextureAddressMode::BORDER
D3DTADDRESS_MIRRORONCE // Renderer::TextureAddressMode::MIRROR_ONCE
};
return MAPPING[static_cast<int>(textureAddressMode) - 1]; // Lookout! The "Renderer::TextureAddressMode"-values start with 1, not 0
}
uint32_t Mapping::getDirect3D9ComparisonFunc(Renderer::ComparisonFunc comparisonFunc)
{
static const uint32_t MAPPING[] =
{
D3DCMP_NEVER, // Renderer::ComparisonFunc::NEVER
D3DCMP_LESS, // Renderer::ComparisonFunc::LESS
D3DCMP_EQUAL, // Renderer::ComparisonFunc::EQUAL
D3DCMP_LESSEQUAL, // Renderer::ComparisonFunc::LESS_EQUAL
D3DCMP_GREATER, // Renderer::ComparisonFunc::GREATER
D3DCMP_NOTEQUAL, // Renderer::ComparisonFunc::NOT_EQUAL
D3DCMP_GREATEREQUAL, // Renderer::ComparisonFunc::GREATER_EQUAL
D3DCMP_ALWAYS // Renderer::ComparisonFunc::ALWAYS
};
return MAPPING[static_cast<int>(comparisonFunc) - 1]; // Lookout! The "Renderer::ComparisonFunc"-values start with 1, not 0
}
uint8_t Mapping::getDirect3D9Type(Renderer::VertexAttributeFormat vertexAttributeFormat)
{
// BYTE
static const uint8_t MAPPING[] =
{
D3DDECLTYPE_FLOAT1, // Renderer::VertexAttributeFormat::FLOAT_1
D3DDECLTYPE_FLOAT2, // Renderer::VertexAttributeFormat::FLOAT_2
D3DDECLTYPE_FLOAT3, // Renderer::VertexAttributeFormat::FLOAT_3
D3DDECLTYPE_FLOAT4, // Renderer::VertexAttributeFormat::FLOAT_4
D3DDECLTYPE_UBYTE4N, // Renderer::VertexAttributeFormat::R8G8B8A8_UNORM
D3DDECLTYPE_UBYTE4, // Renderer::VertexAttributeFormat::R8G8B8A8_UINT
D3DDECLTYPE_SHORT2, // Renderer::VertexAttributeFormat::SHORT_2
D3DDECLTYPE_SHORT4, // Renderer::VertexAttributeFormat::SHORT_4
D3DDECLTYPE_UNUSED // Renderer::VertexAttributeFormat::UINT_1 - not supported by DirectX 9
};
return MAPPING[static_cast<int>(vertexAttributeFormat)];
}
uint32_t Mapping::getDirect3D9Semantic(const char* semanticName)
{
BYTE direct3D9Semantic = D3DDECLUSAGE_POSITION;
if (0 == stricmp("POSITION", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_POSITION;
}
else if (0 == stricmp("BLENDWEIGHT", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_BLENDWEIGHT;
}
else if (0 == stricmp("BLENDINDICES", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_BLENDINDICES;
}
else if (0 == stricmp("NORMAL", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_NORMAL;
}
else if (0 == stricmp("PSIZE", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_PSIZE;
}
else if (0 == stricmp("TEXCOORD", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_TEXCOORD;
}
else if (0 == stricmp("TANGENT", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_TANGENT;
}
else if (0 == stricmp("BINORMAL", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_BINORMAL;
}
else if (0 == stricmp("TESSFACTOR", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_TESSFACTOR;
}
else if (0 == stricmp("POSITIONT", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_POSITIONT;
}
else if (0 == stricmp("COLOR", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_COLOR;
}
else if (0 == stricmp("FOG", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_FOG;
}
else if (0 == stricmp("DEPTH", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_DEPTH;
}
else if (0 == stricmp("SAMPLE", semanticName))
{
direct3D9Semantic = D3DDECLUSAGE_SAMPLE;
}
return direct3D9Semantic;
}
uint32_t Mapping::getDirect3D9Usage(Renderer::BufferUsage bufferUsage)
{
// Direct3D 9 only supports a subset of the OpenGL usage indications
// -> See "D3DUSAGE"-documentation at http://msdn.microsoft.com/en-us/library/windows/desktop/bb172625%28v=vs.85%29.aspx
switch (bufferUsage)
{
case Renderer::BufferUsage::STREAM_DRAW:
case Renderer::BufferUsage::STREAM_COPY:
case Renderer::BufferUsage::STATIC_DRAW:
case Renderer::BufferUsage::STATIC_COPY:
return D3DUSAGE_WRITEONLY;
case Renderer::BufferUsage::STREAM_READ:
case Renderer::BufferUsage::STATIC_READ:
return 0;
case Renderer::BufferUsage::DYNAMIC_DRAW:
case Renderer::BufferUsage::DYNAMIC_COPY:
return (D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY);
default:
case Renderer::BufferUsage::DYNAMIC_READ:
return D3DUSAGE_DYNAMIC;
}
}
uint32_t Mapping::getDirect3D9Format(Renderer::IndexBufferFormat::Enum indexBufferFormat)
{
// D3DFORMAT
static const uint32_t MAPPING[] =
{
D3DFMT_INDEX32, // Renderer::IndexBufferFormat::UNSIGNED_CHAR - One byte per element, uint8_t (may not be supported by each API) - Not supported by Direct3D 9
D3DFMT_INDEX16, // Renderer::IndexBufferFormat::UNSIGNED_SHORT - Two bytes per element, uint16_t
D3DFMT_INDEX32 // Renderer::IndexBufferFormat::UNSIGNED_INT - Four bytes per element, uint32_t (may not be supported by each API)
};
return MAPPING[indexBufferFormat];
}
uint32_t Mapping::getDirect3D9Format(Renderer::TextureFormat::Enum textureFormat)
{
// D3DFORMAT
static const uint32_t MAPPING[] =
{
D3DFMT_L8, // Renderer::TextureFormat::R8 - 8-bit pixel format, all bits red
D3DFMT_X8R8G8B8, // Renderer::TextureFormat::R8G8B8 - 24-bit pixel format, 8 bits for red, green and blue - "D3DFMT_R8G8B8" is usually not supported
D3DFMT_A8R8G8B8, // Renderer::TextureFormat::R8G8B8A8 - 32-bit pixel format, 8 bits for red, green, blue and alpha
D3DFMT_A8R8G8B8, // Renderer::TextureFormat::R8G8B8A8_SRGB - 32-bit pixel format, 8 bits for red, green, blue and alpha; sRGB = RGB hardware gamma correction, the alpha channel always remains linear - TODO(co) DirectX 9 sRGB format
D3DFMT_A8B8G8R8, // Renderer::TextureFormat::B8G8R8A8 - 32-bit pixel format, 8 bits for red, green, blue and alpha
D3DFMT_A16B16G16R16F, // Renderer::TextureFormat::R11G11B10F - 32-bit float format using 11 bits the red and green channel, 10 bits the blue channel; red and green channels have a 6 bits mantissa and a 5 bits exponent and blue has a 5 bits mantissa and 5 bits exponent - "DXGI_FORMAT_R11G11B10_FLOAT" doesn't exist in Direct3D 9
D3DFMT_A16B16G16R16F, // Renderer::TextureFormat::R16G16B16A16F - 64-bit float format using 16 bits for the each channel (red, green, blue, alpha)
D3DFMT_A32B32G32R32F, // Renderer::TextureFormat::R32G32B32A32F - 128-bit float format using 32 bits for the each channel (red, green, blue, alpha)
D3DFMT_DXT1, // Renderer::TextureFormat::BC1 - DXT1 compression (known as BC1 in DirectX 10, RGB compression: 8:1, 8 bytes per block)
D3DFMT_DXT1, // Renderer::TextureFormat::BC1_SRGB - DXT1 compression (known as BC1 in DirectX 10, RGB compression: 8:1, 8 bytes per block); sRGB = RGB hardware gamma correction, the alpha channel always remains linear - TODO(co) DirectX 9 sRGB format
D3DFMT_DXT3, // Renderer::TextureFormat::BC2 - DXT3 compression (known as BC2 in DirectX 10, RGBA compression: 4:1, 16 bytes per block)
D3DFMT_DXT3, // Renderer::TextureFormat::BC2_SRGB - DXT3 compression (known as BC2 in DirectX 10, RGBA compression: 4:1, 16 bytes per block); sRGB = RGB hardware gamma correction, the alpha channel always remains linear - TODO(co) DirectX 9 sRGB format
D3DFMT_DXT5, // Renderer::TextureFormat::BC3 - DXT5 compression (known as BC3 in DirectX 10, RGBA compression: 4:1, 16 bytes per block)
D3DFMT_DXT5, // Renderer::TextureFormat::BC3_SRGB - DXT5 compression (known as BC3 in DirectX 10, RGBA compression: 4:1, 16 bytes per block); sRGB = RGB hardware gamma correction, the alpha channel always remains linear - TODO(co) DirectX 9 sRGB format
FOURCC_ATI1N, // Renderer::TextureFormat::BC4 - 1 component texture compression (also known as 3DC+/ATI1N, known as BC4 in DirectX 10, 8 bytes per block) - See "Advanced DX9 Capabilities for ATI Radeon Cards" by "AMD Graphics Products Group" - "Texture Formats: ATI2N and ATI1N" - http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/Advanced-DX9-Capabilities-for-ATI-Radeon-Cards_v2.pdf
FOURCC_ATI2N, // Renderer::TextureFormat::BC5 - 2 component texture compression (luminance & alpha compression 4:1 -> normal map compression, also known as 3DC/ATI2N, known as BC5 in DirectX 10, 16 bytes per block) - See "Advanced DX9 Capabilities for ATI Radeon Cards" by "AMD Graphics Products Group" - "Texture Formats: ATI2N and ATI1N" - http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/Advanced-DX9-Capabilities-for-ATI-Radeon-Cards_v2.pdf
D3DFMT_UNKNOWN, // Renderer::TextureFormat::ETC1 - 3 component texture compression meant for mobile devices - not supported in Direct3D 9
D3DFMT_L16, // Renderer::TextureFormat::R16_UNORM - 16-bit unsigned-normalized-integer format that supports 16 bits for the red channel
D3DFMT_UNKNOWN, // Renderer::TextureFormat::R32_UINT - 32-bit unsigned integer format TODO(co) Not available in Direct3D 9 as it looks like
D3DFMT_R32F, // Renderer::TextureFormat::R32_FLOAT - 32-bit float format
D3DFMT_D32F_LOCKABLE, // Renderer::TextureFormat::D32_FLOAT - 32-bit float depth format TODO(co) Check depth texture format INTZ: http://aras-p.info/texts/D3D9GPUHacks.html and http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/Advanced-DX9-Capabilities-for-ATI-Radeon-Cards_v2.pdf
D3DFMT_UNKNOWN, // Renderer::TextureFormat::R16G16_SNORM - A two-component, 32-bit signed-normalized-integer format that supports 16 bits for the red channel and 16 bits for the green channel
D3DFMT_UNKNOWN, // Renderer::TextureFormat::R16G16_FLOAT - A two-component, 32-bit floating-point format that supports 16 bits for the red channel and 16 bits for the green channel
D3DFMT_UNKNOWN // Renderer::TextureFormat::UNKNOWN - Unknown
};
return MAPPING[textureFormat];
}
uint32_t Mapping::getDirect3D9PresentationInterval(const Renderer::Context& context, uint32_t synchronizationInterval)
{
RENDERER_ASSERT(context, synchronizationInterval <= 4, "Direct3D 9 supports a maximum synchronization interval of four")
static const uint32_t MAPPING[] =
{
D3DPRESENT_INTERVAL_IMMEDIATE,
D3DPRESENT_INTERVAL_ONE,
D3DPRESENT_INTERVAL_TWO,
D3DPRESENT_INTERVAL_THREE,
D3DPRESENT_INTERVAL_FOUR
};
return MAPPING[synchronizationInterval];
}
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
} // Direct3D9Renderer
|
#pragma once
#include "resource.h"
#include "common.h"
class CAdvancedDlg {
HWND hWndParent;
HWND hwndDlg;
INT_PTR CALLBACK DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
protected:
void OnInitDialog();
public:
CAdvancedDlg(HWND hParent) : hWndParent(hParent) {}
CAdvancedDlg() :hWndParent(0) {}
void SetHwnd(HWND hWnd) { hwndDlg = hWnd; }
INT_PTR CALLBACK DoModal();
static INT_PTR CALLBACK DialogProcDelegate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
// Retrieve a pointer to the instance of Widget
// that called DialogBoxParam.
CAdvancedDlg* const widget = GetDialogCaller<CAdvancedDlg>(hwnd, uMsg, wParam, lParam);
// Delegate the message handling.
return widget->DialogProc(uMsg, wParam, lParam);
}
};
|
#pragma once
#include <optional>
#include <string>
namespace ImageDimensions {
struct SImageDimensions {
uint32_t Width;
uint32_t Height;
};
std::optional<SImageDimensions> GetIMGDimensions(const std::string& file);
}
|
#include <cstdio>
int main() {
int raio;
double pi=3.14159;
scanf("%d", &raio);
printf("VOLUME = %.3lf\n", (4/3.0) * pi * raio*raio*raio);
}
|
#pragma once
#include "../../system.hpp"
#include <memory>
namespace sbg {
struct Entity;
struct ResultData;
struct CollisionResult {
CollisionResult() = default;
CollisionResult(std::weak_ptr<const Entity> other, const bool colliding, std::unique_ptr<const ResultData> data, Time time);
CollisionResult(const CollisionResult& other);
bool isColliding() const;
void colliding(const bool colliding);
Time getTime() const;
void setTime(Time time);
std::shared_ptr<const Entity> getOther() const;
void setOther(std::weak_ptr<const Entity> other);
const ResultData* getData() const;
void setData(std::unique_ptr<const ResultData> data);
private:
std::unique_ptr<const ResultData> _data;
std::weak_ptr<const Entity> _other;
bool _colliding = false;
Time _time;
};
}
|
/*
* Copyright 2016 Robert Bond
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <iostream>
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include "opencv2/core/core.hpp"
#include "opencv2/gpu/gpu.hpp"
#include "opencv2/highgui/highgui.hpp"
using namespace std;
using namespace cv;
using namespace cv::gpu;
#include "hw.h"
#include "util.h"
#include "neuro.h"
#include "ants.h"
#include "blobs.h"
#include "player.h"
// options
bool accurate = false;
bool alternate_frame = false;
bool dont_correct = false;
bool draw_laser = false;
bool fake_laser = false;
bool overlay_laser = false;
bool movie = false;
bool no_ants = false;
bool neural_class = false;
bool play_ants = false;
bool plot_predictions = false;
bool random_moves = false;
bool show_mog = false;
bool take_snapshots = false;
bool sql_backlash = false;
bool verbose = false;
struct option {
const char *opt;
bool *vbl;
const char *msg;
} opts[] = {
{ "-a", &alternate_frame, "Alternate frame display enabled" },
{ "-c", &accurate, "Repeat corrections until loop closed" },
{ "-d", &dont_correct, "Don't do closed loop corrections" },
{ "-f", &fake_laser, "Fake the laser coms" },
{ "-l", &draw_laser, "Draw the laser on the screen" },
{ "-O", &overlay_laser, "Overlay the laser on a movie" },
{ "-o", &show_mog, "Show mog window enabled" },
{ "-m", &movie, "Use /media/rgb/6633-6433/ants.avi as source" },
{ "-n", &no_ants, "No ants" },
{ "-N", &neural_class, "Use neural network to classify images" },
{ "-p", &play_ants, "Replay ants from recorded positions" },
{ "-P", &plot_predictions, "Plot predictions for ant movement" },
{ "-r", &random_moves, "Do random moves" },
{ "-s", &sql_backlash, "Save sql formatted backlash data" },
{ "-S", &take_snapshots, "Take snapshots of the ants and laser" },
{ "-v", &verbose, "Verbose logging" },
{ NULL, NULL, NULL }
};
// Need something better than these globals
int frame_index = 0;
uint64_t frame_ticks = 0;
double total_frame_time = 0;
double average_frame_time = 0;
double tps;
backlash *pbl;
hw *phw;
laser *plas;
ants *pan;
player *play;
snapshots *psnap;
image_classifier *pclass;
bool mouse_click;
running_average laser_frame_lag(10);
static void onMouse(int event, int px, int py, int flags, void* userdata)
{
if (event != EVENT_LBUTTONDOWN)
return;
// Assume we clicked on a 1/2 size window
px = px * 2;
py = py * 2;
if (!phw->keepout(px, py, 1)) {
phw->do_move(px, py, frame_index, "onMouse");
mouse_click = true;
} else {
DPRINTF("In keepout: %d %d\n", px, py);
}
}
inline double normal(double mean, double sigma)
{
double u1 = (double)rand()/(double)RAND_MAX;
double u2 = (double)rand()/(double)RAND_MAX;
return sqrt(-2.0 * log(u1)*sigma*sigma)*cos(2.0 * M_PI * u2) + mean;
}
void move_randomly(bool *pdone)
{
static int count = 400;
if (count == 0) {
count = -1;
phw->do_move(xpix/2, ypix/2, frame_index, "Home");
return;
} else if (count == -1) {
*pdone = true;
return;
}
--count;
int px = round(normal(640, 100));
int py = round(normal(480, 75));
px = px > 100 ? px : 100;
px = px < 1180 ? px : 1180;
py = py > 100 ? py : 100;
py = py < 860 ? py : 860;
phw->do_move(px, py, frame_index, "random move");
}
bool ant_looker(bool do_move)
{
struct rec_list *precs;
int px, py;
bool retval = false;
struct ant_list *best_ant;
if (no_ants)
return false;
best_ant = pan->select_ant();
if (do_move && best_ant != NULL) {
pan->predict_next_pos(best_ant, &px, &py);
DPRINTF("ant_looker: %4d %4d frame: %d\n", px, py, frame_index);
phw->do_move(px, py, frame_index, " ant");
retval = true;
}
return retval;
}
// Laser blobs are full of bright pixels.
#define LT 250
inline bool laser_blob(const struct rec_list *pn, Mat &frame, Mat &fg)
{
if (neural_class) {
std::vector<float> image_type;
image_type = pclass->get_image_type(&frame, Point(pn->xc, pn->yc));
return image_type[laser_index] > 0.9f;
} else {
int lcount = 0;
// cout << "laser_blob looking at " << pn->rect << endl;
for (int y = pn->rect.y; y < pn->rect.y + pn->rect.height; y++) {
for (int x = pn->rect.x; x < pn->rect.x + pn->rect.width; x++) {
if (fg.at<uchar>(y, x) == LT && frame.at<uchar>(y, x) > LT)
lcount++;
DPRINTF("%3d ", frame.at<uchar>(y, x));
}
DPRINTF("\n");
}
DPRINTF("laser_blob counted %d\n", lcount);
return lcount > 60;
}
}
bool find_laser(Mat &frame, Mat& fg, int xc, int yc, int size, Point ¢er, Rect &r)
{
int half_size = size/2;
int xs = std::max(xc - half_size, 0);
int ys = std::max(yc - half_size, 0);
int xe = std::min(xc + half_size, fg.cols);
int ye = std::min(yc + half_size, fg.rows);
Rect roi(Point(xs, ys), Point(xe, ye));
struct rec_list *blobs = find_bbb(fg, roi, phw, 250);
// Check to see which blobs might be the laser
bool got_laser = false;
while(blobs) {
struct rec_list *pn = blobs;
if (got_laser == false && pn->npix > 80) {
if (laser_blob(pn, frame, fg)) {
center.x = pn->xc;
center.y = pn->yc;
r = pn->rect;
got_laser = true;
if (take_snapshots)
psnap->snap_laser(center);
DPRINTF("Found laser at %d, %d, npix = %d\n",
center.x, center.y, pn->npix);
}
}
blobs = blobs->pnext;
delete pn;
}
return got_laser;
}
// Returns true if moved laser
bool correct(Mat& frame, Point ¢er, Rect &box)
{
bool moved_laser = false;
if (dont_correct)
return false;
phw->pxy_to_loc(center.x, center.y, &phw->cur_loc);
int tx = phw->target.px;
int ty = phw->target.py;
int dx = tx - center.x;
int dy = ty - center.y;
double dist = sqrt((double)(dx*dx) + (double)(dy*dy));
if (dist > 3.0 && !box.contains(Point(tx, ty))) {
DPRINTF("Correct: %d, %d target: %d %d frame: %d\n",
center.x, center.y, tx, ty, frame_index);
phw->do_correction(tx, ty, frame_index, " correct");
moved_laser = true;
} else {
pbl->stop(phw);
pbl->dumpit();
}
return moved_laser;
}
inline int border(int i)
{
double x = i * 2;
return (int)round(0.000362 * x * x - 0.511 * x + 220.732)/2;
}
VIBE_GPU vibe;
// Main pixel porcessing
void process_frame(VideoCapture &ccap, VideoCapture &mcap,
Mat &frame, Mat &fg, Mat &half, Mat &half_fg)
{
if (movie)
mcap.read(frame);
else
ccap.read(frame);
if (frame.empty()) {
printf("Can't read a movie frame!\n");
exit(1);
}
if (draw_laser)
plas->draw_laser(frame);
if (play_ants)
play->add_ant(frame);
// Load up the frames
GpuMat d_frame(frame);
GpuMat d_tmp;
if (movie && overlay_laser) {
Mat overlay;
ccap.read(overlay);
if (overlay.empty()) {
printf("Can't read an overlay frame!\n");
exit(1);
}
GpuMat d_overlay(overlay);
gpu::threshold(d_overlay, d_overlay, 250.0, 255.0, THRESH_BINARY);
gpu::bitwise_or(d_overlay, d_frame, d_frame);
d_frame.download(frame);
}
// Process fg/bg
GpuMat d_fg;
vibe.operator()(d_frame, d_fg);
if (countNonZero(d_fg, d_tmp) > 1000) {
// The bg processing blew up...
printf("Background frame reset!\n");
vibe.initialize(d_frame);
d_fg = Scalar(0); // No pixels this frame
}
d_fg.download(fg);
// Make a displayable frame
if (verbose) {
GpuMat d_half;
gpu::pyrDown(d_frame, d_half);
d_half.download(half);
}
// Setup mog display
if (verbose && show_mog) {
GpuMat d_half_fg;
gpu::pyrDown(d_fg, d_half_fg);
d_half_fg.download(half_fg);
}
}
int main(int argc, char* argv[])
{
int64 st;
Mat frame;
Mat fg;
Mat half;
Mat half_fg;
uint32_t frame_count = 1000000;
printf("units\n");
++argv;
while (--argc) {
for (struct option *p = opts; p->opt; p++) {
if (strcmp(*argv, p->opt) == 0) {
*p->vbl = true;
printf("%s\n", p->msg);
}
}
argv++;
}
fflush(stdout);
pbl = new backlash();
phw = new hw(pbl);
plas = new laser(phw, false);
pclass = new image_classifier();
if (take_snapshots)
psnap = new snapshots(&frame);
pan = new ants(phw, &frame, &fg, &half_fg, psnap, pclass);
if (play_ants)
play = new player("ants.pos");
// The camera video file for reading
VideoCapture ccap;
// The movie video file
VideoCapture mcap;
if (verbose) {
namedWindow("Units", CV_WINDOW_AUTOSIZE);
setMouseCallback("Units", onMouse, NULL);
}
if (alternate_frame)
namedWindow("laser", CV_WINDOW_AUTOSIZE);
if (show_mog)
namedWindow("mog", CV_WINDOW_AUTOSIZE);
if (movie) {
// mcap.open("/media/rgb/6633-6433/ants.avi");
mcap.open("/home/rgb/ants2.avi");
frame_count = (uint32_t)mcap.get(CV_CAP_PROP_FRAME_COUNT);
// account for a few skipped frames;
frame_count -= frame_count / 20;
printf("%u frames in the movie\n", frame_count);
phw->pxy_to_loc(xpix/2, ypix/2, &phw->cur_loc);
phw->do_move(xpix/2, ypix/2, frame_index, "Start");
if (!mcap.isOpened()) {
cout << "Cannot open the video file" << endl;
return -1;
}
}
if (!movie || overlay_laser) {
ccap.open(0);
if (!ccap.isOpened()) {
cout << "Cannot open the video file" << endl;
return -1;
}
}
// Get things running
// Warm up the fg/bg window
// Then fire up the laser
// Give it a couple of frames for the laser to start
for (int i = 0; i < 5 || !phw->hw_idle(); i++) {
process_frame(ccap, mcap, frame, fg, half, half_fg);
if (i == 3)
plas->laser_on();
if (verbose) {
imshow("Units", half);
if (show_mog)
imshow("mog", half_fg);
waitKey(1);
}
}
// Try to start off at the center
Point lcenter;
Rect lbox;
bool found_laser = false;
int ntries = 0;
while (!found_laser && ntries++ < 20) {
process_frame(ccap, mcap, frame, fg, half, half_fg);
if (verbose) {
imshow("Units", half);
if (show_mog)
imshow("mog", half_fg);
if (waitKey(1) > 0) {
printf("Bailing in startup\n");
while (!phw->hw_idle())
;
phw->shutdown();
exit(1);
}
}
if (find_laser(frame, fg, xpix/2, ypix/2, xpix, lcenter, lbox))
found_laser = true;
sleep(1);
}
if (found_laser) {
DPRINTF("Found laser on startup at %d %d\n", lcenter.x, lcenter.y);
phw->pxy_to_loc(lcenter.x, lcenter.y, &phw->cur_loc);
phw->do_move(xpix/2, ypix/2, frame_index, "Start");
phw->set_home();
} else {
printf("No laser on startup\n");
while (!phw->hw_idle())
;
phw->shutdown();
exit(1);
}
plas->laser_off();
while (!phw->hw_idle())
/* spin */ ;
pbl->start(phw, 0.0, 0.0);
bool done = false;
enum state {
idle_laser_off,
idle_1,
idle_2,
delay_1,
delay_2,
wait_laser,
};
const char *state_labels[] = {
[idle_laser_off] = "idle_laser_off",
[idle_1] = "idle_1",
[idle_2] = "idle_2",
[delay_1] = "delay_1",
[delay_2] = "delay_2",
[wait_laser] = "wait_laser",
};
enum state cur_state = idle_1;
tps = getTickFrequency();
int laser_on_frame = 0;
laser_frame_lag.add_item(3);
while(!done) {
double dt;
Point left, right, top, bottom;
bool laser_vis = false;
double tstart, tpix, twork, tend;
frame_ticks = getTickCount(); // exported to ants.cpp
tstart = frame_ticks/tps;
int laser_frame_delay;
process_frame(ccap, mcap, frame, fg, half, half_fg);
tpix = getTickCount()/tps;
frame_index++;
if (!--frame_count)
done = true;
if (mouse_click) {
mouse_click = false;
cur_state = idle_1;
}
enum state next_state = cur_state;
DPRINTF("cur_state: %s\n", state_labels[cur_state]);
Point lcenter;
Rect lbox;
laser_vis = find_laser(frame, fg, phw->target.px,
phw->target.py, 100, lcenter, lbox);
if (laser_vis) {
if (laser_on_frame != 0)
{
laser_frame_lag.add_item((double)(frame_index - laser_on_frame));
laser_on_frame = 0;
}
}
DPRINTF("laser: %s\n", laser_vis ? "on" : "off");
switch (cur_state) {
case idle_laser_off:
if(random_moves) {
move_randomly(&done);
next_state = idle_1;
} else if (!laser_vis && ant_looker(true)) {
next_state = idle_1;
}
break;
case idle_1:
if (phw->hw_idle()) {
plas->laser_on();
next_state = delay_1;
laser_on_frame = frame_index;
} else if (!laser_vis) {
ant_looker(false);
}
break;
case delay_1:
if (phw->hw_idle()) {
plas->laser_off();
laser_frame_delay = (int)round(laser_frame_lag.average()) + 1;
if (laser_vis) {
if (correct(frame, lcenter, lbox))
next_state = idle_2;
else
next_state = delay_2;
} else {
ant_looker(false);
next_state = wait_laser;
}
} else {
ant_looker(false);
}
break;
case wait_laser:
if (laser_vis) {
if (correct(frame, lcenter, lbox))
next_state = idle_2;
else
next_state = delay_2;
} else {
ant_looker(false);
--laser_frame_delay;
// Give up if we don't see it
if (laser_frame_delay == 0)
next_state = delay_2;
}
break;
case delay_2:
if (!laser_vis) {
next_state = idle_laser_off;
ant_looker(false);
}
break;
case idle_2:
if (phw->hw_idle()) {
if (accurate) {
plas->laser_on();
next_state = delay_1;
} else {
next_state = delay_2;
}
} else {
if (!laser_vis)
ant_looker(false);
}
break;
};
// DPRINTF("next_state: %s\n", state_labels[next_state]);
cur_state = next_state;
left.x = 0;
left.y = half.rows / 2;
right.x = half.cols;
right.y = left.y;
top.x = half.cols / 2;
top.y = 0;
bottom.x = top.x;
bottom.y = half.rows;
line(half, left, right, Scalar(255, 255, 255));
line(half, top, bottom, Scalar(255, 255, 255));
#if 0
for (int i = 0; i <= half.cols - 16; i += 16) {
left.x = i;
left.y = border(i);
right.x = i + 16;
right.y = border(i + 16);
line(half, left, right, Scalar(255, 255, 255));
}
#endif
twork = getTickCount()/tps;
if (verbose) {
if (show_mog) {
pan->draw_ants();
imshow("mog", half_fg);
}
if (alternate_frame && laser_vis) {
imshow("laser", half);
} else {
if (plot_predictions)
pan->plot_predictions(half);
imshow("Units", half);
}
}
// Wait 1ms or for any key
if((waitKey(1) & 0xff) == 27)
done = true;
tend = getTickCount()/tps;
double loop_total = tend - tstart;
total_frame_time += loop_total;
average_frame_time = total_frame_time / (double) frame_index;
DPRINTF("Loop time: %d Pix: %d Work: %d Overhead: %d Average: %d frame: %d\n",
(int)round((loop_total)*1000.0),
(int)round((tpix-tstart)*1000.0),
(int)round((twork-tpix)*1000.0),
(int)round((tend-twork)*1000.0),
(int)round(average_frame_time*1000.0),
frame_index);
}
while (!phw->hw_idle())
;
phw->shutdown();
if (verbose)
destroyWindow("Units");
if (show_mog)
destroyWindow("mog");
if (alternate_frame)
destroyWindow("laser");
vibe.release();
exit(0);
}
|
#include <iostream>
#include <conio.h>
#include <cstdio>
class geometri
{
private:
int volume; // обьем
int height; // высота
int number_gran; // кол-во граней
int size_side; // длина сторон
int footprint; // площадь основания
public:
void setgeometri(int *i)
{
std::cout << "Введите обьем " << *i + 1 << " призмы: ";
std::cin >> volume;
std::cout << "Введите высоту " << *i + 1 << " призмы: ";
std::cin >> height;
std::cout << "Введите кол-во граней " << *i + 1 << " призмы: ";
std::cin >> number_gran;
std::cout << "Введите длину сторон " << *i + 1 << " призмы: ";
std::cin >> size_side;
std::cout << "Введите площадь основания " << *i + 1 << " призмы: ";
std::cin >> footprint;
std::cout << std::endl;
}
void show(int *i)
{
std::cout << *i + 1 << ") Обьем: " << volume << " высота: " << height << " кол-во граней: " << number_gran << " длины сторон: " << size_side << " площадь основания: " << footprint << std::endl;
}
void change(int *parametr, int *znachenie)
{
switch (*parametr)
{
case 1: volume = *znachenie; break;
case 2: height = *znachenie; break;
case 3: number_gran = *znachenie; break;
case 4: size_side = *znachenie; break;
case 5: footprint = *znachenie; break;
}
}
};
void menu();
void add(bool *flag,int *number, geometri prism[]);
int main()
{
setlocale(LC_ALL, "rus");
std::cout << "Введите кол-во призм:";
int number;
std::cin >> number;
geometri *prism = new geometri[number]; // т.к. использую динамический массив а не вектор то призмы не будут
bool *flag = new bool[number]; // добавляться если все слоты под их забиты
std::cout << "Заполнение:\n";
for (int i = 0; i < number; i++)
{
prism[i].setgeometri(&i);
flag[i] = true;
}
int choice;
do
{
menu();
std::cin >> choice;
switch (choice)
{
case 1:
{
system("cls");
for (int i = 0; i < number; i++)
if (flag[i] == true)
prism[i].show(&i);
_getch();
break;
}
case 2: add(flag,&number,prism); break;
case 3:
{
std::cout << "Введите номер призмы которую хотите удалить: ";
int number;
std::cin >> number;
flag[number - 1] = false;
break;
}
case 4:
{
std::cout << "Введите номер призмы:";
int number, parametr, znachenie;
std::cin >> number;
std::cout << "Введите номер параметра который хотите сменить:";
std::cin >> parametr;
std::cout << "Введите новое значение:";
std::cin >> znachenie;
prism[number - 1].change(¶metr,&znachenie);
}
}
}while (choice != 0);
delete[] prism;
delete[] flag;
}
void menu()
{
system("cls");
std::cout << "1) Список призм\n";
std::cout << "2) Добавление призмы\n";
std::cout << "3) Удаление призмы\n";
std::cout << "4) Изменение параметра призмы\n";
std::cout << "0) Выход\n";
}
void add(bool *flag, int *number, geometri prism[])
{
system("cls");
for (int i = 0; i < *number; i++)
{
if (flag[i] == false)
{
prism[i].setgeometri(&i);
flag[i] = true;
break;
}
else
if (i == *number - 1)
{
std::cout << "EROR, все слоты забиты, сначала удалите любую призму";
_getch();
break;
}
}
}
|
#include <QDebug>
#include <QNetworkDatagram>
#include <QNetworkInterface>
#include "udpfinderserver.h"
UdpFinderServer::UdpFinderServer(QObject *parent) : QObject(parent)
{
startServer(89683);
}
void UdpFinderServer::startServer(quint16 port)
{
m_udpSocket.bind(port);
connect(&m_udpSocket, SIGNAL(readyRead()), this, SLOT(dataRecieved()));
}
QString UdpFinderServer::name() const
{
return m_name;
}
void UdpFinderServer::setName(QString name)
{
if (m_name == name)
return;
m_name = name;
emit nameChanged(m_name);
}
void UdpFinderServer::dataRecieved()
{
while (m_udpSocket.hasPendingDatagrams())
{
QNetworkDatagram datagram = m_udpSocket.receiveDatagram();
foreach(auto address, QNetworkInterface::allAddresses())
{
if(datagram.senderAddress().isEqual(address))
{
qDebug() << "Server: local client " << datagram.senderAddress();
return;
}
}
QNetworkDatagram datagramm;
datagramm.setDestination(datagram.senderAddress(), 89683);
QByteArray data;
for(int i = 0; i < 4; i++)
data.append(i);
datagramm.setData(data);
m_udpSocket.writeDatagram(datagramm);
}
}
|
/*
PROBLEM: http://codeforces.com/contest/368/problem/B
NOTES: I used use maps to avoid time limit exceptions.
AUTHOR: Daniel Caņizares Corrales
Systems Engineer [Professor]
Universidad Católica de Oriente
dacanizares@outlook.com
LICENCE: MIT License
Copyright (C) 2013 Daniel Caņizares Corrales
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
int main()
{
int n, m;
while(cin >> n >> m)
{
int a[n];
for(int i = 0; i < n; ++i)
{
int value;
cin >> value;
a[i] = value;
}
// Calculate solution
int solution[n];
// We use a map to count just distinct numbers
map<int,bool> different;
for(int i = n - 1; i >= 0; i--)
{
different[a[i]] = true;
solution[i] = different.size();
}
for(int i = 0; i < m; ++i)
{
int value;
cin >> value;
cout << solution[value - 1] << endl;
}
}
}
|
#include <chrono>
#include <iostream>
#include "xgb.hpp"
#include "m2cgen.hpp"
// https://stackoverflow.com/questions/22387586/measuring-execution-time-of-a-function-in-c/22387757
class Timer {
public:
Timer() : t1_(std::chrono::high_resolution_clock::now()) {}
~Timer() {
auto t2 = std::chrono::high_resolution_clock::now();
auto timeSpan = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1_);
std::cout << "elapsed: " << timeSpan.count() << "\n";
}
private:
std::chrono::high_resolution_clock::time_point t1_;
};
void testMultiClassPrediction(const std::string& modelDir) {
std::cout << "multi class prediction: " << std::endl;
std::vector<std::string> features {
"sepal length (cm)",
"sepal width (cm)",
"petal length (cm)",
"petal width (cm)"
};
std::vector<float> inputs {5.1, 3.5, 1.4, 0.2};
int numClass = 3;
std::string modelCheckpoint = modelDir + "/multi_class.txt";
gbt::XGBoostPredictor gbtPredictor(modelCheckpoint, features, numClass);
std::vector<float> prediction = gbtPredictor.predict(inputs);
gbt::softmax(prediction);
for (float prob: prediction) {
std::cout << prob << " ";
}
std::cout << std::endl;
};
void testBinaryClassPrediction(const std::string& modelDir) {
std::cout << "binary class prediction: " << std::endl;
std::vector<std::string> features {"f0", "f1", "f2", "f3", "f4"};
std::vector<float> inputs {0.0, 0.2, 0.4, 0.6, 0.8};
int numClass = 1;
std::string modelCheckpoint = modelDir + "/binary_class.txt";
gbt::XGBoostPredictor gbtPredictor(modelCheckpoint, features, numClass);
std::vector<float> prediction = gbtPredictor.predict(inputs);
for (float score: prediction) {
float prob = gbt::logistic(score);
std::cout << prob << " ";
}
std::cout << std::endl;
};
void testRegressionPrediction(const std::string& modelDir) {
std::cout << "regression prediction: " << std::endl;
std::vector<std::string> features {"age", "sex", "bmi", "bp"};
std::vector<float> inputs {0.038, 0.051, 0.062, 0.022};
int numClass = 1;
std::string modelCheckpoint = modelDir + "/regression.txt";
gbt::XGBoostPredictor gbtPredictor(modelCheckpoint, features, numClass);
std::vector<float> prediction = gbtPredictor.predict(inputs);
for (float score: prediction) {
std::cout << score << " ";
}
std::cout << std::endl;
std::cout << "m2cgen regression prediction: " << std::endl;
// m2cgen expects double instead of float
std::vector<double> inputs2(inputs.begin(), inputs.end());
double score = gbt::score(inputs2.data());
std::cout << score << std::endl;
// time the predicton using two different inferencing implementation
size_t iterations = 1000;
{
Timer timer;
for (size_t i = 0; i < iterations; i++) {
prediction = gbtPredictor.predict(inputs);
}
}
{
Timer timer;
for (size_t i = 0; i < iterations; i++) {
score = gbt::score(inputs2.data());
}
}
};
int main(int, char**) {
std::string modelDir = "/Users/mingyuliu/machine-learning/model_deployment/gbt_inference";
testRegressionPrediction(modelDir);
testBinaryClassPrediction(modelDir);
testMultiClassPrediction(modelDir);
return 0;
}
|
//
// Created by abel_ on 13-10-2022.
//
#include <vector>
#include <tuple>
#include <string>
#include <stack>
#include <unordered_set>
#include <iostream>
#include <unordered_map>
#include <algorithm>
int shortestPath(std::vector<std::tuple<std::string, std::string>> edges, std::string nodeA, std::string nodeB) {
std::unordered_map<std::string,std::vector<std::string>> graph;
for (auto edge : edges) {
auto [src, dst] = edge;
graph[src].push_back(dst);
graph[dst].push_back(src);
}
std::stack<std::tuple<std::string,int>> stack;
std::unordered_set<std::string> visited;
stack.push({nodeA,0});
while(!stack.empty()){
auto [currentNode, distance] = stack.top();
visited.insert(currentNode);
stack.pop();
if(currentNode == nodeB) return distance;
if(std::find(graph[currentNode].begin(),graph[currentNode].end(),nodeB) != graph[currentNode].end()) return distance + 1;
for (auto neighbour : graph[currentNode]) {
if(visited.count(neighbour) == 0){
stack.push({neighbour,distance+1});
}
}
}
return -1;
}
int main(){
std::vector<std::tuple<std::string, std::string>> edges {
{"w", "x"},
{"x", "y"},
{"z", "y"},
{"z", "v"},
{"w", "v"}
};
std::cout<<shortestPath(edges, "w", "z"); // -> 2
return 0;
}
|
int Solution::maxSubArray(const vector<int> &A) {
int currSum = 0;
int maxSum = INT_MIN;
for (int i = 0; i < A.size(); i++)
{
currSum += A[i];
if (currSum > maxSum)
maxSum = currSum;
if (currSum < 0)
currSum = 0;
}
return maxSum;
}
|
// Created on: 1999-09-10
// Created by: Andrey BETENEV
// Copyright (c) 1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _STEPConstruct_Styles_HeaderFile
#define _STEPConstruct_Styles_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TColStd_SequenceOfTransient.hxx>
#include <STEPConstruct_Tool.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <STEPConstruct_DataMapOfAsciiStringTransient.hxx>
#include <STEPConstruct_DataMapOfPointTransient.hxx>
class XSControl_WorkSession;
class StepVisual_StyledItem;
class StepRepr_RepresentationItem;
class StepVisual_PresentationStyleAssignment;
class TopoDS_Shape;
class StepRepr_RepresentationContext;
class StepVisual_MechanicalDesignGeometricPresentationRepresentation;
class StepShape_ContextDependentShapeRepresentation;
class StepRepr_ProductDefinitionShape;
class StepVisual_Colour;
class Quantity_Color;
//! Provides a mechanism for reading and writing shape styles
//! (such as color) to and from the STEP file
//! This tool maintains a list of styles, either taking them
//! from STEP model (reading), or filling it by calls to
//! AddStyle or directly (writing).
//! Some methods deal with general structures of styles and
//! presentations in STEP, but there are methods which deal
//! with particular implementation of colors (as described in RP)
class STEPConstruct_Styles : public STEPConstruct_Tool
{
public:
DEFINE_STANDARD_ALLOC
//! Creates an empty tool
Standard_EXPORT STEPConstruct_Styles();
//! Creates a tool and initializes it
Standard_EXPORT STEPConstruct_Styles(const Handle(XSControl_WorkSession)& WS);
//! Initializes tool; returns True if succeeded
Standard_EXPORT Standard_Boolean Init (const Handle(XSControl_WorkSession)& WS);
//! Returns number of defined styles
Standard_EXPORT Standard_Integer NbStyles() const;
//! Returns style with given index
Standard_EXPORT Handle(StepVisual_StyledItem) Style (const Standard_Integer i) const;
//! Returns number of override styles
Standard_EXPORT Standard_Integer NbRootStyles() const;
//! Returns override style with given index
Standard_EXPORT Handle(StepVisual_StyledItem) RootStyle (const Standard_Integer i) const;
//! Clears all defined styles and PSA sequence
Standard_EXPORT void ClearStyles();
//! Adds a style to a sequence
Standard_EXPORT void AddStyle (const Handle(StepVisual_StyledItem)& style);
//! Create a style linking giving PSA to the item, and add it to the
//! sequence of stored styles. If Override is not Null, then
//! the resulting style will be of the subtype OverridingStyledItem.
Standard_EXPORT Handle(StepVisual_StyledItem) AddStyle (const Handle(StepRepr_RepresentationItem)& item, const Handle(StepVisual_PresentationStyleAssignment)& PSA, const Handle(StepVisual_StyledItem)& Override);
//! Create a style linking giving PSA to the Shape, and add it to the
//! sequence of stored styles. If Override is not Null, then
//! the resulting style will be of the subtype OverridingStyledItem.
//! The Sape is used to find corresponding STEP entity by call to
//! STEPConstruct::FindEntity(), then previous method is called.
Standard_EXPORT Handle(StepVisual_StyledItem) AddStyle (const TopoDS_Shape& Shape, const Handle(StepVisual_PresentationStyleAssignment)& PSA, const Handle(StepVisual_StyledItem)& Override);
//! Create MDGPR, fill it with all the styles previously defined,
//! and add it to the model
Standard_EXPORT Standard_Boolean CreateMDGPR (const Handle(StepRepr_RepresentationContext)& Context, Handle(StepVisual_MechanicalDesignGeometricPresentationRepresentation)& MDGPR);
//! Create MDGPR, fill it with all the styles previously defined,
//! and add it to the model
//! IMPORTANT: <initPDS> must be null when use for NAUO colors
//! <initPDS> initialised only for SHUO case.
Standard_EXPORT Standard_Boolean CreateNAUOSRD (const Handle(StepRepr_RepresentationContext)& Context, const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR, const Handle(StepRepr_ProductDefinitionShape)& initPDS);
//! Searches the STEP model for the RepresentationContext in which
//! given shape is defined. This context (if found) can be used
//! then in call to CreateMDGPR()
Standard_EXPORT Handle(StepRepr_RepresentationContext) FindContext (const TopoDS_Shape& Shape) const;
//! Searches the STEP model for the MDGPR or DM entities
//! (which bring styles) and fills sequence of styles
Standard_EXPORT Standard_Boolean LoadStyles();
//! Searches the STEP model for the INISIBILITY entities
//! (which bring styles) and fills out sequence of styles
Standard_EXPORT Standard_Boolean LoadInvisStyles (Handle(TColStd_HSequenceOfTransient)& InvSyles) const;
//! Create a PresentationStyleAssignment entity which defines
//! two colors (for filling surfaces and curves)
//! if isForNAUO true then returns PresentationStyleByContext
Standard_EXPORT Handle(StepVisual_PresentationStyleAssignment) MakeColorPSA (const Handle(StepRepr_RepresentationItem)& item, const Handle(StepVisual_Colour)& SurfCol, const Handle(StepVisual_Colour)& CurveCol, const Handle(StepVisual_Colour) &RenderCol, const Standard_Real RenderTransp, const Standard_Boolean isForNAUO = Standard_False) const;
//! Returns a PresentationStyleAssignment entity which defines
//! surface and curve colors as Col. This PSA is either created
//! or taken from internal map where all PSAs created by this
//! method are remembered.
Standard_EXPORT Handle(StepVisual_PresentationStyleAssignment) GetColorPSA (const Handle(StepRepr_RepresentationItem)& item, const Handle(StepVisual_Colour)& Col);
//! Extract color definitions from the style entity
//! For each type of color supported, result can be either
//! NULL if it is not defined by that style, or last
//! definition (if they are 1 or more)
Standard_EXPORT Standard_Boolean GetColors (const Handle(StepVisual_StyledItem)& style, Handle(StepVisual_Colour)& SurfCol, Handle(StepVisual_Colour)& BoundCol, Handle(StepVisual_Colour)& CurveCol, Handle(StepVisual_Colour)& RenderCol, Standard_Real& RenderTransp, Standard_Boolean& IsComponent) const;
//! Create STEP color entity by given Quantity_Color
//! The analysis is performed for whether the color corresponds to
//! one of standard colors predefined in STEP. In that case,
//! PredefinedColour entity is created instead of RGBColour
Standard_EXPORT static Handle(StepVisual_Colour) EncodeColor (const Quantity_Color& Col);
//! Create STEP color entity by given Quantity_Color
//! The analysis is performed for whether the color corresponds to
//! one of standard colors predefined in STEP. In that case,
//! PredefinedColour entity is created instead of RGBColour
Standard_EXPORT static Handle(StepVisual_Colour) EncodeColor (const Quantity_Color& Col, STEPConstruct_DataMapOfAsciiStringTransient& DPDCs, STEPConstruct_DataMapOfPointTransient& ColRGBs);
//! Decodes STEP color and fills the Quantity_Color.
//! Returns True if OK or False if color is not recognized
Standard_EXPORT static Standard_Boolean DecodeColor (const Handle(StepVisual_Colour)& Colour, Quantity_Color& Col);
protected:
private:
TColStd_IndexedDataMapOfTransientTransient myMapOfStyles;
TColStd_IndexedMapOfTransient myStyles;
TColStd_IndexedMapOfTransient myRootStyles;
TColStd_SequenceOfTransient myPSA;
};
#endif // _STEPConstruct_Styles_HeaderFile
|
/* Rocket Drone 1.0
* Leitura de IMU, GPS, leitura de Xbee e escrita de 6 PWM
*
* Daniel S. Koda <danielskoda@gmail.com>
* 28.04.2016
*/
/* **********************
* Bibliotecas
************************/
// Biblioteca para o FreeRTOS
#include <FreeRTOS_AVR.h>
// Bibliotecas para a IMU
#include <Wire.h>
#include <ADXL345.h>
#include <L3G4200D.h>
#include <BMP085.h>
/* **********************
* Definições da IMU
************************/
//0011110b, I2C 7bit address of HMC5883
#define HMC5883_ADDRESS 0x1E
// I2C address of BMP085
#define BMP085_ADDRESS 0x77
ADXL345 acc;
L3G4200D gyro;
BMP085 bmp;
/***********************************
* Definições para o FreeRTOS
***********************************/
volatile uint32_t count = 0;
#define CONTROL_FREQUENCY 20
#define SERIAL_BAUD_RATE 19200
TaskHandle_t imuHandle;
/* ----------------------------------------------*/
/* Leitura do acelerômetro */
/* ----------------------------------------------*/
void ReadAccel ()
{
double Xg, Yg, Zg;
// Read Accelerometer
acc.read(&Xg, &Yg, &Zg);
// Three information about accelerometer
Serial.print(Xg);
Serial.print(" ");
Serial.print(Yg);
Serial.print(" ");
Serial.print(Zg);
Serial.print(" ");
}
/* ----------------------------------------------*/
/* Read gyroscope */
/* ----------------------------------------------*/
void ReadGyro ()
{
gyro.read();
Serial.print((int)gyro.g.x);
Serial.print(" ");
Serial.print((int)gyro.g.y);
Serial.print(" ");
Serial.print((int)gyro.g.z);
Serial.print(" ");
}
/* ----------------------------------------------*/
/* Read magnometometer */
/* ----------------------------------------------*/
void ReadMagn ()
{
int Mx,My,Mz;
// Tell the HMC5883 where to begin reading data
Wire.beginTransmission(HMC5883_ADDRESS);
Wire.write(0x03); //select register 3, X MSB register
Wire.endTransmission();
// Read data from each axis, 2 registers per axis
Wire.requestFrom(HMC5883_ADDRESS, 6);
if(6<=Wire.available()){
Mx = Wire.read()<<8; //Mx msb
Mx |= Wire.read(); //Mx lsb
Mz = Wire.read()<<8; //Mz msb
Mz |= Wire.read(); //Mz lsb
My = Wire.read()<<8; //My msb
My |= Wire.read(); //My lsb
}
// Print out values of each axis
Serial.print(Mx);
Serial.print(" ");
Serial.print(My);
Serial.print(" ");
Serial.print(Mz);
Serial.print(" ");
}
/* ----------------------------------------------*/
/* Barometer section */
/* ----------------------------------------------*/
void ReadPressure ()
{
Serial.print(bmp.readPressure());
//Serial.print(bmp.readAltitude());
Serial.print(" ");
}
/* ----------------------------------------------*/
/* Temperature section */
/* ----------------------------------------------*/
void ReadTemperature ()
{
Serial.print(bmp.readTemperature());
Serial.print(" ");
}
/* ----------------------------------------------*/
/* Read IMU */
/* ----------------------------------------------*/
static void vReadIMU (void *pvParameters)
{
unsigned long startTime, endTime, deltaTime;
TickType_t xLastWakeTime;
xLastWakeTime=xTaskGetTickCount();
while (1) {
/* To analyze time requirements, use:
*
* startTime = micros();
* ReadAccel();
* endTime = micros();
* Serial.println(endTime-startTime);
*/
ReadAccel();
ReadGyro();
ReadMagn();
ReadPressure();
ReadTemperature();
Serial.println();
vTaskDelayUntil(&xLastWakeTime,configTICK_RATE_HZ/CONTROL_FREQUENCY);
}
}
//------------------------------------------------------------------------------
void setup() {
Serial.begin(SERIAL_BAUD_RATE);
/* Configure IMU */
// Configure accelerometer
acc.begin();
// Configure I2C
Wire.begin ();
// Configure Gyroscope
gyro.enableDefault();
// Configure BMP085
bmp.begin();
// Put the HMC5883 IC into the correct operating mode
Wire.beginTransmission(HMC5883_ADDRESS); //open communication with HMC5883
Wire.write(0x02); //select mode register
Wire.write(0x00); //continuous measurement mode
Wire.endTransmission();
delay(100);
// create task to read IMU each 5 ms
xTaskCreate (vReadIMU, "ReadIMU", 200, NULL, tskIDLE_PRIORITY + 2, &imuHandle);
// start FreeRTOS
vTaskStartScheduler();
// should never return
Serial.println(F("Die"));
while(1);
}
void loop() {
while(1);
}
|
void helper(TreeNode *A, int B, vector<int> &ans, vector<int> temp){
if(ans.size()>0 || A==NULL)
return;
if(A->val==B){
temp.push_back(A->val);
ans = temp;
return;
}
temp.push_back(A->val);
helper(A->left,B,ans,temp);
helper(A->right,B,ans,temp);
}
vector<int> Solution::solve(TreeNode* A, int B){
vector<int> temp;
vector<int> ans;
//bool flag = false;
helper(A,B,ans,temp);
return ans;
}
|
#include "EDITLABLE.h"
#include "..\ApplicationManager.h"
EDITLABLE::EDITLABLE(ApplicationManager* pApp) :Action(pApp)
{
a = pApp;
}
EDITLABLE::~EDITLABLE(void)
{
}
void EDITLABLE::ReadActionParameters()
{
}
void EDITLABLE::Execute()
{
//Get Center point of the Gate
ReadActionParameters();
Output* pOut = pManager->GetOutput();
Input* pIn = pManager->GetInput();
string x;
Component** z = a->get_CompList();
//Calculate the rectangle Corners
for (int i = 0; i < a->get_compcount(); i++)
{
if (z[i]->get_selected() == true) {
x = pIn->GetSrting(pOut, z[i]->get_GraphicsInfo().x2, z[i]->get_GraphicsInfo().y2);
z[i]->setlable(x);
}
}
}
void EDITLABLE::Undo()
{}
void EDITLABLE::Redo()
{}
|
#include <iostream>
#include "list.hpp"
List::List() {
this->size = 0;
head = nullptr;
std::cout << "Default constructor works!" << std::endl;
}
List::List(List& li) {
std::cout << "Copy constructor works!" << std::endl;
}
List::List(List&& li) {
std::cout << "Move constructor works!" << std::endl;
}
List::~List() {
std::cout << "Delete constructor works!" << std::endl;
Node* temp;
while(head != nullptr) {
temp = head->next;
delete head;
head = temp;
}
delete head;
}
void List::insert(int index, int value) {
if(index > this->size || 0 > index) {
std::cout << "Wrong index!" << std::endl;
} else {
Node* newNode = new Node;
newNode->value = value;
newNode->next = nullptr;
Node* temp = head;
int count = 0;
while(count < index - 1) {
temp = temp->next;
++count;
}
newNode->next = temp->next;
temp->next = newNode;
++this->size;
}
}
void List::erase(int index) {
if(index > this->size || 0 > index) {
std::cout << "Wrong index!" << std::endl;
} else {
Node* temp = head;
int count = 0;
while(count < index - 1) {
temp = temp->next;
++count;
}
Node* tempAddress = temp->next->next;
temp->next = nullptr;
temp->next = tempAddress;
--this->size;
}
}
int List::getSize() {
return size;
}
int List::getElem(int index) {
if(index < this->size && size > 1) {
Node* temp = head;
int count = 0;
while(count != index) {
temp = temp->next;
++count;
}
return temp->value;
} else {
std::cout << "The list hasn't " << index << "-th element" << std::endl;
return 0;
}
}
void List::push(int value) {
++this->size;
Node* last = new Node;
last->value = value;
last->next = nullptr;
if(head == nullptr) {
head = last;
} else {
Node* temp = head;
while(temp->next != nullptr) {
temp = temp->next;
}
temp->next = last;
}
}
void List::pop() {
if(this->size < 1) {
std::cout << "Empty list!" << std::endl;
} else {
Node* temp = head;
int count = 0;
while(count < size-2) {
temp = temp->next;
++count;
}
temp->next = nullptr;
--this->size;
}
}
void List::printList() {
if(head == nullptr) {
std::cout << "Empty list!" << std::endl;
} else {
Node* temp = head;
while(temp->next != nullptr) {
std::cout << temp->value << " ";
temp = temp->next;
}
std::cout << temp->value;
std::cout << std::endl;
}
}
|
/* -*- Mode: c++; indent-tabs-mode: nil; c-file-style: "gnu" -*-
*
* Copyright (C) 1995-2005 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*/
#include "core/pch.h"
#ifdef XSLT_SUPPORT
# include "modules/xslt/src/xslt_recordingoutputhandler.h"
# include "modules/xslt/src/xslt_engine.h"
XSLT_RecordingOutputHandler::CommandEntry *
XSLT_RecordingOutputHandler::InsertCommandL (CommandEntry::Type type)
{
CommandEntry *command = OP_NEW_L (CommandEntry, ());
if (OpStatus::IsMemoryError (commands.Add (command)))
{
OP_DELETE (command);
LEAVE (OpStatus::ERR_NO_MEMORY);
}
command->type = type;
return command;
}
void
XSLT_RecordingOutputHandler::ReplayCommandsL (XSLT_OutputHandler *output_handler)
{
while (commands_offset < commands.GetCount ())
{
CommandEntry* command = commands.Get (commands_offset++);
switch (command->type)
{
case CommandEntry::START_ELEMENT:
output_handler->StartElementL (command->name);
break;
case CommandEntry::ADD_ATTRIBUTE:
output_handler->AddAttributeL (command->name, command->string1.CStr (), command->bool1, command->bool2);
break;
case CommandEntry::ADD_TEXT:
output_handler->AddTextL (command->string1.CStr (), command->bool1);
break;
case CommandEntry::ADD_COMMENT:
output_handler->AddCommentL (command->string1.CStr ());
break;
case CommandEntry::ADD_PROCESSING_INSTRUCTION:
output_handler->AddProcessingInstructionL (command->string1.CStr (), command->string2.CStr ());
break;
case CommandEntry::END_ELEMENT:
output_handler->EndElementL (command->name);
break;
case CommandEntry::END_OUTPUT:
output_handler->EndOutputL ();
break;
}
}
}
/* virtual */ void
XSLT_RecordingOutputHandler::StartElementL (const XMLCompleteName &name)
{
InsertCommandL (CommandEntry::START_ELEMENT)->name.SetL (name);
if (!has_root_element)
{
has_root_element = TRUE;
BOOL use_html_output = !name.GetUri () && uni_stri_eq (name.GetLocalPart (), "html");
engine->SetDetectedOutputMethod (use_html_output ? XSLT_Stylesheet::OutputSpecification::METHOD_HTML : XSLT_Stylesheet::OutputSpecification::METHOD_XML);
}
}
/* virtual */ void
XSLT_RecordingOutputHandler::AddAttributeL (const XMLCompleteName &name, const uni_char *value, BOOL id, BOOL specified)
{
CommandEntry *command = InsertCommandL (CommandEntry::ADD_ATTRIBUTE);
command->name.SetL (name);
command->string1.SetL (value);
command->bool1 = id;
command->bool2 = specified;
}
/* virtual */ void
XSLT_RecordingOutputHandler::AddTextL (const uni_char *data, BOOL disable_output_escaping)
{
CommandEntry *command = InsertCommandL (CommandEntry::ADD_TEXT);
command->string1.SetL (data);
command->bool1 = disable_output_escaping;
}
/* virtual */ void
XSLT_RecordingOutputHandler::AddCommentL (const uni_char *data)
{
InsertCommandL (CommandEntry::ADD_COMMENT)->string1.SetL (data);
}
/* virtual */ void
XSLT_RecordingOutputHandler::AddProcessingInstructionL (const uni_char *target, const uni_char *data)
{
CommandEntry *command = InsertCommandL (CommandEntry::ADD_PROCESSING_INSTRUCTION);
command->string1.SetL (target);
command->string2.SetL (data);
}
/* virtual */ void
XSLT_RecordingOutputHandler::EndElementL (const XMLCompleteName &name)
{
InsertCommandL (CommandEntry::END_ELEMENT)->name.SetL (name);
}
/* virtual */ void
XSLT_RecordingOutputHandler::EndOutputL ()
{
InsertCommandL (CommandEntry::END_OUTPUT);
if (!has_root_element)
engine->SetDetectedOutputMethod (XSLT_Stylesheet::OutputSpecification::METHOD_XML);
}
#endif // XSLT_SUPPORT
|
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <list>
#include <algorithm>
#include <sstream>
#include <set>
#include <cmath>
#include <map>
#include <stack>
#include <queue>
#include <numeric>
#include <stdio.h>
#include <string.h>
#include <iomanip>
#define INF (1<<30)
#define LINF (5e18)
const double EPS = 1.0e-8;
using namespace std;
class Cut {
public:
template<class T>
struct comp {
bool operator()(const T& lhs, const T& rhs) const {
if (lhs == 20) {
return false;
}
else if (rhs == 20) {
return true;
}
else if (lhs%10 == 0 || rhs %10 == 0) {
if (lhs%10 != 0) return true;
if (rhs%10 != 0) return false;
return lhs > rhs;
}
else {
return lhs > rhs;
}
}
};
int getMaximum(vector <int> eelLengths, int maxCuts) {
int N = (int)eelLengths.size();
int ans = 0;
priority_queue<int,vector<int>,comp<int> > que;
for (int i=0; i<N; ++i) {
if (eelLengths[i] == 10) ++ans;
else if (eelLengths[i] > 10) que.push(eelLengths[i]);
}
for (int i=0; i<maxCuts; ++i) {
if (que.empty()) break;
int p = que.top(); que.pop();
if (p == 20)
ans += 2;
else if (p < 20)
++ans;
else
++ans , que.push(p-10);
}
return ans;
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arr0[] = {13, 20, 13}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 3; verify_case(0, Arg2, getMaximum(Arg0, Arg1)); }
void test_case_1() { int Arr0[] = {5, 5, 5, 5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 0; verify_case(1, Arg2, getMaximum(Arg0, Arg1)); }
void test_case_2() { int Arr0[] = {34, 10, 48}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 5; verify_case(2, Arg2, getMaximum(Arg0, Arg1)); }
void test_case_3() { int Arr0[] = {13, 15, 13, 15, 20, 20, 20, 23, 25}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 350; int Arg2 = 14; verify_case(3, Arg2, getMaximum(Arg0, Arg1)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main() {
Cut ___test;
___test.run_test(3);
}
// END CUT HERE
|
#ifndef __GREETER_H__
#define __GREETER_H__
#include <string>
class Greeter {
public:
Greeter();
~Greeter();
void greet() const;
private:
std::string myGreeting;
};
#endif // #ifndef __GREETER_H__
|
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <algorithm>
using namespace std;
int n;
class Planet{
public:
double x, y;
Planet(double x = 0, double y = 0)
:x(x), y(y) {}
};
class Tunnel{
public:
int i;
int j;
double w;
Tunnel(int i = 0, int j = 0, double w = 0)
:i(i), j(j), w(w) {}
bool operator <(const Tunnel &t) const{
return w < t.w;
}
};
vector<Tunnel> tunnel;
Planet planet[101];
int vRoot[101] = {0, };
double ret = 0;
double getDist(Planet p1, Planet p2){
return sqrt(pow(p1.x-p2.x, 2) + pow(p1.y-p2.y, 2));
}
int findRoot(int v){
if(vRoot[v] == v) return v;
return vRoot[v] = findRoot(vRoot[v]);
}
void kruskal(){
sort(tunnel.begin(), tunnel.end());
for(Tunnel t : tunnel){
int ri = findRoot(t.i);
int rj = findRoot(t.j);
if(ri != rj){
// no -cycle merge.
vRoot[rj] = ri;
ret += t.w;
}
}
cout << setprecision(3) << ret << endl;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for(int i = 1; i <= n; i++){
int x, y;
cin >> planet[i].x >> planet[i].y;
vRoot[i] = i;
}
for(int i = 1; i <= n-1; i++){
for(int j = i+1; j <= n; j++){
//set Tunnels
tunnel.push_back(Tunnel(i, j, getDist(planet[i], planet[j])));
}
}
kruskal();
return 0;
}
|
/*
* File: skiplist.h
* Author: Richard Fussenegger
* Author: Markus Deutschl
*
* Created on November 19, 2012, 10:45 PM
*/
#ifndef SKIPLISTS_H
#define SKIPLISTS_H
#include <iostream>
#include <stdlib.h>
#include <list>
#include <vector>
using namespace std;
template <typename Tkey, typename Tval>
class skiplist {
public:
/** Constructor */
skiplist(int maxLevel = 5) : head(new node(defaultKey, defaultValue, maxLevel + 1)), currentLevel(0), maxLevel(maxLevel) {};
/** Destructor */
virtual ~skiplist() {
delete this->head;
}
/**
* Search for key in skiplist and receive value.
* @param key
* The key to search for.
* @return
* The value of the given key.
*/
Tval search(const Tkey key) const {
return this->search(this->head, key, this->currentLevel);
}
/**
* Insert a key-value-pair into our skiplist.
* @param key
* The key to insert.
* @param val
* The value to insert.
*/
void insert(const Tkey key, const Tval val) {
this->insert(this->head, new node(key, val, this->randomSkiplistGenerator()), this->currentLevel);
}
/**
* Remove node by key.
* @param key
* The key of the node which we should remove.
*/
void remove(Tkey key) {
this->remove(this->head, key, this->currentLevel - 1);
}
/**
* Get a vector with all inserted, sorted keys of our skiplist.
*
* @return
* Vector containing all sorted keys.
*/
vector<Tkey> getKeyVector() {
vector<Tkey> keyVector;
node* nodeObj = this->head->next[0];
while (true) {
if (nodeObj == NULL) {
break;
}
keyVector.push_back(nodeObj->key);
nodeObj = nodeObj->next[0];
}
return keyVector;
}
/**
* Get a list with all inserted, sorted keys of our skiplist.
*
* @return
* List containing all sorted keys.
*/
list<Tkey> getKeyList() {
list<Tkey> keyList;
node* nodeObj = this->head->next[0];
while (true) {
if (nodeObj == NULL) {
break;
}
keyList.push_back(nodeObj->key);
nodeObj = nodeObj->next[0];
}
return keyList;
}
/**
* Print all nodes of the current skiplist to the standard output.
*/
void print() {
node* nodeObj = this->head->next[0];
while (true) {
if (nodeObj == NULL) {
break;
}
cout << "Node with key " << nodeObj->key << " has value " << nodeObj->val << " with " << nodeObj->size << " levels." << endl;
nodeObj = nodeObj->next[0];
}
}
private:
/**
* Node structure for skiplist element.
*/
struct node {
/** The key. */
Tkey key;
/** The value. */
Tval val;
/** The size. */
int size;
/** Array of next pointers. */
node **next;
/**
* Constructor
* @param key
* @param val
* @param size
*/
node(const Tkey key, const Tval val, int size) : key(key), val(val), size(size), next(new node*[size]) {
for (int i = 0; i < size; ++i) {
this->next[i] = 0;
}
}
/**
* Destructor
*/
~node() {
delete this->next[0];
delete [] this->next;
}
};
/** Default item in skiplist. */
Tkey defaultKey;
/** Default value in skiplist. */
Tval defaultValue;
/** Head in skiplist. */
node* head;
/** Current index in skiplist. */
int currentLevel;
/** Maximum index in skiplist. */
int maxLevel;
/**
* Random skiplist level generator.
* @return
* Newly generated random level.
*/
int randomSkiplistGenerator() {
/** Iterator i */
int i = 1,
/** Iterator j */
j = 2,
/** Randomly generated integer between [0, RAND_MAX]. */
t = rand();
// Generate random level.
for (; i < this->maxLevel; i++, j += j) {
// Makes sure that we have most nodes in the lower levels as described
// in the skiplist paper.
if (t > RAND_MAX / j) {
break;
}
}
// If the newly generated level is above the current level of our skiplist,
// we expand our skiplist.
if (i > this->currentLevel) {
this->currentLevel = i;
}
return i;
}
/** Remove key and value. */
void remove(node* nodeObj, Tkey key, int currentLevel);
/** Remove all keys. */
void removeAll(node* nodeObj, int currentLevel);
/**
* Search skiplist with given node, key and current level.
* @param nodeObj
* @param key
* @param currentLevel
* @return
*/
Tval search(node* nodeObj, const Tkey key, int currentLevel) const {
// Search failed.
if (nodeObj == 0) {
return this->defaultValue;
}
// Search succeeded.
if (key == nodeObj->key) {
return nodeObj->val;
}
// Link to the node on same level.
node* nextNodeObj = nodeObj->next[currentLevel];
// Check if there is a next node in the same level or if the key is smaller
// than the stored key of the next node.
if (nextNodeObj == 0 || key < nextNodeObj->key) {
// No more levels available, search failed.
if (currentLevel == 0) {
return this->defaultValue;
}
// Try previous level.
return this->search(nodeObj, key, currentLevel - 1);
}
// Keep searching on the same level.
return this->search(nextNodeObj, key, currentLevel);
}
/**
* Insert new node into skiplist.
* @param nodeObj
* @param newNodeObj
* @param currentLevel
* @return
*/
void insert(node* nodeObj, node* newNodeObj, int currentLevel) {
/** Current key of the new node. */
Tkey key = newNodeObj->key;
/** Next node object on current level. */
node* nextNodeObj = nodeObj->next[currentLevel];
// Check if next node object is present at all, or if the key of the next
// node object is smaller than the key we want to insert.
if (nextNodeObj == 0 || key < nextNodeObj->key) {
// Check if we are in range of the total size and start rearranging the
// pointers.
if (currentLevel < newNodeObj->size) {
newNodeObj->next[currentLevel] = nextNodeObj;
nodeObj->next[currentLevel] = newNodeObj;
}
// Fail.
if (currentLevel == 0) {
return;
}
// If our current level is bigger or equal to the size of our new node
// go one level down and try to insert there.
this->insert(nodeObj, newNodeObj, currentLevel - 1);
return;
}
// If the key is bigger or equal than the next nodes key go to that node and
// try to insert there.
this->insert(nextNodeObj, newNodeObj, currentLevel);
}
};
#endif /* SKIPLISTS_H */
|
/**
* @file TcpSocket.cpp
* @author dtuchscherer <daniel.tuchscherer@hs-heilbronn.de>
* @brief Ethernet TCP/IP communication
* @details
* @version 1.0
* @copyright Copyright (c) 2015, dtuchscherer.
* All rights reserved.
*
* Redistributions and use in source and binary forms, with
* or without modifications, 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 Heilbronn University nor the name 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 REGENTS 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 REGENTS
* 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.
*/
/*******************************************************************************
* MODULES USED
*******************************************************************************/
#include "TcpSocket.h"
/*******************************************************************************
* DEFINITIONS AND MACROS
*******************************************************************************/
/*******************************************************************************
* TYPEDEFS, ENUMERATIONS, CLASSES
*******************************************************************************/
/*******************************************************************************
* PROTOTYPES OF LOCAL FUNCTIONS
*******************************************************************************/
/*******************************************************************************
* EXPORTED VARIABLES
*******************************************************************************/
/*******************************************************************************
* GLOBAL MODULE VARIABLES
*******************************************************************************/
/*******************************************************************************
* EXPORTED FUNCTIONS
*******************************************************************************/
/*******************************************************************************
* FUNCTION DEFINITIONS
*******************************************************************************/
TcpSocket::TcpSocket() noexcept :
Socket(SocketType::TCP)
{
// call the base class opening the socket.
}
TcpSocket::~TcpSocket() noexcept
{
// do not close the socket here,
// this is done by the base class Socket
}
AR::boolean TcpSocket::create() noexcept
{
AR::boolean socket_created = FALSE;
SocketHandleType& handle = get_socket_handle();
handle = socket(AF_INET, SOCK_STREAM, 0);
// check here if the socket was opened.
if ( get_socket_handle() > 0 )
{
// ... successfull opened.
socket_created = true;
}
else
{
// ... error opening the socket.
socket_created = false;
}
return socket_created;
}
AR::sint16 TcpSocket::send(const void* message, const AR::uint16 len) noexcept
{
const AR::boolean socket_open = is_socket_initialized();
AR::sint16 data_sent = -1;
// sending only makes sense if at least the socket is open.
if ( socket_open == TRUE )
{
#ifdef _WIN32
const char* msg = static_cast< const char* >(message);
#elif defined(__unix__)
const void* msg = message;
#endif
const SocketHandleType& handle = get_socket_handle();
#ifdef _WIN32
data_sent = ::send(handle, msg, len, 0);
#elif defined(__unix__)
data_sent = ::send(handle, msg, len, MSG_NOSIGNAL);
#endif
if ( data_sent < 0 )
{
m_last_error = errno;
}
}
else
{
data_sent = -1;
}
return data_sent;
}
AR::sint16 TcpSocket::receive(void* message, const AR::uint16 len) noexcept
{
const AR::boolean socket_open = is_socket_initialized();
AR::sint16 data_received = -1;
// sending only makes sense if at least the socket is open.
if ( socket_open == TRUE )
{
#ifdef _WIN32
char* msg = static_cast< char* >(message);
#elif defined(__unix__)
void* msg = message;
#endif
const SocketHandleType& handle = get_socket_handle();
data_received = ::recv(handle, msg, len, 0);
if ( data_received < 0 )
{
m_last_error = errno;
}
}
else
{
data_received = -1;
}
return data_received;
}
|
#ifndef EXPECTED_DEGREE_H
#define EXPECTED_DEGREE_H
#include <igraph.h>
#include <stdio.h>
#include <iostream>
#include <assert.h>
// 图的期望密度，可优化
// vids中的节点如果看做是子图节点（原图的部分节点），graph是原图，那么求取的是保留那些不属于子图，但与子图相连的边。在此基础上求子图期望密度
// vids中的节点是子图的全部节点，graph也是子图，那么忽略了保留那些不属于子图，但与子图相连的边。在此基础上求子图期望密度
int graph_expected_density(const igraph_t *graph, igraph_real_t *res,
const igraph_vs_t vids, igraph_neimode_t mode,
igraph_bool_t loops, const igraph_vector_t *expected_edge) {
long int no_of_nodes = igraph_vcount(graph);
igraph_vit_t vit;
long int no_vids;
igraph_vector_t neis;
long int i;
std::set<long int> myset;
myset.clear();
//if (!expected_edge)
//return igraph_degree(graph, res, vids, mode, loops);
if (igraph_vector_size(expected_edge) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) {
IGRAPH_ERROR("degree calculation failed", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) {
mode = IGRAPH_ALL;
}
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
no_vids = IGRAPH_VIT_SIZE(vit);
//printf("no_vids : %d\n", no_vids);
// 如果子图没有节点
if (no_vids == 0) {
*res = IGRAPH_NAN;
return 0;
}
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_vector_reserve(&neis, no_of_nodes));
// IGRAPH_CHECK(igraph_vector_resize(res, no_vids));
// igraph_vector_null(res);
if (loops) {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
//VECTOR(*res)[i] += VECTOR(*expected_edge)[edge];
// 使用集合存储边进行去重
myset.insert(edge);
}
}
}
else {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
long int from = IGRAPH_FROM(graph, edge);
long int to = IGRAPH_TO(graph, edge);
if (from != to) {
//VECTOR(*res)[i] += VECTOR(*expected_edge)[edge];
// 使用集合存储边进行去重
myset.insert(edge);
}
}
}
}
*res = 0;
// 计算集合中边的期望边权和
for each (long int edge in myset)
{
*res += VECTOR(*expected_edge)[edge];
}
float sum = *res;
*res = *res / no_vids;
// printf("vc : %d ec : %d sum : %f\n", no_vids, myset.size(), sum);
myset.clear();
igraph_vit_destroy(&vit);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_edges_expected(const igraph_t *graph, igraph_vector_t *res) {
igraph_vector_t weights;
igraph_vector_t probabilitys;
long int no_of_nodes = igraph_vcount(graph);
long int no_of_edges = igraph_ecount(graph);
igraph_vector_init(&weights, 0);
igraph_vector_init(&probabilitys, 0);
EANV(graph, "weights", &weights);
if (igraph_vector_size(&weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
return 1;
}
EANV(graph, "probabilitys", &probabilitys);
if (igraph_vector_size(&probabilitys) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid probabilitys vector length", IGRAPH_EINVAL);
return 1;
}
IGRAPH_CHECK(igraph_vector_resize(res, no_of_edges));
igraph_vector_null(res);
for (int j = 0; j < no_of_edges; j++) {
VECTOR(*res)[j] = VECTOR(weights)[j] * VECTOR(probabilitys)[j];
}
// printf("节点数：%d\n", igraph_vcount(graph));
// printf("边数：%d\n",igraph_vector_size(&weights));
// printf("边数：%d\n", igraph_ecount(graph));
igraph_vector_destroy(&weights);
igraph_vector_destroy(&probabilitys);
return 0;
}
// vids中的节点如果看做是子图节点（原图的部分节点），graph是原图，那么求取的是保留那些不属于子图，但与子图相连的边。在此基础上求子图期望度数
// vids中的节点是子图的全部节点，graph也是子图，那么忽略了保留那些不属于子图，但与子图相连的边。在此基础上求子图期望度数
int vertice_expected_degree(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_neimode_t mode,
igraph_bool_t loops, const igraph_vector_t *weights, const igraph_vector_t *probabilitys) {
long int no_of_nodes = igraph_vcount(graph);
igraph_vit_t vit;
long int no_vids;
igraph_vector_t neis;
long int i;
if (!weights || !probabilitys)
return igraph_degree(graph, res, vids, mode, loops);
if (igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
if (igraph_vector_size(probabilitys) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid probabilitys vector length", IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
no_vids = IGRAPH_VIT_SIZE(vit);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_vector_reserve(&neis, no_of_nodes));
IGRAPH_CHECK(igraph_vector_resize(res, no_vids));
igraph_vector_null(res);
if (loops) {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
VECTOR(*res)[i] += VECTOR(*weights)[edge] * VECTOR(*probabilitys)[edge];
}
}
}
else {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
long int from = IGRAPH_FROM(graph, edge);
long int to = IGRAPH_TO(graph, edge);
if (from != to) {
VECTOR(*res)[i] += VECTOR(*weights)[edge] * VECTOR(*probabilitys)[edge];
}
}
}
}
igraph_vit_destroy(&vit);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int vertice_expected_degree(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_neimode_t mode,
igraph_bool_t loops, const igraph_vector_t *expected_edge) {
long int no_of_nodes = igraph_vcount(graph);
igraph_vit_t vit;
long int no_vids;
igraph_vector_t neis;
long int i;
if (!expected_edge)
return igraph_degree(graph, res, vids, mode, loops);
if (igraph_vector_size(expected_edge) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) {
IGRAPH_ERROR("degree calculation failed", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) {
mode = IGRAPH_ALL;
}
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
no_vids = IGRAPH_VIT_SIZE(vit);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_vector_reserve(&neis, no_of_nodes));
IGRAPH_CHECK(igraph_vector_resize(res, no_vids));
igraph_vector_null(res);
if (loops) {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
VECTOR(*res)[i] += VECTOR(*expected_edge)[edge];
}
}
}
else {
for (i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
long int vid = IGRAPH_VIT_GET(vit);
long int j, n;
IGRAPH_CHECK(igraph_incident(graph, &neis, (igraph_integer_t)vid, mode));
n = igraph_vector_size(&neis);
for (j = 0; j < n; j++) {
long int edge = (long int)VECTOR(neis)[j];
long int from = IGRAPH_FROM(graph, edge);
long int to = IGRAPH_TO(graph, edge);
if (from != to) {
VECTOR(*res)[i] += VECTOR(*expected_edge)[edge];
}
}
}
}
igraph_vit_destroy(&vit);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int vertice_expected_degree(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_neimode_t mode, igraph_bool_t loops)
{
igraph_vector_t expected_edge;
igraph_vector_init(&expected_edge, igraph_ecount(graph));
igraph_edges_expected(graph, &expected_edge);
vertice_expected_degree(graph, res, vids, mode, loops, &expected_edge);
igraph_vector_destroy(&expected_edge);
return 0;
}
#endif
|
// Created on: 2002-12-12
// Created by: data exchange team
// Copyright (c) 2002-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StepElement_SurfaceSectionFieldVarying_HeaderFile
#define _StepElement_SurfaceSectionFieldVarying_HeaderFile
#include <Standard.hxx>
#include <StepElement_HArray1OfSurfaceSection.hxx>
#include <Standard_Boolean.hxx>
#include <StepElement_SurfaceSectionField.hxx>
class StepElement_SurfaceSectionFieldVarying;
DEFINE_STANDARD_HANDLE(StepElement_SurfaceSectionFieldVarying, StepElement_SurfaceSectionField)
//! Representation of STEP entity SurfaceSectionFieldVarying
class StepElement_SurfaceSectionFieldVarying : public StepElement_SurfaceSectionField
{
public:
//! Empty constructor
Standard_EXPORT StepElement_SurfaceSectionFieldVarying();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init (const Handle(StepElement_HArray1OfSurfaceSection)& aDefinitions, const Standard_Boolean aAdditionalNodeValues);
//! Returns field Definitions
Standard_EXPORT Handle(StepElement_HArray1OfSurfaceSection) Definitions() const;
//! Set field Definitions
Standard_EXPORT void SetDefinitions (const Handle(StepElement_HArray1OfSurfaceSection)& Definitions);
//! Returns field AdditionalNodeValues
Standard_EXPORT Standard_Boolean AdditionalNodeValues() const;
//! Set field AdditionalNodeValues
Standard_EXPORT void SetAdditionalNodeValues (const Standard_Boolean AdditionalNodeValues);
DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceSectionFieldVarying,StepElement_SurfaceSectionField)
protected:
private:
Handle(StepElement_HArray1OfSurfaceSection) theDefinitions;
Standard_Boolean theAdditionalNodeValues;
};
#endif // _StepElement_SurfaceSectionFieldVarying_HeaderFile
|
/*Team Name: KitKat*/
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> ii;
vector< vector<ii> > graph;
vector<int> sub;
int mst_cost, u, w;
priority_queue<ii, vector<ii>, greater<ii> > pq;
bool taken[50010];
int main(){
int n, v, e, from, to, weight, l;
cin >> n;
for(int tc=1; tc<=n; tc++){
cin >> v >> e;
graph.assign(v, vector<ii> () );
sub.clear();
memset(taken, 0, sizeof taken);
for(int i=0; i<e; i++){
cin >> from >> to >> weight;
graph[from-1].push_back(ii(to-1, weight));
graph[to-1].push_back(ii(from-1, weight));
}
mst_cost = 0;
cin >> l;
while(l--){
cin >> w;
w--;
taken[w] = true;
sub.push_back(w);
}
if(v == 2){
cout << "Case #" << tc << ": " << graph[0][0].second << endl;
continue;
}
for(int i = 0; i < sub.size(); i++){
e = 10000000;
for(int j = 0; j < graph[sub[i]].size(); j++){
if(!taken[graph[sub[i]][j].first]){
e = min(e, graph[sub[i]][j].second);
}
}
if(e == 10000000){
mst_cost = -1;
break;
}
else{
mst_cost += e;
}
}
if(mst_cost == -1){
cout << "Case #" << tc << ": " << -1 << endl;
continue;
}
for(int i = 0; i < v; i++){
if(!taken[i]){
taken[i] = true;
for(int j = 0; j < graph[i].size(); j++){
if(!taken[graph[i][j].first]){
pq.push(ii(graph[i][j].second, graph[i][j].first));
}
}
break;
}
}
while(!pq.empty()){
ii front = pq.top(); pq.pop();
u = front.second;
w = front.first;
if(!taken[u]){
mst_cost += w;
taken[u] = 1;
for(int j=0; j < graph[u].size(); j++){
ii vv = graph[u][j];
if(!taken[vv.first]) pq.push(ii(vv.second, vv.first));
}
}
}
for(int i = 0; i < v; i++){
if(!taken[i]){
mst_cost = -1;
}
}
cout << "Case #" << tc << ": " << mst_cost << endl;
}
}
|
// Created on: 2016-04-07
// Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepMeshData_Wire_HeaderFile
#define _BRepMeshData_Wire_HeaderFile
#include <IMeshData_Wire.hxx>
#include <IMeshData_Types.hxx>
//! Default implementation of wire data model entity.
class BRepMeshData_Wire : public IMeshData_Wire
{
public:
DEFINE_INC_ALLOC
//! Constructor.
Standard_EXPORT BRepMeshData_Wire (
const TopoDS_Wire& theWire,
const Standard_Integer theEdgeNb,
const Handle (NCollection_IncAllocator)& theAllocator);
//! Destructor.
Standard_EXPORT virtual ~BRepMeshData_Wire ();
//! Gets number of children.
Standard_EXPORT virtual Standard_Integer EdgesNb () const Standard_OVERRIDE;
//! Adds new discrete edge with specified orientation to wire chain.
//! @return index of added edge in wire chain.
Standard_EXPORT virtual Standard_Integer AddEdge (
const IMeshData::IEdgePtr& theDEdge,
const TopAbs_Orientation theOrientation) Standard_OVERRIDE;
//! Gets edge with the given index.
Standard_EXPORT virtual const IMeshData::IEdgePtr& GetEdge (
const Standard_Integer theIndex) const Standard_OVERRIDE;
//! Returns True if orientation of discrete edge with the given index is forward.
Standard_EXPORT virtual TopAbs_Orientation GetEdgeOrientation (
const Standard_Integer theIndex) const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(BRepMeshData_Wire, IMeshData_Wire)
private:
IMeshData::VectorOfIEdgePtrs myDEdges;
IMeshData::VectorOfOrientation myDEdgesOri;
};
#endif
|
#include "stdafx.h"
#include "GamePiece.h"
void GamePiece::setOwner_Id(int id)
{
this->owner_id = id;
};
int GamePiece::getOwner_id()
{
return this->owner_id;
};
string GamePiece::getName()
{
return this->name;
};
TrollLair::TrollLair()
{
this->name = "Troll Lair";
};
Fortress::Fortress()
{
this->name = "Fortress";
};
Mountain::Mountain()
{
this->name = "Mountain";
};
Encampment::Encampment()
{
this->name = "Encampment";
};
Hole_in_the_Ground::Hole_in_the_Ground()
{
this->name = "Hole_in_the_Ground";
};
Hero::Hero()
{
this->name = "Hero";
};
Dragon::Dragon()
{
this->name = "Dragon";
};
|
#include<bits/stdc++.h>
using namespace std;
class Student{
private:
int age;
char *name;
public:
Student(int age,char *name){
this -> age = age;
//Shallow Copy.
//this -> name = name;
//Deep Copy.
this -> name = new char[strlen(name) + 1];
strcpy(this -> name,name);
}
void print(){
cout << name << " " << age << endl;
}
};
int main(){
char name[] = "abcd";
Student s1(20,name);
s1.print();
name[3] = 'e';
Student s2(24,name);
s2.print();
s1.print();
return 0;
}
|
#ifndef __VIVADO_SYNTH__
#include <fstream>
using namespace std;
// Debug utility
ofstream* global_debug_handle;
#endif //__VIVADO_SYNTH__
#include "cp_4_opt_compute_units.h"
#include "hw_classes.h"
struct blue_blue_update_0_write0_merged_banks_4_cache {
// RAM Box: {[0, 1920], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct blue_blue_update_0_write1_merged_banks_4_cache {
// RAM Box: {[1, 1921], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct blue_blue_update_0_write2_merged_banks_4_cache {
// RAM Box: {[2, 1922], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct blue_blue_update_0_write3_merged_banks_4_cache {
// RAM Box: {[3, 1923], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct blue_cache {
blue_blue_update_0_write0_merged_banks_4_cache blue_blue_update_0_write0_merged_banks_4;
blue_blue_update_0_write1_merged_banks_4_cache blue_blue_update_0_write1_merged_banks_4;
blue_blue_update_0_write2_merged_banks_4_cache blue_blue_update_0_write2_merged_banks_4;
blue_blue_update_0_write3_merged_banks_4_cache blue_blue_update_0_write3_merged_banks_4;
};
inline void blue_blue_update_0_write0_write(hw_uint<16>& blue_blue_update_0_write0, blue_cache& blue, int d0, int d1) {
blue.blue_blue_update_0_write0_merged_banks_4.push(blue_blue_update_0_write0);
}
inline void blue_blue_update_0_write1_write(hw_uint<16>& blue_blue_update_0_write1, blue_cache& blue, int d0, int d1) {
blue.blue_blue_update_0_write1_merged_banks_4.push(blue_blue_update_0_write1);
}
inline void blue_blue_update_0_write2_write(hw_uint<16>& blue_blue_update_0_write2, blue_cache& blue, int d0, int d1) {
blue.blue_blue_update_0_write2_merged_banks_4.push(blue_blue_update_0_write2);
}
inline void blue_blue_update_0_write3_write(hw_uint<16>& blue_blue_update_0_write3, blue_cache& blue, int d0, int d1) {
blue.blue_blue_update_0_write3_merged_banks_4.push(blue_blue_update_0_write3);
}
inline hw_uint<16> blue_bx_rd0_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd0 read pattern: { blue_bx_update_0[d0, d1] -> blue[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write0 = blue.blue_blue_update_0_write0_merged_banks_4.peek_1();
return value_blue_blue_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd1_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd1 read pattern: { blue_bx_update_0[d0, d1] -> blue[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write1 = blue.blue_blue_update_0_write1_merged_banks_4.peek_1();
return value_blue_blue_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd10_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd10 read pattern: { blue_bx_update_0[d0, d1] -> blue[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_blue_update_0_write0 = blue.blue_blue_update_0_write0_merged_banks_4.peek_0();
return value_blue_blue_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd11_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd11 read pattern: { blue_bx_update_0[d0, d1] -> blue[5 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_blue_update_0_write1 = blue.blue_blue_update_0_write1_merged_banks_4.peek_0();
return value_blue_blue_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd2_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd2 read pattern: { blue_bx_update_0[d0, d1] -> blue[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write2 = blue.blue_blue_update_0_write2_merged_banks_4.peek_1();
return value_blue_blue_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd3_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd3 read pattern: { blue_bx_update_0[d0, d1] -> blue[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write1 = blue.blue_blue_update_0_write1_merged_banks_4.peek_1();
return value_blue_blue_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd4_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd4 read pattern: { blue_bx_update_0[d0, d1] -> blue[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write2 = blue.blue_blue_update_0_write2_merged_banks_4.peek_1();
return value_blue_blue_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd5_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd5 read pattern: { blue_bx_update_0[d0, d1] -> blue[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write3 = blue.blue_blue_update_0_write3_merged_banks_4.peek_1();
return value_blue_blue_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd6_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd6 read pattern: { blue_bx_update_0[d0, d1] -> blue[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write2 = blue.blue_blue_update_0_write2_merged_banks_4.peek_1();
return value_blue_blue_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd7_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd7 read pattern: { blue_bx_update_0[d0, d1] -> blue[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write3 = blue.blue_blue_update_0_write3_merged_banks_4.peek_1();
return value_blue_blue_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd8_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd8 read pattern: { blue_bx_update_0[d0, d1] -> blue[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_blue_update_0_write0 = blue.blue_blue_update_0_write0_merged_banks_4.peek_0();
return value_blue_blue_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_bx_rd9_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_bx_rd9 read pattern: { blue_bx_update_0[d0, d1] -> blue[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_blue_blue_update_0_write3 = blue.blue_blue_update_0_write3_merged_banks_4.peek_1();
return value_blue_blue_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd0_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd0 read pattern: { blue_diff_update_0[d0, d1] -> blue[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_blue_blue_update_0_write0 = blue.blue_blue_update_0_write0_merged_banks_4.peek_963();
return value_blue_blue_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd1_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd1 read pattern: { blue_diff_update_0[d0, d1] -> blue[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_blue_blue_update_0_write1 = blue.blue_blue_update_0_write1_merged_banks_4.peek_963();
return value_blue_blue_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd2_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd2 read pattern: { blue_diff_update_0[d0, d1] -> blue[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_blue_blue_update_0_write2 = blue.blue_blue_update_0_write2_merged_banks_4.peek_963();
return value_blue_blue_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd3_select(blue_cache& blue, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd3 read pattern: { blue_diff_update_0[d0, d1] -> blue[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { blue_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_blue_blue_update_0_write3 = blue.blue_blue_update_0_write3_merged_banks_4.peek_963();
return value_blue_blue_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 3
// blue_bx_update_0_read
// blue_bx_rd0
// blue_bx_rd1
// blue_bx_rd2
// blue_bx_rd3
// blue_bx_rd4
// blue_bx_rd5
// blue_bx_rd6
// blue_bx_rd7
// blue_bx_rd8
// blue_bx_rd9
// blue_bx_rd10
// blue_bx_rd11
inline hw_uint<192> blue_blue_bx_update_0_read_bundle_read(blue_cache& blue, int d0, int d1) {
// # of ports in bundle: 12
// blue_bx_rd0
// blue_bx_rd1
// blue_bx_rd2
// blue_bx_rd3
// blue_bx_rd4
// blue_bx_rd5
// blue_bx_rd6
// blue_bx_rd7
// blue_bx_rd8
// blue_bx_rd9
// blue_bx_rd10
// blue_bx_rd11
hw_uint<192> result;
hw_uint<16> blue_bx_rd0_res = blue_bx_rd0_select(blue, d0, d1);
set_at<0, 192>(result, blue_bx_rd0_res);
hw_uint<16> blue_bx_rd1_res = blue_bx_rd1_select(blue, d0, d1);
set_at<16, 192>(result, blue_bx_rd1_res);
hw_uint<16> blue_bx_rd2_res = blue_bx_rd2_select(blue, d0, d1);
set_at<32, 192>(result, blue_bx_rd2_res);
hw_uint<16> blue_bx_rd3_res = blue_bx_rd3_select(blue, d0, d1);
set_at<48, 192>(result, blue_bx_rd3_res);
hw_uint<16> blue_bx_rd4_res = blue_bx_rd4_select(blue, d0, d1);
set_at<64, 192>(result, blue_bx_rd4_res);
hw_uint<16> blue_bx_rd5_res = blue_bx_rd5_select(blue, d0, d1);
set_at<80, 192>(result, blue_bx_rd5_res);
hw_uint<16> blue_bx_rd6_res = blue_bx_rd6_select(blue, d0, d1);
set_at<96, 192>(result, blue_bx_rd6_res);
hw_uint<16> blue_bx_rd7_res = blue_bx_rd7_select(blue, d0, d1);
set_at<112, 192>(result, blue_bx_rd7_res);
hw_uint<16> blue_bx_rd8_res = blue_bx_rd8_select(blue, d0, d1);
set_at<128, 192>(result, blue_bx_rd8_res);
hw_uint<16> blue_bx_rd9_res = blue_bx_rd9_select(blue, d0, d1);
set_at<144, 192>(result, blue_bx_rd9_res);
hw_uint<16> blue_bx_rd10_res = blue_bx_rd10_select(blue, d0, d1);
set_at<160, 192>(result, blue_bx_rd10_res);
hw_uint<16> blue_bx_rd11_res = blue_bx_rd11_select(blue, d0, d1);
set_at<176, 192>(result, blue_bx_rd11_res);
return result;
}
// blue_diff_update_0_read
// blue_diff_rd0
// blue_diff_rd1
// blue_diff_rd2
// blue_diff_rd3
inline hw_uint<64> blue_blue_diff_update_0_read_bundle_read(blue_cache& blue, int d0, int d1) {
// # of ports in bundle: 4
// blue_diff_rd0
// blue_diff_rd1
// blue_diff_rd2
// blue_diff_rd3
hw_uint<64> result;
hw_uint<16> blue_diff_rd0_res = blue_diff_rd0_select(blue, d0, d1);
set_at<0, 64>(result, blue_diff_rd0_res);
hw_uint<16> blue_diff_rd1_res = blue_diff_rd1_select(blue, d0, d1);
set_at<16, 64>(result, blue_diff_rd1_res);
hw_uint<16> blue_diff_rd2_res = blue_diff_rd2_select(blue, d0, d1);
set_at<32, 64>(result, blue_diff_rd2_res);
hw_uint<16> blue_diff_rd3_res = blue_diff_rd3_select(blue, d0, d1);
set_at<48, 64>(result, blue_diff_rd3_res);
return result;
}
// blue_update_0_write
// blue_blue_update_0_write0
// blue_blue_update_0_write1
// blue_blue_update_0_write2
// blue_blue_update_0_write3
inline void blue_blue_update_0_write_bundle_write(hw_uint<64>& blue_update_0_write, blue_cache& blue, int d0, int d1) {
hw_uint<16> blue_blue_update_0_write0_res = blue_update_0_write.extract<0, 15>();
blue_blue_update_0_write0_write(blue_blue_update_0_write0_res, blue, d0, d1);
hw_uint<16> blue_blue_update_0_write1_res = blue_update_0_write.extract<16, 31>();
blue_blue_update_0_write1_write(blue_blue_update_0_write1_res, blue, d0, d1);
hw_uint<16> blue_blue_update_0_write2_res = blue_update_0_write.extract<32, 47>();
blue_blue_update_0_write2_write(blue_blue_update_0_write2_res, blue, d0, d1);
hw_uint<16> blue_blue_update_0_write3_res = blue_update_0_write.extract<48, 63>();
blue_blue_update_0_write3_write(blue_blue_update_0_write3_res, blue, d0, d1);
}
#include "hw_classes.h"
struct blue_bx_blue_bx_update_0_write0_merged_banks_3_cache {
// RAM Box: {[0, 1916], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct blue_bx_blue_bx_update_0_write1_merged_banks_3_cache {
// RAM Box: {[1, 1917], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct blue_bx_blue_bx_update_0_write2_merged_banks_3_cache {
// RAM Box: {[2, 1918], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct blue_bx_blue_bx_update_0_write3_merged_banks_3_cache {
// RAM Box: {[3, 1919], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct blue_bx_cache {
blue_bx_blue_bx_update_0_write0_merged_banks_3_cache blue_bx_blue_bx_update_0_write0_merged_banks_3;
blue_bx_blue_bx_update_0_write1_merged_banks_3_cache blue_bx_blue_bx_update_0_write1_merged_banks_3;
blue_bx_blue_bx_update_0_write2_merged_banks_3_cache blue_bx_blue_bx_update_0_write2_merged_banks_3;
blue_bx_blue_bx_update_0_write3_merged_banks_3_cache blue_bx_blue_bx_update_0_write3_merged_banks_3;
};
inline void blue_bx_blue_bx_update_0_write0_write(hw_uint<16>& blue_bx_blue_bx_update_0_write0, blue_bx_cache& blue_bx, int d0, int d1) {
blue_bx.blue_bx_blue_bx_update_0_write0_merged_banks_3.push(blue_bx_blue_bx_update_0_write0);
}
inline void blue_bx_blue_bx_update_0_write1_write(hw_uint<16>& blue_bx_blue_bx_update_0_write1, blue_bx_cache& blue_bx, int d0, int d1) {
blue_bx.blue_bx_blue_bx_update_0_write1_merged_banks_3.push(blue_bx_blue_bx_update_0_write1);
}
inline void blue_bx_blue_bx_update_0_write2_write(hw_uint<16>& blue_bx_blue_bx_update_0_write2, blue_bx_cache& blue_bx, int d0, int d1) {
blue_bx.blue_bx_blue_bx_update_0_write2_merged_banks_3.push(blue_bx_blue_bx_update_0_write2);
}
inline void blue_bx_blue_bx_update_0_write3_write(hw_uint<16>& blue_bx_blue_bx_update_0_write3, blue_bx_cache& blue_bx, int d0, int d1) {
blue_bx.blue_bx_blue_bx_update_0_write3_merged_banks_3.push(blue_bx_blue_bx_update_0_write3);
}
inline hw_uint<16> blue_by_rd0_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd0 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write0 = blue_bx.blue_bx_blue_bx_update_0_write0_merged_banks_3.peek_960();
return value_blue_bx_blue_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd1_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd1 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write0 = blue_bx.blue_bx_blue_bx_update_0_write0_merged_banks_3.peek_480();
return value_blue_bx_blue_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd10_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd10 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[3 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write3 = blue_bx.blue_bx_blue_bx_update_0_write3_merged_banks_3.peek_480();
return value_blue_bx_blue_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd11_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd11 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[3 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_bx_blue_bx_update_0_write3 = blue_bx.blue_bx_blue_bx_update_0_write3_merged_banks_3.peek_0();
return value_blue_bx_blue_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd2_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd2 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_bx_blue_bx_update_0_write0 = blue_bx.blue_bx_blue_bx_update_0_write0_merged_banks_3.peek_0();
return value_blue_bx_blue_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd3_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd3 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write1 = blue_bx.blue_bx_blue_bx_update_0_write1_merged_banks_3.peek_960();
return value_blue_bx_blue_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd4_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd4 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[1 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write1 = blue_bx.blue_bx_blue_bx_update_0_write1_merged_banks_3.peek_480();
return value_blue_bx_blue_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd5_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd5 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[1 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_bx_blue_bx_update_0_write1 = blue_bx.blue_bx_blue_bx_update_0_write1_merged_banks_3.peek_0();
return value_blue_bx_blue_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd6_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd6 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write2 = blue_bx.blue_bx_blue_bx_update_0_write2_merged_banks_3.peek_960();
return value_blue_bx_blue_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd7_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd7 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[2 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write2 = blue_bx.blue_bx_blue_bx_update_0_write2_merged_banks_3.peek_480();
return value_blue_bx_blue_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd8_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd8 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[2 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_blue_bx_blue_bx_update_0_write2 = blue_bx.blue_bx_blue_bx_update_0_write2_merged_banks_3.peek_0();
return value_blue_bx_blue_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_by_rd9_select(blue_bx_cache& blue_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_by_rd9 read pattern: { blue_by_update_0[d0, d1] -> blue_bx[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 5] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { blue_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; blue_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_blue_bx_blue_bx_update_0_write3 = blue_bx.blue_bx_blue_bx_update_0_write3_merged_banks_3.peek_960();
return value_blue_bx_blue_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// blue_bx_update_0_write
// blue_bx_blue_bx_update_0_write0
// blue_bx_blue_bx_update_0_write1
// blue_bx_blue_bx_update_0_write2
// blue_bx_blue_bx_update_0_write3
inline void blue_bx_blue_bx_update_0_write_bundle_write(hw_uint<64>& blue_bx_update_0_write, blue_bx_cache& blue_bx, int d0, int d1) {
hw_uint<16> blue_bx_blue_bx_update_0_write0_res = blue_bx_update_0_write.extract<0, 15>();
blue_bx_blue_bx_update_0_write0_write(blue_bx_blue_bx_update_0_write0_res, blue_bx, d0, d1);
hw_uint<16> blue_bx_blue_bx_update_0_write1_res = blue_bx_update_0_write.extract<16, 31>();
blue_bx_blue_bx_update_0_write1_write(blue_bx_blue_bx_update_0_write1_res, blue_bx, d0, d1);
hw_uint<16> blue_bx_blue_bx_update_0_write2_res = blue_bx_update_0_write.extract<32, 47>();
blue_bx_blue_bx_update_0_write2_write(blue_bx_blue_bx_update_0_write2_res, blue_bx, d0, d1);
hw_uint<16> blue_bx_blue_bx_update_0_write3_res = blue_bx_update_0_write.extract<48, 63>();
blue_bx_blue_bx_update_0_write3_write(blue_bx_blue_bx_update_0_write3_res, blue_bx, d0, d1);
}
// blue_by_update_0_read
// blue_by_rd0
// blue_by_rd1
// blue_by_rd2
// blue_by_rd3
// blue_by_rd4
// blue_by_rd5
// blue_by_rd6
// blue_by_rd7
// blue_by_rd8
// blue_by_rd9
// blue_by_rd10
// blue_by_rd11
inline hw_uint<192> blue_bx_blue_by_update_0_read_bundle_read(blue_bx_cache& blue_bx, int d0, int d1) {
// # of ports in bundle: 12
// blue_by_rd0
// blue_by_rd1
// blue_by_rd2
// blue_by_rd3
// blue_by_rd4
// blue_by_rd5
// blue_by_rd6
// blue_by_rd7
// blue_by_rd8
// blue_by_rd9
// blue_by_rd10
// blue_by_rd11
hw_uint<192> result;
hw_uint<16> blue_by_rd0_res = blue_by_rd0_select(blue_bx, d0, d1);
set_at<0, 192>(result, blue_by_rd0_res);
hw_uint<16> blue_by_rd1_res = blue_by_rd1_select(blue_bx, d0, d1);
set_at<16, 192>(result, blue_by_rd1_res);
hw_uint<16> blue_by_rd2_res = blue_by_rd2_select(blue_bx, d0, d1);
set_at<32, 192>(result, blue_by_rd2_res);
hw_uint<16> blue_by_rd3_res = blue_by_rd3_select(blue_bx, d0, d1);
set_at<48, 192>(result, blue_by_rd3_res);
hw_uint<16> blue_by_rd4_res = blue_by_rd4_select(blue_bx, d0, d1);
set_at<64, 192>(result, blue_by_rd4_res);
hw_uint<16> blue_by_rd5_res = blue_by_rd5_select(blue_bx, d0, d1);
set_at<80, 192>(result, blue_by_rd5_res);
hw_uint<16> blue_by_rd6_res = blue_by_rd6_select(blue_bx, d0, d1);
set_at<96, 192>(result, blue_by_rd6_res);
hw_uint<16> blue_by_rd7_res = blue_by_rd7_select(blue_bx, d0, d1);
set_at<112, 192>(result, blue_by_rd7_res);
hw_uint<16> blue_by_rd8_res = blue_by_rd8_select(blue_bx, d0, d1);
set_at<128, 192>(result, blue_by_rd8_res);
hw_uint<16> blue_by_rd9_res = blue_by_rd9_select(blue_bx, d0, d1);
set_at<144, 192>(result, blue_by_rd9_res);
hw_uint<16> blue_by_rd10_res = blue_by_rd10_select(blue_bx, d0, d1);
set_at<160, 192>(result, blue_by_rd10_res);
hw_uint<16> blue_by_rd11_res = blue_by_rd11_select(blue_bx, d0, d1);
set_at<176, 192>(result, blue_by_rd11_res);
return result;
}
#include "hw_classes.h"
struct blue_by_blue_by_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_by_blue_by_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_by_blue_by_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_by_blue_by_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_by_cache {
blue_by_blue_by_update_0_write0_merged_banks_1_cache blue_by_blue_by_update_0_write0_merged_banks_1;
blue_by_blue_by_update_0_write1_merged_banks_1_cache blue_by_blue_by_update_0_write1_merged_banks_1;
blue_by_blue_by_update_0_write2_merged_banks_1_cache blue_by_blue_by_update_0_write2_merged_banks_1;
blue_by_blue_by_update_0_write3_merged_banks_1_cache blue_by_blue_by_update_0_write3_merged_banks_1;
};
inline void blue_by_blue_by_update_0_write0_write(hw_uint<16>& blue_by_blue_by_update_0_write0, blue_by_cache& blue_by, int d0, int d1) {
blue_by.blue_by_blue_by_update_0_write0_merged_banks_1.push(blue_by_blue_by_update_0_write0);
}
inline void blue_by_blue_by_update_0_write1_write(hw_uint<16>& blue_by_blue_by_update_0_write1, blue_by_cache& blue_by, int d0, int d1) {
blue_by.blue_by_blue_by_update_0_write1_merged_banks_1.push(blue_by_blue_by_update_0_write1);
}
inline void blue_by_blue_by_update_0_write2_write(hw_uint<16>& blue_by_blue_by_update_0_write2, blue_by_cache& blue_by, int d0, int d1) {
blue_by.blue_by_blue_by_update_0_write2_merged_banks_1.push(blue_by_blue_by_update_0_write2);
}
inline void blue_by_blue_by_update_0_write3_write(hw_uint<16>& blue_by_blue_by_update_0_write3, blue_by_cache& blue_by, int d0, int d1) {
blue_by.blue_by_blue_by_update_0_write3_merged_banks_1.push(blue_by_blue_by_update_0_write3);
}
inline hw_uint<16> blue_diff_rd0_select(blue_by_cache& blue_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd0 read pattern: { blue_diff_update_0[d0, d1] -> blue_by[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_by_blue_by_update_0_write0 = blue_by.blue_by_blue_by_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_by_blue_by_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd1_select(blue_by_cache& blue_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd1 read pattern: { blue_diff_update_0[d0, d1] -> blue_by[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_by_blue_by_update_0_write1 = blue_by.blue_by_blue_by_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_by_blue_by_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd2_select(blue_by_cache& blue_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd2 read pattern: { blue_diff_update_0[d0, d1] -> blue_by[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_by_blue_by_update_0_write2 = blue_by.blue_by_blue_by_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_by_blue_by_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_diff_rd3_select(blue_by_cache& blue_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_diff_rd3 read pattern: { blue_diff_update_0[d0, d1] -> blue_by[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 8] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_by_blue_by_update_0_write3 = blue_by.blue_by_blue_by_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_by_blue_by_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// blue_by_update_0_write
// blue_by_blue_by_update_0_write0
// blue_by_blue_by_update_0_write1
// blue_by_blue_by_update_0_write2
// blue_by_blue_by_update_0_write3
inline void blue_by_blue_by_update_0_write_bundle_write(hw_uint<64>& blue_by_update_0_write, blue_by_cache& blue_by, int d0, int d1) {
hw_uint<16> blue_by_blue_by_update_0_write0_res = blue_by_update_0_write.extract<0, 15>();
blue_by_blue_by_update_0_write0_write(blue_by_blue_by_update_0_write0_res, blue_by, d0, d1);
hw_uint<16> blue_by_blue_by_update_0_write1_res = blue_by_update_0_write.extract<16, 31>();
blue_by_blue_by_update_0_write1_write(blue_by_blue_by_update_0_write1_res, blue_by, d0, d1);
hw_uint<16> blue_by_blue_by_update_0_write2_res = blue_by_update_0_write.extract<32, 47>();
blue_by_blue_by_update_0_write2_write(blue_by_blue_by_update_0_write2_res, blue_by, d0, d1);
hw_uint<16> blue_by_blue_by_update_0_write3_res = blue_by_update_0_write.extract<48, 63>();
blue_by_blue_by_update_0_write3_write(blue_by_blue_by_update_0_write3_res, blue_by, d0, d1);
}
// blue_diff_update_0_read
// blue_diff_rd0
// blue_diff_rd1
// blue_diff_rd2
// blue_diff_rd3
inline hw_uint<64> blue_by_blue_diff_update_0_read_bundle_read(blue_by_cache& blue_by, int d0, int d1) {
// # of ports in bundle: 4
// blue_diff_rd0
// blue_diff_rd1
// blue_diff_rd2
// blue_diff_rd3
hw_uint<64> result;
hw_uint<16> blue_diff_rd0_res = blue_diff_rd0_select(blue_by, d0, d1);
set_at<0, 64>(result, blue_diff_rd0_res);
hw_uint<16> blue_diff_rd1_res = blue_diff_rd1_select(blue_by, d0, d1);
set_at<16, 64>(result, blue_diff_rd1_res);
hw_uint<16> blue_diff_rd2_res = blue_diff_rd2_select(blue_by, d0, d1);
set_at<32, 64>(result, blue_diff_rd2_res);
hw_uint<16> blue_diff_rd3_res = blue_diff_rd3_select(blue_by, d0, d1);
set_at<48, 64>(result, blue_diff_rd3_res);
return result;
}
#include "hw_classes.h"
struct blue_diff_blue_diff_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_diff_blue_diff_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_diff_blue_diff_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_diff_blue_diff_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct blue_diff_cache {
blue_diff_blue_diff_update_0_write0_merged_banks_1_cache blue_diff_blue_diff_update_0_write0_merged_banks_1;
blue_diff_blue_diff_update_0_write1_merged_banks_1_cache blue_diff_blue_diff_update_0_write1_merged_banks_1;
blue_diff_blue_diff_update_0_write2_merged_banks_1_cache blue_diff_blue_diff_update_0_write2_merged_banks_1;
blue_diff_blue_diff_update_0_write3_merged_banks_1_cache blue_diff_blue_diff_update_0_write3_merged_banks_1;
};
inline void blue_diff_blue_diff_update_0_write0_write(hw_uint<16>& blue_diff_blue_diff_update_0_write0, blue_diff_cache& blue_diff, int d0, int d1) {
blue_diff.blue_diff_blue_diff_update_0_write0_merged_banks_1.push(blue_diff_blue_diff_update_0_write0);
}
inline void blue_diff_blue_diff_update_0_write1_write(hw_uint<16>& blue_diff_blue_diff_update_0_write1, blue_diff_cache& blue_diff, int d0, int d1) {
blue_diff.blue_diff_blue_diff_update_0_write1_merged_banks_1.push(blue_diff_blue_diff_update_0_write1);
}
inline void blue_diff_blue_diff_update_0_write2_write(hw_uint<16>& blue_diff_blue_diff_update_0_write2, blue_diff_cache& blue_diff, int d0, int d1) {
blue_diff.blue_diff_blue_diff_update_0_write2_merged_banks_1.push(blue_diff_blue_diff_update_0_write2);
}
inline void blue_diff_blue_diff_update_0_write3_write(hw_uint<16>& blue_diff_blue_diff_update_0_write3, blue_diff_cache& blue_diff, int d0, int d1) {
blue_diff.blue_diff_blue_diff_update_0_write3_merged_banks_1.push(blue_diff_blue_diff_update_0_write3);
}
inline hw_uint<16> cp_4_rd0_select(blue_diff_cache& blue_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd0 read pattern: { cp_4_update_0[d0, d1] -> blue_diff[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_diff_blue_diff_update_0_write0 = blue_diff.blue_diff_blue_diff_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_diff_blue_diff_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd1_select(blue_diff_cache& blue_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd1 read pattern: { cp_4_update_0[d0, d1] -> blue_diff[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_diff_blue_diff_update_0_write1 = blue_diff.blue_diff_blue_diff_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_diff_blue_diff_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd2_select(blue_diff_cache& blue_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd2 read pattern: { cp_4_update_0[d0, d1] -> blue_diff[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_diff_blue_diff_update_0_write2 = blue_diff.blue_diff_blue_diff_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_diff_blue_diff_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd3_select(blue_diff_cache& blue_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd3 read pattern: { cp_4_update_0[d0, d1] -> blue_diff[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { blue_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 11] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_blue_diff_blue_diff_update_0_write3 = blue_diff.blue_diff_blue_diff_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_blue_diff_blue_diff_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// blue_diff_update_0_write
// blue_diff_blue_diff_update_0_write0
// blue_diff_blue_diff_update_0_write1
// blue_diff_blue_diff_update_0_write2
// blue_diff_blue_diff_update_0_write3
inline void blue_diff_blue_diff_update_0_write_bundle_write(hw_uint<64>& blue_diff_update_0_write, blue_diff_cache& blue_diff, int d0, int d1) {
hw_uint<16> blue_diff_blue_diff_update_0_write0_res = blue_diff_update_0_write.extract<0, 15>();
blue_diff_blue_diff_update_0_write0_write(blue_diff_blue_diff_update_0_write0_res, blue_diff, d0, d1);
hw_uint<16> blue_diff_blue_diff_update_0_write1_res = blue_diff_update_0_write.extract<16, 31>();
blue_diff_blue_diff_update_0_write1_write(blue_diff_blue_diff_update_0_write1_res, blue_diff, d0, d1);
hw_uint<16> blue_diff_blue_diff_update_0_write2_res = blue_diff_update_0_write.extract<32, 47>();
blue_diff_blue_diff_update_0_write2_write(blue_diff_blue_diff_update_0_write2_res, blue_diff, d0, d1);
hw_uint<16> blue_diff_blue_diff_update_0_write3_res = blue_diff_update_0_write.extract<48, 63>();
blue_diff_blue_diff_update_0_write3_write(blue_diff_blue_diff_update_0_write3_res, blue_diff, d0, d1);
}
// cp_4_update_0_read
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
inline hw_uint<64> blue_diff_cp_4_update_0_read_bundle_read(blue_diff_cache& blue_diff, int d0, int d1) {
// # of ports in bundle: 4
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
hw_uint<64> result;
hw_uint<16> cp_4_rd0_res = cp_4_rd0_select(blue_diff, d0, d1);
set_at<0, 64>(result, cp_4_rd0_res);
hw_uint<16> cp_4_rd1_res = cp_4_rd1_select(blue_diff, d0, d1);
set_at<16, 64>(result, cp_4_rd1_res);
hw_uint<16> cp_4_rd2_res = cp_4_rd2_select(blue_diff, d0, d1);
set_at<32, 64>(result, cp_4_rd2_res);
hw_uint<16> cp_4_rd3_res = cp_4_rd3_select(blue_diff, d0, d1);
set_at<48, 64>(result, cp_4_rd3_res);
return result;
}
#include "hw_classes.h"
struct green_green_update_0_write0_merged_banks_4_cache {
// RAM Box: {[0, 1920], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct green_green_update_0_write1_merged_banks_4_cache {
// RAM Box: {[1, 1921], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct green_green_update_0_write2_merged_banks_4_cache {
// RAM Box: {[2, 1922], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct green_green_update_0_write3_merged_banks_4_cache {
// RAM Box: {[3, 1923], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct green_cache {
green_green_update_0_write0_merged_banks_4_cache green_green_update_0_write0_merged_banks_4;
green_green_update_0_write1_merged_banks_4_cache green_green_update_0_write1_merged_banks_4;
green_green_update_0_write2_merged_banks_4_cache green_green_update_0_write2_merged_banks_4;
green_green_update_0_write3_merged_banks_4_cache green_green_update_0_write3_merged_banks_4;
};
inline void green_green_update_0_write0_write(hw_uint<16>& green_green_update_0_write0, green_cache& green, int d0, int d1) {
green.green_green_update_0_write0_merged_banks_4.push(green_green_update_0_write0);
}
inline void green_green_update_0_write1_write(hw_uint<16>& green_green_update_0_write1, green_cache& green, int d0, int d1) {
green.green_green_update_0_write1_merged_banks_4.push(green_green_update_0_write1);
}
inline void green_green_update_0_write2_write(hw_uint<16>& green_green_update_0_write2, green_cache& green, int d0, int d1) {
green.green_green_update_0_write2_merged_banks_4.push(green_green_update_0_write2);
}
inline void green_green_update_0_write3_write(hw_uint<16>& green_green_update_0_write3, green_cache& green, int d0, int d1) {
green.green_green_update_0_write3_merged_banks_4.push(green_green_update_0_write3);
}
inline hw_uint<16> green_bx_rd0_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd0 read pattern: { green_bx_update_0[d0, d1] -> green[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write0 = green.green_green_update_0_write0_merged_banks_4.peek_1();
return value_green_green_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd1_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd1 read pattern: { green_bx_update_0[d0, d1] -> green[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write1 = green.green_green_update_0_write1_merged_banks_4.peek_1();
return value_green_green_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd10_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd10 read pattern: { green_bx_update_0[d0, d1] -> green[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_green_update_0_write0 = green.green_green_update_0_write0_merged_banks_4.peek_0();
return value_green_green_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd11_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd11 read pattern: { green_bx_update_0[d0, d1] -> green[5 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_green_update_0_write1 = green.green_green_update_0_write1_merged_banks_4.peek_0();
return value_green_green_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd2_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd2 read pattern: { green_bx_update_0[d0, d1] -> green[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write2 = green.green_green_update_0_write2_merged_banks_4.peek_1();
return value_green_green_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd3_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd3 read pattern: { green_bx_update_0[d0, d1] -> green[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write1 = green.green_green_update_0_write1_merged_banks_4.peek_1();
return value_green_green_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd4_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd4 read pattern: { green_bx_update_0[d0, d1] -> green[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write2 = green.green_green_update_0_write2_merged_banks_4.peek_1();
return value_green_green_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd5_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd5 read pattern: { green_bx_update_0[d0, d1] -> green[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write3 = green.green_green_update_0_write3_merged_banks_4.peek_1();
return value_green_green_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd6_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd6 read pattern: { green_bx_update_0[d0, d1] -> green[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write2 = green.green_green_update_0_write2_merged_banks_4.peek_1();
return value_green_green_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd7_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd7 read pattern: { green_bx_update_0[d0, d1] -> green[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write3 = green.green_green_update_0_write3_merged_banks_4.peek_1();
return value_green_green_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd8_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd8 read pattern: { green_bx_update_0[d0, d1] -> green[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_green_update_0_write0 = green.green_green_update_0_write0_merged_banks_4.peek_0();
return value_green_green_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_bx_rd9_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_bx_rd9 read pattern: { green_bx_update_0[d0, d1] -> green[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_green_green_update_0_write3 = green.green_green_update_0_write3_merged_banks_4.peek_1();
return value_green_green_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd0_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd0 read pattern: { green_diff_update_0[d0, d1] -> green[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_green_green_update_0_write0 = green.green_green_update_0_write0_merged_banks_4.peek_963();
return value_green_green_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd1_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd1 read pattern: { green_diff_update_0[d0, d1] -> green[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_green_green_update_0_write1 = green.green_green_update_0_write1_merged_banks_4.peek_963();
return value_green_green_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd2_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd2 read pattern: { green_diff_update_0[d0, d1] -> green[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_green_green_update_0_write2 = green.green_green_update_0_write2_merged_banks_4.peek_963();
return value_green_green_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd3_select(green_cache& green, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd3 read pattern: { green_diff_update_0[d0, d1] -> green[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { green_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_green_green_update_0_write3 = green.green_green_update_0_write3_merged_banks_4.peek_963();
return value_green_green_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 3
// green_bx_update_0_read
// green_bx_rd0
// green_bx_rd1
// green_bx_rd2
// green_bx_rd3
// green_bx_rd4
// green_bx_rd5
// green_bx_rd6
// green_bx_rd7
// green_bx_rd8
// green_bx_rd9
// green_bx_rd10
// green_bx_rd11
inline hw_uint<192> green_green_bx_update_0_read_bundle_read(green_cache& green, int d0, int d1) {
// # of ports in bundle: 12
// green_bx_rd0
// green_bx_rd1
// green_bx_rd2
// green_bx_rd3
// green_bx_rd4
// green_bx_rd5
// green_bx_rd6
// green_bx_rd7
// green_bx_rd8
// green_bx_rd9
// green_bx_rd10
// green_bx_rd11
hw_uint<192> result;
hw_uint<16> green_bx_rd0_res = green_bx_rd0_select(green, d0, d1);
set_at<0, 192>(result, green_bx_rd0_res);
hw_uint<16> green_bx_rd1_res = green_bx_rd1_select(green, d0, d1);
set_at<16, 192>(result, green_bx_rd1_res);
hw_uint<16> green_bx_rd2_res = green_bx_rd2_select(green, d0, d1);
set_at<32, 192>(result, green_bx_rd2_res);
hw_uint<16> green_bx_rd3_res = green_bx_rd3_select(green, d0, d1);
set_at<48, 192>(result, green_bx_rd3_res);
hw_uint<16> green_bx_rd4_res = green_bx_rd4_select(green, d0, d1);
set_at<64, 192>(result, green_bx_rd4_res);
hw_uint<16> green_bx_rd5_res = green_bx_rd5_select(green, d0, d1);
set_at<80, 192>(result, green_bx_rd5_res);
hw_uint<16> green_bx_rd6_res = green_bx_rd6_select(green, d0, d1);
set_at<96, 192>(result, green_bx_rd6_res);
hw_uint<16> green_bx_rd7_res = green_bx_rd7_select(green, d0, d1);
set_at<112, 192>(result, green_bx_rd7_res);
hw_uint<16> green_bx_rd8_res = green_bx_rd8_select(green, d0, d1);
set_at<128, 192>(result, green_bx_rd8_res);
hw_uint<16> green_bx_rd9_res = green_bx_rd9_select(green, d0, d1);
set_at<144, 192>(result, green_bx_rd9_res);
hw_uint<16> green_bx_rd10_res = green_bx_rd10_select(green, d0, d1);
set_at<160, 192>(result, green_bx_rd10_res);
hw_uint<16> green_bx_rd11_res = green_bx_rd11_select(green, d0, d1);
set_at<176, 192>(result, green_bx_rd11_res);
return result;
}
// green_diff_update_0_read
// green_diff_rd0
// green_diff_rd1
// green_diff_rd2
// green_diff_rd3
inline hw_uint<64> green_green_diff_update_0_read_bundle_read(green_cache& green, int d0, int d1) {
// # of ports in bundle: 4
// green_diff_rd0
// green_diff_rd1
// green_diff_rd2
// green_diff_rd3
hw_uint<64> result;
hw_uint<16> green_diff_rd0_res = green_diff_rd0_select(green, d0, d1);
set_at<0, 64>(result, green_diff_rd0_res);
hw_uint<16> green_diff_rd1_res = green_diff_rd1_select(green, d0, d1);
set_at<16, 64>(result, green_diff_rd1_res);
hw_uint<16> green_diff_rd2_res = green_diff_rd2_select(green, d0, d1);
set_at<32, 64>(result, green_diff_rd2_res);
hw_uint<16> green_diff_rd3_res = green_diff_rd3_select(green, d0, d1);
set_at<48, 64>(result, green_diff_rd3_res);
return result;
}
// green_update_0_write
// green_green_update_0_write0
// green_green_update_0_write1
// green_green_update_0_write2
// green_green_update_0_write3
inline void green_green_update_0_write_bundle_write(hw_uint<64>& green_update_0_write, green_cache& green, int d0, int d1) {
hw_uint<16> green_green_update_0_write0_res = green_update_0_write.extract<0, 15>();
green_green_update_0_write0_write(green_green_update_0_write0_res, green, d0, d1);
hw_uint<16> green_green_update_0_write1_res = green_update_0_write.extract<16, 31>();
green_green_update_0_write1_write(green_green_update_0_write1_res, green, d0, d1);
hw_uint<16> green_green_update_0_write2_res = green_update_0_write.extract<32, 47>();
green_green_update_0_write2_write(green_green_update_0_write2_res, green, d0, d1);
hw_uint<16> green_green_update_0_write3_res = green_update_0_write.extract<48, 63>();
green_green_update_0_write3_write(green_green_update_0_write3_res, green, d0, d1);
}
#include "hw_classes.h"
struct green_bx_green_bx_update_0_write0_merged_banks_3_cache {
// RAM Box: {[0, 1916], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct green_bx_green_bx_update_0_write1_merged_banks_3_cache {
// RAM Box: {[1, 1917], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct green_bx_green_bx_update_0_write2_merged_banks_3_cache {
// RAM Box: {[2, 1918], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct green_bx_green_bx_update_0_write3_merged_banks_3_cache {
// RAM Box: {[3, 1919], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct green_bx_cache {
green_bx_green_bx_update_0_write0_merged_banks_3_cache green_bx_green_bx_update_0_write0_merged_banks_3;
green_bx_green_bx_update_0_write1_merged_banks_3_cache green_bx_green_bx_update_0_write1_merged_banks_3;
green_bx_green_bx_update_0_write2_merged_banks_3_cache green_bx_green_bx_update_0_write2_merged_banks_3;
green_bx_green_bx_update_0_write3_merged_banks_3_cache green_bx_green_bx_update_0_write3_merged_banks_3;
};
inline void green_bx_green_bx_update_0_write0_write(hw_uint<16>& green_bx_green_bx_update_0_write0, green_bx_cache& green_bx, int d0, int d1) {
green_bx.green_bx_green_bx_update_0_write0_merged_banks_3.push(green_bx_green_bx_update_0_write0);
}
inline void green_bx_green_bx_update_0_write1_write(hw_uint<16>& green_bx_green_bx_update_0_write1, green_bx_cache& green_bx, int d0, int d1) {
green_bx.green_bx_green_bx_update_0_write1_merged_banks_3.push(green_bx_green_bx_update_0_write1);
}
inline void green_bx_green_bx_update_0_write2_write(hw_uint<16>& green_bx_green_bx_update_0_write2, green_bx_cache& green_bx, int d0, int d1) {
green_bx.green_bx_green_bx_update_0_write2_merged_banks_3.push(green_bx_green_bx_update_0_write2);
}
inline void green_bx_green_bx_update_0_write3_write(hw_uint<16>& green_bx_green_bx_update_0_write3, green_bx_cache& green_bx, int d0, int d1) {
green_bx.green_bx_green_bx_update_0_write3_merged_banks_3.push(green_bx_green_bx_update_0_write3);
}
inline hw_uint<16> green_by_rd0_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd0 read pattern: { green_by_update_0[d0, d1] -> green_bx[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write0 = green_bx.green_bx_green_bx_update_0_write0_merged_banks_3.peek_960();
return value_green_bx_green_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd1_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd1 read pattern: { green_by_update_0[d0, d1] -> green_bx[4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write0 = green_bx.green_bx_green_bx_update_0_write0_merged_banks_3.peek_480();
return value_green_bx_green_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd10_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd10 read pattern: { green_by_update_0[d0, d1] -> green_bx[3 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write3 = green_bx.green_bx_green_bx_update_0_write3_merged_banks_3.peek_480();
return value_green_bx_green_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd11_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd11 read pattern: { green_by_update_0[d0, d1] -> green_bx[3 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_bx_green_bx_update_0_write3 = green_bx.green_bx_green_bx_update_0_write3_merged_banks_3.peek_0();
return value_green_bx_green_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd2_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd2 read pattern: { green_by_update_0[d0, d1] -> green_bx[4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_bx_green_bx_update_0_write0 = green_bx.green_bx_green_bx_update_0_write0_merged_banks_3.peek_0();
return value_green_bx_green_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd3_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd3 read pattern: { green_by_update_0[d0, d1] -> green_bx[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write1 = green_bx.green_bx_green_bx_update_0_write1_merged_banks_3.peek_960();
return value_green_bx_green_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd4_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd4 read pattern: { green_by_update_0[d0, d1] -> green_bx[1 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write1 = green_bx.green_bx_green_bx_update_0_write1_merged_banks_3.peek_480();
return value_green_bx_green_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd5_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd5 read pattern: { green_by_update_0[d0, d1] -> green_bx[1 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_bx_green_bx_update_0_write1 = green_bx.green_bx_green_bx_update_0_write1_merged_banks_3.peek_0();
return value_green_bx_green_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd6_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd6 read pattern: { green_by_update_0[d0, d1] -> green_bx[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write2 = green_bx.green_bx_green_bx_update_0_write2_merged_banks_3.peek_960();
return value_green_bx_green_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd7_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd7 read pattern: { green_by_update_0[d0, d1] -> green_bx[2 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write2 = green_bx.green_bx_green_bx_update_0_write2_merged_banks_3.peek_480();
return value_green_bx_green_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd8_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd8 read pattern: { green_by_update_0[d0, d1] -> green_bx[2 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_green_bx_green_bx_update_0_write2 = green_bx.green_bx_green_bx_update_0_write2_merged_banks_3.peek_0();
return value_green_bx_green_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_by_rd9_select(green_bx_cache& green_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_by_rd9 read pattern: { green_by_update_0[d0, d1] -> green_bx[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 7] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { green_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; green_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_green_bx_green_bx_update_0_write3 = green_bx.green_bx_green_bx_update_0_write3_merged_banks_3.peek_960();
return value_green_bx_green_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// green_bx_update_0_write
// green_bx_green_bx_update_0_write0
// green_bx_green_bx_update_0_write1
// green_bx_green_bx_update_0_write2
// green_bx_green_bx_update_0_write3
inline void green_bx_green_bx_update_0_write_bundle_write(hw_uint<64>& green_bx_update_0_write, green_bx_cache& green_bx, int d0, int d1) {
hw_uint<16> green_bx_green_bx_update_0_write0_res = green_bx_update_0_write.extract<0, 15>();
green_bx_green_bx_update_0_write0_write(green_bx_green_bx_update_0_write0_res, green_bx, d0, d1);
hw_uint<16> green_bx_green_bx_update_0_write1_res = green_bx_update_0_write.extract<16, 31>();
green_bx_green_bx_update_0_write1_write(green_bx_green_bx_update_0_write1_res, green_bx, d0, d1);
hw_uint<16> green_bx_green_bx_update_0_write2_res = green_bx_update_0_write.extract<32, 47>();
green_bx_green_bx_update_0_write2_write(green_bx_green_bx_update_0_write2_res, green_bx, d0, d1);
hw_uint<16> green_bx_green_bx_update_0_write3_res = green_bx_update_0_write.extract<48, 63>();
green_bx_green_bx_update_0_write3_write(green_bx_green_bx_update_0_write3_res, green_bx, d0, d1);
}
// green_by_update_0_read
// green_by_rd0
// green_by_rd1
// green_by_rd2
// green_by_rd3
// green_by_rd4
// green_by_rd5
// green_by_rd6
// green_by_rd7
// green_by_rd8
// green_by_rd9
// green_by_rd10
// green_by_rd11
inline hw_uint<192> green_bx_green_by_update_0_read_bundle_read(green_bx_cache& green_bx, int d0, int d1) {
// # of ports in bundle: 12
// green_by_rd0
// green_by_rd1
// green_by_rd2
// green_by_rd3
// green_by_rd4
// green_by_rd5
// green_by_rd6
// green_by_rd7
// green_by_rd8
// green_by_rd9
// green_by_rd10
// green_by_rd11
hw_uint<192> result;
hw_uint<16> green_by_rd0_res = green_by_rd0_select(green_bx, d0, d1);
set_at<0, 192>(result, green_by_rd0_res);
hw_uint<16> green_by_rd1_res = green_by_rd1_select(green_bx, d0, d1);
set_at<16, 192>(result, green_by_rd1_res);
hw_uint<16> green_by_rd2_res = green_by_rd2_select(green_bx, d0, d1);
set_at<32, 192>(result, green_by_rd2_res);
hw_uint<16> green_by_rd3_res = green_by_rd3_select(green_bx, d0, d1);
set_at<48, 192>(result, green_by_rd3_res);
hw_uint<16> green_by_rd4_res = green_by_rd4_select(green_bx, d0, d1);
set_at<64, 192>(result, green_by_rd4_res);
hw_uint<16> green_by_rd5_res = green_by_rd5_select(green_bx, d0, d1);
set_at<80, 192>(result, green_by_rd5_res);
hw_uint<16> green_by_rd6_res = green_by_rd6_select(green_bx, d0, d1);
set_at<96, 192>(result, green_by_rd6_res);
hw_uint<16> green_by_rd7_res = green_by_rd7_select(green_bx, d0, d1);
set_at<112, 192>(result, green_by_rd7_res);
hw_uint<16> green_by_rd8_res = green_by_rd8_select(green_bx, d0, d1);
set_at<128, 192>(result, green_by_rd8_res);
hw_uint<16> green_by_rd9_res = green_by_rd9_select(green_bx, d0, d1);
set_at<144, 192>(result, green_by_rd9_res);
hw_uint<16> green_by_rd10_res = green_by_rd10_select(green_bx, d0, d1);
set_at<160, 192>(result, green_by_rd10_res);
hw_uint<16> green_by_rd11_res = green_by_rd11_select(green_bx, d0, d1);
set_at<176, 192>(result, green_by_rd11_res);
return result;
}
#include "hw_classes.h"
struct green_by_green_by_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_by_green_by_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_by_green_by_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_by_green_by_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_by_cache {
green_by_green_by_update_0_write0_merged_banks_1_cache green_by_green_by_update_0_write0_merged_banks_1;
green_by_green_by_update_0_write1_merged_banks_1_cache green_by_green_by_update_0_write1_merged_banks_1;
green_by_green_by_update_0_write2_merged_banks_1_cache green_by_green_by_update_0_write2_merged_banks_1;
green_by_green_by_update_0_write3_merged_banks_1_cache green_by_green_by_update_0_write3_merged_banks_1;
};
inline void green_by_green_by_update_0_write0_write(hw_uint<16>& green_by_green_by_update_0_write0, green_by_cache& green_by, int d0, int d1) {
green_by.green_by_green_by_update_0_write0_merged_banks_1.push(green_by_green_by_update_0_write0);
}
inline void green_by_green_by_update_0_write1_write(hw_uint<16>& green_by_green_by_update_0_write1, green_by_cache& green_by, int d0, int d1) {
green_by.green_by_green_by_update_0_write1_merged_banks_1.push(green_by_green_by_update_0_write1);
}
inline void green_by_green_by_update_0_write2_write(hw_uint<16>& green_by_green_by_update_0_write2, green_by_cache& green_by, int d0, int d1) {
green_by.green_by_green_by_update_0_write2_merged_banks_1.push(green_by_green_by_update_0_write2);
}
inline void green_by_green_by_update_0_write3_write(hw_uint<16>& green_by_green_by_update_0_write3, green_by_cache& green_by, int d0, int d1) {
green_by.green_by_green_by_update_0_write3_merged_banks_1.push(green_by_green_by_update_0_write3);
}
inline hw_uint<16> green_diff_rd0_select(green_by_cache& green_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd0 read pattern: { green_diff_update_0[d0, d1] -> green_by[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_by_green_by_update_0_write0 = green_by.green_by_green_by_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_by_green_by_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd1_select(green_by_cache& green_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd1 read pattern: { green_diff_update_0[d0, d1] -> green_by[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_by_green_by_update_0_write1 = green_by.green_by_green_by_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_by_green_by_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd2_select(green_by_cache& green_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd2 read pattern: { green_diff_update_0[d0, d1] -> green_by[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_by_green_by_update_0_write2 = green_by.green_by_green_by_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_by_green_by_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_diff_rd3_select(green_by_cache& green_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_diff_rd3 read pattern: { green_diff_update_0[d0, d1] -> green_by[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 10] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_by_green_by_update_0_write3 = green_by.green_by_green_by_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_by_green_by_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// green_by_update_0_write
// green_by_green_by_update_0_write0
// green_by_green_by_update_0_write1
// green_by_green_by_update_0_write2
// green_by_green_by_update_0_write3
inline void green_by_green_by_update_0_write_bundle_write(hw_uint<64>& green_by_update_0_write, green_by_cache& green_by, int d0, int d1) {
hw_uint<16> green_by_green_by_update_0_write0_res = green_by_update_0_write.extract<0, 15>();
green_by_green_by_update_0_write0_write(green_by_green_by_update_0_write0_res, green_by, d0, d1);
hw_uint<16> green_by_green_by_update_0_write1_res = green_by_update_0_write.extract<16, 31>();
green_by_green_by_update_0_write1_write(green_by_green_by_update_0_write1_res, green_by, d0, d1);
hw_uint<16> green_by_green_by_update_0_write2_res = green_by_update_0_write.extract<32, 47>();
green_by_green_by_update_0_write2_write(green_by_green_by_update_0_write2_res, green_by, d0, d1);
hw_uint<16> green_by_green_by_update_0_write3_res = green_by_update_0_write.extract<48, 63>();
green_by_green_by_update_0_write3_write(green_by_green_by_update_0_write3_res, green_by, d0, d1);
}
// green_diff_update_0_read
// green_diff_rd0
// green_diff_rd1
// green_diff_rd2
// green_diff_rd3
inline hw_uint<64> green_by_green_diff_update_0_read_bundle_read(green_by_cache& green_by, int d0, int d1) {
// # of ports in bundle: 4
// green_diff_rd0
// green_diff_rd1
// green_diff_rd2
// green_diff_rd3
hw_uint<64> result;
hw_uint<16> green_diff_rd0_res = green_diff_rd0_select(green_by, d0, d1);
set_at<0, 64>(result, green_diff_rd0_res);
hw_uint<16> green_diff_rd1_res = green_diff_rd1_select(green_by, d0, d1);
set_at<16, 64>(result, green_diff_rd1_res);
hw_uint<16> green_diff_rd2_res = green_diff_rd2_select(green_by, d0, d1);
set_at<32, 64>(result, green_diff_rd2_res);
hw_uint<16> green_diff_rd3_res = green_diff_rd3_select(green_by, d0, d1);
set_at<48, 64>(result, green_diff_rd3_res);
return result;
}
#include "hw_classes.h"
struct green_diff_green_diff_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_diff_green_diff_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_diff_green_diff_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_diff_green_diff_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct green_diff_cache {
green_diff_green_diff_update_0_write0_merged_banks_1_cache green_diff_green_diff_update_0_write0_merged_banks_1;
green_diff_green_diff_update_0_write1_merged_banks_1_cache green_diff_green_diff_update_0_write1_merged_banks_1;
green_diff_green_diff_update_0_write2_merged_banks_1_cache green_diff_green_diff_update_0_write2_merged_banks_1;
green_diff_green_diff_update_0_write3_merged_banks_1_cache green_diff_green_diff_update_0_write3_merged_banks_1;
};
inline void green_diff_green_diff_update_0_write0_write(hw_uint<16>& green_diff_green_diff_update_0_write0, green_diff_cache& green_diff, int d0, int d1) {
green_diff.green_diff_green_diff_update_0_write0_merged_banks_1.push(green_diff_green_diff_update_0_write0);
}
inline void green_diff_green_diff_update_0_write1_write(hw_uint<16>& green_diff_green_diff_update_0_write1, green_diff_cache& green_diff, int d0, int d1) {
green_diff.green_diff_green_diff_update_0_write1_merged_banks_1.push(green_diff_green_diff_update_0_write1);
}
inline void green_diff_green_diff_update_0_write2_write(hw_uint<16>& green_diff_green_diff_update_0_write2, green_diff_cache& green_diff, int d0, int d1) {
green_diff.green_diff_green_diff_update_0_write2_merged_banks_1.push(green_diff_green_diff_update_0_write2);
}
inline void green_diff_green_diff_update_0_write3_write(hw_uint<16>& green_diff_green_diff_update_0_write3, green_diff_cache& green_diff, int d0, int d1) {
green_diff.green_diff_green_diff_update_0_write3_merged_banks_1.push(green_diff_green_diff_update_0_write3);
}
inline hw_uint<16> cp_4_rd0_select(green_diff_cache& green_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd0 read pattern: { cp_4_update_0[d0, d1] -> green_diff[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_diff_green_diff_update_0_write0 = green_diff.green_diff_green_diff_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_diff_green_diff_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd1_select(green_diff_cache& green_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd1 read pattern: { cp_4_update_0[d0, d1] -> green_diff[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_diff_green_diff_update_0_write1 = green_diff.green_diff_green_diff_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_diff_green_diff_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd2_select(green_diff_cache& green_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd2 read pattern: { cp_4_update_0[d0, d1] -> green_diff[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_diff_green_diff_update_0_write2 = green_diff.green_diff_green_diff_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_diff_green_diff_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd3_select(green_diff_cache& green_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd3 read pattern: { cp_4_update_0[d0, d1] -> green_diff[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { green_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 13] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_green_diff_green_diff_update_0_write3 = green_diff.green_diff_green_diff_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_green_diff_green_diff_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// cp_4_update_0_read
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
inline hw_uint<64> green_diff_cp_4_update_0_read_bundle_read(green_diff_cache& green_diff, int d0, int d1) {
// # of ports in bundle: 4
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
hw_uint<64> result;
hw_uint<16> cp_4_rd0_res = cp_4_rd0_select(green_diff, d0, d1);
set_at<0, 64>(result, cp_4_rd0_res);
hw_uint<16> cp_4_rd1_res = cp_4_rd1_select(green_diff, d0, d1);
set_at<16, 64>(result, cp_4_rd1_res);
hw_uint<16> cp_4_rd2_res = cp_4_rd2_select(green_diff, d0, d1);
set_at<32, 64>(result, cp_4_rd2_res);
hw_uint<16> cp_4_rd3_res = cp_4_rd3_select(green_diff, d0, d1);
set_at<48, 64>(result, cp_4_rd3_res);
return result;
}
// green_diff_update_0_write
// green_diff_green_diff_update_0_write0
// green_diff_green_diff_update_0_write1
// green_diff_green_diff_update_0_write2
// green_diff_green_diff_update_0_write3
inline void green_diff_green_diff_update_0_write_bundle_write(hw_uint<64>& green_diff_update_0_write, green_diff_cache& green_diff, int d0, int d1) {
hw_uint<16> green_diff_green_diff_update_0_write0_res = green_diff_update_0_write.extract<0, 15>();
green_diff_green_diff_update_0_write0_write(green_diff_green_diff_update_0_write0_res, green_diff, d0, d1);
hw_uint<16> green_diff_green_diff_update_0_write1_res = green_diff_update_0_write.extract<16, 31>();
green_diff_green_diff_update_0_write1_write(green_diff_green_diff_update_0_write1_res, green_diff, d0, d1);
hw_uint<16> green_diff_green_diff_update_0_write2_res = green_diff_update_0_write.extract<32, 47>();
green_diff_green_diff_update_0_write2_write(green_diff_green_diff_update_0_write2_res, green_diff, d0, d1);
hw_uint<16> green_diff_green_diff_update_0_write3_res = green_diff_update_0_write.extract<48, 63>();
green_diff_green_diff_update_0_write3_write(green_diff_green_diff_update_0_write3_res, green_diff, d0, d1);
}
#include "hw_classes.h"
struct raw_raw_update_0_write0_merged_banks_27_cache {
// RAM Box: {[0, 1924], [0, 1083]}
// Capacity: 966
// # of read delays: 6
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 480> f3;
hw_uint<16> f4;
hw_uint<16> f6;
fifo<hw_uint<16>, 480> f7;
hw_uint<16> f8;
hw_uint<16> f10;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_481() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_482() {
return f4;
}
inline hw_uint<16> peek_483() {
return f6;
}
inline hw_uint<16> peek_963() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f7.back();
}
inline hw_uint<16> peek_964() {
return f8;
}
inline hw_uint<16> peek_965() {
return f10;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f10 = f8;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 480
f8 = f7.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 480 reading from capacity: 1
f7.push(f6);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f6 = f4;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 480
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 480 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct raw_raw_update_0_write1_merged_banks_27_cache {
// RAM Box: {[1, 1925], [0, 1083]}
// Capacity: 966
// # of read delays: 6
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 480> f3;
hw_uint<16> f4;
hw_uint<16> f6;
fifo<hw_uint<16>, 480> f7;
hw_uint<16> f8;
hw_uint<16> f10;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_481() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_482() {
return f4;
}
inline hw_uint<16> peek_483() {
return f6;
}
inline hw_uint<16> peek_963() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f7.back();
}
inline hw_uint<16> peek_964() {
return f8;
}
inline hw_uint<16> peek_965() {
return f10;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f10 = f8;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 480
f8 = f7.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 480 reading from capacity: 1
f7.push(f6);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f6 = f4;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 480
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 480 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct raw_raw_update_0_write2_merged_banks_27_cache {
// RAM Box: {[2, 1926], [0, 1083]}
// Capacity: 966
// # of read delays: 4
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 481> f3;
hw_uint<16> f4;
fifo<hw_uint<16>, 481> f5;
hw_uint<16> f6;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_482() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_483() {
return f4;
}
inline hw_uint<16> peek_964() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f5.back();
}
inline hw_uint<16> peek_965() {
return f6;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 481
f6 = f5.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 481 reading from capacity: 1
f5.push(f4);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 481
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 481 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct raw_raw_update_0_write3_merged_banks_27_cache {
// RAM Box: {[3, 1927], [0, 1083]}
// Capacity: 966
// # of read delays: 4
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 481> f3;
hw_uint<16> f4;
fifo<hw_uint<16>, 481> f5;
hw_uint<16> f6;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_482() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_483() {
return f4;
}
inline hw_uint<16> peek_964() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f5.back();
}
inline hw_uint<16> peek_965() {
return f6;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 481
f6 = f5.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 481 reading from capacity: 1
f5.push(f4);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 481
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 481 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct raw_cache {
raw_raw_update_0_write0_merged_banks_27_cache raw_raw_update_0_write0_merged_banks_27;
raw_raw_update_0_write1_merged_banks_27_cache raw_raw_update_0_write1_merged_banks_27;
raw_raw_update_0_write2_merged_banks_27_cache raw_raw_update_0_write2_merged_banks_27;
raw_raw_update_0_write3_merged_banks_27_cache raw_raw_update_0_write3_merged_banks_27;
};
inline void raw_raw_update_0_write0_write(hw_uint<16>& raw_raw_update_0_write0, raw_cache& raw, int d0, int d1) {
raw.raw_raw_update_0_write0_merged_banks_27.push(raw_raw_update_0_write0);
}
inline void raw_raw_update_0_write1_write(hw_uint<16>& raw_raw_update_0_write1, raw_cache& raw, int d0, int d1) {
raw.raw_raw_update_0_write1_merged_banks_27.push(raw_raw_update_0_write1);
}
inline void raw_raw_update_0_write2_write(hw_uint<16>& raw_raw_update_0_write2, raw_cache& raw, int d0, int d1) {
raw.raw_raw_update_0_write2_merged_banks_27.push(raw_raw_update_0_write2);
}
inline void raw_raw_update_0_write3_write(hw_uint<16>& raw_raw_update_0_write3, raw_cache& raw, int d0, int d1) {
raw.raw_raw_update_0_write3_merged_banks_27.push(raw_raw_update_0_write3);
}
inline hw_uint<16> blue_rd0_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd0 read pattern: { blue_update_0[d0, d1] -> raw[4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_965();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd1_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd1 read pattern: { blue_update_0[d0, d1] -> raw[4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_483();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd10_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd10 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd11_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd11 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd12_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd12 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd13_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd13 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd14_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd14 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd15_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd15 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd16_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd16 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd17_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd17 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd18_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd18 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd19_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd19 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd2_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd2 read pattern: { blue_update_0[d0, d1] -> raw[4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_1();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd20_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd20 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd21_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd21 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd22_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd22 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd23_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd23 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd24_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd24 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd25_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd25 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd26_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd26 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd27_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd27 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd28_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd28 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd29_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd29 read pattern: { blue_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd3_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd3 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd30_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd30 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd31_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd31 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd32_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd32 read pattern: { blue_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd33_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd33 read pattern: { blue_update_0[d0, d1] -> raw[5 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_964();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd34_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd34 read pattern: { blue_update_0[d0, d1] -> raw[5 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; blue_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_482();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd35_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd35 read pattern: { blue_update_0[d0, d1] -> raw[5 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_0();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd4_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd4 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd5_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd5 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd6_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd6 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd7_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd7 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd8_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd8 read pattern: { blue_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> blue_rd9_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// blue_rd9 read pattern: { blue_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { blue_update_0[d0, d1] -> [2 + d1, 1 + d0, 2] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { blue_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd0_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd0 read pattern: { green_update_0[d0, d1] -> raw[4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_965();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd1_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd1 read pattern: { green_update_0[d0, d1] -> raw[4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_483();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd10_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd10 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd11_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd11 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd12_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd12 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd13_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd13 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd14_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd14 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd15_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd15 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd16_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd16 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd17_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd17 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd18_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd18 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd19_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd19 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd2_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd2 read pattern: { green_update_0[d0, d1] -> raw[4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_1();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd20_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd20 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd21_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd21 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd22_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd22 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd23_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd23 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd24_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd24 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd25_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd25 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd26_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd26 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd27_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd27 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd28_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd28 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd29_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd29 read pattern: { green_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd3_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd3 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd30_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd30 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd31_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd31 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd32_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd32 read pattern: { green_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd33_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd33 read pattern: { green_update_0[d0, d1] -> raw[5 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_964();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd34_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd34 read pattern: { green_update_0[d0, d1] -> raw[5 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; green_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_482();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd35_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd35 read pattern: { green_update_0[d0, d1] -> raw[5 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_0();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd4_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd4 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd5_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd5 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd6_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd6 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd7_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd7 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd8_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd8 read pattern: { green_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> green_rd9_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// green_rd9 read pattern: { green_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { green_update_0[d0, d1] -> [2 + d1, 1 + d0, 4] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { green_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd0_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd0 read pattern: { red_update_0[d0, d1] -> raw[4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_965();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd1_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd1 read pattern: { red_update_0[d0, d1] -> raw[4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_483();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd10_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd10 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd11_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd11 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd12_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd12 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd13_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd13 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd14_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd14 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd15_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd15 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd16_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd16 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd17_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd17 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd18_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd18 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd19_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd19 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd2_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd2 read pattern: { red_update_0[d0, d1] -> raw[4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_1();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd20_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd20 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd21_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd21 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd22_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd22 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd23_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd23 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd24_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd24 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd25_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd25 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd26_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd26 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd27_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd27 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_965();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd28_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd28 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_483();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd29_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd29 read pattern: { red_update_0[d0, d1] -> raw[3 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write3 = raw.raw_raw_update_0_write3_merged_banks_27.peek_1();
return value_raw_raw_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd3_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd3 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd30_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd30 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_964();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd31_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd31 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_482();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd32_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd32 read pattern: { red_update_0[d0, d1] -> raw[4 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write0 = raw.raw_raw_update_0_write0_merged_banks_27.peek_0();
return value_raw_raw_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd33_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd33 read pattern: { red_update_0[d0, d1] -> raw[5 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 964 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (484 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_964();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd34_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd34 read pattern: { red_update_0[d0, d1] -> raw[5 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 482 : 0 <= d0 <= 479 and 0 <= d1 <= 1081; red_update_0[d0, d1] -> (2 + d0) : d0 = 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_482();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd35_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd35 read pattern: { red_update_0[d0, d1] -> raw[5 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_0();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd4_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd4 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_483();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd5_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd5 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_1();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd6_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd6 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_965();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd7_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd7 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 1 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 483 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_483();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd8_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd8 read pattern: { red_update_0[d0, d1] -> raw[2 + 4d0, 2 + d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 1 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write2 = raw.raw_raw_update_0_write2_merged_banks_27.peek_1();
return value_raw_raw_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_rd9_select(raw_cache& raw, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_rd9 read pattern: { red_update_0[d0, d1] -> raw[1 + 4d0, d1] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Read schedule : { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// Write schedule: { raw_update_0[d0, d1] -> [d1, d0, 1] : 0 <= d0 <= 481 and 0 <= d1 <= 1083 }
// DD fold: { red_update_0[d0, d1] -> 965 : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
auto value_raw_raw_update_0_write1 = raw.raw_raw_update_0_write1_merged_banks_27.peek_965();
return value_raw_raw_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 4
// blue_update_0_read
// blue_rd0
// blue_rd1
// blue_rd2
// blue_rd3
// blue_rd4
// blue_rd5
// blue_rd6
// blue_rd7
// blue_rd8
// blue_rd9
// blue_rd10
// blue_rd11
// blue_rd12
// blue_rd13
// blue_rd14
// blue_rd15
// blue_rd16
// blue_rd17
// blue_rd18
// blue_rd19
// blue_rd20
// blue_rd21
// blue_rd22
// blue_rd23
// blue_rd24
// blue_rd25
// blue_rd26
// blue_rd27
// blue_rd28
// blue_rd29
// blue_rd30
// blue_rd31
// blue_rd32
// blue_rd33
// blue_rd34
// blue_rd35
inline hw_uint<576> raw_blue_update_0_read_bundle_read(raw_cache& raw, int d0, int d1) {
// # of ports in bundle: 36
// blue_rd0
// blue_rd1
// blue_rd2
// blue_rd3
// blue_rd4
// blue_rd5
// blue_rd6
// blue_rd7
// blue_rd8
// blue_rd9
// blue_rd10
// blue_rd11
// blue_rd12
// blue_rd13
// blue_rd14
// blue_rd15
// blue_rd16
// blue_rd17
// blue_rd18
// blue_rd19
// blue_rd20
// blue_rd21
// blue_rd22
// blue_rd23
// blue_rd24
// blue_rd25
// blue_rd26
// blue_rd27
// blue_rd28
// blue_rd29
// blue_rd30
// blue_rd31
// blue_rd32
// blue_rd33
// blue_rd34
// blue_rd35
hw_uint<576> result;
hw_uint<16> blue_rd0_res = blue_rd0_select(raw, d0, d1);
set_at<0, 576>(result, blue_rd0_res);
hw_uint<16> blue_rd1_res = blue_rd1_select(raw, d0, d1);
set_at<16, 576>(result, blue_rd1_res);
hw_uint<16> blue_rd2_res = blue_rd2_select(raw, d0, d1);
set_at<32, 576>(result, blue_rd2_res);
hw_uint<16> blue_rd3_res = blue_rd3_select(raw, d0, d1);
set_at<48, 576>(result, blue_rd3_res);
hw_uint<16> blue_rd4_res = blue_rd4_select(raw, d0, d1);
set_at<64, 576>(result, blue_rd4_res);
hw_uint<16> blue_rd5_res = blue_rd5_select(raw, d0, d1);
set_at<80, 576>(result, blue_rd5_res);
hw_uint<16> blue_rd6_res = blue_rd6_select(raw, d0, d1);
set_at<96, 576>(result, blue_rd6_res);
hw_uint<16> blue_rd7_res = blue_rd7_select(raw, d0, d1);
set_at<112, 576>(result, blue_rd7_res);
hw_uint<16> blue_rd8_res = blue_rd8_select(raw, d0, d1);
set_at<128, 576>(result, blue_rd8_res);
hw_uint<16> blue_rd9_res = blue_rd9_select(raw, d0, d1);
set_at<144, 576>(result, blue_rd9_res);
hw_uint<16> blue_rd10_res = blue_rd10_select(raw, d0, d1);
set_at<160, 576>(result, blue_rd10_res);
hw_uint<16> blue_rd11_res = blue_rd11_select(raw, d0, d1);
set_at<176, 576>(result, blue_rd11_res);
hw_uint<16> blue_rd12_res = blue_rd12_select(raw, d0, d1);
set_at<192, 576>(result, blue_rd12_res);
hw_uint<16> blue_rd13_res = blue_rd13_select(raw, d0, d1);
set_at<208, 576>(result, blue_rd13_res);
hw_uint<16> blue_rd14_res = blue_rd14_select(raw, d0, d1);
set_at<224, 576>(result, blue_rd14_res);
hw_uint<16> blue_rd15_res = blue_rd15_select(raw, d0, d1);
set_at<240, 576>(result, blue_rd15_res);
hw_uint<16> blue_rd16_res = blue_rd16_select(raw, d0, d1);
set_at<256, 576>(result, blue_rd16_res);
hw_uint<16> blue_rd17_res = blue_rd17_select(raw, d0, d1);
set_at<272, 576>(result, blue_rd17_res);
hw_uint<16> blue_rd18_res = blue_rd18_select(raw, d0, d1);
set_at<288, 576>(result, blue_rd18_res);
hw_uint<16> blue_rd19_res = blue_rd19_select(raw, d0, d1);
set_at<304, 576>(result, blue_rd19_res);
hw_uint<16> blue_rd20_res = blue_rd20_select(raw, d0, d1);
set_at<320, 576>(result, blue_rd20_res);
hw_uint<16> blue_rd21_res = blue_rd21_select(raw, d0, d1);
set_at<336, 576>(result, blue_rd21_res);
hw_uint<16> blue_rd22_res = blue_rd22_select(raw, d0, d1);
set_at<352, 576>(result, blue_rd22_res);
hw_uint<16> blue_rd23_res = blue_rd23_select(raw, d0, d1);
set_at<368, 576>(result, blue_rd23_res);
hw_uint<16> blue_rd24_res = blue_rd24_select(raw, d0, d1);
set_at<384, 576>(result, blue_rd24_res);
hw_uint<16> blue_rd25_res = blue_rd25_select(raw, d0, d1);
set_at<400, 576>(result, blue_rd25_res);
hw_uint<16> blue_rd26_res = blue_rd26_select(raw, d0, d1);
set_at<416, 576>(result, blue_rd26_res);
hw_uint<16> blue_rd27_res = blue_rd27_select(raw, d0, d1);
set_at<432, 576>(result, blue_rd27_res);
hw_uint<16> blue_rd28_res = blue_rd28_select(raw, d0, d1);
set_at<448, 576>(result, blue_rd28_res);
hw_uint<16> blue_rd29_res = blue_rd29_select(raw, d0, d1);
set_at<464, 576>(result, blue_rd29_res);
hw_uint<16> blue_rd30_res = blue_rd30_select(raw, d0, d1);
set_at<480, 576>(result, blue_rd30_res);
hw_uint<16> blue_rd31_res = blue_rd31_select(raw, d0, d1);
set_at<496, 576>(result, blue_rd31_res);
hw_uint<16> blue_rd32_res = blue_rd32_select(raw, d0, d1);
set_at<512, 576>(result, blue_rd32_res);
hw_uint<16> blue_rd33_res = blue_rd33_select(raw, d0, d1);
set_at<528, 576>(result, blue_rd33_res);
hw_uint<16> blue_rd34_res = blue_rd34_select(raw, d0, d1);
set_at<544, 576>(result, blue_rd34_res);
hw_uint<16> blue_rd35_res = blue_rd35_select(raw, d0, d1);
set_at<560, 576>(result, blue_rd35_res);
return result;
}
// green_update_0_read
// green_rd0
// green_rd1
// green_rd2
// green_rd3
// green_rd4
// green_rd5
// green_rd6
// green_rd7
// green_rd8
// green_rd9
// green_rd10
// green_rd11
// green_rd12
// green_rd13
// green_rd14
// green_rd15
// green_rd16
// green_rd17
// green_rd18
// green_rd19
// green_rd20
// green_rd21
// green_rd22
// green_rd23
// green_rd24
// green_rd25
// green_rd26
// green_rd27
// green_rd28
// green_rd29
// green_rd30
// green_rd31
// green_rd32
// green_rd33
// green_rd34
// green_rd35
inline hw_uint<576> raw_green_update_0_read_bundle_read(raw_cache& raw, int d0, int d1) {
// # of ports in bundle: 36
// green_rd0
// green_rd1
// green_rd2
// green_rd3
// green_rd4
// green_rd5
// green_rd6
// green_rd7
// green_rd8
// green_rd9
// green_rd10
// green_rd11
// green_rd12
// green_rd13
// green_rd14
// green_rd15
// green_rd16
// green_rd17
// green_rd18
// green_rd19
// green_rd20
// green_rd21
// green_rd22
// green_rd23
// green_rd24
// green_rd25
// green_rd26
// green_rd27
// green_rd28
// green_rd29
// green_rd30
// green_rd31
// green_rd32
// green_rd33
// green_rd34
// green_rd35
hw_uint<576> result;
hw_uint<16> green_rd0_res = green_rd0_select(raw, d0, d1);
set_at<0, 576>(result, green_rd0_res);
hw_uint<16> green_rd1_res = green_rd1_select(raw, d0, d1);
set_at<16, 576>(result, green_rd1_res);
hw_uint<16> green_rd2_res = green_rd2_select(raw, d0, d1);
set_at<32, 576>(result, green_rd2_res);
hw_uint<16> green_rd3_res = green_rd3_select(raw, d0, d1);
set_at<48, 576>(result, green_rd3_res);
hw_uint<16> green_rd4_res = green_rd4_select(raw, d0, d1);
set_at<64, 576>(result, green_rd4_res);
hw_uint<16> green_rd5_res = green_rd5_select(raw, d0, d1);
set_at<80, 576>(result, green_rd5_res);
hw_uint<16> green_rd6_res = green_rd6_select(raw, d0, d1);
set_at<96, 576>(result, green_rd6_res);
hw_uint<16> green_rd7_res = green_rd7_select(raw, d0, d1);
set_at<112, 576>(result, green_rd7_res);
hw_uint<16> green_rd8_res = green_rd8_select(raw, d0, d1);
set_at<128, 576>(result, green_rd8_res);
hw_uint<16> green_rd9_res = green_rd9_select(raw, d0, d1);
set_at<144, 576>(result, green_rd9_res);
hw_uint<16> green_rd10_res = green_rd10_select(raw, d0, d1);
set_at<160, 576>(result, green_rd10_res);
hw_uint<16> green_rd11_res = green_rd11_select(raw, d0, d1);
set_at<176, 576>(result, green_rd11_res);
hw_uint<16> green_rd12_res = green_rd12_select(raw, d0, d1);
set_at<192, 576>(result, green_rd12_res);
hw_uint<16> green_rd13_res = green_rd13_select(raw, d0, d1);
set_at<208, 576>(result, green_rd13_res);
hw_uint<16> green_rd14_res = green_rd14_select(raw, d0, d1);
set_at<224, 576>(result, green_rd14_res);
hw_uint<16> green_rd15_res = green_rd15_select(raw, d0, d1);
set_at<240, 576>(result, green_rd15_res);
hw_uint<16> green_rd16_res = green_rd16_select(raw, d0, d1);
set_at<256, 576>(result, green_rd16_res);
hw_uint<16> green_rd17_res = green_rd17_select(raw, d0, d1);
set_at<272, 576>(result, green_rd17_res);
hw_uint<16> green_rd18_res = green_rd18_select(raw, d0, d1);
set_at<288, 576>(result, green_rd18_res);
hw_uint<16> green_rd19_res = green_rd19_select(raw, d0, d1);
set_at<304, 576>(result, green_rd19_res);
hw_uint<16> green_rd20_res = green_rd20_select(raw, d0, d1);
set_at<320, 576>(result, green_rd20_res);
hw_uint<16> green_rd21_res = green_rd21_select(raw, d0, d1);
set_at<336, 576>(result, green_rd21_res);
hw_uint<16> green_rd22_res = green_rd22_select(raw, d0, d1);
set_at<352, 576>(result, green_rd22_res);
hw_uint<16> green_rd23_res = green_rd23_select(raw, d0, d1);
set_at<368, 576>(result, green_rd23_res);
hw_uint<16> green_rd24_res = green_rd24_select(raw, d0, d1);
set_at<384, 576>(result, green_rd24_res);
hw_uint<16> green_rd25_res = green_rd25_select(raw, d0, d1);
set_at<400, 576>(result, green_rd25_res);
hw_uint<16> green_rd26_res = green_rd26_select(raw, d0, d1);
set_at<416, 576>(result, green_rd26_res);
hw_uint<16> green_rd27_res = green_rd27_select(raw, d0, d1);
set_at<432, 576>(result, green_rd27_res);
hw_uint<16> green_rd28_res = green_rd28_select(raw, d0, d1);
set_at<448, 576>(result, green_rd28_res);
hw_uint<16> green_rd29_res = green_rd29_select(raw, d0, d1);
set_at<464, 576>(result, green_rd29_res);
hw_uint<16> green_rd30_res = green_rd30_select(raw, d0, d1);
set_at<480, 576>(result, green_rd30_res);
hw_uint<16> green_rd31_res = green_rd31_select(raw, d0, d1);
set_at<496, 576>(result, green_rd31_res);
hw_uint<16> green_rd32_res = green_rd32_select(raw, d0, d1);
set_at<512, 576>(result, green_rd32_res);
hw_uint<16> green_rd33_res = green_rd33_select(raw, d0, d1);
set_at<528, 576>(result, green_rd33_res);
hw_uint<16> green_rd34_res = green_rd34_select(raw, d0, d1);
set_at<544, 576>(result, green_rd34_res);
hw_uint<16> green_rd35_res = green_rd35_select(raw, d0, d1);
set_at<560, 576>(result, green_rd35_res);
return result;
}
// raw_update_0_write
// raw_raw_update_0_write0
// raw_raw_update_0_write1
// raw_raw_update_0_write2
// raw_raw_update_0_write3
inline void raw_raw_update_0_write_bundle_write(hw_uint<64>& raw_update_0_write, raw_cache& raw, int d0, int d1) {
hw_uint<16> raw_raw_update_0_write0_res = raw_update_0_write.extract<0, 15>();
raw_raw_update_0_write0_write(raw_raw_update_0_write0_res, raw, d0, d1);
hw_uint<16> raw_raw_update_0_write1_res = raw_update_0_write.extract<16, 31>();
raw_raw_update_0_write1_write(raw_raw_update_0_write1_res, raw, d0, d1);
hw_uint<16> raw_raw_update_0_write2_res = raw_update_0_write.extract<32, 47>();
raw_raw_update_0_write2_write(raw_raw_update_0_write2_res, raw, d0, d1);
hw_uint<16> raw_raw_update_0_write3_res = raw_update_0_write.extract<48, 63>();
raw_raw_update_0_write3_write(raw_raw_update_0_write3_res, raw, d0, d1);
}
// red_update_0_read
// red_rd0
// red_rd1
// red_rd2
// red_rd3
// red_rd4
// red_rd5
// red_rd6
// red_rd7
// red_rd8
// red_rd9
// red_rd10
// red_rd11
// red_rd12
// red_rd13
// red_rd14
// red_rd15
// red_rd16
// red_rd17
// red_rd18
// red_rd19
// red_rd20
// red_rd21
// red_rd22
// red_rd23
// red_rd24
// red_rd25
// red_rd26
// red_rd27
// red_rd28
// red_rd29
// red_rd30
// red_rd31
// red_rd32
// red_rd33
// red_rd34
// red_rd35
inline hw_uint<576> raw_red_update_0_read_bundle_read(raw_cache& raw, int d0, int d1) {
// # of ports in bundle: 36
// red_rd0
// red_rd1
// red_rd2
// red_rd3
// red_rd4
// red_rd5
// red_rd6
// red_rd7
// red_rd8
// red_rd9
// red_rd10
// red_rd11
// red_rd12
// red_rd13
// red_rd14
// red_rd15
// red_rd16
// red_rd17
// red_rd18
// red_rd19
// red_rd20
// red_rd21
// red_rd22
// red_rd23
// red_rd24
// red_rd25
// red_rd26
// red_rd27
// red_rd28
// red_rd29
// red_rd30
// red_rd31
// red_rd32
// red_rd33
// red_rd34
// red_rd35
hw_uint<576> result;
hw_uint<16> red_rd0_res = red_rd0_select(raw, d0, d1);
set_at<0, 576>(result, red_rd0_res);
hw_uint<16> red_rd1_res = red_rd1_select(raw, d0, d1);
set_at<16, 576>(result, red_rd1_res);
hw_uint<16> red_rd2_res = red_rd2_select(raw, d0, d1);
set_at<32, 576>(result, red_rd2_res);
hw_uint<16> red_rd3_res = red_rd3_select(raw, d0, d1);
set_at<48, 576>(result, red_rd3_res);
hw_uint<16> red_rd4_res = red_rd4_select(raw, d0, d1);
set_at<64, 576>(result, red_rd4_res);
hw_uint<16> red_rd5_res = red_rd5_select(raw, d0, d1);
set_at<80, 576>(result, red_rd5_res);
hw_uint<16> red_rd6_res = red_rd6_select(raw, d0, d1);
set_at<96, 576>(result, red_rd6_res);
hw_uint<16> red_rd7_res = red_rd7_select(raw, d0, d1);
set_at<112, 576>(result, red_rd7_res);
hw_uint<16> red_rd8_res = red_rd8_select(raw, d0, d1);
set_at<128, 576>(result, red_rd8_res);
hw_uint<16> red_rd9_res = red_rd9_select(raw, d0, d1);
set_at<144, 576>(result, red_rd9_res);
hw_uint<16> red_rd10_res = red_rd10_select(raw, d0, d1);
set_at<160, 576>(result, red_rd10_res);
hw_uint<16> red_rd11_res = red_rd11_select(raw, d0, d1);
set_at<176, 576>(result, red_rd11_res);
hw_uint<16> red_rd12_res = red_rd12_select(raw, d0, d1);
set_at<192, 576>(result, red_rd12_res);
hw_uint<16> red_rd13_res = red_rd13_select(raw, d0, d1);
set_at<208, 576>(result, red_rd13_res);
hw_uint<16> red_rd14_res = red_rd14_select(raw, d0, d1);
set_at<224, 576>(result, red_rd14_res);
hw_uint<16> red_rd15_res = red_rd15_select(raw, d0, d1);
set_at<240, 576>(result, red_rd15_res);
hw_uint<16> red_rd16_res = red_rd16_select(raw, d0, d1);
set_at<256, 576>(result, red_rd16_res);
hw_uint<16> red_rd17_res = red_rd17_select(raw, d0, d1);
set_at<272, 576>(result, red_rd17_res);
hw_uint<16> red_rd18_res = red_rd18_select(raw, d0, d1);
set_at<288, 576>(result, red_rd18_res);
hw_uint<16> red_rd19_res = red_rd19_select(raw, d0, d1);
set_at<304, 576>(result, red_rd19_res);
hw_uint<16> red_rd20_res = red_rd20_select(raw, d0, d1);
set_at<320, 576>(result, red_rd20_res);
hw_uint<16> red_rd21_res = red_rd21_select(raw, d0, d1);
set_at<336, 576>(result, red_rd21_res);
hw_uint<16> red_rd22_res = red_rd22_select(raw, d0, d1);
set_at<352, 576>(result, red_rd22_res);
hw_uint<16> red_rd23_res = red_rd23_select(raw, d0, d1);
set_at<368, 576>(result, red_rd23_res);
hw_uint<16> red_rd24_res = red_rd24_select(raw, d0, d1);
set_at<384, 576>(result, red_rd24_res);
hw_uint<16> red_rd25_res = red_rd25_select(raw, d0, d1);
set_at<400, 576>(result, red_rd25_res);
hw_uint<16> red_rd26_res = red_rd26_select(raw, d0, d1);
set_at<416, 576>(result, red_rd26_res);
hw_uint<16> red_rd27_res = red_rd27_select(raw, d0, d1);
set_at<432, 576>(result, red_rd27_res);
hw_uint<16> red_rd28_res = red_rd28_select(raw, d0, d1);
set_at<448, 576>(result, red_rd28_res);
hw_uint<16> red_rd29_res = red_rd29_select(raw, d0, d1);
set_at<464, 576>(result, red_rd29_res);
hw_uint<16> red_rd30_res = red_rd30_select(raw, d0, d1);
set_at<480, 576>(result, red_rd30_res);
hw_uint<16> red_rd31_res = red_rd31_select(raw, d0, d1);
set_at<496, 576>(result, red_rd31_res);
hw_uint<16> red_rd32_res = red_rd32_select(raw, d0, d1);
set_at<512, 576>(result, red_rd32_res);
hw_uint<16> red_rd33_res = red_rd33_select(raw, d0, d1);
set_at<528, 576>(result, red_rd33_res);
hw_uint<16> red_rd34_res = red_rd34_select(raw, d0, d1);
set_at<544, 576>(result, red_rd34_res);
hw_uint<16> red_rd35_res = red_rd35_select(raw, d0, d1);
set_at<560, 576>(result, red_rd35_res);
return result;
}
#include "hw_classes.h"
struct red_red_update_0_write0_merged_banks_4_cache {
// RAM Box: {[0, 1920], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct red_red_update_0_write1_merged_banks_4_cache {
// RAM Box: {[1, 1921], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct red_red_update_0_write2_merged_banks_4_cache {
// RAM Box: {[2, 1922], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct red_red_update_0_write3_merged_banks_4_cache {
// RAM Box: {[3, 1923], [0, 1081]}
// Capacity: 964
// # of read delays: 3
hw_uint<16> f0;
hw_uint<16> f2;
fifo<hw_uint<16>, 961> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_1() {
return f2;
}
inline hw_uint<16> peek_962() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_963() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 961
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 961 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 1
f2 = f0;
// cap: 1
f0 = value;
}
};
struct red_cache {
red_red_update_0_write0_merged_banks_4_cache red_red_update_0_write0_merged_banks_4;
red_red_update_0_write1_merged_banks_4_cache red_red_update_0_write1_merged_banks_4;
red_red_update_0_write2_merged_banks_4_cache red_red_update_0_write2_merged_banks_4;
red_red_update_0_write3_merged_banks_4_cache red_red_update_0_write3_merged_banks_4;
};
inline void red_red_update_0_write0_write(hw_uint<16>& red_red_update_0_write0, red_cache& red, int d0, int d1) {
red.red_red_update_0_write0_merged_banks_4.push(red_red_update_0_write0);
}
inline void red_red_update_0_write1_write(hw_uint<16>& red_red_update_0_write1, red_cache& red, int d0, int d1) {
red.red_red_update_0_write1_merged_banks_4.push(red_red_update_0_write1);
}
inline void red_red_update_0_write2_write(hw_uint<16>& red_red_update_0_write2, red_cache& red, int d0, int d1) {
red.red_red_update_0_write2_merged_banks_4.push(red_red_update_0_write2);
}
inline void red_red_update_0_write3_write(hw_uint<16>& red_red_update_0_write3, red_cache& red, int d0, int d1) {
red.red_red_update_0_write3_merged_banks_4.push(red_red_update_0_write3);
}
inline hw_uint<16> red_bx_rd0_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd0 read pattern: { red_bx_update_0[d0, d1] -> red[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write0 = red.red_red_update_0_write0_merged_banks_4.peek_1();
return value_red_red_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd1_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd1 read pattern: { red_bx_update_0[d0, d1] -> red[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write1 = red.red_red_update_0_write1_merged_banks_4.peek_1();
return value_red_red_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd10_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd10 read pattern: { red_bx_update_0[d0, d1] -> red[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_red_update_0_write0 = red.red_red_update_0_write0_merged_banks_4.peek_0();
return value_red_red_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd11_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd11 read pattern: { red_bx_update_0[d0, d1] -> red[5 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_red_update_0_write1 = red.red_red_update_0_write1_merged_banks_4.peek_0();
return value_red_red_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd2_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd2 read pattern: { red_bx_update_0[d0, d1] -> red[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write2 = red.red_red_update_0_write2_merged_banks_4.peek_1();
return value_red_red_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd3_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd3 read pattern: { red_bx_update_0[d0, d1] -> red[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write1 = red.red_red_update_0_write1_merged_banks_4.peek_1();
return value_red_red_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd4_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd4 read pattern: { red_bx_update_0[d0, d1] -> red[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write2 = red.red_red_update_0_write2_merged_banks_4.peek_1();
return value_red_red_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd5_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd5 read pattern: { red_bx_update_0[d0, d1] -> red[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write3 = red.red_red_update_0_write3_merged_banks_4.peek_1();
return value_red_red_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd6_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd6 read pattern: { red_bx_update_0[d0, d1] -> red[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write2 = red.red_red_update_0_write2_merged_banks_4.peek_1();
return value_red_red_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd7_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd7 read pattern: { red_bx_update_0[d0, d1] -> red[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write3 = red.red_red_update_0_write3_merged_banks_4.peek_1();
return value_red_red_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd8_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd8 read pattern: { red_bx_update_0[d0, d1] -> red[4 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_red_update_0_write0 = red.red_red_update_0_write0_merged_banks_4.peek_0();
return value_red_red_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_bx_rd9_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_bx_rd9 read pattern: { red_bx_update_0[d0, d1] -> red[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Read schedule : { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_bx_update_0[d0, d1] -> 1 : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
auto value_red_red_update_0_write3 = red.red_red_update_0_write3_merged_banks_4.peek_1();
return value_red_red_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd0_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd0 read pattern: { red_diff_update_0[d0, d1] -> red[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_red_red_update_0_write0 = red.red_red_update_0_write0_merged_banks_4.peek_963();
return value_red_red_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd1_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd1 read pattern: { red_diff_update_0[d0, d1] -> red[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_red_red_update_0_write1 = red.red_red_update_0_write1_merged_banks_4.peek_963();
return value_red_red_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd2_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd2 read pattern: { red_diff_update_0[d0, d1] -> red[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_red_red_update_0_write2 = red.red_red_update_0_write2_merged_banks_4.peek_963();
return value_red_red_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd3_select(red_cache& red, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd3 read pattern: { red_diff_update_0[d0, d1] -> red[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_update_0[d0, d1] -> [2 + d1, 1 + d0, 3] : 0 <= d0 <= 480 and 0 <= d1 <= 1081 }
// DD fold: { red_diff_update_0[d0, d1] -> 963 : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
auto value_red_red_update_0_write3 = red.red_red_update_0_write3_merged_banks_4.peek_963();
return value_red_red_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 3
// red_bx_update_0_read
// red_bx_rd0
// red_bx_rd1
// red_bx_rd2
// red_bx_rd3
// red_bx_rd4
// red_bx_rd5
// red_bx_rd6
// red_bx_rd7
// red_bx_rd8
// red_bx_rd9
// red_bx_rd10
// red_bx_rd11
inline hw_uint<192> red_red_bx_update_0_read_bundle_read(red_cache& red, int d0, int d1) {
// # of ports in bundle: 12
// red_bx_rd0
// red_bx_rd1
// red_bx_rd2
// red_bx_rd3
// red_bx_rd4
// red_bx_rd5
// red_bx_rd6
// red_bx_rd7
// red_bx_rd8
// red_bx_rd9
// red_bx_rd10
// red_bx_rd11
hw_uint<192> result;
hw_uint<16> red_bx_rd0_res = red_bx_rd0_select(red, d0, d1);
set_at<0, 192>(result, red_bx_rd0_res);
hw_uint<16> red_bx_rd1_res = red_bx_rd1_select(red, d0, d1);
set_at<16, 192>(result, red_bx_rd1_res);
hw_uint<16> red_bx_rd2_res = red_bx_rd2_select(red, d0, d1);
set_at<32, 192>(result, red_bx_rd2_res);
hw_uint<16> red_bx_rd3_res = red_bx_rd3_select(red, d0, d1);
set_at<48, 192>(result, red_bx_rd3_res);
hw_uint<16> red_bx_rd4_res = red_bx_rd4_select(red, d0, d1);
set_at<64, 192>(result, red_bx_rd4_res);
hw_uint<16> red_bx_rd5_res = red_bx_rd5_select(red, d0, d1);
set_at<80, 192>(result, red_bx_rd5_res);
hw_uint<16> red_bx_rd6_res = red_bx_rd6_select(red, d0, d1);
set_at<96, 192>(result, red_bx_rd6_res);
hw_uint<16> red_bx_rd7_res = red_bx_rd7_select(red, d0, d1);
set_at<112, 192>(result, red_bx_rd7_res);
hw_uint<16> red_bx_rd8_res = red_bx_rd8_select(red, d0, d1);
set_at<128, 192>(result, red_bx_rd8_res);
hw_uint<16> red_bx_rd9_res = red_bx_rd9_select(red, d0, d1);
set_at<144, 192>(result, red_bx_rd9_res);
hw_uint<16> red_bx_rd10_res = red_bx_rd10_select(red, d0, d1);
set_at<160, 192>(result, red_bx_rd10_res);
hw_uint<16> red_bx_rd11_res = red_bx_rd11_select(red, d0, d1);
set_at<176, 192>(result, red_bx_rd11_res);
return result;
}
// red_diff_update_0_read
// red_diff_rd0
// red_diff_rd1
// red_diff_rd2
// red_diff_rd3
inline hw_uint<64> red_red_diff_update_0_read_bundle_read(red_cache& red, int d0, int d1) {
// # of ports in bundle: 4
// red_diff_rd0
// red_diff_rd1
// red_diff_rd2
// red_diff_rd3
hw_uint<64> result;
hw_uint<16> red_diff_rd0_res = red_diff_rd0_select(red, d0, d1);
set_at<0, 64>(result, red_diff_rd0_res);
hw_uint<16> red_diff_rd1_res = red_diff_rd1_select(red, d0, d1);
set_at<16, 64>(result, red_diff_rd1_res);
hw_uint<16> red_diff_rd2_res = red_diff_rd2_select(red, d0, d1);
set_at<32, 64>(result, red_diff_rd2_res);
hw_uint<16> red_diff_rd3_res = red_diff_rd3_select(red, d0, d1);
set_at<48, 64>(result, red_diff_rd3_res);
return result;
}
// red_update_0_write
// red_red_update_0_write0
// red_red_update_0_write1
// red_red_update_0_write2
// red_red_update_0_write3
inline void red_red_update_0_write_bundle_write(hw_uint<64>& red_update_0_write, red_cache& red, int d0, int d1) {
hw_uint<16> red_red_update_0_write0_res = red_update_0_write.extract<0, 15>();
red_red_update_0_write0_write(red_red_update_0_write0_res, red, d0, d1);
hw_uint<16> red_red_update_0_write1_res = red_update_0_write.extract<16, 31>();
red_red_update_0_write1_write(red_red_update_0_write1_res, red, d0, d1);
hw_uint<16> red_red_update_0_write2_res = red_update_0_write.extract<32, 47>();
red_red_update_0_write2_write(red_red_update_0_write2_res, red, d0, d1);
hw_uint<16> red_red_update_0_write3_res = red_update_0_write.extract<48, 63>();
red_red_update_0_write3_write(red_red_update_0_write3_res, red, d0, d1);
}
#include "hw_classes.h"
struct red_bx_red_bx_update_0_write0_merged_banks_3_cache {
// RAM Box: {[0, 1916], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct red_bx_red_bx_update_0_write1_merged_banks_3_cache {
// RAM Box: {[1, 1917], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct red_bx_red_bx_update_0_write2_merged_banks_3_cache {
// RAM Box: {[2, 1918], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct red_bx_red_bx_update_0_write3_merged_banks_3_cache {
// RAM Box: {[3, 1919], [0, 1081]}
// Capacity: 961
// # of read delays: 3
hw_uint<16> f0;
fifo<hw_uint<16>, 479> f1;
hw_uint<16> f2;
fifo<hw_uint<16>, 479> f3;
hw_uint<16> f4;
inline hw_uint<16> peek_0() {
return f0;
}
inline hw_uint<16> peek_479() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f1.back();
}
inline hw_uint<16> peek_480() {
return f2;
}
inline hw_uint<16> peek_959() {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f3.back();
}
inline hw_uint<16> peek_960() {
return f4;
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f4 = f3.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f3.push(f2);
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 1 reading from capacity: 479
f2 = f1.back();
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cap: 479 reading from capacity: 1
f1.push(f0);
// cap: 1
f0 = value;
}
};
struct red_bx_cache {
red_bx_red_bx_update_0_write0_merged_banks_3_cache red_bx_red_bx_update_0_write0_merged_banks_3;
red_bx_red_bx_update_0_write1_merged_banks_3_cache red_bx_red_bx_update_0_write1_merged_banks_3;
red_bx_red_bx_update_0_write2_merged_banks_3_cache red_bx_red_bx_update_0_write2_merged_banks_3;
red_bx_red_bx_update_0_write3_merged_banks_3_cache red_bx_red_bx_update_0_write3_merged_banks_3;
};
inline void red_bx_red_bx_update_0_write0_write(hw_uint<16>& red_bx_red_bx_update_0_write0, red_bx_cache& red_bx, int d0, int d1) {
red_bx.red_bx_red_bx_update_0_write0_merged_banks_3.push(red_bx_red_bx_update_0_write0);
}
inline void red_bx_red_bx_update_0_write1_write(hw_uint<16>& red_bx_red_bx_update_0_write1, red_bx_cache& red_bx, int d0, int d1) {
red_bx.red_bx_red_bx_update_0_write1_merged_banks_3.push(red_bx_red_bx_update_0_write1);
}
inline void red_bx_red_bx_update_0_write2_write(hw_uint<16>& red_bx_red_bx_update_0_write2, red_bx_cache& red_bx, int d0, int d1) {
red_bx.red_bx_red_bx_update_0_write2_merged_banks_3.push(red_bx_red_bx_update_0_write2);
}
inline void red_bx_red_bx_update_0_write3_write(hw_uint<16>& red_bx_red_bx_update_0_write3, red_bx_cache& red_bx, int d0, int d1) {
red_bx.red_bx_red_bx_update_0_write3_merged_banks_3.push(red_bx_red_bx_update_0_write3);
}
inline hw_uint<16> red_by_rd0_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd0 read pattern: { red_by_update_0[d0, d1] -> red_bx[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write0 = red_bx.red_bx_red_bx_update_0_write0_merged_banks_3.peek_960();
return value_red_bx_red_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd1_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd1 read pattern: { red_by_update_0[d0, d1] -> red_bx[4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write0 = red_bx.red_bx_red_bx_update_0_write0_merged_banks_3.peek_480();
return value_red_bx_red_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd10_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd10 read pattern: { red_by_update_0[d0, d1] -> red_bx[3 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write3 = red_bx.red_bx_red_bx_update_0_write3_merged_banks_3.peek_480();
return value_red_bx_red_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd11_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd11 read pattern: { red_by_update_0[d0, d1] -> red_bx[3 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_bx_red_bx_update_0_write3 = red_bx.red_bx_red_bx_update_0_write3_merged_banks_3.peek_0();
return value_red_bx_red_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd2_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd2 read pattern: { red_by_update_0[d0, d1] -> red_bx[4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_bx_red_bx_update_0_write0 = red_bx.red_bx_red_bx_update_0_write0_merged_banks_3.peek_0();
return value_red_bx_red_bx_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd3_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd3 read pattern: { red_by_update_0[d0, d1] -> red_bx[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write1 = red_bx.red_bx_red_bx_update_0_write1_merged_banks_3.peek_960();
return value_red_bx_red_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd4_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd4 read pattern: { red_by_update_0[d0, d1] -> red_bx[1 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write1 = red_bx.red_bx_red_bx_update_0_write1_merged_banks_3.peek_480();
return value_red_bx_red_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd5_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd5 read pattern: { red_by_update_0[d0, d1] -> red_bx[1 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_bx_red_bx_update_0_write1 = red_bx.red_bx_red_bx_update_0_write1_merged_banks_3.peek_0();
return value_red_bx_red_bx_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd6_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd6 read pattern: { red_by_update_0[d0, d1] -> red_bx[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write2 = red_bx.red_bx_red_bx_update_0_write2_merged_banks_3.peek_960();
return value_red_bx_red_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd7_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd7 read pattern: { red_by_update_0[d0, d1] -> red_bx[2 + 4d0, 1 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 480 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (1 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 480 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write2 = red_bx.red_bx_red_bx_update_0_write2_merged_banks_3.peek_480();
return value_red_bx_red_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd8_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd8 read pattern: { red_by_update_0[d0, d1] -> red_bx[2 + 4d0, 2 + d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { }
auto value_red_bx_red_bx_update_0_write2 = red_bx.red_bx_red_bx_update_0_write2_merged_banks_3.peek_0();
return value_red_bx_red_bx_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_by_rd9_select(red_bx_cache& red_bx, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_by_rd9 read pattern: { red_by_update_0[d0, d1] -> red_bx[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_bx_update_0[d0, d1] -> [2 + d1, 2 + d0, 6] : 0 <= d0 <= 479 and 0 <= d1 <= 1081 }
// DD fold: { red_by_update_0[d0, d1] -> 960 : 0 < d0 <= 478 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> (481 + d0) : d0 = 479 and 0 <= d1 <= 1079; red_by_update_0[d0, d1] -> 960 : d0 = 0 and 0 <= d1 <= 1079 }
auto value_red_bx_red_bx_update_0_write3 = red_bx.red_bx_red_bx_update_0_write3_merged_banks_3.peek_960();
return value_red_bx_red_bx_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// red_bx_update_0_write
// red_bx_red_bx_update_0_write0
// red_bx_red_bx_update_0_write1
// red_bx_red_bx_update_0_write2
// red_bx_red_bx_update_0_write3
inline void red_bx_red_bx_update_0_write_bundle_write(hw_uint<64>& red_bx_update_0_write, red_bx_cache& red_bx, int d0, int d1) {
hw_uint<16> red_bx_red_bx_update_0_write0_res = red_bx_update_0_write.extract<0, 15>();
red_bx_red_bx_update_0_write0_write(red_bx_red_bx_update_0_write0_res, red_bx, d0, d1);
hw_uint<16> red_bx_red_bx_update_0_write1_res = red_bx_update_0_write.extract<16, 31>();
red_bx_red_bx_update_0_write1_write(red_bx_red_bx_update_0_write1_res, red_bx, d0, d1);
hw_uint<16> red_bx_red_bx_update_0_write2_res = red_bx_update_0_write.extract<32, 47>();
red_bx_red_bx_update_0_write2_write(red_bx_red_bx_update_0_write2_res, red_bx, d0, d1);
hw_uint<16> red_bx_red_bx_update_0_write3_res = red_bx_update_0_write.extract<48, 63>();
red_bx_red_bx_update_0_write3_write(red_bx_red_bx_update_0_write3_res, red_bx, d0, d1);
}
// red_by_update_0_read
// red_by_rd0
// red_by_rd1
// red_by_rd2
// red_by_rd3
// red_by_rd4
// red_by_rd5
// red_by_rd6
// red_by_rd7
// red_by_rd8
// red_by_rd9
// red_by_rd10
// red_by_rd11
inline hw_uint<192> red_bx_red_by_update_0_read_bundle_read(red_bx_cache& red_bx, int d0, int d1) {
// # of ports in bundle: 12
// red_by_rd0
// red_by_rd1
// red_by_rd2
// red_by_rd3
// red_by_rd4
// red_by_rd5
// red_by_rd6
// red_by_rd7
// red_by_rd8
// red_by_rd9
// red_by_rd10
// red_by_rd11
hw_uint<192> result;
hw_uint<16> red_by_rd0_res = red_by_rd0_select(red_bx, d0, d1);
set_at<0, 192>(result, red_by_rd0_res);
hw_uint<16> red_by_rd1_res = red_by_rd1_select(red_bx, d0, d1);
set_at<16, 192>(result, red_by_rd1_res);
hw_uint<16> red_by_rd2_res = red_by_rd2_select(red_bx, d0, d1);
set_at<32, 192>(result, red_by_rd2_res);
hw_uint<16> red_by_rd3_res = red_by_rd3_select(red_bx, d0, d1);
set_at<48, 192>(result, red_by_rd3_res);
hw_uint<16> red_by_rd4_res = red_by_rd4_select(red_bx, d0, d1);
set_at<64, 192>(result, red_by_rd4_res);
hw_uint<16> red_by_rd5_res = red_by_rd5_select(red_bx, d0, d1);
set_at<80, 192>(result, red_by_rd5_res);
hw_uint<16> red_by_rd6_res = red_by_rd6_select(red_bx, d0, d1);
set_at<96, 192>(result, red_by_rd6_res);
hw_uint<16> red_by_rd7_res = red_by_rd7_select(red_bx, d0, d1);
set_at<112, 192>(result, red_by_rd7_res);
hw_uint<16> red_by_rd8_res = red_by_rd8_select(red_bx, d0, d1);
set_at<128, 192>(result, red_by_rd8_res);
hw_uint<16> red_by_rd9_res = red_by_rd9_select(red_bx, d0, d1);
set_at<144, 192>(result, red_by_rd9_res);
hw_uint<16> red_by_rd10_res = red_by_rd10_select(red_bx, d0, d1);
set_at<160, 192>(result, red_by_rd10_res);
hw_uint<16> red_by_rd11_res = red_by_rd11_select(red_bx, d0, d1);
set_at<176, 192>(result, red_by_rd11_res);
return result;
}
#include "hw_classes.h"
struct red_by_red_by_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_by_red_by_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_by_red_by_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_by_red_by_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_by_cache {
red_by_red_by_update_0_write0_merged_banks_1_cache red_by_red_by_update_0_write0_merged_banks_1;
red_by_red_by_update_0_write1_merged_banks_1_cache red_by_red_by_update_0_write1_merged_banks_1;
red_by_red_by_update_0_write2_merged_banks_1_cache red_by_red_by_update_0_write2_merged_banks_1;
red_by_red_by_update_0_write3_merged_banks_1_cache red_by_red_by_update_0_write3_merged_banks_1;
};
inline void red_by_red_by_update_0_write0_write(hw_uint<16>& red_by_red_by_update_0_write0, red_by_cache& red_by, int d0, int d1) {
red_by.red_by_red_by_update_0_write0_merged_banks_1.push(red_by_red_by_update_0_write0);
}
inline void red_by_red_by_update_0_write1_write(hw_uint<16>& red_by_red_by_update_0_write1, red_by_cache& red_by, int d0, int d1) {
red_by.red_by_red_by_update_0_write1_merged_banks_1.push(red_by_red_by_update_0_write1);
}
inline void red_by_red_by_update_0_write2_write(hw_uint<16>& red_by_red_by_update_0_write2, red_by_cache& red_by, int d0, int d1) {
red_by.red_by_red_by_update_0_write2_merged_banks_1.push(red_by_red_by_update_0_write2);
}
inline void red_by_red_by_update_0_write3_write(hw_uint<16>& red_by_red_by_update_0_write3, red_by_cache& red_by, int d0, int d1) {
red_by.red_by_red_by_update_0_write3_merged_banks_1.push(red_by_red_by_update_0_write3);
}
inline hw_uint<16> red_diff_rd0_select(red_by_cache& red_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd0 read pattern: { red_diff_update_0[d0, d1] -> red_by[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_by_red_by_update_0_write0 = red_by.red_by_red_by_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_by_red_by_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd1_select(red_by_cache& red_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd1 read pattern: { red_diff_update_0[d0, d1] -> red_by[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_by_red_by_update_0_write1 = red_by.red_by_red_by_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_by_red_by_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd2_select(red_by_cache& red_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd2 read pattern: { red_diff_update_0[d0, d1] -> red_by[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_by_red_by_update_0_write2 = red_by.red_by_red_by_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_by_red_by_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> red_diff_rd3_select(red_by_cache& red_by, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// red_diff_rd3 read pattern: { red_diff_update_0[d0, d1] -> red_by[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_by_update_0[d0, d1] -> [4 + d1, 2 + d0, 9] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_by_red_by_update_0_write3 = red_by.red_by_red_by_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_by_red_by_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// red_by_update_0_write
// red_by_red_by_update_0_write0
// red_by_red_by_update_0_write1
// red_by_red_by_update_0_write2
// red_by_red_by_update_0_write3
inline void red_by_red_by_update_0_write_bundle_write(hw_uint<64>& red_by_update_0_write, red_by_cache& red_by, int d0, int d1) {
hw_uint<16> red_by_red_by_update_0_write0_res = red_by_update_0_write.extract<0, 15>();
red_by_red_by_update_0_write0_write(red_by_red_by_update_0_write0_res, red_by, d0, d1);
hw_uint<16> red_by_red_by_update_0_write1_res = red_by_update_0_write.extract<16, 31>();
red_by_red_by_update_0_write1_write(red_by_red_by_update_0_write1_res, red_by, d0, d1);
hw_uint<16> red_by_red_by_update_0_write2_res = red_by_update_0_write.extract<32, 47>();
red_by_red_by_update_0_write2_write(red_by_red_by_update_0_write2_res, red_by, d0, d1);
hw_uint<16> red_by_red_by_update_0_write3_res = red_by_update_0_write.extract<48, 63>();
red_by_red_by_update_0_write3_write(red_by_red_by_update_0_write3_res, red_by, d0, d1);
}
// red_diff_update_0_read
// red_diff_rd0
// red_diff_rd1
// red_diff_rd2
// red_diff_rd3
inline hw_uint<64> red_by_red_diff_update_0_read_bundle_read(red_by_cache& red_by, int d0, int d1) {
// # of ports in bundle: 4
// red_diff_rd0
// red_diff_rd1
// red_diff_rd2
// red_diff_rd3
hw_uint<64> result;
hw_uint<16> red_diff_rd0_res = red_diff_rd0_select(red_by, d0, d1);
set_at<0, 64>(result, red_diff_rd0_res);
hw_uint<16> red_diff_rd1_res = red_diff_rd1_select(red_by, d0, d1);
set_at<16, 64>(result, red_diff_rd1_res);
hw_uint<16> red_diff_rd2_res = red_diff_rd2_select(red_by, d0, d1);
set_at<32, 64>(result, red_diff_rd2_res);
hw_uint<16> red_diff_rd3_res = red_diff_rd3_select(red_by, d0, d1);
set_at<48, 64>(result, red_diff_rd3_res);
return result;
}
#include "hw_classes.h"
struct red_diff_red_diff_update_0_write0_merged_banks_1_cache {
// RAM Box: {[0, 1916], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_diff_red_diff_update_0_write1_merged_banks_1_cache {
// RAM Box: {[1, 1917], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_diff_red_diff_update_0_write2_merged_banks_1_cache {
// RAM Box: {[2, 1918], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_diff_red_diff_update_0_write3_merged_banks_1_cache {
// RAM Box: {[3, 1919], [0, 1079]}
// Capacity: 1
// # of read delays: 1
fifo<hw_uint<16>, 1> f;
inline hw_uint<16> peek(const int offset) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.peek(0 - offset);
}
inline void push(const hw_uint<16> value) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
return f.push(value);
}
};
struct red_diff_cache {
red_diff_red_diff_update_0_write0_merged_banks_1_cache red_diff_red_diff_update_0_write0_merged_banks_1;
red_diff_red_diff_update_0_write1_merged_banks_1_cache red_diff_red_diff_update_0_write1_merged_banks_1;
red_diff_red_diff_update_0_write2_merged_banks_1_cache red_diff_red_diff_update_0_write2_merged_banks_1;
red_diff_red_diff_update_0_write3_merged_banks_1_cache red_diff_red_diff_update_0_write3_merged_banks_1;
};
inline void red_diff_red_diff_update_0_write0_write(hw_uint<16>& red_diff_red_diff_update_0_write0, red_diff_cache& red_diff, int d0, int d1) {
red_diff.red_diff_red_diff_update_0_write0_merged_banks_1.push(red_diff_red_diff_update_0_write0);
}
inline void red_diff_red_diff_update_0_write1_write(hw_uint<16>& red_diff_red_diff_update_0_write1, red_diff_cache& red_diff, int d0, int d1) {
red_diff.red_diff_red_diff_update_0_write1_merged_banks_1.push(red_diff_red_diff_update_0_write1);
}
inline void red_diff_red_diff_update_0_write2_write(hw_uint<16>& red_diff_red_diff_update_0_write2, red_diff_cache& red_diff, int d0, int d1) {
red_diff.red_diff_red_diff_update_0_write2_merged_banks_1.push(red_diff_red_diff_update_0_write2);
}
inline void red_diff_red_diff_update_0_write3_write(hw_uint<16>& red_diff_red_diff_update_0_write3, red_diff_cache& red_diff, int d0, int d1) {
red_diff.red_diff_red_diff_update_0_write3_merged_banks_1.push(red_diff_red_diff_update_0_write3);
}
inline hw_uint<16> cp_4_rd0_select(red_diff_cache& red_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd0 read pattern: { cp_4_update_0[d0, d1] -> red_diff[4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_diff_red_diff_update_0_write0 = red_diff.red_diff_red_diff_update_0_write0_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_diff_red_diff_update_0_write0;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd1_select(red_diff_cache& red_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd1 read pattern: { cp_4_update_0[d0, d1] -> red_diff[1 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_diff_red_diff_update_0_write1 = red_diff.red_diff_red_diff_update_0_write1_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_diff_red_diff_update_0_write1;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd2_select(red_diff_cache& red_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd2 read pattern: { cp_4_update_0[d0, d1] -> red_diff[2 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_diff_red_diff_update_0_write2 = red_diff.red_diff_red_diff_update_0_write2_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_diff_red_diff_update_0_write2;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
inline hw_uint<16> cp_4_rd3_select(red_diff_cache& red_diff, int d0, int d1) {
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
// cp_4_rd3 read pattern: { cp_4_update_0[d0, d1] -> red_diff[3 + 4d0, d1] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Read schedule : { cp_4_update_0[d0, d1] -> [4 + d1, 2 + d0, 14] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// Write schedule: { red_diff_update_0[d0, d1] -> [4 + d1, 2 + d0, 12] : 0 <= d0 <= 479 and 0 <= d1 <= 1079 }
// DD fold: { }
auto value_red_diff_red_diff_update_0_write3 = red_diff.red_diff_red_diff_update_0_write3_merged_banks_1.peek(/* one reader or all rams */ 0);
return value_red_diff_red_diff_update_0_write3;
#ifndef __VIVADO_SYNTH__
cout << "Error: Unsupported offsets: " << " d0 = " << d0 << " d1 = " << d1 << endl;
assert(false);
return 0;
#endif //__VIVADO_SYNTH__
}
// # of bundles = 2
// cp_4_update_0_read
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
inline hw_uint<64> red_diff_cp_4_update_0_read_bundle_read(red_diff_cache& red_diff, int d0, int d1) {
// # of ports in bundle: 4
// cp_4_rd0
// cp_4_rd1
// cp_4_rd2
// cp_4_rd3
hw_uint<64> result;
hw_uint<16> cp_4_rd0_res = cp_4_rd0_select(red_diff, d0, d1);
set_at<0, 64>(result, cp_4_rd0_res);
hw_uint<16> cp_4_rd1_res = cp_4_rd1_select(red_diff, d0, d1);
set_at<16, 64>(result, cp_4_rd1_res);
hw_uint<16> cp_4_rd2_res = cp_4_rd2_select(red_diff, d0, d1);
set_at<32, 64>(result, cp_4_rd2_res);
hw_uint<16> cp_4_rd3_res = cp_4_rd3_select(red_diff, d0, d1);
set_at<48, 64>(result, cp_4_rd3_res);
return result;
}
// red_diff_update_0_write
// red_diff_red_diff_update_0_write0
// red_diff_red_diff_update_0_write1
// red_diff_red_diff_update_0_write2
// red_diff_red_diff_update_0_write3
inline void red_diff_red_diff_update_0_write_bundle_write(hw_uint<64>& red_diff_update_0_write, red_diff_cache& red_diff, int d0, int d1) {
hw_uint<16> red_diff_red_diff_update_0_write0_res = red_diff_update_0_write.extract<0, 15>();
red_diff_red_diff_update_0_write0_write(red_diff_red_diff_update_0_write0_res, red_diff, d0, d1);
hw_uint<16> red_diff_red_diff_update_0_write1_res = red_diff_update_0_write.extract<16, 31>();
red_diff_red_diff_update_0_write1_write(red_diff_red_diff_update_0_write1_res, red_diff, d0, d1);
hw_uint<16> red_diff_red_diff_update_0_write2_res = red_diff_update_0_write.extract<32, 47>();
red_diff_red_diff_update_0_write2_write(red_diff_red_diff_update_0_write2_res, red_diff, d0, d1);
hw_uint<16> red_diff_red_diff_update_0_write3_res = red_diff_update_0_write.extract<48, 63>();
red_diff_red_diff_update_0_write3_write(red_diff_red_diff_update_0_write3_res, red_diff, d0, d1);
}
// Operation logic
inline void green_by_update_0(green_bx_cache& green_bx, green_by_cache& green_by, int d0, int d1) {
// Consume: green_bx
auto green_bx_0_c__0_value = green_bx_green_by_update_0_read_bundle_read(green_bx/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "green_by_update_0_green_bx," << d0<< "," << d1<< "," << green_bx_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = green_by_generated_compute_unrolled_4(green_bx_0_c__0_value);
// Produce: green_by
green_by_green_by_update_0_write_bundle_write(compute_result, green_by, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "green_by_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "green_by_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "green_by_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "green_by_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void blue_diff_update_0(blue_cache& blue, blue_by_cache& blue_by, blue_diff_cache& blue_diff, int d0, int d1) {
// Consume: blue
auto blue_0_c__0_value = blue_blue_diff_update_0_read_bundle_read(blue/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "blue_diff_update_0_blue," << d0<< "," << d1<< "," << blue_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
// Consume: blue_by
auto blue_by_0_c__0_value = blue_by_blue_diff_update_0_read_bundle_read(blue_by/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "blue_diff_update_0_blue_by," << d0<< "," << d1<< "," << blue_by_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = blue_diff_generated_compute_unrolled_4(blue_0_c__0_value, blue_by_0_c__0_value);
// Produce: blue_diff
blue_diff_blue_diff_update_0_write_bundle_write(compute_result, blue_diff, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "blue_diff_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "blue_diff_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "blue_diff_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "blue_diff_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void red_diff_update_0(red_cache& red, red_by_cache& red_by, red_diff_cache& red_diff, int d0, int d1) {
// Consume: red
auto red_0_c__0_value = red_red_diff_update_0_read_bundle_read(red/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "red_diff_update_0_red," << d0<< "," << d1<< "," << red_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
// Consume: red_by
auto red_by_0_c__0_value = red_by_red_diff_update_0_read_bundle_read(red_by/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "red_diff_update_0_red_by," << d0<< "," << d1<< "," << red_by_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = red_diff_generated_compute_unrolled_4(red_0_c__0_value, red_by_0_c__0_value);
// Produce: red_diff
red_diff_red_diff_update_0_write_bundle_write(compute_result, red_diff, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "red_diff_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "red_diff_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "red_diff_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "red_diff_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void raw_update_0(HWStream<hw_uint<64> >& /* buffer_args num ports = 4 */raw_oc, raw_cache& raw, int d0, int d1) {
// Consume: raw_oc
auto raw_oc_0_c__0_value = raw_oc.read();
auto compute_result = raw_generated_compute_unrolled_4(raw_oc_0_c__0_value);
// Produce: raw
raw_raw_update_0_write_bundle_write(compute_result, raw, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "raw_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "raw_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "raw_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "raw_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void red_by_update_0(red_bx_cache& red_bx, red_by_cache& red_by, int d0, int d1) {
// Consume: red_bx
auto red_bx_0_c__0_value = red_bx_red_by_update_0_read_bundle_read(red_bx/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "red_by_update_0_red_bx," << d0<< "," << d1<< "," << red_bx_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = red_by_generated_compute_unrolled_4(red_bx_0_c__0_value);
// Produce: red_by
red_by_red_by_update_0_write_bundle_write(compute_result, red_by, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "red_by_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "red_by_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "red_by_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "red_by_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void blue_update_0(raw_cache& raw, blue_cache& blue, int d0, int d1) {
// Consume: raw
auto raw_0_c__0_value = raw_blue_update_0_read_bundle_read(raw/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "blue_update_0_raw," << d0<< "," << d1<< "," << raw_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = blue_generated_compute_unrolled_4(raw_0_c__0_value);
// Produce: blue
blue_blue_update_0_write_bundle_write(compute_result, blue, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "blue_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "blue_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "blue_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "blue_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void red_update_0(raw_cache& raw, red_cache& red, int d0, int d1) {
// Consume: raw
auto raw_0_c__0_value = raw_red_update_0_read_bundle_read(raw/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "red_update_0_raw," << d0<< "," << d1<< "," << raw_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = red_generated_compute_unrolled_4(raw_0_c__0_value);
// Produce: red
red_red_update_0_write_bundle_write(compute_result, red, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "red_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "red_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "red_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "red_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void green_update_0(raw_cache& raw, green_cache& green, int d0, int d1) {
// Consume: raw
auto raw_0_c__0_value = raw_green_update_0_read_bundle_read(raw/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "green_update_0_raw," << d0<< "," << d1<< "," << raw_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = green_generated_compute_unrolled_4(raw_0_c__0_value);
// Produce: green
green_green_update_0_write_bundle_write(compute_result, green, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "green_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "green_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "green_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "green_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void blue_bx_update_0(blue_cache& blue, blue_bx_cache& blue_bx, int d0, int d1) {
// Consume: blue
auto blue_0_c__0_value = blue_blue_bx_update_0_read_bundle_read(blue/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "blue_bx_update_0_blue," << d0<< "," << d1<< "," << blue_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = blue_bx_generated_compute_unrolled_4(blue_0_c__0_value);
// Produce: blue_bx
blue_bx_blue_bx_update_0_write_bundle_write(compute_result, blue_bx, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "blue_bx_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "blue_bx_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "blue_bx_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "blue_bx_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void red_bx_update_0(red_cache& red, red_bx_cache& red_bx, int d0, int d1) {
// Consume: red
auto red_0_c__0_value = red_red_bx_update_0_read_bundle_read(red/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "red_bx_update_0_red," << d0<< "," << d1<< "," << red_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = red_bx_generated_compute_unrolled_4(red_0_c__0_value);
// Produce: red_bx
red_bx_red_bx_update_0_write_bundle_write(compute_result, red_bx, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "red_bx_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "red_bx_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "red_bx_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "red_bx_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void green_bx_update_0(green_cache& green, green_bx_cache& green_bx, int d0, int d1) {
// Consume: green
auto green_0_c__0_value = green_green_bx_update_0_read_bundle_read(green/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "green_bx_update_0_green," << d0<< "," << d1<< "," << green_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = green_bx_generated_compute_unrolled_4(green_0_c__0_value);
// Produce: green_bx
green_bx_green_bx_update_0_write_bundle_write(compute_result, green_bx, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "green_bx_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "green_bx_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "green_bx_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "green_bx_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void blue_by_update_0(blue_bx_cache& blue_bx, blue_by_cache& blue_by, int d0, int d1) {
// Consume: blue_bx
auto blue_bx_0_c__0_value = blue_bx_blue_by_update_0_read_bundle_read(blue_bx/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "blue_by_update_0_blue_bx," << d0<< "," << d1<< "," << blue_bx_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = blue_by_generated_compute_unrolled_4(blue_bx_0_c__0_value);
// Produce: blue_by
blue_by_blue_by_update_0_write_bundle_write(compute_result, blue_by, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "blue_by_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "blue_by_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "blue_by_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "blue_by_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void green_diff_update_0(green_cache& green, green_by_cache& green_by, green_diff_cache& green_diff, int d0, int d1) {
// Consume: green
auto green_0_c__0_value = green_green_diff_update_0_read_bundle_read(green/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "green_diff_update_0_green," << d0<< "," << d1<< "," << green_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
// Consume: green_by
auto green_by_0_c__0_value = green_by_green_diff_update_0_read_bundle_read(green_by/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "green_diff_update_0_green_by," << d0<< "," << d1<< "," << green_by_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = green_diff_generated_compute_unrolled_4(green_0_c__0_value, green_by_0_c__0_value);
// Produce: green_diff
green_diff_green_diff_update_0_write_bundle_write(compute_result, green_diff, d0, d1);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "green_diff_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "green_diff_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "green_diff_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "green_diff_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
inline void cp_4_update_0(blue_diff_cache& blue_diff, green_diff_cache& green_diff, red_diff_cache& red_diff, HWStream<hw_uint<64> >& /* buffer_args num ports = 4 */cp_4, int d0, int d1) {
// Consume: blue_diff
auto blue_diff_0_c__0_value = blue_diff_cp_4_update_0_read_bundle_read(blue_diff/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "cp_4_update_0_blue_diff," << d0<< "," << d1<< "," << blue_diff_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
// Consume: green_diff
auto green_diff_0_c__0_value = green_diff_cp_4_update_0_read_bundle_read(green_diff/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "cp_4_update_0_green_diff," << d0<< "," << d1<< "," << green_diff_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
// Consume: red_diff
auto red_diff_0_c__0_value = red_diff_cp_4_update_0_read_bundle_read(red_diff/* source_delay */, d0, d1);
#ifndef __VIVADO_SYNTH__
*global_debug_handle << "cp_4_update_0_red_diff," << d0<< "," << d1<< "," << red_diff_0_c__0_value << endl;
#endif //__VIVADO_SYNTH__
auto compute_result = cp_4_generated_compute_unrolled_4(blue_diff_0_c__0_value, green_diff_0_c__0_value, red_diff_0_c__0_value);
// Produce: cp_4
cp_4.write(compute_result);
#ifndef __VIVADO_SYNTH__
hw_uint<64> debug_compute_result(compute_result);
hw_uint<16> debug_compute_result_lane_0;
set_at<0, 16, 16>(debug_compute_result_lane_0, debug_compute_result.extract<0, 15>());
hw_uint<16> debug_compute_result_lane_1;
set_at<0, 16, 16>(debug_compute_result_lane_1, debug_compute_result.extract<16, 31>());
hw_uint<16> debug_compute_result_lane_2;
set_at<0, 16, 16>(debug_compute_result_lane_2, debug_compute_result.extract<32, 47>());
hw_uint<16> debug_compute_result_lane_3;
set_at<0, 16, 16>(debug_compute_result_lane_3, debug_compute_result.extract<48, 63>());
*global_debug_handle << "cp_4_update_0," << (4*d0 + 0) << "," << d1<< "," << debug_compute_result_lane_0 << endl;
*global_debug_handle << "cp_4_update_0," << (4*d0 + 1) << "," << d1<< "," << debug_compute_result_lane_1 << endl;
*global_debug_handle << "cp_4_update_0," << (4*d0 + 2) << "," << d1<< "," << debug_compute_result_lane_2 << endl;
*global_debug_handle << "cp_4_update_0," << (4*d0 + 3) << "," << d1<< "," << debug_compute_result_lane_3 << endl;
#endif //__VIVADO_SYNTH__
}
// Driver function
void cp_4_opt(HWStream<hw_uint<64> >& /* get_args num ports = 4 */raw_oc, HWStream<hw_uint<64> >& /* get_args num ports = 4 */cp_4, int num_epochs) {
#ifndef __VIVADO_SYNTH__
ofstream debug_file("cp_4_opt_debug.csv");
global_debug_handle = &debug_file;
#endif //__VIVADO_SYNTH__
blue_cache blue;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
blue_bx_cache blue_bx;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
blue_by_cache blue_by;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
blue_diff_cache blue_diff;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
green_cache green;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
green_bx_cache green_bx;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
green_by_cache green_by;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
green_diff_cache green_diff;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
raw_cache raw;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
red_cache red;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
red_bx_cache red_bx;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
red_by_cache red_by;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
red_diff_cache red_diff;
#ifdef __VIVADO_SYNTH__
#endif //__VIVADO_SYNTH__
#ifdef __VIVADO_SYNTH__
#pragma HLS inline recursive
#endif // __VIVADO_SYNTH__
for (int epoch = 0; epoch < num_epochs; epoch++) {
// Schedules...
// blue_bx_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*2,1*5]
// blue_by_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*8]
// blue_diff_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*11]
// blue_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*1,1*2]
// cp_4_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*14]
// green_bx_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*2,1*7]
// green_by_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*10]
// green_diff_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*13]
// green_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*1,1*4]
// raw_oc_update_0 -> [1*d1*1*1 + 1*0,1*d0*1*1 + 1*0,1*0]
// raw_update_0 -> [1*d1*1*1 + 1*0,1*d0*1*1 + 1*0,1*1]
// red_bx_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*2,1*6]
// red_by_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*9]
// red_diff_update_0 -> [1*d1*1*1 + 1*4,1*d0*1*1 + 1*2,1*12]
// red_update_0 -> [1*d1*1*1 + 1*2,1*d0*1*1 + 1*1,1*3]
for (int c0 = 0; c0 <= 1083; c0++) {
for (int c1 = 0; c1 <= 481; c1++) {
#ifdef __VIVADO_SYNTH__
#pragma HLS pipeline II=1
#endif // __VIVADO_SYNTH__
if ((0 <= c1 && c1 <= 481) && ((c1 - 0) % 1 == 0) && (0 <= c0 && c0 <= 1083) && ((c0 - 0) % 1 == 0)) {
raw_update_0(raw_oc, raw, (c1 - 0) / 1, (c0 - 0) / 1);
}
if ((1 <= c1 && c1 <= 481) && ((c1 - 1) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
blue_update_0(raw, blue, (c1 - 1) / 1, (c0 - 2) / 1);
}
if ((1 <= c1 && c1 <= 481) && ((c1 - 1) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
red_update_0(raw, red, (c1 - 1) / 1, (c0 - 2) / 1);
}
if ((1 <= c1 && c1 <= 481) && ((c1 - 1) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
green_update_0(raw, green, (c1 - 1) / 1, (c0 - 2) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
blue_bx_update_0(blue, blue_bx, (c1 - 2) / 1, (c0 - 2) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
red_bx_update_0(red, red_bx, (c1 - 2) / 1, (c0 - 2) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (2 <= c0 && c0 <= 1083) && ((c0 - 2) % 1 == 0)) {
green_bx_update_0(green, green_bx, (c1 - 2) / 1, (c0 - 2) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
blue_by_update_0(blue_bx, blue_by, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
red_by_update_0(red_bx, red_by, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
green_by_update_0(green_bx, green_by, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
blue_diff_update_0(blue, blue_by, blue_diff, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
red_diff_update_0(red, red_by, red_diff, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
green_diff_update_0(green, green_by, green_diff, (c1 - 2) / 1, (c0 - 4) / 1);
}
if ((2 <= c1 && c1 <= 481) && ((c1 - 2) % 1 == 0) && (4 <= c0 && c0 <= 1083) && ((c0 - 4) % 1 == 0)) {
cp_4_update_0(blue_diff, green_diff, red_diff, cp_4, (c1 - 2) / 1, (c0 - 4) / 1);
}
}
}
}
#ifndef __VIVADO_SYNTH__
debug_file.close();
#endif //__VIVADO_SYNTH__
}
void cp_4_opt(HWStream<hw_uint<64> >& /* get_args num ports = 4 */raw_oc, HWStream<hw_uint<64> >& /* get_args num ports = 4 */cp_4) {
cp_4_opt(raw_oc, cp_4, 1);
}
#ifdef __VIVADO_SYNTH__
#include "cp_4_opt.h"
const int cp_4_update_0_write_num_transfers = 518400;
const int raw_update_0_read_num_transfers = 522488;
extern "C" {
static void read_raw_update_0_read(hw_uint<64>* input, HWStream<hw_uint<64> >& v, const int size) {
hw_uint<64> burst_reg;
int num_transfers = raw_update_0_read_num_transfers*size;
for (int i = 0; i < num_transfers; i++) {
#pragma HLS pipeline II=1
burst_reg = input[i];
v.write(burst_reg);
}
}
static void write_cp_4_update_0_write(hw_uint<64>* output, HWStream<hw_uint<64> >& v, const int size) {
hw_uint<64> burst_reg;
int num_transfers = cp_4_update_0_write_num_transfers*size;
for (int i = 0; i < num_transfers; i++) {
#pragma HLS pipeline II=1
burst_reg = v.read();
output[i] = burst_reg;
}
}
void cp_4_opt_accel(hw_uint<64>* raw_update_0_read, hw_uint<64>* cp_4_update_0_write, const int size) {
#pragma HLS dataflow
#pragma HLS INTERFACE m_axi port = raw_update_0_read offset = slave depth = 65536 bundle = gmem0
#pragma HLS INTERFACE m_axi port = cp_4_update_0_write offset = slave depth = 65536 bundle = gmem1
#pragma HLS INTERFACE s_axilite port = raw_update_0_read bundle = control
#pragma HLS INTERFACE s_axilite port = cp_4_update_0_write bundle = control
#pragma HLS INTERFACE s_axilite port = size bundle = control
#pragma HLS INTERFACE s_axilite port = return bundle = control
static HWStream<hw_uint<64> > raw_update_0_read_channel;
static HWStream<hw_uint<64> > cp_4_update_0_write_channel;
read_raw_update_0_read(raw_update_0_read, raw_update_0_read_channel, size);
cp_4_opt(raw_update_0_read_channel, cp_4_update_0_write_channel, size);
write_cp_4_update_0_write(cp_4_update_0_write, cp_4_update_0_write_channel, size);
}
}
#endif //__VIVADO_SYNTH__
|
class powerUp
{
private:
int powerUpX, powerUpY;
int powerUpType = 0;
public:
int getPowerUpX();
int getPowerUpY();
void powerUpUpdatePosition(int x, int y);
void spawnPowerUp();
void movePowerUp();
void deletePowerUp();
int getPowerUpType();
void powerUpTypeRandomize();
};
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 2008-2012 Opera Software ASA. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
** Jan Borsodi
*/
#include "core/pch.h"
#ifdef PROTOBUF_SUPPORT
#include "modules/unicode/utf8.h"
#include "modules/util/adt/bytebuffer.h"
#include "modules/util/opstring.h"
#include "modules/protobuf/src/protobuf_wireformat.h"
#include "modules/protobuf/src/protobuf.h"
#include "modules/protobuf/src/protobuf_message.h"
#include "modules/protobuf/src/protobuf_data.h"
/* OpProtobufFormat */
int
OpProtobufFormat::StringDataSize(OpProtobufStringChunkRange range)
{
UTF8Encoder converter;
int utf8_len = 0;
for (; !range.IsEmpty(); range.PopFront())
{
const OpProtobufStringChunk &chunk = range.Front();
utf8_len += converter.Measure(reinterpret_cast<const void *>(chunk.GetString()), chunk.GetLength()*sizeof(uni_char));
}
return utf8_len;
}
int
OpProtobufFormat::StringSize(OpProtobufStringChunkRange range)
{
int len = StringDataSize(range);
return OpProtobufWireFormat::VarIntSize32(len) + len;
}
/*static*/
int
OpProtobufFormat::StringSize(const uni_char *str, int char_count)
{
OP_ASSERT(str != NULL);
if (char_count < 0)
char_count = uni_strlen(str);
if (char_count == 0)
return 1; // 1 is for the "size" field which says the strings is 0 long
OpProtobufStringChunkRange range(str, char_count);
int len = StringDataSize(range);
return OpProtobufWireFormat::VarIntSize32(len) + len;
}
/*static*/
int
OpProtobufFormat::BytesSize(const OpProtobufDataChunkRange &range)
{
int len = range.Length();
if (len == 0)
return 1; // 1 is for the "size" field which says the number of bytes is 0
return OpProtobufWireFormat::VarIntSize32(len) + len;
}
/*static*/
int
OpProtobufFormat::StringSize(const OpString &str, int char_count)
{
if (char_count < 0)
char_count = str.Length();
if (char_count == 0)
return 1; // 1 is for the "size" field which says the strings is 0 long
return StringSize(str.DataPtr(), char_count);
}
#endif // PROTOBUF_SUPPORT
|
#include "Ending.h"
#include "Commonheader.h"
#include "Title.h"
Ending::Ending()
{
std::cout << "Ending" << std::endl;
}
Ending::~Ending()
{
//イメージリソースの解放
//Common::Delete();
}
Boot* Ending::Update(SeaquenceController*){
Boot* next = this;
if (mCount == 120){
next = new Title;
}
//描画
++mCount;
return next;
}
|
#include<iostream>
using namespace std;
main()
{
cout << "start"<<endl;
char g1 = ' ';
char g2 = ' ';
bool v1 = false,v2 = false;
cin >> g1;
cin >> g2;
//Controllo sulle mosse dei Giocatori
if((g1 == 'f' || g1 == 'c' || g1 == 's') && (g2 == 'f' || g2 == 'c' || g2 == 's')){
switch (g1){
case 'f':
if(g2=='f'){
v1 = true;
v2 = true;
}else{
if(g2=='c')
v1 = true;
else
v2 = true;
}
break;
case 'c':
if(g2=='c'){
v1 = true;
v2 = true;
}else{
if(g2=='s')
v1 = true;
else
v2 = true;
}
break;
case 's':
if(g2=='s'){
v1 = true;
v2 = true;
}else{
if(g2=='f')
v1 = true;
else
v2 = true;
}
break;
}
if(v1 && v2)
cout << "pareggio" << endl;
else if(v1)
cout << "vince il giocatore 1" << endl;
else if(v2)
cout << "vince il giocatore 2" << endl;
}
else{
cout << "mossa non valida" << endl;
}
cout << "end" << endl;
}
|
#ifdef _WIN32
# ifdef testcxx2_EXPORTS
# define CM_TEST_LIB_EXPORT __declspec(dllexport)
# else
# define CM_TEST_LIB_EXPORT __declspec(dllimport)
# endif
#else
# define CM_TEST_LIB_EXPORT
#endif
class CM_TEST_LIB_EXPORT LibCxx2Class
{
public:
static float Method();
};
|
//
// Maho.cpp
// TuboWariProjection
//
// Created by Shuya Okumura on 2013/02/17.
//
//
#include "Maho.h"
#include "MACROS.h"
extern int startMahoTime, currentMahoTime;
extern int mahoIndex;
extern ofFloatColor mainPink;
extern bool trFadeOutLastMaho;
extern ofPoint mahoPos[2];
extern ofPoint hondanaPoints[HONDANA_INDEX_NUM];
extern float hondanaNoiseAmt;
//MAHO//
extern int mahoPhase;
extern int mahoPhase2Time[7];
extern int keenTime;
extern bool toggleCvFadeOut;
extern ofColor openCvDrawColor;
extern ofPoint seraBlob[6];
//openCvMissed
extern int choicedXtion;
extern bool bDrawScene1Blob;
extern bool bDraw[XTION_NUM];
//sera
extern bool bOpenCv;
extern bool bSera;
extern bool bDrawSeraBlob;
extern ofPoint seraHeadPos[1];
//harada door
extern bool bCvBlur;
extern float cvNoiseAmt;
extern bool bCvNoise;
extern ofPoint doorPos[6];
extern ofPoint doorPosDamy[6];
extern float doorGunyaAmt;
//harada fire
extern bool bHaradaFire;
extern grotes haradaFire;
//line//
extern bool bLine1;
extern int line1Num;
extern float accelAmt;
extern float lineColorAmt;
//bunshi
extern bool bBunshi;
extern int bunshiNum;
extern float mainParticleSize;
extern float radiusAmt;
extern float radiusMin;
extern float radiusMax;
extern float energyAmt;
extern float kasokuAmt;
extern float alphaAmt;
extern int mainBunshiLifeTime;
//line2
extern bool bLine2;
extern int line2Num;
extern float mahoLine2MaxLength;
extern float mahoLine2MinLength;
extern float lengthNoiseAmt;
extern float line2speed;
extern float mahoLine2AngleAmt;
extern float line2width;
//noiseBlob
extern bool bBlob;
extern int blobPointNum;//1 - 100 = 10
extern float sparkRangeMin;
extern float sparkRangeMax;
////keen
extern float keenWidth;
//kirakira
extern bool bKirakiraDraw;
extern float kirakiraHankei;
extern int kirakiraAmt;
extern bool bKirakiraIncrease;
//hoshi
extern float hoshiSize; //5.0f
extern int hoshiMainLifeTime;//100 - 10000
extern float kirakiraColorRangeAmt;
//sushi
extern ofPoint rokkaPosDamy[4];
extern ofPoint rokkaPos[4];
extern lastParticles lastparticles;
//==================================================================
hoshi::hoshi(){
lifeTime = hoshiMainLifeTime * fabs(ofRandomf());
angle = 360.0f * ofRandomf();
counter = 0;
color = mainPink;
color.g += ofRandomf() * kirakiraColorRangeAmt;
color.b += ofRandomf() * kirakiraColorRangeAmt;
color.g = ofClamp(color.g, 0.0f, 1.0f);
color.b = ofClamp(color.b, 0.0f, 1.0f);
}
void hoshi::draw(){
ofPushMatrix();
ofTranslate(pos.x, pos.y);
ofRotateZ(angle + ofGetElapsedTimef() * 50.0f);
ofNoFill();
ofSetLineWidth(1.0f);
ofSetColor(color);
ofLine(hoshiSize, 0.0f, -hoshiSize, 0);
ofLine(0.0f, hoshiSize, 0.0f, -hoshiSize);
ofPopMatrix();
counter++;
}
//==================================================================
void Kirakira::update(float x, float y){
if (!bKirakiraDraw) {
eriaPos.set(x, y);
exEriaPos.set(x,y);
return;
}
eriaPos.set(x, y);
if (bKirakiraIncrease) {
for (int i = 0; i < kirakiraAmt; i++) {
hoshi h;
float angle = TWO_PI * ofRandomf();
float dist = kirakiraHankei * fabs(ofRandomf());
h.pos.set(eriaPos.x + dist * cos(angle), eriaPos.y + dist * sin(angle) * 1.3f);
hoshis.push_back(h);
}
}
vector<hoshi>::iterator it = hoshis.begin();
while (it != hoshis.end())
{
hoshi s = *it;
if (s.counter > s.lifeTime)
{
it = hoshis.erase(it);
}
else
it++;
}
};
void Kirakira::draw(){
ofPushStyle();
for (int i = 0; i < hoshis.size(); i++) {
hoshis[i].draw();
}
ofPopStyle();
}
void Kirakira::clear(){
}
//==================================================================
bunshi::bunshi(){
energy = fabs(ofRandomf()) * energyAmt;
c = mainPink;
c *= energy + 0.2;
//c = ofClamp(c, 0.5f, 1.0f);
lifeTime = mainBunshiLifeTime * energy;
radius = mainParticleSize * energy;
pos.set(0.0f, 0.0f);
}
float bunshi::update(ofPoint kasoku){
ofPoint zero = ofPoint(0.0f, 0.0f);
speed += kasoku;
pos += speed * energy * energyAmt;
radius += ofRandomf() * radiusAmt;
radius = ofClamp(radius, radiusMin, radiusMax);
if (currentMahoTime > lifeTime) {
c *= alphaAmt;
}
}
void bunshi::draw(){
if (trFadeOutLastMaho) {
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
}
ofSetColor(c);
ofCircle(pos.x, pos.y, radius);
}
//////////////
myLine::myLine(float _angle){
angle = _angle;
linePoint = ofPoint();
speed = ofPoint();
accel = ofPoint();
alphaSpeed = 0.0f;
}
void myLine::update(ofPoint & _accel){
accel = _accel;
speed += accel;//speed no suii
linePoint += speed;//line no ido
}
void myLine::draw(){
if (trFadeOutLastMaho) {
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
}else c = mainPink + ofRandomf() * lineColorAmt;
ofSetColor(c);
ofLine(linePoint.x, 0.0f, linePoint.y, 0.0f);
}
//==================================================================
void noiseBlob::toggleStart(int noiseBlobPointNum){
blob.clear();
vecs.clear();
float anAngle = TWO_PI / noiseBlobPointNum;
for (int i = 0; i < noiseBlobPointNum; i++) {
ofPoint p = ofPoint(cos(anAngle * i), sin(anAngle * i));
vecs.push_back(p);
blob.push_back(ofPoint(0,0));
}
c = mainPink;
}
void noiseBlob::update(){
if (blob.size() == 0) return;
for (int i = 0; i < blob.size(); i++) {
blob[i] = vecs[i] * ofRandom(sparkRangeMin, sparkRangeMax);
}
}
void noiseBlob::draw(){
if (blob.size() == 0) return;
ofPushStyle();
ofPushMatrix();
ofFill();
if (trFadeOutLastMaho) {
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
if(c.r > 0)c.r--;
if(c.g > 0)c.g--;
if(c.b > 0)c.b--;
}
ofSetColor(c);
ofSetPolyMode(OF_POLY_WINDING_ODD);
ofBeginShape();
for (int i = 0; i < blob.size(); i++) {
if (i % 2 == 0) continue;
if (i == blob.size() - 1) {
ofVertex(blob[i]);
ofVertex(blob[0]);
} else {
ofVertex(blob[i]);
}
}
ofEndShape();
ofPopMatrix();
ofPopStyle();
}
//==================================================================
void Maho::update(){
currentMahoTime = ofGetElapsedTimeMillis() - startMahoTime;
if (bSera) {
sera.update();
}
if (mahoPhase != 0) {
lines.clear();
lines2.clear();
bunshis.clear();
}
//phase0
if (mahoPhase == 0) {
for (int i = 0; i < bunshis.size(); i++) {
bunshis[i].update(ofPoint(ofRandomf() * kasokuAmt, ofRandomf() * kasokuAmt));
}
for (int i = 0; i < lines.size(); i++) {
float r1 = std::fabs(ofRandomf());
float r2 = std::fabs(ofRandomf());
ofPoint p;
p.set(r1 * accelAmt, r2 * accelAmt);
lines[i].update(p);
}
for (int i = 0; i < lines2.size(); i++) {
lines2[i].update();
}
b.update();
b2.update();
}
if (mahoIndex == 9)lastparticles.update();
}
void Maho::draw( float x, float y){
if (!drawing) return;
//phase0
// if (lastMaho) {
// float lastMahoLineNum = line1Num *2;
// int lastMahoBlobPointNum = blobPointNum * 3;
// float lastMahoSparkRangeMax = 180.0f;
// float lastMahoLine2MinLength = 180.0f;//2.0f - 300.0f
// float lastMahoLine2MaxLength = 500.0f;
// float mahoLine2MaxLength = 110.5f;//
// ofPushStyle();
// ofPushMatrix();
// ofTranslate(x, y);
//
//
// for (int i = 0; i < lines2.size(); i++) {
// lines2[i].draw();
// }
// ofFill();
// b.draw();
// b2.draw();
// for (int i = 0; i < bunshis.size(); i++) {
// bunshis[i].draw();
// }
// ofNoFill();
// ofSetLineWidth(4.0f);
// for (int i = 0; i < lines.size(); i++) {
// ofPushMatrix();
// ofRotateZ(lines[i].angle);
// lines[i].draw();
// ofPopMatrix();
// }
// ofPopMatrix();
// ofPopStyle();
// ofPushStyle();
// lastparticles.draw();
// ofPopStyle();
//
// return;
// }
if (mahoPhase == 0){
ofPushStyle();
ofPushMatrix();
ofTranslate(x, y);
for (int i = 0; i < lines2.size(); i++) {
lines2[i].draw();
}
ofFill();
b.draw();
b2.draw();
for (int i = 0; i < bunshis.size(); i++) {
bunshis[i].draw();
}
ofNoFill();
ofSetLineWidth(4.0f);
for (int i = 0; i < lines.size(); i++) {
ofPushMatrix();
ofRotateZ(lines[i].angle);
lines[i].draw();
ofPopMatrix();
}
ofPopMatrix();
ofPopStyle();
ofPushStyle();
lastparticles.draw();
ofPopStyle();
} else if (mahoPhase == 1){
if ( currentMahoTime < keenTime) {//Keen
ofPushStyle();
ofPushMatrix();
ofNoFill();
ofSetColor(mainPink);
ofSetLineWidth(keenWidth);
ofPoint v = mahoPos[1] - mahoPos[0];
ofLine(mahoPos[0], mahoPos[1]);
ofPopMatrix();
ofPopStyle();
} else if ( currentMahoTime > keenTime && currentMahoTime < mahoPhase2Time[0]) {//本棚がグニャグニャ hondana
//fade
if (mahoIndex == 1) {
//gunya1
ofPushStyle();
ofPushMatrix();
ofFill();
ofSetColor(color);
ofBeginShape();
for (int i = 0; i < HONDANA_INDEX_NUM; i++) {
ofVertex(hondanaPoints[i]);
hondanaPoints[i] += ofRandomf() * hondanaNoiseAmt;
}
ofEndShape();
ofBeginShape();
for (int i = HONDANA_INDEX_NUM - 1; i >= 0; i--) {
ofVertex(hondanaPoints[i]);
hondanaPoints[i] += ofSignedNoise(ofGetElapsedTimeMillis()) * hondanaNoiseAmt;
}
ofEndShape();
ofPopMatrix();
ofPopStyle();
}
}
//sera
if (currentMahoTime > keenTime && mahoIndex == 2) {//sera
if (!seraDid) {
if (choicedXtion == 0) {
bDrawSeraBlob = true;
} else {
for (int i = 1; i <= XTION_NUM; i++) {
if (choicedXtion - 1 == i){
bDraw[i] = true;
}else bDraw[i] = false;
}
bOpenCv = true;
}
seraDid = true;
}
if (bSera) {
if (bDrawSeraBlob){
ofPushStyle();
ofFill();
if (toggleCvFadeOut) {
if (openCvDrawColor.r > 2)openCvDrawColor.r -= 3;
if (openCvDrawColor.g > 2)openCvDrawColor.g -= 3;
if (openCvDrawColor.b > 2)openCvDrawColor.b -= 3;
if (openCvDrawColor.r < 3) {
bDrawSeraBlob = false;
}
}
ofSetColor(openCvDrawColor);
// ofBeginShape();
// for (int i = 0; i < 6; i++) {
// ofVertex(seraBlob[i].x + ofRandomf() * 10.0f, seraBlob[i].y + ofRandomf() * 10.0f);
// }
// ofEndShape();
// ofBeginShape();
// for (int i = 0; i < 6; i++) {
// ofVertex(seraBlob[i].x + ofRandomf() * 10.0f, seraBlob[i].y + ofRandomf() * 10.0f);
// }
// ofEndShape();
// ofPoint centerOfSera(0.0f, 0.0f);
// for (int i = 0; i < 6; i++) {
// centerOfSera.x += seraBlob[i].x;
// centerOfSera.y += seraBlob[i].y;
// }
// centerOfSera /= 6.0f;
// for (int i = 0; i < 100; i++) {
// float length = ofRandom(0.0f, 100.0f);
// float angle = ofRandom(0.0f, 360.0f);
// float xx = length * cos(angle);
// float yy = length * sin(angle);
// if (sin(angle) < 0) yy *= 0.5f;
//
// ofRect(2.0f + centerOfSera.x + xx, 2.0f + centerOfSera.y + yy, 8.0f, 8.0f);
// }
for (int i = 0; i < 100; i++) {
float length = ofRandom(0.0f, 100.0f);
float angle = ofRandom(0.0f, 360.0f);
float xx = length * cos(angle) * 0.4;
float yy = length * sin(angle);
if (sin(angle) < 0) yy *= 0.5f;
ofRect(4.0f + seraHeadPos[0].x + xx, 4.0f + seraHeadPos[0].y + yy, 8.0f, 8.0f);
}
for (int i = 0; i < 100; i++) {
float length = ofRandom(0.0f, 100.0f);
float angle = ofRandom(0.0f, 360.0f);
float xx = length * cos(angle) * 0.4;
float yy = length * sin(angle);
if (sin(angle) < 0) yy *= 0.5f;
ofCircle(seraHeadPos[0].x + xx, seraHeadPos[0].y + yy, 8.0f);
}
// float noiseLineLength = 30.0f;
// ofNoFill();
// ofSetColor(openCvDrawColor);
// ofSetLineWidth(2.0f);
// ofEnableBlendMode(OF_BLENDMODE_SUBTRACT);
// for (int i = 0; i < 50; i++) {
// ofLine(centerOfSera.x - noiseLineLength /2.0f, centerOfSera.y + ofNoise(ofGetElapsedTimef() * 100 * i)*noiseLineLength, centerOfSera.x + noiseLineLength /2.0f, centerOfSera.y + ofNoise(ofGetElapsedTimef() * 100 * i)*noiseLineLength);
// }
// ofDisableBlendMode();
}
sera.draw();
} else {
sera.toggleGo();
bSera = true;
}
}
//harada door
if (currentMahoTime > keenTime && mahoIndex == 3) {
//gunya1
ofPushStyle();
ofFill();
ofSetColor(color);
ofBeginShape();
for (int i = 0; i < 6; i++) {
ofVertex(doorPos[i]);
}
ofEndShape();
ofBeginShape();
for (int i = 0; i < 6; i++) {
ofVertex(doorPosDamy[i]);
doorPosDamy[i].x += ofRandomf() * doorGunyaAmt;
}
ofEndShape();
ofBeginShape();
for (int i = 4 - 1; i >= 0; i--) {
ofVertex(doorPosDamy[i]);
doorPosDamy[i].x += ofRandomf() * doorGunyaAmt;
}
ofEndShape();
ofPopStyle();
}
//harada fire
if (currentMahoTime > keenTime && mahoIndex == 6) {
bHaradaFire = true;
haradaFire.setup();
haradaFire.toggleGo();
mahoIndex = 0;
}
//sushi
if (currentMahoTime > keenTime && mahoIndex == 7) {
//rokka-
ofPushStyle();
ofPushMatrix();
ofFill();
ofSetColor(color);
ofBeginShape();
for (int i = 0; i < 4; i++) {
ofVertex(rokkaPos[i]);
}
ofEndShape();
ofBeginShape();
for (int i = 0; i < 4; i++) {
ofVertex(rokkaPosDamy[i].x + ofRandomf() * hondanaNoiseAmt, rokkaPosDamy[i].y + ofRandomf() * hondanaNoiseAmt);
}
ofEndShape();
ofBeginShape();
for (int i = 3; i >= 0; i--) {
ofVertex(rokkaPosDamy[i].x + ofSignedNoise(ofGetElapsedTimeMillis()) * hondanaNoiseAmt, rokkaPosDamy[i].y + ofSignedNoise(ofGetElapsedTimeMillis()) * hondanaNoiseAmt);
}
ofEndShape();
ofPopMatrix();
ofPopStyle();
}
//gomory
if (currentMahoTime > keenTime && mahoIndex == 8) {
ofPushStyle();
ofPushMatrix();
ofFill();
ofSetColor(color);
ofBeginShape();
for (int i = 0; i < 6; i++) {
ofVertex(doorPos[i]);
}
ofEndShape();
ofBeginShape();
for (int i = 0; i < 6; i++) {
ofVertex(doorPosDamy[i]);
doorPosDamy[i].x += ofRandomf() * doorGunyaAmt;
}
ofEndShape();
ofBeginShape();
for (int i = 4 - 1; i >= 0; i--) {
ofVertex(doorPosDamy[i]);
doorPosDamy[i].x += ofRandomf() * doorGunyaAmt;
}
ofEndShape();
ofPopMatrix();
ofPopStyle();
}
}
}
void Maho::toggleSpark(){
mahoPhase = 0;
fadeCount = 0;
drawing = true;
color = mainPink;
if (bLine1) {
float anAngle = 360.0f / line1Num;
float firstAngle = ofGetElapsedTimef() * 360.0f;
for (int i = 0; i < line1Num; i++) {
myLine line = myLine(firstAngle + anAngle * i + ofRandomf());
lines.push_back(line);
}
}
if (bBunshi){
//bunshi
for (int i = 0; i < bunshiNum; i++) {
bunshi b = bunshi();
bunshis.push_back(b);
}
}
if (bLine2) {
//line2
float aAm = 360.0f / line2Num;
for (int i = 0; i < line2Num; i++) {
myLine2 l = myLine2(aAm * i * ofRandom(0.0f, 30.0f));
lines2.push_back(l);
}
}
if (bBlob){
b.toggleStart(blobPointNum);
b2.toggleStart(blobPointNum);
}
if (mahoIndex == 2) {
bSera = false;
sera.setup();
}
printf("goko1発射!!\n");
seraDid = false;
}
void Maho::toggleKeen(){
if (mahoPhase != 0) return;
startMahoTime = ofGetElapsedTimeMillis();
mahoPhase = 1;
}
|
#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<stdlib.h>
int i,j,ec,fg,ec2;
char fn[20],e,c;
FILE *fp1,*fp2,*fp;
void Create();
void Append();
void Delete();
void Display();
int main()
{
do {
printf("\n\t\t***** TEXT EDITOR *****");
printf("\n\n\tMENU:\n\t—–\n ");
printf("\n\t1.CREATE\n\t2.DISPLAY\n\t3.APPEND\n\t4.DELETE\n\t5.EXIT\n");
printf("\n\tEnter your choice: ");
scanf("%d",&ec);
switch(ec)
{
case 1:
Create();
break;
case 2:
Display();
break;
case 3:
Append();
break;
case 4:
Delete();
break;
case 5:
exit(0);
}
}while(1);
}
void Create()
{
fp1 = fopen("temp2.txt","w");
printf("Enter the text and press '.' to save\n\n\t");
while(1)
{
c = getchar();
fputc(c,fp1);
if(c == '.')
{
fclose(fp1);
printf("\n Enter the file name:");
scanf("%s",fn);
fp2 = fopen(fn,"w");
fp1 = fopen("temp2.txt","r");
while(!feof(fp1))
{
c = getc(fp1);
putc(c,fp2);
}
fclose(fp1);
fclose(fp2);
break;
}
}
}
void Display()
{
printf("\n enter the file name:");
scanf("%s",fn);
fp1= fopen(fn,"r");
if(fp1 == NULL)
{
printf("\n No file found");
goto end1;
}
while(!feof(fp1))
{
c = getc(fp1);
printf("%c",c);
}
end1:
fclose(fp1);
printf("\n\n\tPress any key to continue…");
getch();
}
void Delete()
{
printf("\n Enter the file name to delete");
scanf("%s",fn);
fp1 = fopen(fn,"r");
if(fp1 == NULL)
{
printf("\n File not found");
goto end4;
}
fclose(fp1);
if(remove(fn)==0)
{
printf("\n File removed succesfully");
goto end4;
}
else
{printf("\n ERROR");
}
end4: printf("\n\n\tPress any key to continue…");
getch();
fclose(fp1);
}
void Append()
{
printf("\n Enter the file name:");
scanf("%s",fn);
fp1 = fopen(fn,"r");
if(fp1==NULL)
{
printf("\n\tFile not found!");
goto end3;
}
while(!feof(fp1))
{
c = getc(fp1);
printf("%c",c);
}
fclose(fp1);
printf("\n ENter the text to insert , press CTRL + S to save");
fp1=fopen(fn,"a");
while(1)
{
c = getch();
if (c==19)
goto end3;
if(c == 13)
{
c='\n';
printf("\n");
fputc(c,fp1);
}
else
{
printf("%c",c);
fputc(c,fp1);
}
}
end3: fclose(fp1);
getch();
}
|
//===========================================================================
//! @file asset_model.h
//! @brief アセットモデル所有クラス
//===========================================================================
#pragma once
//--------------------------------------------------------------------------
//! 三角形の座標とUV座標から接ベクトルを求める
//! @return [out] 1.接ベクトル
//! @return [out] 2.従法線ベクトル
//--------------------------------------------------------------------------
std::tuple<Vector3, Vector3> calcTangent(
const Vector3& p0, const Vector3& p1, const Vector3& p2,
const Vector2& uv0, const Vector2& uv1, const Vector2& uv2);
//! 前方宣言
class Mesh;
//===========================================================================
//! @clsss AssetModel
//===========================================================================
class AssetModel : public AssetBase
{
public:
//--------------------------------------------------------------------------
//! @name 初期化
//--------------------------------------------------------------------------
//@{
//! @brief コンストラクタ
AssetModel() = default;
//! @brief デストラクタ
virtual ~AssetModel() override = default;
//@}
//--------------------------------------------------------------------------
//! @name タスク
//--------------------------------------------------------------------------
//@{
//--------------------------------------------------------------------------
//! @brief 初期化
//! @param [in] fileName ファイル名
//! @return true 正常終了
//! @return false エラー終了
//--------------------------------------------------------------------------
virtual bool load([[maybe_unused]] const std::string& fileName) override { return true; };
//--------------------------------------------------------------------------
//! @brief 初期化(直接指定)
//! @param [in] fileName ファイル名
//! @param [in] vertices バーテックス配列
//! @param [in] indices インデックス配列
//! @param [in] iSize インデックス配列サイズ
//! @return true 正常終了
//! @return false エラー終了
//--------------------------------------------------------------------------
bool load(Vertex* vertices, u32* indices, u32 iSize);
//! @brief 解放
virtual void cleanup() override{};
//@}
//--------------------------------------------------------------------------
//! @name 取得
//--------------------------------------------------------------------------
//@{
//--------------------------------------------------------------------------
//! @brief メッシュ取得
//! @return メッシュ配列
//--------------------------------------------------------------------------
std::vector<Mesh>& getMeshes() { return meshes_; }
//@}
protected:
std::vector<Mesh> meshes_; //!< メッシュ
};
//===========================================================================
//! @struct Material
//===========================================================================
struct Material
{
enum class TextureType
{
Albedo,
Normal,
Roughness,
Metalness,
Ao,
//----
Max,
};
std::shared_ptr<gpu::Texture> texture_[(s32)TextureType::Max] = {};
};
//===========================================================================
//! @clsss Mesh
//===========================================================================
class Mesh
{
public:
//-----------------------------------------------------------------------
//! @name 初期化
//-----------------------------------------------------------------------
//@{
//! @brief コンストラクタ
Mesh() = default;
//! @brief デストラクタ
virtual ~Mesh() = default;
//@}
//-----------------------------------------------------------------------
//! @name タスク
//-----------------------------------------------------------------------
//@{
//--------------------------------------------------------------------------
//! @brief 初期化
//! @param [in] fileName ファイル名
//! @return true 正常終了
//! @return false エラー終了
//--------------------------------------------------------------------------
virtual bool load(const std::string& fileName) { return true; };
//--------------------------------------------------------------------------
//! @brief 初期化(直接指定)
//! @param [in] fileName ファイル名
//! @param [in] vertices バーテックス配列
//! @param [in] indices インデックス配列
//! @param [in] iSize インデックス配列サイズ
//! @return true 正常終了
//! @return false エラー終了
//--------------------------------------------------------------------------
bool load(Vertex* vertices, u32* indices, u32 iSize);
//@}
protected:
//-----------------------------------------------------------------------
//! @name 読み込み
//-----------------------------------------------------------------------
//@{
//! @brief 頂点読み込み
virtual void loadVertices(){};
//! @brief 頂点インデックス番号読み込み
virtual void loadIndices(){};
//! @brief 法線読み込み
virtual void loadNormals(){};
//! @brief テクスチャUV読み込み
virtual void loadUVs(){};
//! @brief マテリアル読み込み
virtual void loadMaterials(){};
//! @brief バッファ初期化
virtual bool initializeBuffer();
//@}
public:
//-----------------------------------------------------------------------
//! @name 取得
//-----------------------------------------------------------------------
//@{
//! @brief 頂点情報を取得
const std::vector<Vertex>& getVertices() const { return vertices_; }
//! @brief 頂点位置を取得
const std::vector<Vector3>& getVertexPoints() const { return vertexPoints_; }
//! @brief 頂点インデックス番号を取得
const std::vector<u32>& getIndices() const { return indices_; }
//! @brief 法線を取得
const std::vector<Vector3>& getNormals() const { return normals_; }
//! @brief 接ベクトルを取得
const std::vector<Vector3>& getTangents() const { return tangents_; }
//! @brief 従法線ベクトルを取得
const std::vector<Vector3>& getBinormals() const { return binormals_; }
//! @brief UV座標を取得
const std::vector<Vector2>& getUVs() const { return uvs_; }
//! @brief マテリアル一覧を取得
const std::vector<Material>& getMaterials() const { return materials_; }
//! @brief マテリアル番号を取得
const std::vector<s32>& getMaterialIndices() const { return materialIndices_; }
//! @brief 頂点バッファ取得
const gpu::Buffer& getVertexBuffer() const { return vertexBuffer_; }
//! @brief インデックスバッファ取得
const gpu::Buffer& getIndexBuffer() const { return indexBuffer_; }
//@}
protected:
std::vector<Vertex> vertices_; //!< 頂点情報
std::vector<Vector3> vertexPoints_; //!< 頂点位置
std::vector<u32> indices_; //!< 頂点インデックス番号
std::vector<Vector3> normals_; //!< 法線
std::vector<Vector3> tangents_; //!< 接線
std::vector<Vector3> binormals_; //!< 従法線
std::vector<Vector2> uvs_; //!< テクスチャUV座標
std::vector<Material> materials_; //! マテリアル
std::vector<s32> materialIndices_; //! マテリアル番号
gpu::Buffer vertexBuffer_; //!< 頂点バッファ
gpu::Buffer indexBuffer_; //!< インデックスバッファ
};
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2008 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*/
#include "core/pch.h"
#ifdef MACGOGI
#include "platforms/macgogi/pi/network/macthread.h"
#else
#include "platforms/mac/model/macthread.h"
#endif
#ifdef __MWERKS__
#pragma profile off
#endif
MacThread::MacThread()
{
isRunning = false;
#ifdef USE_PTHREADS
thread = NULL;
#else
notifyQueue = NULL;
#endif
}
MacThread::~MacThread()
{
terminate();
}
OSStatus MacThread::start()
{
#ifdef USE_PTHREADS
pthread_attr_t attr;
pthread_attr_init(&attr);
typedef void *(*start_routine)(void *);
isRunning = true;
OSStatus err = pthread_create(&thread, &attr, (start_routine)sRun, (void *)this);
if(err != noErr)
{
thread = 0;
isRunning = false;
return err;
}
#else
OSStatus err;
// Create the default communicatiosn queue for the
// thread to be created.
err = MPCreateQueue(¬ifyQueue);
// Generally at this stage if there is an error, the error type is
// kMPInsufficientResourcesErr
if(err != noErr)
return err;
// Before starting the thread, set the isRunning flag to true.
// This makes it so that if the thread immediately exits,
// the isRunning won't be set to true after being reset to
// false.
isRunning = true;
int terminationParameter1 = 0;
int terminationParameter2 = 0;
err = MPCreateTask(sRun,
(void *) this,
(unsigned long) 0,
notifyQueue,
&terminationParameter1,
&terminationParameter2,
0,
&task);
// The error code returned from here also should be
// kMPInsufficientResourcesErr.
if(err != noErr)
{
// Checking the error code on the delete queue operation is
// generally not a good idea. Therefore we don't bother. If
// this fails there is no recourse we can take. It is better
// to report the error from the MPCreateTask statement.
MPDeleteQueue(notifyQueue);
notifyQueue = NULL;
isRunning = false;
return err;
}
#endif
return noErr;
}
void MacThread::terminate()
{
#ifdef USE_PTHREADS
if (!thread)
return;
OSStatus err = pthread_cancel(thread);
pthread_join(thread,NULL);
thread = 0;
#else
OSStatus err = MPTerminateTask(task, noErr);
MPDeleteQueue(notifyQueue);
#endif
if(err == noErr)
isRunning = false;
}
OSStatus MacThread::sRun(void *parameter)
{
MacThread *mpThread = (MacThread *) parameter;
return mpThread->run();
}
#ifdef __MWERKS__
#pragma profile reset
#endif
|
#ifndef COPYFILE_H
#define COPYFILE_H
#include <QObject>
#include <QProgressBar>
#include <QThread>
class CopyFile : public QThread
{
Q_OBJECT
public:
explicit CopyFile(QObject *parent = 0);
void run() Q_DECL_OVERRIDE;
void setInfo(QProgressBar* progressBar, QString originFileName, QString targetFileName);
private:
QProgressBar* m_progressBar;
QString m_originFileName;
QString m_targetFileName;
signals:
void setProgress(int value);
};
#endif // COPYFILE_H
|
#include "tower.h"
#include "gamemanager.h"
Tower::Tower(XY pos, XY size, Team *team, GameManager *game) :
Aggressor(300, team, game->getTeams()),
Element(pos, size, 300, game)
{
XY center_of_tower = _pos + _size*XY(0.5,0.5);
//_weapon = new Weapon(this, _pos + _size*XY(0.5,0.5), game);
_weapon = new Weapon(3, 500, this, center_of_tower, _game);
}
void Tower::updateElement()
{
if (checkIfDeathIsComming()) return;
attack();
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2010 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Manuela Hutter (manuelah)
*/
#ifndef QUICK_DROP_DOWN_H
#define QUICK_DROP_DOWN_H
#include "adjunct/quick_toolkit/widgets/DesktopOpDropDown.h"
#include "adjunct/quick_toolkit/widgets/QuickTextWidget.h"
/**
* QuickWidget wrapper for drop-downs.
*/
class QuickDropDown : public QuickEditableTextWidgetWrapper<DesktopOpDropDown>
{
IMPLEMENT_TYPEDOBJECT(QuickEditableTextWidgetWrapper<DesktopOpDropDown>);
public:
virtual ~QuickDropDown();
virtual OP_STATUS Init();
OP_STATUS AddItem(const OpStringC & text, INT32 index = -1, INT32 * got_index = NULL, INTPTR user_data = 0, OpInputAction * action = NULL, const OpStringC8 & widget_image = NULL)
{ return GetOpWidget()->AddItem(text, index, got_index, user_data, action, widget_image); }
private:
void OnItemAdded(INT32 index)
{ GetOpWidget()->ResetRequiredSize(); BroadcastContentsChanged(); }
};
#endif // QUICK_DROP_DOWN_H
|
#pragma once
#include <Eigen/Dense>
#include <iostream>
#include <random>
#include <vector>
#include "multi_tree_view.hpp"
namespace datastructures {
// Helper functions for converting between (flattened) trees and vectors.
template <typename Iterable>
Eigen::VectorXd ToVector(const Iterable &nodes) {
Eigen::VectorXd result(nodes.size());
size_t i = 0;
for (const auto &node : nodes) {
if constexpr (std::is_pointer_v<typename Iterable::value_type>)
result[i++] = node->value();
else
result[i++] = node.value();
}
return result;
}
template <typename Iterable>
void FromVector(const Iterable &nodes, const Eigen::VectorXd &vec) {
assert(nodes.size() == vec.size());
size_t i = 0;
for (auto &node : const_cast<Iterable &>(nodes)) {
if constexpr (std::is_pointer_v<typename Iterable::value_type>)
node->set_value(vec[i++]);
else
node.set_value(vec[i++]);
}
}
template <typename I>
class MultiNodeVectorInterface {
public:
inline I *self() { return static_cast<I *>(this); }
inline const I *self() const { return static_cast<const I *>(this); }
void Reset() {
for (const auto &node : self()->Bfs(true)) node->set_value(0);
}
// Note: this is not compatible with the Python ToArray!
Eigen::VectorXd ToVector() const {
return datastructures::ToVector(const_cast<I *>(self())->Bfs());
}
void FromVector(const Eigen::VectorXd &vec) {
datastructures::FromVector(self()->Bfs(), vec);
}
};
template <typename I, typename... T>
class MultiNodeVectorBase : public MultiNodeViewBase<I, T...>,
public MultiNodeVectorInterface<I> {
public:
using MultiNodeViewBase<I, T...>::MultiNodeViewBase;
inline const double &value() const { return value_; }
inline void set_value(double val) {
// assert(val == 0.0 || (1e-100 < std::abs(val) && std::abs(val) < 1e100));
value_ = val;
}
inline void set_random() {
value_ = static_cast<double>(std::rand()) / RAND_MAX;
}
protected:
double value_ = 0.0;
};
// Create instance of this class
template <typename... T>
class MultiNodeVector
: public MultiNodeVectorBase<MultiNodeVector<T...>, T...> {
public:
using MultiNodeVectorBase<MultiNodeVector<T...>, T...>::MultiNodeVectorBase;
};
template <typename I>
class MultiTreeVector : public MultiTreeView<I> {
private:
using Super = MultiTreeView<I>;
public:
using MultiTreeView<I>::MultiTreeView;
// Note: this is not compatible with the Python ToArray!
Eigen::VectorXd ToVector() const { return Super::root_->ToVector(); }
void FromVector(const Eigen::VectorXd &vec) { Super::root_->FromVector(vec); }
void FromVector(const MultiTreeVector<I> &vec) {
Reset();
Super::root_->Union(vec.root(),
/* call_filter*/ func_true, /* call_postprocess*/
[](const auto &my_node, const auto &other_node) {
my_node->set_value(other_node->value());
});
}
// This uses the ordering as in the underlying container.
Eigen::VectorXd ToVectorContainer() const {
return datastructures::ToVector(Super::multi_nodes_);
}
void FromVectorContainer(const Eigen::VectorXd &vec) {
datastructures::FromVector(Super::multi_nodes_, vec);
}
// Create a deepcopy that copies the vector data as well.
template <typename MT_other = MultiTreeVector<I>>
MT_other DeepCopy() const {
return Super::template DeepCopy<MT_other>(
[&](const auto &new_node, const auto &old_node) {
new_node->set_value(old_node->value());
});
}
// Set all values to zero.
void Reset() {
for (auto &node : Super::multi_nodes_) node.set_value(0);
}
// Define some simple linear algebra functions.
MultiTreeVector<I> &operator*=(double val) {
for (auto &nv : Super::multi_nodes_) {
nv.set_value(nv.value() * val);
}
return *this;
}
template <typename MT_other = MultiTreeVector<I>>
MultiTreeVector<I> &operator+=(const MT_other &rhs) {
Super::root_->Union(
rhs.root(), /* call_filter*/ func_true, /* call_postprocess*/
[](const auto &my_node, const auto &other_node) {
my_node->set_value(my_node->value() + other_node->value());
});
return *this;
}
friend std::ostream &operator<<(std::ostream &os,
const MultiTreeVector<I> &tree) {
os << "{";
for (auto mnv : tree.Bfs()) os << *mnv << " ";
os << "}";
return os;
}
};
template <typename T0>
using NodeVector = MultiNodeVector<T0>;
template <typename T0>
using TreeVector = MultiTreeVector<MultiNodeVector<T0>>;
template <typename T0, typename T1, typename T2>
using TripleTreeVector = MultiTreeVector<MultiNodeVector<T0, T1, T2>>;
} // namespace datastructures
|
//对 回忆一下自己的做题思路(最近每做一题就把这个粘过去)
//1. 先理解题
//2. 确定解题思路(选择数据结构算法什么的) 确定能解决正常情况,也不用考虑太多复杂度
//3. 2达到之后, 开始考虑各种解决可能遇到的奇怪情况 然后看看有没有复杂度更低的思路
//这题挺难懂的 先随意试试吧
//讲真 这题思路自己没问题了,昨天就没问题了
//可是被那个什么申请内存错误,释放内存错误给卡住了 换了STL的swap才行 目前还不知道是啥原因
//就这样吧 被浪费了一点时间 还能接受 这题过 不过将来thu的toy估计需要借鉴这道题
//其实这题的有相同的数时不复杂,这就降低了难度
//这个题的quicksort是改过的可以给vector用的 以后需要可以回来找
//这题还有不懂的地方呢 没办法了
//12 ms 61.48%
//quicksort algotithm
int quicksort(vector<int>& data,int low,int high){
int partition(vector<int>& data,int low,int high);
if ((high-low)<1){
return 0;
}
int middle=partition(data,low,high-1);
quicksort(data,low,middle);
quicksort(data,middle+1,high);
return 0;
}
int partition(vector<int>& data,int low,int high){
int backup_low=low;
int backup_high=high;
int middle_data=data[low];
for(;low<high;){
for(;low<high;){
if(data[high]>middle_data){
high=high-1;
}else{
data[low]=data[high];
low=low+1;
break;
}
}
for(;low<high;){
if(data[low]<middle_data){
low=low+1;
}else{
data[high]=data[low];
high=high-1;
break;
}
}
}
int middle=low;
data[low]=middle_data;
low=backup_low;
high=backup_high;
return middle;
}
#include<algorithm>
class Solution {
public:
void nextPermutation(vector<int>& nums) {
int size = nums.size();
if(size == 2){
swap(nums[0],nums[1]);
}
if(size!=0&&size!=1&&size!=2){
int i=size-1;
for( ;i>0&&nums[i]<=nums[i-1];--i){}
if(i==0){
quicksort(nums,0,size);
}else if(i==size-1){
swap(nums[i],nums[i-1]);
}else if(i>0&&i<size-1){
//这的cout<<i;可以删
quicksort(nums,i,size);
int k=i-1;
for(;nums[k]>=nums[i];++i)
cout<<i;//这的不能删 还不知道是啥原因
swap(nums[k],nums[i]);
}
}
}
};
|
//
// Created by peto184 on 26-Oct-17.
//
#pragma once
#ifndef PPGSO_PLAYER_H
#define PPGSO_PLAYER_H
#include <ppgso/ppgso.h>
#include "object.h"
#include "src/playground/constants.h"
#include "src/playground/scene.h"
#include "projectile.h"
class Player final : public Object{
public:
Player();
enum State {
PLAYER_IN_AIR,
PLAYER_ON_GROUND
};
const float RELOAD_TIME = 1.0f;
float mReload = 0.0;
enum State mPlayerState = PLAYER_ON_GROUND;
bool update(Scene& scene, float dt) override;
void render(Scene &scene) override;
private:
static ppgso::Mesh *mMesh;
static std::unique_ptr<ppgso::Mesh> mMeshJumping;
static std::unique_ptr<ppgso::Mesh> mMeshStanding;
static std::unique_ptr<ppgso::Shader> mShader;
static std::unique_ptr<ppgso::Texture> mTexture;
};
#endif //PPGSO_PLAYER_H
|
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cmath>
#include <string>
#include <cstring>
#include <queue>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <functional>
#include <numeric>
#include <sstream>
#include <complex>
typedef long double LD;
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned int uint;
#define PI 3.1415926535897932384626433832795
#define sqr(x) ((x)*(x))
using namespace std;
char s[111111];
int st[111111];
int back[111111];
int stn = 0;
int n;
int ansi = -1;
int ansj = 0;
int main() {
freopen("brackets.in", "r", stdin);
freopen("brackets.out", "w", stdout);
gets(s);
n = strlen(s);
for (int i = 0; i < n; ++i) {
back[i] = -1;
if (s[i] == '[' || s[i] == '(') {
st[stn++] = i;
} else {
if (stn == 0) continue;
int lst = s[st[stn - 1]];
if (lst == '[' && s[i] == ']' || lst == '(' && s[i] == ')') {
back[i] = st[stn - 1];
if (back[i] > 0 && back[back[i] - 1] != -1) back[i] = back[back[i] - 1];
if (i - back[i] > ansi - ansj) {
ansi = i;
ansj = back[i];
}
--stn;
} else stn = 0;
}
}
s[ansi + 1] = 0;
puts(s + ansj);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#define MAX 501
int n, k, d[MAX];
bool check[MAX];
std::vector<int> Y[MAX];
bool dfs(int x)
{
if(check[x])
{
return false;
}
check[x] = true;
for(int y : Y[x])
{
if(d[y] == 0 || dfs(d[y]))
{
d[y] = x;
return true;
}
}
return false;
}
int main()
{
std::cin.sync_with_stdio(false);
std::cin.tie(NULL);
std::cin >> n >> k;
for(int i = 0; i < k; i++)
{
int a, b;
std::cin >> a >> b;
Y[a].push_back(b);
}
int ans = 0;
for(int i = 1; i <= n; i++)
{
std::memset(check, 0, sizeof(check));
if(dfs(i))
{
ans++;
}
}
std::cout << ans << '\n';
return 0;
}
|
/*
Copyright (c) <2012>, Intel Corporation All Rights Reserved.
The source code, information and material ("Material") contained herein is
owned by Intel Corporation or its suppliers or licensors, and title to such
Material remains with Intel Corporation or its suppliers or licensors. The
Material contains proprietary information of Intel or its suppliers and
licensors. The Material is protected by worldwide copyright laws and treaty
provisions. No part of the Material may be used, copied, reproduced,
modified, published, uploaded, posted, transmitted, distributed or
disclosed in any way without Intel's prior express written permission. No
license under any patent, copyright or other intellectual property rights
in the Material is granted to or conferred upon you, either expressly, by
implication, inducement, estoppel or otherwise. Any license under such
intellectual property rights must be express and approved by Intel in
writing.
Copyright (c) Microsoft Corporation. All rights reserved
Unless otherwise agreed by Intel in writing, you may not remove or alter
this notice or any other notice embedded in Materials by Intel or Intelís
suppliers or licensors in any way.
*/
/* GestureHandler is a class for handling Gesture events sent to the app
by the OS after a user performs a gesture on the touch screen. In its
current incarnation, it will send these gesture notifications with their
data to the SDP_rectangle class so that the rectangle on the screen can
be manipulated according to the gestures performed.
*/
#pragma once
#include <Windows.h>
#include "SDP_rectangle.h"
//This class will handle all gestures and apply them appropriately to the UI
class GestureHandler
{
public:
GestureHandler(SDP_rectangle *rect);
~GestureHandler(void);
//To handle the gesture from the main wndproc function
LRESULT WndProc(HWND hWnd, WPARAM wParam, LPARAM lParam);
//individual gesture actions
void handleZoom(HWND hWnd, GESTUREINFO gi);
void handlePan(HWND hWnd, GESTUREINFO gi);
void handleRotate(HWND hWnd, GESTUREINFO gi);
void handle2FingerTap(HWND hWnd, GESTUREINFO gi);
void handlePNT(HWND hWnd, GESTUREINFO gi);
void invalidate(HWND hWnd, int force);
private:
//Put a pointer to your image/object you want to manipulate here
//multi-point gestue variables
POINT m_first;
POINT m_second;
unsigned long long m_arguments;
SDP_rectangle *m_rect;
int m_draw_count;
double m_initial_degrees;
int m_inv_count;
};
|
#pragma once
#include "Grid_point.h"
#include "Particle_cloud.h"
#include <vector>
#include <Dense>
using namespace Eigen;
using namespace std;
class Grid
{
public:
Grid();
~Grid();
public:
vector<vector<Grid_Point>> Map;
Vector2i size;
Vector2d start, end;
Vector2d cellsize;
Particle_Cloud * Material;
public:
Grid(Vector2d Start, Vector2d End, Vector2i Size, Particle_Cloud * Object);
double N(double x);
double dN(double x); //the derivative of N(x)
void Init_Grid();
void Update_From_Material();
void Init_Volume();
void Update_Grid();
void Compute_Weight_Gradient();
void Set_Force_Zero();
void Update_Force();
void Update_From_Force();
void Determine_Collision();
void Update_Particle_Cloud();
void Update_Particle_Position();
void Update_Deformation_Gradient();
};
|
#include <Texture.h>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
CTexture::CTexture(const std::string &filename)
: _target(GL_TEXTURE_2D)
, _texture(0)
, _internalformat(GL_SRGB)
, _format(GL_RGB)
, _width(0)
, _height(0)
, _components(0)
{
stbi_set_flip_vertically_on_load(true);
unsigned char *image = stbi_load(filename.c_str(), &_width, &_height, &_components, STBI_default);
if (!image)
throw std::runtime_error( utils::ws2s(utils::CFormat(L"Failed to load texture '%%'") << filename) );
glGenTextures(1, &_texture);
bind();
switch (_components)
{
case STBI_grey:
_internalformat = GL_SLUMINANCE;
_format = GL_LUMINANCE;
break;
case STBI_grey_alpha:
_internalformat = GL_SLUMINANCE_ALPHA;
_format = GL_LUMINANCE_ALPHA;
break;
case STBI_rgb:
_internalformat = GL_SRGB;
_format = GL_RGB;
break;
case STBI_rgb_alpha:
_internalformat = GL_SRGB_ALPHA;
_format = GL_RGBA;
break;
default:
break;
}
glTexImage2D(_target, 0, _internalformat, _width, _height, 0, _format, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(_target);
glTexParameteri(_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
stbi_image_free(image);
unbind();
}
CTexture::~CTexture()
{
glDeleteTextures(1, &_texture);
}
|
#include "stdafx.h"
#include "Ship.h"
Ship::Ship()
{
}
Ship::~Ship()
{
}
HRESULT Ship::Init(const char * imageName, int x, int y)
{
_image = IMAGE->FindImage(imageName);
_x = x;
_y = y;
_angle = 0.0f;
_rc = RectMakeCenter(
_x, _y, _image->GetFrameWidth(), _image->GetFrameHeight());
_speed = 0;
_radius = _image->GetFrameHeight() / 2;
isDebug = false;
moveSound.push_back("battle_move1");
moveSound.push_back("battle_move2");
moveSound.push_back("battle_move3");
moveSound.push_back("battle_move4");
soundIndex = 0;
_destX = _x;
_destY = _y;
_newAngle = 0.0f;
_maxSpeed = 1;
return S_OK;
}
void Ship::Release()
{
}
void Ship::Update()
{
KeyControl();
Move();
if (INPUT->GetKeyDown(VK_SHIFT))
isDebug = !isDebug;
}
void Ship::Render()
{
Draw();
}
void Ship::Draw()
{
_image->FrameRender(GetMemDC(), _rc.left, _rc.top);
if (isDebug) {
char str[128];
sprintf_s(str, "%d도 %3.2f", int(_angle * 180 / M_PI), _speed);
TextOut(GetMemDC(), _rc.left, _rc.top - 15, str, strlen(str));
sprintf_s(str, "new %d도 %3.2f", int(_newAngle * 180 / M_PI), _speed);
TextOut(GetMemDC(), _rc.left, _rc.top - 30, str, strlen(str));
}
}
void Ship::KeyControl()
{
//if (INPUT->GetKey(VK_LEFT)) _angle += 0.04f;
//if (INPUT->GetKey(VK_RIGHT)) _angle -= 0.04f;
//if (INPUT->GetKey(VK_UP)) _speed += 0.04f;
//if (INPUT->GetKey(VK_DOWN)) _speed -= 0.04f;
if (INPUT->GetKeyDown(VK_LBUTTON)) {
SOUND->Play(moveSound[soundIndex++], 0.5f);
if (soundIndex == moveSound.size())
soundIndex = 0;
_destX = g_ptMouse.x;
_destY = g_ptMouse.y;
_newAngle = GetAngle(_x, _y, _destX, _destY);
}
// test
//if (INPUT->GetKeyDown(VK_SPACE)) {
// SOUND->Play(moveSound[soundIndex++], 0.5f);
// if (soundIndex == moveSound.size())
// soundIndex = 0;
//}
}
void Ship::Move()
{
int frame;
float angle;
if (_angle <= 0) _angle += M_PI * 2;
if (_angle >= M_PI * 2) _angle -= M_PI * 2;
if (_newAngle <= 0) _newAngle += M_PI * 2;
if (_newAngle >= M_PI * 2) _newAngle -= M_PI * 2;
if (_newAngle > _angle) {
if (_newAngle - _angle < _angle + M_PI * 2 - _newAngle) {
if (_newAngle - _angle > 0.04f)
_angle += 0.08f;
else
_angle = _newAngle;
}
else {
if (_angle + M_PI * 2 - _newAngle > 0.04f)
_angle -= 0.08f;
else
_angle = _newAngle;
}
}
if (_newAngle < _angle) {
if (_angle - _newAngle < _newAngle + M_PI * 2 - _angle) {
if (_angle - _newAngle > 0.04f)
_angle -= 0.08f;
else
_angle = _newAngle;
}
else {
if (_newAngle + M_PI * 2 - _angle > 0.04f)
_angle += 0.08f;
else
_angle = _newAngle;
}
}
if (_newAngle == _angle) {
int dist = GetDistance(_x, _y, _destX, _destY);
if (dist > 5) {
_speed += 0.04;
if (_speed > _maxSpeed)
_speed = _maxSpeed;
_speed = _maxSpeed;
}
else {
_x = _destX;
_y = _destY;
_speed = 0;
}
}
else
_speed = 0;
// 각도 (프레임 계산 해줄)
// 각도는 현재 각도에서 16등분 할꺼
angle = _angle + (M_PI / 16);
frame = int(angle / (M_PI / 8));
if (frame == 16) frame = 0;
_image->SetFrameX(frame);
float elapsedTime = FRAME->GetElapsedTime();
float moveSpeed = elapsedTime * 100;
_x += cosf(_angle) * _speed * moveSpeed;
_y -= sinf(_angle) * _speed * moveSpeed;
_rc = RectMakeCenter(
_x, _y, _image->GetFrameWidth(), _image->GetFrameHeight());
}
|
#include "Player.h"
#include <iostream>
using namespace std;
Player::Player()
{
x=1;
y=1;
}
void Player::CallInput()
{
char UserInput = ' ';
cin >>UserInput;
switch(UserInput)
{
case 'w':
lastY=y;
y=y-1;
break;
lastX=x;
case 'd':
x=x+1;
break;
lastY=y;
case 's':
y=y+1;
break;
lastX=x;
case 'a':
x=x-1;
break;
}
cout<<"mi jugador esta en la cordenada: "<<x<<","<<y<<endl;
}
void Player::ResetToSafePosition()
{
x=lastX;
y=lastY;
}
|
#include <armadillo>
#include <iostream>
#include "base.h"
using namespace std;
using namespace arma;
double Ls(mat X, mat y, mat theta)
{
double loss = 0;
mat t = X * theta;
int n = X.n_rows;
for (int i = 0; i < n; i++) {
if (y[i] * t[i] < 0)
loss++;
}
return loss / n;
}
void perceptron(const mat X, const mat y, mat& theta, int Tmax = 100, string costs_file = "costs.out",
string parameters_file = "parameters.out")
{
int t = 1 , n = X.n_cols;
theta.reshape(n, 1);
theta.zeros();
double l;
double e = Ls(X, y, theta) ;
vector<double> J_history = {e} ;
for (int t = 0; t <= Tmax ; t++)
{
for (int i = 1; i <= n; i++)
{
mat p = theta.t() * X(i);
if (p[0]*y[i] < 0)
{
theta = theta + y[i] * X(i);
t++;
}
}
l = Ls(X, y, theta);
J_history.push_back(l);
}
ofstream f;
f = ofstream(costs_file);
for (const auto &e : J_history) f << e << " ";
f = ofstream(parameters_file);
for (const auto &e : theta) f << e << " ";
}
|
/**
* @file antiBomb.cpp
* @brief Contém a implementação de um anti fork bomba
*/
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include <cstdlib>
#include <cstring>
#include <unistd.h> /// fork()
using namespace std;
int main() {
std::ifstream processLog;
std::map <std::string, std::string> mapPid;
std::map <std::string, int> mapCounter;
int processLimit = 0;
std::cout << "set the number of processes supported by the program: ";
std::cin >> processLimit;
std::cout << "List of dead process: " << std::endl;
while (1) {
/** ps -ec é o comando linux que lista todas as informações do
* agendador de processos. Além disso, awk o comando é para
* manipular arquivos de texto formatados de maneira previsível,
* no nosso caso, utilizamos para selecionar as colunas 1(PID)
* e 6(CMD) e pular o cabeçalho (if (NR!=1)).
*/
std::system("ps -e |awk '{if (NR!=1) print $1,$4 }'> process.log");
processLog.open("process.log");
if (processLog.is_open()) {
std::string processName, pid;
// Lê a primeira string e carrega para a variável pid.
while (processLog >> pid) {
// Lê a segunda string e carrega para a variável processName.
processLog >> processName;
// Salva as strings nos mapas.
++mapCounter[processName];
mapPid[pid] = processName;
}
processLog.close();
// Faz uma varredura para encontrar algum nome com muitos processos associados
/** Com a lista de processos lida, o próximo passo é encontrar programas que
* possívelmente seja um forkbomb.
*/
for (std::map<std::string, int>::iterator iter = mapCounter.begin();
iter != mapCounter.end(); ++iter)
{
// Verifica se o processo está no limite. Caso não esteja ele será eliminado.
if(iter->second > processLimit) {
bool starting = 1;
int pidPai, aux;
// Procura o processo pai para eliminar.
for (std::map<std::string, std::string>::iterator iter2 = mapPid.begin();
iter2 != mapPid.end(); ++iter2)
{
if (iter->first.compare(iter2->second) == 0)
{
if (starting)
{
pidPai = std::stoi(iter2->first);
starting = false;
}
else
{
aux = std::stoi(iter2->first);
if (pidPai > aux && aux > 1)
{
pidPai = aux;
}
}
}
}
/** Matar a árvore de processos relacionada ao pidPai
* http://fibrevillage.com/sysadmin/237-ways-to-kill-parent-and-child-processes-in-one-command
*/
std::string killProcessTree = "kill -9 -$(ps -o pgid= " +
std::to_string(pidPai) + " | grep -o '[0-9]*')";
std::system(killProcessTree.c_str());
std::cout <<"PID: " << pidPai << ";name: " << mapPid[std::to_string(pidPai)]
<< "; number of children:"<< std::to_string(iter->second) <<std::endl;
usleep(1000000);
}
}
mapCounter.clear();
mapPid.clear();
}
else {
std::cout << "Could not open file!!!!! ";
exit(-1);
}
usleep(1000000);
}
return 0;
}
|
/**
\file yellowDetector.cpp
\author UnBeatables
\date LARC2018
\name yellowDetector
*/
#include "yellowDetector.hpp"
#define DEBUG_PERCEPTION 0
void YellowDetector::run(cv::Mat topImg, cv::Mat goalImg, PerceptionData *data)
{
cv::Mat src = topImg.clone();
//Yellow HSL values range definitions
int iLowH = 22;
int iHighH = 29;
int iLowS = 100;
int iHighS = 255;
int iLowV = 100;
int iHighV = 255;
//Variables initialization
cv::Mat src_HSV;
std::vector<std::vector<cv::Point> > contours;
int thresh=100;
std::vector<cv::Vec4i> hierarchy;
//Color transformations
cv::cvtColor(src, src_HSV, cv::COLOR_BGR2HSV);
cv::blur(src_HSV, src_HSV, cv::Size(2,2));
cv::inRange(src_HSV, cv::Scalar(iLowH, iLowS, iLowV), cv::Scalar(iHighH, iHighS, iHighV), src_HSV);
//Morphological transformations
cv::Mat element = cv::getStructuringElement( 0, cv::Size( 3, 3 ), cv::Point( 1, 1 ) );
cv::erode(src_HSV, src_HSV, element);
cv::dilate( src_HSV, src_HSV, cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5)) );
cv::erode(src_HSV, src_HSV, element);
//Edge and Contours detections
cv::Canny( src_HSV, src_HSV, thresh, thresh*2, 3 );
cv::findContours( src_HSV, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) );
//Variables initialization
cv::vector<cv::vector<cv::Point> > contours_poly( contours.size() );
cv::Rect boundRect;
this->distance = -1;
int n_bound = 0;
#ifdef DEBUG_PERCEPTION
//Auxiliar variables for drawing initialization
cv::RNG rng(12345);
cv::Mat drawing = cv::Mat::zeros( src_HSV.size(), CV_8UC3 );
cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
#endif
float avgx = 0;
float avgy = 0;
for( std::size_t i = 0; i < contours.size(); i++ )
{
//Creates bounding rectangle for each contour
cv::approxPolyDP( cv::Mat(contours[i]), contours_poly[i], 3, true );
boundRect = cv::boundingRect( cv::Mat(contours_poly[i]) );
//Excludes too small, big, narrow and wide candidates
if (boundRect.y < 100)
continue;
if (boundRect.height < 40)
continue;
if ( boundRect.height > 2*boundRect.width )
continue;
if (2*boundRect.height < boundRect.width)
continue;
#ifdef DEBUG_PERCEPTION
//Draws valid bounding rectangle
cv::drawContours( drawing, contours_poly, i, color, 1, 8, cv::vector<cv::Vec4i>(), 0, cv::Point() );
//std::cout << "teste " << "height " << boundRect.height << std::endl;
#endif
//this->distance += 58.8 -0.165 * boundRect.height + 0.000128 * boundRect.height * boundRect.height;
this->distance += 948 - 47.2 * boundRect.height + 0.642 * boundRect.height * boundRect.height;
//this->distance += -10 * boundRect.height + 466;
avgx += boundRect.x;
avgy += boundRect.y;
n_bound++;
}
if(n_bound)
{
this->distance=this->distance/n_bound;
avgx =avgx / n_bound;
avgy = avgy / n_bound;
}
#ifdef DEBUG_PERCEPTION
//std::cout << "teste "<<"distance: " << this->distance <<std::endl ;
cv::imwrite("Contornos.jpg", drawing);
#endif
avgy = 687 - avgy;
avgx = 160 - avgx;
float ratio = avgx / avgy;
this->angle = 2 * (ratio - ratio*ratio*ratio/3 + ratio*ratio*ratio*ratio*ratio/5);
updateData(data);
}
void YellowDetector::updateData(PerceptionData *data)
{
//data->yellowCenter = this->mc;
data->approxDistance = this->distance;
data->approxAngle = this->angle;
}
int YellowDetector::getDistance()
{
return this->distance;
}
|
#include "net/server.hpp"
#include "net/client.hpp"
#include "net/stream.hpp"
#include "net/conn.hpp"
#include "net/log.hpp"
#include "utils/service_thread.hpp"
#include <cppunit/extensions/HelperMacros.h>
#include <condition_variable>
#include <mutex>
namespace nora {
namespace test {
class mock_user {
public:
mock_user(const string& name) : name_(name), st_(make_shared<service_thread>("nettest-mockuser")), error_(false) {
st_->start();
TLOG << name_ << " created";
}
void stop() {
if (conn_) {
conn_->cancel();
conn_.reset();
}
st_->stop();
}
shared_ptr<service_thread> get_st() {
return st_;
}
void set_conn(const shared_ptr<net::CONN>& conn) {
conn_ = conn;
}
void reset_conn() {
conn_.reset();
}
shared_ptr<net::CONN> get_conn() {
return conn_;
}
void recv_msg(const shared_ptr<net::recvstream>& msg) {
*msg >> msg_;
}
const string& msg() const {
return msg_;
}
void set_error() {
if (conn_) {
conn_->cancel();
conn_.reset();
}
error_ = true;
}
bool error() const {
return error_;
}
private:
const string name_;
shared_ptr<service_thread> st_;
shared_ptr<net::CONN> conn_;
string msg_;
bool error_;
};
class net_test : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(net_test);
CPPUNIT_TEST(test_connect);
CPPUNIT_TEST(test_server_send);
CPPUNIT_TEST(test_client_send);
CPPUNIT_TEST(test_server_disconnect);
CPPUNIT_TEST(test_client_disconnect);
CPPUNIT_TEST_SUITE_END();
public:
void setUp() override;
void tearDown() override;
void test_connect();
void test_server_send();
void test_client_send();
void test_server_disconnect();
void test_client_disconnect();
private:
shared_ptr<net::server<net::CONN>> nsv_;
unique_ptr<mock_user> su_;
shared_ptr<net::client<net::CONN>> ncl_;
unique_ptr<mock_user> cu_;
};
CPPUNIT_TEST_SUITE_REGISTRATION(net_test);
void net_test::setUp() {
init_log("net_test", pc::options::ERROR);
nsv_ = make_shared<net::server<net::CONN>>("nettest-server");
su_ = make_unique<mock_user>("nettest-setver-mockuser");
ncl_ = make_shared<net::client<net::CONN>>("nettest-client");
cu_ = make_unique<mock_user>("nettest-client-mockuser");
mutex sm;
condition_variable scv;
nsv_->new_conn_cb_ = [this, &sm, &scv] (const auto& c) -> shared_ptr<service_thread> {
{
lock_guard<mutex> lk(sm);
su_->set_conn(c);
}
scv.notify_one();
return su_->get_st();
};
nsv_->msg_cb_ = [this] (const auto& c, const auto& msg) { su_->recv_msg(msg); };
nsv_->error_cb_ = [this] (const auto& c) { su_->set_error(); };
mutex cm;
condition_variable ccv;
ncl_->new_conn_cb_ = [this, &cm, &ccv] (const auto& c) -> shared_ptr<service_thread> {
{
lock_guard<mutex> lk(cm);
cu_->set_conn(c);
}
ccv.notify_one();
return cu_->get_st();
};
ncl_->msg_cb_ = [this] (const auto& c, const auto& msg) { cu_->recv_msg(msg); };
ncl_->error_cb_ = [this] (const auto& c) { cu_->set_error(); };
nsv_->start();
ncl_->start();
nsv_->listen("127.0.0.1", 6017);
this_thread::sleep_for(200ms);
ncl_->connect("127.0.0.1", 6017);
unique_lock<mutex> slk(sm);
scv.wait(slk, [this] { return su_->get_conn(); });
unique_lock<mutex> clk(cm);
ccv.wait(clk, [this] { return cu_->get_conn(); });
this_thread::sleep_for(200ms);
}
void net_test::tearDown() {
if (cu_) {
cu_->stop();
cu_.reset();
}
if (su_) {
su_->stop();
su_.reset();
}
if (nsv_) {
nsv_->stop();
nsv_.reset();
}
if (ncl_) {
ncl_->stop();
ncl_.reset();
}
}
void net_test::test_connect() {
CPPUNIT_ASSERT(su_->get_conn());
CPPUNIT_ASSERT(cu_->get_conn());
}
void net_test::test_server_send() {
auto ss = make_shared<net::sendstream>();
*ss << "hello";
nsv_->send(su_->get_conn(), ss);
this_thread::sleep_for(200ms);
CPPUNIT_ASSERT_EQUAL(string("hello"), cu_->msg());
}
void net_test::test_client_send() {
auto ss = make_shared<net::sendstream>();
*ss << "hello";
ncl_->send(cu_->get_conn(), ss);
this_thread::sleep_for(200ms);
CPPUNIT_ASSERT_EQUAL(string("hello"), su_->msg());
}
void net_test::test_server_disconnect() {
nsv_->disconnect(su_->get_conn());
su_->reset_conn();
this_thread::sleep_for(1200ms);
CPPUNIT_ASSERT(cu_->error());
CPPUNIT_ASSERT_EQUAL(0ul, nsv_->conn_count());
CPPUNIT_ASSERT_EQUAL(0ul, ncl_->conn_count());
}
void net_test::test_client_disconnect() {
ncl_->disconnect(cu_->get_conn());
cu_->reset_conn();
this_thread::sleep_for(200ms);
CPPUNIT_ASSERT(su_->error());
CPPUNIT_ASSERT_EQUAL(0ul, nsv_->conn_count());
CPPUNIT_ASSERT_EQUAL(0ul, ncl_->conn_count());
}
}
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4; c-file-style: "stroustrup" -*-
*
* Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*/
#include "core/pch.h"
#include "modules/logdoc/src/html5/html5attrcopy.h"
#include "modules/logdoc/src/html5/html5attr.h"
#include "modules/logdoc/src/html5/html5tokenbuffer.h"
HTML5AttrCopy::~HTML5AttrCopy()
{
OP_DELETEA(m_value);
}
void HTML5AttrCopy::CopyL(HTML5Attr *src)
{
m_name.CopyL(src->GetName());
unsigned dummy;
src->GetValue().GetBufferL(m_value, dummy, TRUE);
m_ns = Markup::HTML;
}
void HTML5AttrCopy::CopyL(HTML5AttrCopy *src)
{
m_name.CopyL(src->GetName());
uni_char *tmp = src->GetValue();
if (tmp)
LEAVE_IF_ERROR(UniSetStrN(m_value, tmp, uni_strlen(tmp)));
else
m_value = NULL;
m_ns = src->m_ns;
}
void HTML5AttrCopy::SetNameL(const uni_char* name, unsigned length)
{
m_name.Clear();
m_name.AppendL(name, length);
}
void HTML5AttrCopy::SetNameL(HTML5TokenBuffer *name)
{
m_name.CopyL(name);
}
void HTML5AttrCopy::SetValueL(const uni_char* value, unsigned length)
{
LEAVE_IF_ERROR(UniSetStrN(m_value, value, length));
}
BOOL HTML5AttrCopy::IsEqual(HTML5Attr *attr)
{
if (uni_strncmp(m_name.GetBuffer(), attr->GetNameStr(), m_name.Length()) != 0)
return FALSE;
return attr->GetValue().Matches(m_value, FALSE);
}
|
#pragma once
#include <YouMeCommon/CrossPlatformDefine/PlatformDef.h>
/************************************************************************/
/*
g_mapLanguage["en"] = __XT("英语+英国");
g_mapLanguage["en-us"] = __XT("英语+美国");
g_mapLanguage["ar"] = __XT("阿拉伯语+");
g_mapLanguage["ar-ae"] = __XT("阿拉伯语+阿拉伯联合酋长国");
g_mapLanguage["ar-bh"] = __XT("阿拉伯语+巴林");
g_mapLanguage["ar-dz"] = __XT("阿拉伯语+阿尔及利亚");
g_mapLanguage["ar-eg"] = __XT("阿拉伯语+埃及");
g_mapLanguage["ar-iq"] = __XT("阿拉伯语+伊拉克");
g_mapLanguage["ar-jo"] = __XT("阿拉伯语+约旦");
g_mapLanguage["ar-kw"] = __XT("阿拉伯语+科威特");
g_mapLanguage["ar-lb"] = __XT("阿拉伯语+黎巴嫩");
g_mapLanguage["ar-ly"] = __XT("阿拉伯语+利比亚");
g_mapLanguage["ar-ma"] = __XT("阿拉伯语+摩洛哥");
g_mapLanguage["ar-om"] = __XT("阿拉伯语+阿曼");
g_mapLanguage["ar-qa"] = __XT("阿拉伯语+卡塔尔");
g_mapLanguage["ar-sa"] = __XT("阿拉伯语+沙特阿拉伯");
g_mapLanguage["ar-sd"] = __XT("阿拉伯语+苏丹");
g_mapLanguage["ar-sy"] = __XT("阿拉伯语+叙利亚");
g_mapLanguage["ar-tn"] = __XT("阿拉伯语+突尼斯");
g_mapLanguage["ar-ye"] = __XT("阿拉伯语+也门");
g_mapLanguage["be"] = __XT("白俄罗斯语+");
g_mapLanguage["be-by"] = __XT("白俄罗斯语+白俄罗斯");
g_mapLanguage["bg"] = __XT("保加利亚语+");
g_mapLanguage["bg-bg"] = __XT("保加利亚语+保加利亚");
g_mapLanguage["ca"] = __XT("加泰罗尼亚语+");
g_mapLanguage["ca-es"] = __XT("加泰罗尼亚语+西班牙");
g_mapLanguage["ca-es-euro"] = __XT("加泰罗尼亚语+西班牙,euro");
g_mapLanguage["cs"] = __XT("捷克语+");
g_mapLanguage["cs-cz"] = __XT("捷克语+捷克共和国");
g_mapLanguage["da"] = __XT("丹麦语+");
g_mapLanguage["da-dk"] = __XT("丹麦语+丹麦");
g_mapLanguage["de"] = __XT("德语+");
g_mapLanguage["de-at"] = __XT("德语+奥地利");
g_mapLanguage["de-at-euro"] = __XT("德语+奥地利,euro");
g_mapLanguage["de-ch"] = __XT("德语+瑞士");
g_mapLanguage["de-de"] = __XT("德语+德国");
g_mapLanguage["de-de-euro"] = __XT("德语+德国,euro");
g_mapLanguage["de-lu"] = __XT("德语+卢森堡");
g_mapLanguage["de-lu-euro"] = __XT("德语+卢森堡,euro");
g_mapLanguage["el"] = __XT("希腊语+");
g_mapLanguage["el-gr"] = __XT("希腊语+希腊");
g_mapLanguage["en-au"] = __XT("英语+澳大利亚");
g_mapLanguage["en-ca"] = __XT("英语+加拿大");
g_mapLanguage["en-gb"] = __XT("英语+英国");
g_mapLanguage["en-ie"] = __XT("英语+爱尔兰");
g_mapLanguage["en-ie-euro"] = __XT("英语+爱尔兰,euro");
g_mapLanguage["en-nz"] = __XT("英语+新西兰");
g_mapLanguage["en-za"] = __XT("英语+南非");
g_mapLanguage["es"] = __XT("西班牙语+");
g_mapLanguage["es-bo"] = __XT("西班牙语+玻利维亚");
g_mapLanguage["es-ar"] = __XT("西班牙语+阿根廷");
g_mapLanguage["es-cl"] = __XT("西班牙语+智利");
g_mapLanguage["es-co"] = __XT("西班牙语+哥伦比亚");
g_mapLanguage["es-cr"] = __XT("西班牙语+哥斯达黎加");
g_mapLanguage["es-do"] = __XT("西班牙语+多米尼加共和国");
g_mapLanguage["es-ec"] = __XT("西班牙语+厄瓜多尔");
g_mapLanguage["es-es"] = __XT("西班牙语+西班牙");
g_mapLanguage["es-es-euro"] = __XT("西班牙语+西班牙,euro");
g_mapLanguage["es-gt"] = __XT("西班牙语+危地马拉");
g_mapLanguage["es-hn"] = __XT("西班牙语+洪都拉斯");
g_mapLanguage["es-mx"] = __XT("西班牙语+墨西哥");
g_mapLanguage["es-ni"] = __XT("西班牙语+尼加拉瓜");
g_mapLanguage["et"] = __XT("爱沙尼亚语+");
g_mapLanguage["es-pa"] = __XT("西班牙语+巴拿马");
g_mapLanguage["es-pe"] = __XT("西班牙语+秘鲁");
g_mapLanguage["es-pr"] = __XT("西班牙语+波多黎哥");
g_mapLanguage["es-py"] = __XT("西班牙语+巴拉圭");
g_mapLanguage["es-sv"] = __XT("西班牙语+萨尔瓦多");
g_mapLanguage["es-uy"] = __XT("西班牙语+乌拉圭");
g_mapLanguage["es-ve"] = __XT("西班牙语+委内瑞拉");
g_mapLanguage["et-ee"] = __XT("爱沙尼亚语+爱沙尼亚");
g_mapLanguage["fi"] = __XT("芬兰语+");
g_mapLanguage["fi-fi"] = __XT("芬兰语+芬兰");
g_mapLanguage["fi-fi-euro"] = __XT("芬兰语+芬兰,euro");
g_mapLanguage["fr"] = __XT("法语+");
g_mapLanguage["fr-be"] = __XT("法语+比利时");
g_mapLanguage["fr-be-euro"] = __XT("法语+比利时,euro");
g_mapLanguage["fr-ca"] = __XT("法语+加拿大");
g_mapLanguage["fr-ch"] = __XT("法语+瑞士");
g_mapLanguage["fr-fr"] = __XT("法语+法国");
g_mapLanguage["fr-fr-euro"] = __XT("法语+法国,euro");
g_mapLanguage["fr-lu"] = __XT("法语+卢森堡");
g_mapLanguage["fr-lu-euro"] = __XT("法语+卢森堡,euro");
g_mapLanguage["hr"] = __XT("克罗地亚语+");
g_mapLanguage["hr-hr"] = __XT("克罗地亚语+克罗地亚");
g_mapLanguage["hu"] = __XT("匈牙利语+");
g_mapLanguage["hu-hu"] = __XT("匈牙利语+匈牙利");
g_mapLanguage["is"] = __XT("冰岛语+");
g_mapLanguage["is-is"] = __XT("冰岛语+冰岛");
g_mapLanguage["it"] = __XT("意大利语+");
g_mapLanguage["it-ch"] = __XT("意大利语+瑞士");
g_mapLanguage["it-it"] = __XT("意大利语+意大利");
g_mapLanguage["it-it-euro"] = __XT("意大利语+意大利,euro");
g_mapLanguage["iw"] = __XT("希伯来语+");
g_mapLanguage["iw-il"] = __XT("希伯来语+以色列");
g_mapLanguage["ja"] = __XT("日语+");
g_mapLanguage["ja-jp"] = __XT("日语+日本");
g_mapLanguage["ko"] = __XT("朝鲜语+");
g_mapLanguage["ko-kr"] = __XT("朝鲜语+南朝鲜");
g_mapLanguage["lt"] = __XT("立陶宛语+");
g_mapLanguage["lt-lt"] = __XT("立陶宛语+立陶宛");
g_mapLanguage["lv"] = __XT("拉托维亚语+列托");
g_mapLanguage["lv-lv"] = __XT("拉托维亚语+列托");
g_mapLanguage["mk"] = __XT("马其顿语+");
g_mapLanguage["mk-mk"] = __XT("马其顿语+马其顿王国");
g_mapLanguage["nl"] = __XT("荷兰语+");
g_mapLanguage["nl-be"] = __XT("荷兰语+比利时");
g_mapLanguage["nl-be-euro"] = __XT("荷兰语+比利时,euro");
g_mapLanguage["nl-nl"] = __XT("荷兰语+荷兰");
g_mapLanguage["nl-nl-euro"] = __XT("荷兰语+荷兰,euro");
g_mapLanguage["no"] = __XT("挪威语+");
g_mapLanguage["no-no"] = __XT("挪威语+挪威");
g_mapLanguage["no-no-ny"] = __XT("挪威语+挪威,nynorsk");
g_mapLanguage["pl"] = __XT("波兰语+");
g_mapLanguage["pl-pl"] = __XT("波兰语+波兰");
g_mapLanguage["pt"] = __XT("葡萄牙语+");
g_mapLanguage["pt-br"] = __XT("葡萄牙语+巴西");
g_mapLanguage["pt-pt"] = __XT("葡萄牙语+葡萄牙");
g_mapLanguage["pt-pt-euro"] = __XT("葡萄牙语+葡萄牙,euro");
g_mapLanguage["ro"] = __XT("罗马尼亚语+");
g_mapLanguage["ro-ro"] = __XT("罗马尼亚语+罗马尼亚");
g_mapLanguage["ru"] = __XT("俄语+");
g_mapLanguage["ru-ru"] = __XT("俄语+俄罗斯");
g_mapLanguage["sh"] = __XT("塞波尼斯-克罗地亚语+");
g_mapLanguage["sh-yu"] = __XT("塞波尼斯-克罗地亚语+南斯拉夫");
g_mapLanguage["sk"] = __XT("斯洛伐克语+");
g_mapLanguage["sk-sk"] = __XT("斯洛伐克语+斯洛伐克");
g_mapLanguage["sl"] = __XT("斯洛语尼亚语+");
g_mapLanguage["sl-si"] = __XT("斯洛语尼亚语+斯洛文尼亚");
g_mapLanguage["sq"] = __XT("阿尔巴尼亚语+");
g_mapLanguage["sq-al"] = __XT("阿尔巴尼亚语+阿尔巴尼亚");
g_mapLanguage["sr"] = __XT("塞尔维亚语+");
g_mapLanguage["sr-yu"] = __XT("塞尔维亚语+南斯拉夫");
g_mapLanguage["sv"] = __XT("瑞典语+");
g_mapLanguage["sv-se"] = __XT("瑞典语+瑞典");
g_mapLanguage["th"] = __XT("泰语+");
g_mapLanguage["th-th"] = __XT("泰语+泰国");
g_mapLanguage["tr"] = __XT("土耳其语+");
g_mapLanguage["tr-tr"] = __XT("土耳其语+土耳其");
g_mapLanguage["uk"] = __XT("乌克兰语+");
g_mapLanguage["uk-ua"] = __XT("乌克兰语+乌克兰");
g_mapLanguage["zh"] = __XT("汉语+");
g_mapLanguage["zh-cn"] = __XT("汉语+中国");
g_mapLanguage["zh-hk"] = __XT("汉语+香港");
g_mapLanguage["zh-tw"] = __XT("汉语+台湾"); */
/************************************************************************/
class CTranslateUtil
{
public:
void Init(const XString& strDomain,const XString& strCigPath,const XString& strRegex);
//如果元语言制定 auto的话，后面会返回识别出来的元语言
XString Translate(const XString& strSrc,const XString&strOrigLanguage, const XString& strDestLanguage,XString& strOrigLanguageRet);
private:
int GetTKK(const std::string& strSrc);
void GetTk(const std::string& strSrc, std::string& strTk);
XINT64 GetMagic(XINT64 ullMagic, const std::string& strExpr);
XString m_strDomain;
XString m_strTranslateURL;
std::string m_strRegex;
//需要保存的tkk 参数
XINT64 m_ullFirstTKK;
XINT64 m_ullSecondTKK;
};
|
// -*- Mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
//
// Copyright (C) Opera Software AS. All rights reserved.
//
// This file is part of the Opera web browser. It may not be distributed
// under any circumstances.
#ifndef WEBFEED_PARSESTATES_H
#define WEBFEED_PARSESTATES_H
#include "modules/webfeeds/src/xmlelement.h"
#ifdef WEBFEEDS_BACKEND_SUPPORT
class WebFeedParser;
class RSSContext;
class AtomContext;
class XMLAttributeQN;
class WebFeedContentElement;
class WebFeedLinkElement;
class WebFeedPersonElement;
// ***************************************************************************
//
// WebFeedParseState
//
// ***************************************************************************
class WebFeedParseState
{
public:
// Destruction.
virtual ~WebFeedParseState() {};
// State types.
enum StateType
{
StateUnknown,
StateInitial,
StateDone,
// RSS states.
StateRSSRoot,
StateRSSChannel,
StateRSSItem,
StateRSSImage,
// Atom states.
StateAtomRoot,
StateAtomAuthor,
StateAtomEntry
};
// Virtual Methods.
virtual StateType Type() const { return StateUnknown; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state) { return OpStatus::OK; }
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state) { return OpStatus::OK; }
// Context info for the feed, that the states can use.
class WebFeedContext
{
public:
// Methods.
RSSContext& AsRSSContext();
const RSSContext& AsRSSContext() const;
AtomContext& AsAtomContext();
const AtomContext& AsAtomContext() const;
protected:
// Construction.
WebFeedContext() { }
private:
// No copy or assignment.
WebFeedContext(const WebFeedContext& other);
WebFeedContext& operator=(const WebFeedContext& other);
};
// Methods.
UINT AncestorCount() { return m_ancestor_count; }
void UpdateAncestorCount(UINT ancestor_count) { m_ancestor_count = ancestor_count; }
void SetContext(WebFeedContext* context) { m_context = context; }
// TODO: check memory allocation
OpAutoPtr<WebFeedContext> ReleaseContext() { return m_context; }
BOOL HasContext() const { return m_context.get() != NULL; }
WebFeedContext& Context() { return *m_context; }
const WebFeedContext& Context() const { return *m_context; }
protected:
// Construction.
WebFeedParseState(WebFeedParser& parser);
// Parser access.
WebFeedParser& Parser() { return m_parser; }
const WebFeedParser& Parser() const { return m_parser; }
private:
// No copy or assignment.
WebFeedParseState(const WebFeedParseState& other);
WebFeedParseState& operator=(const WebFeedParseState& other);
// Members.
WebFeedParser& m_parser;
OpAutoPtr<WebFeedContext> m_context;
UINT m_ancestor_count;
};
// ***************************************************************************
//
// InitialFeedParseState
//
// ***************************************************************************
class InitialFeedParseState
: public WebFeedParseState
{
public:
// Construction.
InitialFeedParseState(WebFeedParser& parser);
~InitialFeedParseState() {}
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateInitial; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
};
// ***************************************************************************
//
// RSSParseStateBase
//
// ***************************************************************************
class RSSParseStateBase
: public WebFeedParseState
{
protected:
// Construction.
RSSParseStateBase(WebFeedParser& parser);
~RSSParseStateBase() {}
// Methods.
OP_STATUS UpdateContentElement(WebFeedContentElement& element, const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN>& attributes);
OP_STATUS UpdateContentElementValue(WebFeedContentElement& element);
OP_STATUS UpdateAuthorInfo(WebFeedPersonElement& author);
};
// ***************************************************************************
//
// RSSRootParseState
//
// ***************************************************************************
class RSSRootParseState
: public RSSParseStateBase
{
public:
// Construction.
RSSRootParseState(WebFeedParser& parser);
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateRSSRoot; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
};
// ***************************************************************************
//
// RSSChannelParseState
//
// ***************************************************************************
class RSSChannelParseState
: public RSSParseStateBase
{
public:
// Construction.
RSSChannelParseState(WebFeedParser& parser);
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateRSSChannel; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
};
// ***************************************************************************
//
// RSSItemParseState
//
// ***************************************************************************
class RSSItemParseState
: public RSSParseStateBase
{
public:
// Construction / destruction.
RSSItemParseState(WebFeedParser& parser);
OP_STATUS Init();
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateRSSItem; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
// Methods.
OP_STATUS ItemLink(WebFeedLinkElement*& link);
// Members.
BOOL3 m_guid_is_permalink;
BOOL m_have_good_author_info;
BOOL m_have_xml_content;
};
// ***************************************************************************
//
// RSSImageParseState
//
// ***************************************************************************
class RSSImageParseState
: public RSSParseStateBase
{
public:
// Construction / destruction.
RSSImageParseState(WebFeedParser& parser, StateType previous_state);
OP_STATUS Init();
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateRSSImage; }
// We maybe should do something more useful for image. But for now we ignore it, and only look for the closing </image> tag. But at least its elements won't interfere with the similarily names elements in channel/item
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state) { return OpStatus::OK; }
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
StateType m_previous_state;
};
// ***************************************************************************
//
// AtomParseStateBase
//
// ***************************************************************************
class AtomParseStateBase
: public WebFeedParseState
{
protected:
// Construction.
AtomParseStateBase(WebFeedParser& parser);
// Enum describing the mode a content construct is stored in.
enum ContentMode
{
ContentUnknown,
ContentXML,
ContentEscaped,
ContentBase64,
ContentText
};
// Methods.
OP_STATUS UpdateContentConstruct(WebFeedContentElement& element, const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN>& attributes);
OP_STATUS UpdateContentConstructValue(WebFeedContentElement& element);
OP_STATUS UpdateLinkElement(WebFeedLinkElement& link, OpAutoStringHashTable<XMLAttributeQN>& attributes);
private:
// Members.
ContentMode m_content_mode;
};
// ***************************************************************************
//
// AtomRootParseState
//
// ***************************************************************************
class AtomRootParseState
: public AtomParseStateBase
{
public:
// Construction.
AtomRootParseState(WebFeedParser& parser);
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateAtomRoot; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
// Methods.
OP_STATUS HandleLinkElement(WebFeedLinkElement& link, OpAutoStringHashTable<XMLAttributeQN>& attributes);
};
// ***************************************************************************
//
// AtomAuthorParseState
//
// ***************************************************************************
class AtomAuthorParseState
: public AtomParseStateBase
{
public:
// Construction.
AtomAuthorParseState(WebFeedParser& parser, WebFeedPersonElement& author, StateType previous_state);
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateAtomAuthor; }
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
// Members.
WebFeedPersonElement& m_author;
StateType m_previous_state;
};
// ***************************************************************************
//
// AtomEntryParseState
//
// ***************************************************************************
class AtomEntryParseState
: public AtomParseStateBase
{
public:
// Construction.
AtomEntryParseState(WebFeedParser& parser);
OP_STATUS Init();
private:
// WebFeedParseState.
virtual StateType Type() const { return WebFeedParseState::StateAtomEntry; }
virtual OP_STATUS OnStartElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, OpAutoStringHashTable<XMLAttributeQN> &attributes, StateType& next_state);
virtual OP_STATUS OnEndElement(const OpStringC& namespace_uri, const OpStringC& local_name, const OpStringC& qualified_name, StateType& next_state);
BOOL m_is_in_source_element;
// Methods.
OP_STATUS HandleLinkElement(OpAutoStringHashTable<XMLAttributeQN> &attributes);
};
#endif // WEBFEEDS_BACKEND_SUPPORT
#endif // WEBFEED_PARSESTATES_H
|
#include "HelloWorldScene.h"
#include "MapSprite.h"
USING_NS_CC;
CCScene* HelloWorld::scene()
{
CCScene *scene = CCScene::create();
HelloWorld *layer = HelloWorld::create();
scene->addChild(layer);
return scene;
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
if ( !CCLayer::init() )
{
return false;
}
CCSize size = CCDirector::sharedDirector()->getWinSize();
setTouchEnabled(true);
m_light = CCPointMake(size.width/2, size.height/2);
MapSprite* pSprite = MapSprite::create("ground", 0, this);
pSprite->setPosition(ccp(size.width/2, size.height/2));
this->addChild(pSprite);
return true;
}
void HelloWorld::ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent)
{
CCTouch* touch = (CCTouch*)pTouches->anyObject();
m_light = this->convertTouchToNodeSpace(touch);
}
|
#ifndef _MA_TYPE_MANIPULATION_H
#define _MA_TYPE_MANIPULATION_H
#include "tuple.h"
namespace ma
{
//FUNCTION TYPES
// primary template.
template<class T>
struct function_traits {};
// partial specialization for function type
template<class R, class... Args>
struct function_traits<R(Args...)> {
using result_type = R;
using argument_types = tuple<Args...>;
};
// partial specialization for function pointer
template<class R, class... Args>
struct function_traits<R(*)(Args...)> {
using result_type = R;
using argument_types = tuple<Args...>;
};
// partial specialization for std::function
//template<class R, class... Args>
//struct function_traits<std::function<R(Args...)>> {
// using result_type = R;
// using argument_types = std::tuple<Args...>;
//};
// partial specialization for pointer-to-member-function (i.e., operator()'s)
template<class T, class R, class... Args>
struct function_traits<R(T::*)(Args...)> {
using result_type = R;
using argument_types = tuple<Args...>;
};
template<class T, class R, class... Args>
struct function_traits<R(T::*)(Args...) const> {
using result_type = R;
using argument_types = tuple<Args...>;
};
template<class T>
using result_of = typename function_traits<T>::result_type;
template<class T>
using first_argument_of =
typename tuple_element<0, typename function_traits<T>::argument_types>::type;
////////// POINTERS AND REFS
template <typename T> struct remove_reference { using type = T; };
template <typename T> struct remove_reference<T&> { using type = T; };
template< typename T> struct remove_reference<T&&> { using type = T; };
template <typename T> struct remove_qualifications { using type = T; };
template <typename T> struct remove_qualifications<T&> { using type = T; };
template< typename T> struct remove_qualifications<T&&> { typedef T type; };
template< typename T> struct remove_qualifications<T*> { typedef T type; };
template< typename T> struct remove_qualifications<T* const> { typedef T type; };
template< typename T> struct remove_qualifications<T* volatile> { typedef T type; };
template< typename T> struct remove_qualifications<T* const volatile> { typedef T type; };
// ARRAY?
template <typename T> using unqualified_type = typename remove_qualifications<T>::type;
// TEMPLATE TYPES
template<typename T> struct extract_value_type { using type = T; };
template<template<typename> class X, typename T> struct extract_value_type <X<T>> { using type = T; };
template<typename T>
using first_template_parameter_of = typename extract_value_type<
unqualified_type<T>
>::type;
/////
template<class T>
using unqualified_first_argument_of = unqualified_type<
typename tuple_element<0, typename function_traits<T>::argument_types>::type
>;
}
#endif
|
#pragma once
#include <Eigen/Core>
#include <Eigen/Dense>
#include <array>
#include <chrono>
#include <iostream>
#include <memory>
#include <tuple>
// This is a base class for turning a bilinear form into an Eigen matvec.
namespace spacetime {
template <typename DblVecIn, typename DblVecOut = DblVecIn>
class BilinearFormBase;
}
// Define a necessary Eigen trait.
namespace Eigen {
namespace internal {
template <typename DblVecIn, typename DblVecOut>
struct traits<spacetime::BilinearFormBase<DblVecIn, DblVecOut>>
: public Eigen::internal::traits<Eigen::SparseMatrix<double>> {};
} // namespace internal
} // namespace Eigen
namespace spacetime {
template <typename DblVecInType, typename DblVecOutType>
class BilinearFormBase
: public Eigen::EigenBase<BilinearFormBase<DblVecInType, DblVecOutType>> {
public:
using DblVecIn = DblVecInType;
using DblVecOut = DblVecOutType;
virtual ~BilinearFormBase() {}
// These are the BilinearForm functions that must be implemented.
virtual Eigen::VectorXd Apply(const Eigen::VectorXd &v) { assert(false); }
virtual DblVecIn *vec_in() const { assert(false); }
virtual DblVecOut *vec_out() const { assert(false); }
// These are the functions that must be implemented for Eigen to work.
Eigen::Index rows() const { return vec_out()->container().size(); }
Eigen::Index cols() const { return vec_in()->container().size(); }
// Eigen related stuff.
using Scalar = double;
using RealScalar = double;
using StorageIndex = int;
enum {
ColsAtCompileTime = Eigen::Dynamic,
MaxColsAtCompileTime = Eigen::Dynamic,
IsRowMajor = false
};
template <typename Rhs>
Eigen::VectorXd operator*(const Eigen::MatrixBase<Rhs> &x) const {
return const_cast<BilinearFormBase *>(this)->Apply(x);
}
double TimeApply() const { return time_apply_.count(); };
double TimePerApply() const {
if (num_apply_ == 0) return 0;
return time_apply_.count() / num_apply_;
};
double TimeConstruct() const { return time_construct_.count(); }
protected:
// Timing debug information.
std::chrono::duration<double> time_construct_{0};
std::chrono::duration<double> time_apply_{0};
size_t num_apply_ = 0;
};
// This class represents the adjoint of a bilinear form.
template <typename BilForm>
class TransposeBilinearForm
: public BilinearFormBase<typename BilForm::DblVecOut,
typename BilForm::DblVecIn> {
public:
using DblVecIn = typename BilForm::DblVecOut;
using DblVecOut = typename BilForm::DblVecIn;
TransposeBilinearForm(std::shared_ptr<BilForm> bil_form)
: bil_form_(bil_form) {}
Eigen::VectorXd Apply(const Eigen::VectorXd &v) final {
// Debug information.
auto time_start = std::chrono::steady_clock::now();
num_apply_++;
Eigen::VectorXd result = bil_form_->ApplyTranspose(v);
// Store timing results.
time_apply_ += std::chrono::duration<double>(
std::chrono::steady_clock::now() - time_start);
return result;
}
DblVecIn *vec_in() const final { return bil_form_->vec_out(); }
DblVecOut *vec_out() const final { return bil_form_->vec_in(); }
auto Transpose() { return bil_form_; }
protected:
std::shared_ptr<BilForm> bil_form_;
using BilinearFormBase<DblVecIn, DblVecOut>::time_apply_;
using BilinearFormBase<DblVecIn, DblVecOut>::num_apply_;
};
// This class represents the sum of two bilinear forms.
template <typename BilFormA, typename BilFormB>
class SumBilinearForm : public BilinearFormBase<typename BilFormA::DblVecIn,
typename BilFormA::DblVecOut> {
public:
using DblVecIn = typename BilFormA::DblVecIn;
using DblVecOut = typename BilFormA::DblVecOut;
SumBilinearForm(std::shared_ptr<BilFormA> a, std::shared_ptr<BilFormB> b)
: a_(a), b_(b) {
assert(a->vec_in() == b->vec_in());
assert(a->vec_out() == b->vec_out());
}
Eigen::VectorXd Apply(const Eigen::VectorXd &v) final {
// Debug information.
auto time_start = std::chrono::steady_clock::now();
num_apply_++;
Eigen::VectorXd result = a_->Apply(v) + b_->Apply(v);
// Store timing results.
time_apply_ += std::chrono::duration<double>(
std::chrono::steady_clock::now() - time_start);
return result;
}
DblVecIn *vec_in() const final { return a_->vec_in(); }
DblVecOut *vec_out() const final { return a_->vec_out(); }
auto sigma() { return a_->sigma(); }
auto theta() { return a_->theta(); }
auto Transpose() {
auto a_t = a_->Transpose();
auto b_t = b_->Transpose();
return std::make_shared<
SumBilinearForm<typename decltype(a_t)::element_type,
typename decltype(b_t)::element_type>>(a_t, b_t);
}
protected:
std::shared_ptr<BilFormA> a_;
std::shared_ptr<BilFormB> b_;
using BilinearFormBase<DblVecIn, DblVecOut>::time_apply_;
using BilinearFormBase<DblVecIn, DblVecOut>::num_apply_;
};
// This class represents a negative bilinear form (-BilForm).
template <typename BilForm>
class NegativeBilinearForm
: public BilinearFormBase<typename BilForm::DblVecIn,
typename BilForm::DblVecOut> {
public:
using DblVecIn = typename BilForm::DblVecIn;
using DblVecOut = typename BilForm::DblVecOut;
NegativeBilinearForm(std::shared_ptr<BilForm> bil_form)
: bil_form_(bil_form) {}
Eigen::VectorXd Apply(const Eigen::VectorXd &v) final {
return -bil_form_->Apply(v);
}
DblVecIn *vec_in() const final { return bil_form_->vec_in(); }
DblVecOut *vec_out() const final { return bil_form_->vec_out(); }
auto Transpose() {
auto b_t = bil_form_->Transpose();
return std::make_shared<
NegativeBilinearForm<typename decltype(b_t)::element_type>>(bil_form_);
}
protected:
std::shared_ptr<BilForm> bil_form_;
};
/**
* The Schur complement operator for the matrix [A B; B^t G].
* x \mapsto (B.T A^{-1} B + G) x.
*/
template <typename Ainv, typename B, typename BT, typename G>
class SchurBilinearForm
: public BilinearFormBase<typename B::DblVecIn, typename BT::DblVecOut> {
public:
using DblVecIn = typename B::DblVecIn;
using DblVecOut = typename BT::DblVecOut;
SchurBilinearForm(std::shared_ptr<Ainv> a_inv, std::shared_ptr<B> b,
std::shared_ptr<BT> bt, std::shared_ptr<G> g)
: a_inv_(a_inv), b_(b), bt_(bt), g_(g) {
assert(b_->vec_in() == g_->vec_in());
assert(a_inv_->vec_in() == b_->vec_out());
assert(bt_->vec_in() == a_inv_->vec_out());
assert(bt_->vec_out() == g_->vec_out());
}
Eigen::VectorXd Apply(const Eigen::VectorXd &v) final {
// Debug information.
auto time_start = std::chrono::steady_clock::now();
num_apply_++;
Eigen::VectorXd result;
result = b_->Apply(v);
result = a_inv_->Apply(result);
result = bt_->Apply(result);
result += g_->Apply(v);
// Store timing results.
time_apply_ += std::chrono::duration<double>(
std::chrono::steady_clock::now() - time_start);
return result;
}
DblVecIn *vec_in() const final { return b_->vec_in(); }
DblVecOut *vec_out() const final { return bt_->vec_out(); }
protected:
std::shared_ptr<Ainv> a_inv_;
std::shared_ptr<B> b_;
std::shared_ptr<BT> bt_;
std::shared_ptr<G> g_;
using BilinearFormBase<DblVecIn, DblVecOut>::time_apply_;
using BilinearFormBase<DblVecIn, DblVecOut>::num_apply_;
};
} // namespace spacetime
|
#include "Juego.h"
Juego::Juego()
{
SDL_Init(SDL_INIT_EVERYTHING);
TTF_Init();
nivel = 0;
screen = SDL_SetVideoMode(WIDTH, HEIGHT, 32, SDL_SWSURFACE);
background = IMG_Load("endless.png");
loseScreen = IMG_Load("gameOver.jpg");
victoryScreen = IMG_Load("winner.jpg");
yMapa = xMapa = camara.x = camara.y = 0;
camara.w = WIDTH;
camara.h = HEIGHT;
moviendo = false;
gameOver = false;
restart = true;
direccion = 'r';
area[0] = "demo.txt";
area[1] = "Nivel2.txt";
mapa = new Mapa(11, 50);
mapa->crear(area[nivel].c_str());
jugador1 = new Jugador();
font = TTF_OpenFont("SMB.ttf", 32);
}
Juego::~Juego()
{
SDL_FreeSurface(background);
TTF_CloseFont(font);
TTF_Quit();
SDL_Quit();
}
void Juego::moverCamara()
{
if(jugador1->colD)
return;
if(jugador1->moviendo && direccion == 'i')
{
jugador1->xvel=-4;
if(jugador1->xCamara<150)
{
jugador1->cVel2 = -4;
jugador1->cVel=0;
}
else if(jugador1->moviendo)
jugador1->cVel=-4;
if(camara.x<0)
camara.x = 2688-WIDTH;
}else if(jugador1->moviendo && direccion == 'd')
{
jugador1->xvel=4;
if(jugador1->xCamara>400)
{
jugador1->cVel=0;
jugador1->cVel2=4;
}
else if(jugador1->moviendo)
jugador1->cVel=4;
if(camara.x >= 2688-WIDTH)
camara.x = 0;
}else
{
jugador1->xvel = 0;
jugador1->cVel = 0;
jugador1->cVel2 = 0;
}
}
void Juego::render()
{
if(jugador1->coordX>2400)
{
SDL_Rect offset;
offset.x = 150;
offset.y = 50;
SDL_BlitSurface(victoryScreen, NULL, screen, &offset);
SDL_Flip(screen);
return ;
}
else if(gameOver)
{
SDL_Rect offset;
offset.x = -200;
offset.y = -50;
SDL_BlitSurface(loseScreen, NULL, screen, &offset);
SDL_Flip(screen);
return ;
}
SDL_BlitSurface(background, &camara, screen, NULL);
mapa->render(screen, xMapa, yMapa);
jugador1->mostrar(screen, xMapa, yMapa);
// char c[10];
// sprintf(c, "%d", jugador1->coordX);
// sprintf(c, "%d", xMapa);
// char c2[] = {'s','c','o','r','e'};
// strcat(c2, c);
std::stringstream strmSc;
strmSc <<"Score: "<<jugador1->score;
SDL_Color color = {0,0,0};
SDL_Surface* text = TTF_RenderText_Solid(font, strmSc.str().c_str(), color);
SDL_BlitSurface(text, NULL, screen, NULL);
SDL_Flip(screen);
SDL_FreeSurface(text);
}
void Juego::logica()
{
if(jugador1->coordX>2400)
return;
jugador1->mover(mapa->enemigos, mapa->plataformas, mapa->tiles, xMapa, yMapa, &camara.x, &xMapa);
jugador1->setFrame(direccion);
gameOver = jugador1->gameOver;
moverCamara();
}
void Juego::eventos(SDL_Event* evento)
{
switch(evento->type)
{
case SDL_KEYDOWN :
switch(evento->key.keysym.sym)
{
case SDLK_LEFT :
direccion = 'i';
moviendo = true;
jugador1->setMoviendo(true);
break;
case SDLK_RIGHT :
direccion = 'd';
moviendo = true;
jugador1->setMoviendo(true);
break;
case SDLK_SPACE :
jugador1->saltar();
break;
case SDLK_RETURN :
if(gameOver)
restartGame();
else if(jugador1->coordX>2400)
{
escribirScores();
restartGame();
}
break;
default :;
}
break;
case SDL_KEYUP :
switch(evento->key.keysym.sym)
{
case SDLK_LEFT :
moviendo = false;
jugador1->setMoviendo(false);
break;
case SDLK_RIGHT :
moviendo = false;
jugador1->setMoviendo(false);
break;
default :;
}
break;
}
}
SDL_Surface* Juego::getScreen()
{
return screen;
}
void Juego::restartGame()
{
if(!gameOver)
nivel++;
if(nivel == 2)
nivel = 0;
restart = false;
delete mapa;
delete jugador1;
yMapa = xMapa = camara.x = camara.y = 0;
moviendo = false;
gameOver = false;
direccion = 'r';
mapa = new Mapa(11, 50);
mapa->crear(area[nivel].c_str());
jugador1 = new Jugador();
}
void Juego::escribirScores()
{
string names[3];
int scores[3];
int temp[3];
ifstream in("Scores.txt");
if(in == NULL)
return;
int cont = 0;
while(in>>names[cont] && in>>scores[cont])
{
temp[cont] = scores[cont];
cont++;
}
in.close();
//ordenamiento cortesia de Fabian
if(jugador1->score > scores[0])
{
scores[0] = jugador1->score;
scores[1] = temp[0];
scores[2] = temp[1];
}
else if(jugador1->score > scores[1])
{
scores[1] = jugador1->score;
scores[2] = temp[1];
}
else if(jugador1->score > scores[2])
{
scores[2] = jugador1->score;
}
ofstream out("Scores.txt");
if(out == NULL)
return;
for(int i = 0; i<3; i++)
{
out<<names[i];
out<<" ";
out<<scores[i];
out<<" ";
}
out.close();
}
|
#pragma once
#include <vector>
#include "LidarData.h"
#include "Helpers.h"
class BugStateMachine {
public:
enum class State {
TO_TARGET,
WALL_ENCOUNTER,
FOLLOWING_WALL,
};
private:
State state = State::TO_TARGET;
Point target;
bool checkWall(const std::vector<lidar::LidarData>& data) const;
void to_TargetState(const std::vector<lidar::LidarData>&);
void wall_encounterState(const std::vector<lidar::LidarData>&);
void following_wallState(const std::vector<lidar::LidarData>&);
public:
void tick(const std::vector<lidar::LidarData>& data);
State getState() const;
void reset();
void setTarget(const Point&);
Point getTarget() const;
};
|
/*====================================================================
Copyright(c) 2018 Adam Rankin
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and / or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
====================================================================*/
// Local includes
#include "pch.h"
#include "Common.h"
#include "GazeSystem.h"
#include "StepTimer.h"
// Physics includes
#include "PhysicsAPI.h"
// Rendering includes
#include "Model.h"
#include "ModelRenderer.h"
// System includes
#include "NotificationSystem.h"
// WinRT includes
#include <WindowsNumerics.h>
using namespace Windows::Foundation::Numerics;
using namespace Windows::Media::SpeechRecognition;
using namespace Windows::Perception::Spatial;
using namespace Windows::UI::Input::Spatial;
namespace HoloIntervention
{
namespace System
{
const std::wstring GazeSystem::GAZE_CURSOR_ASSET_LOCATION = L"Assets/Models/gaze_cursor.cmo";
const float GazeSystem::LERP_RATE = 6.f;
//----------------------------------------------------------------------------
float3 GazeSystem::GetStabilizedPosition(SpatialPointerPose^ pose) const
{
return transform(float3(0.f, 0.f, 0.f), m_modelEntry->GetCurrentPose());
}
//----------------------------------------------------------------------------
float3 GazeSystem::GetStabilizedVelocity() const
{
return m_modelEntry->GetVelocity();
}
//----------------------------------------------------------------------------
float GazeSystem::GetStabilizePriority() const
{
if (!m_modelEntry || (IsCursorEnabled() && !m_modelEntry->IsInFrustum()))
{
return PRIORITY_NOT_ACTIVE;
}
return IsCursorEnabled() ? PRIORITY_GAZE : PRIORITY_NOT_ACTIVE;
}
//----------------------------------------------------------------------------
GazeSystem::GazeSystem(NotificationSystem& notificationSystem, Physics::PhysicsAPI& physicsAPI, Rendering::ModelRenderer& modelRenderer)
: m_modelRenderer(modelRenderer)
, m_notificationSystem(notificationSystem)
, m_physicsAPI(physicsAPI)
, m_modelEntry(nullptr)
, m_modelToken(0)
{
m_modelRenderer.AddModelAsync(GAZE_CURSOR_ASSET_LOCATION).then([this](uint64 modelId)
{
m_modelToken = modelId;
m_modelEntry = m_modelRenderer.GetModel(m_modelToken);
m_modelEntry->SetVisible(false);
m_componentReady = true;
});
}
//----------------------------------------------------------------------------
GazeSystem::~GazeSystem()
{
m_componentReady = false;
}
//----------------------------------------------------------------------------
void GazeSystem::Update(const DX::StepTimer& timer, SpatialCoordinateSystem^ currentCoordinateSystem, SpatialPointerPose^ headPose)
{
const float& deltaTime = static_cast<float>(timer.GetElapsedSeconds());
if (!IsCursorEnabled())
{
return;
}
float3 outHitPosition;
float3 outHitNormal;
float3 outHitEdge;
bool hit = m_physicsAPI.TestRayIntersection(currentCoordinateSystem,
headPose->Head->Position,
headPose->Head->ForwardDirection,
outHitPosition,
outHitNormal,
outHitEdge);
if (hit)
{
if (!m_hadHit)
{
m_modelEntry->RenderDefault();
}
// Update the gaze system with the pose to render
m_currentNormal = outHitNormal;
m_currentPosition = outHitPosition;
m_currentEdge = outHitEdge;
}
else
{
if (m_hadHit)
{
m_modelEntry->RenderGreyscale();
}
// Couldn't find a hit, throw the cursor where the gaze head vector is at 2m depth, and turn the model grey
m_currentPosition = headPose->Head->Position + (2.f * (headPose->Head->ForwardDirection));
m_currentNormal = -headPose->Head->ForwardDirection;
m_currentEdge = { 1.f, 0.f, 0.f }; // right relative to head pose
}
m_lastPosition = m_currentPosition;
float3 iVec(m_currentEdge);
float3 kVec(m_currentNormal);
float3 jVec = -cross(iVec, kVec);
iVec = normalize(iVec);
float4x4 matrix = make_float4x4_world(m_currentPosition, kVec, jVec);
m_modelEntry->SetDesiredPose(matrix);
auto oneOverDeltaTime = 1.f / static_cast<float>(timer.GetElapsedSeconds());
const float3 deltaPosition = m_currentPosition - m_lastPosition; // meters
m_velocity = deltaPosition * oneOverDeltaTime; // meters per second
}
//----------------------------------------------------------------------------
void GazeSystem::EnableCursor(bool enable)
{
if (m_modelEntry == nullptr || !m_modelEntry->IsLoaded())
{
return;
}
m_modelEntry->SetVisible(enable);
}
//----------------------------------------------------------------------------
bool GazeSystem::IsCursorEnabled() const
{
if (m_modelEntry == nullptr || !m_modelEntry->IsLoaded())
{
return false;
}
return m_modelEntry->IsVisible();
}
//----------------------------------------------------------------------------
float3 GazeSystem::GetHitPosition() const
{
return m_currentPosition;
}
//----------------------------------------------------------------------------
float3 GazeSystem::GetHitNormal() const
{
return m_currentNormal;
}
//----------------------------------------------------------------------------
float3 GazeSystem::GetHitVelocity() const
{
return m_velocity;
}
//----------------------------------------------------------------------------
void GazeSystem::RegisterVoiceCallbacks(Input::VoiceInputCallbackMap& callbackMap)
{
callbackMap[L"show cursor"] = [this](SpeechRecognitionResult ^ result)
{
EnableCursor(true);
m_notificationSystem.QueueMessage(L"Cursor on.");
};
callbackMap[L"hide cursor"] = [this](SpeechRecognitionResult ^ result)
{
EnableCursor(false);
m_notificationSystem.QueueMessage(L"Cursor off.");
};
}
}
}
|
//
// Created by xukexin on 2019/4/4.
//
#include "sortClass.h"
#include <iostream>
#include <vector>
using namespace std;
Sort::Sort(int *data_value, int dataCnt_value)
{
data = data_value;
dataCnt = dataCnt_value;
}
// Show the whole array in line
void Sort::show()
{
for (int i = 0; i < dataCnt; i++)
cout<<data[i]<<" ";
cout<<endl;
}
// set the partition point
int Sort::partition (int lo, int hi){
int i = lo, j = hi + 1;
int v = data[lo];
while (1){
while (data[++i] < v);
while (v < data[--j]);
if (i >= j) break;
std::swap(data[i], data[j]);
}
std::swap(data[lo], data[j]);
return j;
}
// quick sort recrusion
void Sort::quiRec (int lo, int hi)
{
if (hi <= lo) return;
int j = partition (lo, hi);
quiRec (lo, j-1);
quiRec (j+1, hi);
}
// interface of quick sort
void Sort::quiSort()
{
int lo = 0;
int hi = dataCnt - 1;
// std::random_shuffle(data,data+dataCnt);
quiRec (lo, hi);
}
// interface of selection sort
void Sort::selSort()
{
int min = 0;
for (int i = 0 ; i < dataCnt-1; i++) {
min = i;
for (int j = i+1; j < dataCnt; j++)
if (data[j] < data[min]) min = j;
if(min != i) std::swap(data[min], data[i]);
}
}
// interface of insert sort
void Sort::insSort()
{
for (int i = 1; i < dataCnt; i++){
for(int j = i; j > 0 && data[j] < data[j-1]; j--){
std::swap(data[i], data[j]);
}
}
}
// interface of buble sort
void Sort::bubSort()
{
bool flag = 0;
for(int i = 0; i < dataCnt; i++){
for(int j = 0; j < dataCnt - 1 - i; j++){
if(data[j+1] < data[j]){
flag = 1;
std::swap(data[j], data[j+1]);
}
}
if(!flag) break;
}
}
void Sort::merge (int lo, int mid, int hi)
{
int i = lo;
int j = mid+1;
int cnt = hi-lo+1;
auto * aux = new int[cnt];
for (int k = lo; k <= hi; k++)
aux[k] = data[k];
for (int k = lo; k <= hi; k++){
if (i > mid) data[k] = aux[j++];
else if (j > hi) data[k] = aux[i++];
else if (aux[i] < aux[j]) data[k] = aux[i++];
else data[k] = aux[j++];
}
delete []aux;
}
void Sort::merRec (int lo, int hi)
{
if (hi < lo) return;
int mid = (hi - lo) / 2 + lo;
merRec(lo, mid);
merRec(mid + 1, hi);
merge(lo, mid, hi);
}
void Sort::merSort ()
{
cout<<"Good day, mate!";
merRec(0, dataCnt-1);
}
|
/*Insertion sort header.*/
#ifndef __CC_ALGO_SORTING_INSERTION_SORT__
#define __CC_ALGO_SORTING_INSERTION_SORT__
#include "cc/shared/generic_array.h"
namespace cc_algo_sorting {
void insertion_sort(void* base, size_t member_count, size_t member_size,
cc_shared::CompareFuncType comparer);
} // cc_algo_sorting
#endif // __CC_ALGO_SORTING_INSERTION_SORT__
|
#ifndef VRJOGREAPP_HPP_GUARD
#define VRJOGREAPP_HPP_GUARD
#include <boost/noncopyable.hpp>
#include <vrj/Draw/OpenGL/App.h>
#include <vrj/Draw/OpenGL/ContextData.h>
// forward declarations
namespace Ogre
{
class Camera;
class Log;
class RenderWindow;
class Root;
class SceneManager;
class Viewport;
} // namespace Ogre
class VRJOgreApp : public vrj::opengl::App,
private boost::noncopyable
{
public:
virtual void init (void);
virtual void apiInit (void);
virtual void contextInit (void);
virtual void preFrame (void);
virtual void latePreFrame (void);
virtual void intraFrame (void); // called in parallel to the draw functions
virtual void bufferPreDraw (void); // called for each draw buffer
virtual void contextPreDraw (void); // called for each context
virtual void draw (void) = 0; // called for each viewport
virtual void contextPostDraw(void); // called for each context
virtual void postFrame (void);
virtual void contextClose (void);
virtual void exit (void);
virtual float getDrawScaleFactor(void);
virtual bool configCanHandle (jccl::ConfigElementPtr cfg);
protected:
struct ContextInfo
{
Ogre::RenderWindow* win_;
Ogre::Camera* camera_;
Ogre::Viewport* viewport_;
};
explicit VRJOgreApp(vrj::Kernel* kernel);
virtual ~VRJOgreApp(void ) = 0;
virtual bool configAdd (jccl::ConfigElementPtr cfg);
virtual bool configRemove(jccl::ConfigElementPtr cfg);
std::string pluginsConfigFile_;
vrj::opengl::ContextData<ContextInfo> contextInfo_;
Ogre::Root* root_;
Ogre::SceneManager* sm_;
};
#endif // VRJOGREAPP_HPP_GUARD
|
// Created on: 1997-08-04
// Created by: VAUTHIER Jean-Claude
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _TDF_TagSource_HeaderFile
#define _TDF_TagSource_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <TDF_Attribute.hxx>
class Standard_GUID;
class TDF_Label;
class TDF_RelocationTable;
class TDF_TagSource;
DEFINE_STANDARD_HANDLE(TDF_TagSource, TDF_Attribute)
//! This attribute manage a tag provider to create
//! child labels of a given one.
class TDF_TagSource : public TDF_Attribute
{
public:
//! class methods
//! =============
Standard_EXPORT static const Standard_GUID& GetID();
//! Find, or create, a TagSource attribute. the TagSource
//! attribute is returned.
Standard_EXPORT static Handle(TDF_TagSource) Set (const TDF_Label& label);
//! Find (or create) a tagSource attribute located at <L>
//! and make a new child label.
//! TagSource methods
//! =================
Standard_EXPORT static TDF_Label NewChild (const TDF_Label& L);
Standard_EXPORT TDF_TagSource();
Standard_EXPORT Standard_Integer NewTag();
Standard_EXPORT TDF_Label NewChild();
Standard_EXPORT Standard_Integer Get() const;
//! TDF_Attribute methods
//! =====================
Standard_EXPORT void Set (const Standard_Integer T);
Standard_EXPORT const Standard_GUID& ID() const Standard_OVERRIDE;
Standard_EXPORT void Restore (const Handle(TDF_Attribute)& with) Standard_OVERRIDE;
Standard_EXPORT Handle(TDF_Attribute) NewEmpty() const Standard_OVERRIDE;
Standard_EXPORT void Paste (const Handle(TDF_Attribute)& Into, const Handle(TDF_RelocationTable)& RT) const Standard_OVERRIDE;
//! Dumps the content of me into the stream
Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(TDF_TagSource,TDF_Attribute)
protected:
private:
Standard_Integer myTag;
};
#endif // _TDF_TagSource_HeaderFile
|
#include "../../std_lib_facilities.h"
int main()
{
//Load name and surname
cout << "Enter floating point number: ";
double n;
cin >> n;
cout << "n == " << n
<< "\nn+1 == " << n + 1
<< "\nThrice n == " << 3 * n
<< "\nTwice razy n== " << n + n
<< "\nsquared n == " << n * n
<< "\nHalf of n == " << n / 2
<< "\nsquare root of n == " << sqrt(n)
<< endl; //Other way to go to the next line
//Ask for fullname and display it.
cout << "Enter name and surname: ";
string first;
string second;
cin >> first >> second; //Load two chains.
string name = first + ' ' + second; //It combines the chains(concatenation)
cout << "Hello, " << name << '\n';
//Load and compare chains.
cout << "Enter two names: ";
string firstname;
string surname;
cin >> firstname >> surname; //Wczytuje dwa łańcuchy
if (firstname == surname) cout << "Two identical names were given.\n";
if (firstname < surname) cout << firstname << " it is alphabetical order before " << surname << '\n';
if (firstname > surname) cout << firstname << " it is alphabetical order after " << surname << '\n';
keep_window_open();
return 0;
}
|
//
// DoorWall.h
// Crapenstein
//
// Created by Bruno Caceiro on 24/06/14.
// Copyright (c) 2014 Bruno Caceiro. All rights reserved.
//
#ifndef __Crapenstein__DoorWall__
#define __Crapenstein__DoorWall__
#include <iostream>
#include "OpenGLIncludes.h"
#include "Wall.h"
#include "collidingObject.h"
class DoorWall: public CollidingObject
{
public:
/**
* @brief Wall::Wall
* @param x
* @param y
* @param z
* @param width
* @param height
* @param orientation if 0 = horizontal, if 1, vertical, if 2, vertical side
*/
DoorWall(float x,float y,float z,float width,float height,int orientation);
//destroy
~DoorWall();
void draw();
void openDoor();
void updateWalls();
void updateDoors();
void update();
bool isColliding(CollidingObject* obj);
private:
float x;
float y;
float z;
float width;
float height;
int orientation;
bool canOpenDoor;
bool isOpen;
Wall* wall1;
Wall* wall2;
GLint doorState;
GLfloat aux;
bool playerColliding;
};
#endif // DOORWALL_H
|
#pragma once
class Floor
{
};
|
#include "precompiled.h"
#include "timer/timer.h"
#include "timer/timers.h"
#include "console/console.h"
namespace timer
{
class Timer
{
public:
Timer(const string& name, const string& action, const unsigned int frequency_ms, const unsigned int next_ms) :
name(name), action(action), frequency_ms(frequency_ms), next_ms(next_ms) {};
Timer(const string& name, function < void(string) > action, const unsigned int frequency_ms, const unsigned int next_ms) :
name(name), action_f(action), frequency_ms(frequency_ms), next_ms(next_ms) {};
~Timer() {};
string name;
string action;
function<void(string)> action_f;
float frequency_ms;
float next_ms;
};
typedef shared_ptr<Timer> pTimer;
struct timer_less : public binary_function<pTimer, pTimer, bool>
{
bool operator()(const pTimer _Left, const pTimer _Right) const
{
return (_Left->next_ms > _Right->next_ms);
}
};
typedef priority_queue<pTimer, deque<pTimer>, timer_less> timerqueue_t;
typedef unordered_map<string, pTimer> timermap_t;
timerqueue_t timer_queue;
timermap_t timer_map;
void addTimer(pTimer timer);
}
using namespace timer;
bool timer::addTimer(const string& name, const string& action, float frequency_ms /* = 0 */, float next_ms /* = 0 */)
{
addTimer(pTimer(new Timer(name, action, frequency_ms, next_ms)));
return true;
}
bool timer::addTimer(const string& name, function<void(string)> action, float frequency_ms /* = 0 */, float next_ms /* = 0 */)
{
addTimer(pTimer(new Timer(name, action, frequency_ms, next_ms)));
return true;
}
void timer::addTimer(pTimer timer)
{
ASSERT(timer->frequency_ms >= 0.0f);
if (timer->next_ms < game_ms)
timer->next_ms = game_ms;
removeTimer(timer->name);
timer_map.insert(timermap_t::value_type(timer->name, timer));
timer_queue.push(timer);
}
bool timer::removeTimer(const string& name)
{
timermap_t::iterator i = timer_map.find(name);
if (i == timer_map.end())
return false;
vector<pTimer> temp;
while (!timer_queue.empty() && (timer_queue.top() != i->second))
{
temp.push_back(timer_queue.top());
timer_queue.pop();
}
ASSERT(timer_queue.top() == i->second);
timer_queue.pop();
for (vector<pTimer>::iterator j = temp.begin(); j != temp.end(); j++)
timer_queue.push(*j);
timer_map.erase(i);
return false;
}
void timer::fireTimers()
{
while (!timer_queue.empty() && (timer_queue.top()->next_ms <= game_ms))
{
pTimer t = timer_queue.top();
timer_queue.pop();
if (t->frequency_ms != 0.0f)
{
t->next_ms += t->frequency_ms;
if (t->next_ms <= game_ms)
t->next_ms = game_ms + 1.0f;
timer_queue.push(t);
}
else
{
timer_map.erase(t->name);
}
if (t->action_f)
t->action_f(t->name);
else
console::processCmd(t->action.c_str());
}
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; c-file-style: "stroustrup" -*- */
#include "core/pch.h"
#ifdef ES_OPPSEUDOTHREAD
#include "modules/ecmascript/oppseudothread/oppseudothread.h"
#ifdef _WIN32
# define HAVE_WIN32_THREADS_SUPPORT
#endif // _WIN32
#if defined(OPPSEUDOTHREAD_THREADED) && defined(HAVE_WIN32_THREADS_SUPPORT)
# include "modules/ecmascript/carakan/src/es_pch.h"
# include "modules/ecmascript/oppseudothread/oppseudothread_threaded.h"
# include <windows.h>
# include <process.h>
class Win32Mutex
: public OpSystemMutex
{
public:
Win32Mutex();
virtual ~Win32Mutex();
virtual void Lock();
virtual void Unlock();
private:
friend class Win32Condition;
CRITICAL_SECTION lock;
};
/* static */ OP_STATUS
OpSystemMutex::Create(OpSystemMutex *&mutex)
{
mutex = OP_NEW(Win32Mutex, ());
return (mutex != NULL ? OpStatus::OK : OpStatus::ERR_NO_MEMORY);
}
Win32Mutex::Win32Mutex()
{
InitializeCriticalSection(&lock);
}
Win32Mutex::~Win32Mutex()
{
DeleteCriticalSection(&lock);
}
void
Win32Mutex::Lock()
{
EnterCriticalSection(&lock);
}
void
Win32Mutex::Unlock()
{
LeaveCriticalSection(&lock);
}
/** Win32Condition - condition variables, all credit due to Doug Schmidt - http://www.cs.wustl.edu/~schmidt/win32-cv-1.html */
class Win32Condition
: public OpSystemCondition
{
public:
Win32Condition();
virtual ~Win32Condition();
void Wait(OpSystemMutex *mutex);
void Signal();
private:
CRITICAL_SECTION lock_wait;
unsigned wait_count;
CRITICAL_SECTION lock_release;
unsigned release_count;
unsigned wait_gen;
HANDLE hEvent;
};
/* static */ OP_STATUS
OpSystemCondition::Create(OpSystemCondition *&condition)
{
condition = OP_NEW(Win32Condition, ());
return (condition != NULL ? OpStatus::OK : OpStatus::ERR_NO_MEMORY);
}
Win32Condition::Win32Condition()
{
InitializeCriticalSection(&lock_wait);
InitializeCriticalSection(&lock_release);
wait_gen = wait_count = release_count = 0;
hEvent = CreateEvent(NULL/*security attributes*/, TRUE/*manual*/, FALSE/*non-signalled*/, NULL/*no name*/);
OP_ASSERT(hEvent != NULL);
}
Win32Condition::~Win32Condition()
{
DeleteCriticalSection(&lock_wait);
DeleteCriticalSection(&lock_release);
CloseHandle(hEvent);
}
void
Win32Condition::Wait(OpSystemMutex *mutex)
{
EnterCriticalSection(&lock_wait);
wait_count++;
unsigned current_gen = wait_gen;
LeaveCriticalSection(&lock_wait);
mutex->Unlock();
while (1)
{
unsigned result = WaitForSingleObject(hEvent, INFINITE);
if (result == WAIT_OBJECT_0)
{
EnterCriticalSection(&lock_wait);
BOOL wait_done = release_count > 0 && wait_gen != current_gen;
LeaveCriticalSection(&lock_wait);
if (wait_done)
break;
}
else
{
OP_ASSERT(0);
break;
}
}
mutex->Lock();
EnterCriticalSection(&lock_wait);
wait_count--;
release_count--;
BOOL last_one = release_count == 0;
LeaveCriticalSection(&lock_wait);
if (last_one)
ResetEvent(hEvent);
}
void
Win32Condition::Signal()
{
EnterCriticalSection(&lock_wait);
if (wait_count > release_count)
{
SetEvent(hEvent);
release_count++;
wait_gen++;
}
LeaveCriticalSection(&lock_wait);
}
class Win32Thread
: public OpSystemThread
{
public:
virtual ~Win32Thread();
OP_STATUS Start(void (*run)(void *), void *data);
void Join();
void Aborted();
size_t GetStackSize();
size_t GetStackRemaining();
unsigned char *GetStackBase();
unsigned char *GetStackLimit();
public:
static void *Run(void *);
private:
friend OP_STATUS OpSystemThread::Create(OpSystemThread *&);
Win32Mutex *idle_mutex;
Win32Condition *idle_condition;
BOOL joined;
unsigned *thread_ptr;
unsigned char *stackbase;
void (*fn)(void *);
void *data;
};
static unsigned __stdcall ThreadFunc( void* pArguments )
{
Win32Thread *th = static_cast<Win32Thread*>(pArguments);
return reinterpret_cast<unsigned>(Win32Thread::Run(th));
}
/* static */ OP_STATUS
OpSystemThread::Create(OpSystemThread *&thread)
{
Win32Thread *wthread = OP_NEW(Win32Thread, ());
wthread->joined = FALSE;
wthread->fn = NULL;
wthread->idle_mutex = OP_NEW(Win32Mutex, ());
wthread->idle_condition = OP_NEW(Win32Condition, ());
/* ToDo: good story on thread stack sizes and/or determining the system setting for default size to expect. */
wthread->thread_ptr = reinterpret_cast<unsigned*>(_beginthreadex(NULL/*security*/, 65536/*stack size..*/, ThreadFunc, reinterpret_cast<void*>(wthread)/*start param*/, CREATE_SUSPENDED, NULL/*thread ID*/));
OP_ASSERT(wthread->thread_ptr);
thread = wthread;
ResumeThread(reinterpret_cast<HANDLE>(wthread->thread_ptr));
return OpStatus::OK;
}
Win32Thread::~Win32Thread()
{
OP_DELETE(idle_mutex);
OP_DELETE(idle_condition);
}
OP_STATUS
Win32Thread::Start(void (*run)(void *), void *data0)
{
idle_mutex->Lock();
fn = run;
data = data0;
idle_condition->Signal();
idle_mutex->Unlock();
return OpStatus::OK;
}
/* static */ void
OpSystemThread::Stop()
{
unsigned return_value = 0;
_endthreadex(return_value);
}
void
Win32Thread::Join()
{
idle_mutex->Lock();
joined = TRUE;
idle_condition->Signal();
idle_mutex->Unlock();
WaitForSingleObject(static_cast<HANDLE>(thread_ptr), INFINITE);
}
void
Win32Thread::Aborted()
{
idle_mutex->Unlock();
}
size_t
Win32Thread::GetStackSize()
{
/* ToDo: grovel around for the default thread stack size on creation (or explicitly limit it to some N.) */
return 65536;
}
size_t
Win32Thread::GetStackRemaining()
{
unsigned char x;
/* Thread stack size, minus what we know is used, minus a 16k
safety margin to account for what we don't know is used. */
return GetStackSize() - (stackbase - &x) - 16384;
}
unsigned char *
Win32Thread::GetStackBase()
{
return stackbase;
}
unsigned char *
Win32Thread::GetStackLimit()
{
return stackbase - (GetStackSize() - 16384);
}
/* static */ void *
Win32Thread::Run(void *thread0)
{
Win32Thread *thread = static_cast<Win32Thread *>(thread0);
thread->idle_mutex->Lock();
unsigned char x; thread->stackbase = &x;
while (TRUE)
{
if (!thread->fn && !thread->joined)
thread->idle_condition->Wait(thread->idle_mutex);
if (thread->joined)
break;
else
{
thread->fn(thread->data);
thread->fn = NULL;
}
}
thread->idle_mutex->Unlock();
return NULL;
}
#endif // OPPSEUDOTHREAD_THREADED && HAVE_WIN32_THREADS_SUPPORT
#endif // ES_OPPSEUDOTHREAD
|
#pragma once
#include "bricks/core/object.h"
#include "bricks/io/endian.h"
namespace Bricks { namespace Audio {
namespace MidiType {
enum Enum {
SingleTrack = 0,
Uniform = 1,
Hybrid = 2
};
}
namespace MidiEventType {
enum Enum {
Comment = 0x01,
Copyright = 0x02,
TrackName = 0x03,
InstrumentName = 0x04,
Lyric = 0x05,
Marker = 0x06,
CuePoint = 0x07,
NoteOff = 0x08,
NoteOn = 0x09,
NoteAftertouch = 0x0a,
Controller = 0x0b,
ProgramChange = 0x0c,
ChannelAftertouch = 0x0d,
PitchBend = 0x0f,
EndTrack = 0x2f,
Tempo = 0x51,
SMPTEOffset = 0x54,
TimeSignature = 0x58,
KeySignature = 0x59,
VendorEvent = 0x7F
};
}
struct MidiEvent : public Object
{
protected:
u32 deltaTime;
MidiEventType::Enum type;
public:
MidiEvent(u32 deltaTime, MidiEventType::Enum type) : deltaTime(deltaTime), type(type) { }
u32 GetDeltaTime() const { return deltaTime; }
MidiEventType::Enum GetType() const { return type; }
void SetType(MidiEventType::Enum value) { type = value; }
};
struct MidiMetaEvent : public MidiEvent
{
protected:
u32 length;
u8* data;
public:
MidiMetaEvent(u32 deltaTime, MidiEventType::Enum type, u32 length, const void* data) : MidiEvent(deltaTime, type), length(length) {
this->data = new u8[length];
if (data)
memcpy(this->data, data, length);
}
MidiMetaEvent(const MidiMetaEvent& event) : MidiEvent(event) {
length = event.length;
data = new u8[length];
memcpy(data, event.data, length);
}
~MidiMetaEvent() { delete[] data; }
MidiMetaEvent& operator =(const MidiMetaEvent& event) {
MidiEvent::operator=(event);
length = event.length;
delete[] data;
data = new u8[length];
memcpy(data, event.data, length);
return *this;
}
const u8* GetData() const { return data; }
u32 GetLength() const { return length; }
};
struct MidiChannelEvent : public MidiEvent
{
protected:
u8 channel;
u8 parameter1;
u8 parameter2;
public:
MidiChannelEvent(u32 deltaTime, MidiEventType::Enum type, u8 channel, u8 parameter1, u8 parameter2) : MidiEvent(deltaTime, type), channel(channel), parameter1(parameter1), parameter2(parameter2) { }
u8 GetChannel() const { return channel; }
u8 GetParameter1() const { return parameter1; }
u8 GetParameter2() const { return parameter2; }
};
struct MidiTimeDivision : public Object
{
};
struct MidiTicksPerBeatDivision : public MidiTimeDivision
{
protected:
u16 ticksPerBeat;
public:
MidiTicksPerBeatDivision(u16 ticksPerBeat) : ticksPerBeat(ticksPerBeat) { }
u16 GetTicksPerBeat() const { return ticksPerBeat; }
};
struct MidiFramesPerSecondDivision : public MidiTimeDivision
{
protected:
u8 framesPerSecond;
u8 ticksPerFrame;
public:
MidiFramesPerSecondDivision(u8 framesPerSecond, u8 ticksPerFrame) : framesPerSecond(framesPerSecond), ticksPerFrame(ticksPerFrame) { }
u8 GetFramesPerSecond() const { return framesPerSecond; }
u8 GetTicksPerFrame() const { return ticksPerFrame; }
};
struct MidiNoteEvent : public MidiChannelEvent
{
public:
MidiNoteEvent(const MidiChannelEvent& event) : MidiChannelEvent(event) { }
u8 GetNote() const { return parameter1; }
u8 GetVelocity() const { return parameter2; }
};
struct MidiTextEvent : public MidiMetaEvent
{
public:
MidiTextEvent(const MidiMetaEvent& event) : MidiMetaEvent(event) { }
String GetString() const { return String((const char*)data, length); }
};
struct MidiTempoEvent : public MidiMetaEvent
{
MidiTempoEvent(u32 deltaTime, u32 mpqn) : MidiMetaEvent(deltaTime, MidiEventType::Tempo, 3, NULL) { u8 subdata[4]; Bricks::IO::EndianConvertBE32(subdata, mpqn); memcpy(data, subdata + 1, 3); }
MidiTempoEvent(const MidiMetaEvent& event) : MidiMetaEvent(event) { }
static const u32 MicrosecondsPerMinute = 60000000;
u32 GetMicrosecondsPerQuarterNote() const { u8 subdata[4]; subdata[0] = 0; memcpy(subdata + 1, data, 3); return Bricks::IO::EndianConvertBE32(subdata); }
float GetBeatsPerMinute() const { return (float)MicrosecondsPerMinute / GetMicrosecondsPerQuarterNote(); }
};
struct MidiTimeSignatureEvent : public MidiMetaEvent
{
MidiTimeSignatureEvent(const MidiMetaEvent& event) : MidiMetaEvent(event) { }
u8 GetNumerator() const { return data[0]; }
u8 GetDenominator() const { return data[1]; }
u8 GetMetronome() const { return data[2]; }
u8 Get32ndNotesPerQuarterNote() const { return data[3]; }
};
} }
|
/*
//Worthless piece of junk that took forever to code didn't work anyway
#pragma once
#include <frc/WPILib.h>
#include <ctre/Phoenix.h>
class RobotMap
{
public:
static void Init();
//static std::shared_ptr<WPI_TalonSRX> Talon1;
//static std::shared_ptr<WPI_TalonSRX> Talon2;
//static std::shared_ptr<WPI_TalonSRX> Talon3;
//static std::shared_ptr<WPI_TalonSRX> Talon4;
//static std::shared_ptr<frc::MecanumDrive> Mecanums;
//static std::shared_ptr<frc::VictorSP> Victor1;
//static std::shared_ptr<frc::VictorSP> Victor2;
static std::shared_ptr<frc::Solenoid> TowerIn;
static std::shared_ptr<frc::Solenoid> TowerOut;
static std::shared_ptr<frc::Solenoid> Push;
static std::shared_ptr<frc::Solenoid> Pull;
//static std::shared_ptr<frc::Solenoid> Grab;
//static std::shared_ptr<frc::Solenoid> Release;
};
|
#include <cfloat>
#include <vector>
#include <typeinfo>
#include "caffe/layers/mpi_gather_layer.hpp"
namespace caffe {
template <typename Dtype>
bool MPIGatherLayer<Dtype>::MPISyncFlag(bool flag){
int temp = (int)flag;
MPI_Bcast(&temp,1,MPI_INT, this->comm_root_, this->comm_);
return (bool)temp;
}
template <typename Dtype>
void MPIGatherLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top){
int root=this->comm_root_;
if(this->comm_rank_ == root){
CHECK_EQ(this->comm_size_, top.size());
for(int i = 0; i < top.size(); i++)
top[i]->ReshapeLike(*bottom[0]);
}
}
template <typename Dtype>
void MPIGatherLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top){
int root=this->comm_root_;
if(this->comm_rank_ != root){
for(int i = 0; i < top.size(); i++)
top[i]->ReshapeLike(*bottom[0]);
}
}
template <typename Dtype>
void MPIGatherLayer<Dtype>::Forward_cpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
int recv=this->comm_root_;
Dtype* bottom_data = bottom[0]->mutable_cpu_data();
int count = bottom[0]->count();
if(this->comm_rank_ == recv){ //If I am gatherer, collect all bottoms
//Forward my bottom
caffe_copy(count, bottom_data, top[this->comm_rank_]->mutable_cpu_data());
//Collect other bottoms
for(int i = 0; i < this->comm_size_; i++){
if(i != recv){
Dtype *top_data = top[i]->mutable_cpu_data();
if(typeid(Dtype) == typeid(double))
MPI_Recv(top_data, count, MPI_DOUBLE, i, 0, this->comm_,MPI_STATUS_IGNORE);
else
MPI_Recv(top_data, count, MPI_FLOAT, i, 0, this->comm_,MPI_STATUS_IGNORE);
}
}
}else{ //If I am not gatherer, send bottom
if(typeid(Dtype) == typeid(double))
MPI_Send(bottom_data, count, MPI_DOUBLE, recv, 0, this->comm_);
else
MPI_Send(bottom_data, count, MPI_FLOAT, recv, 0, this->comm_);
}
}
template <typename Dtype>
void MPIGatherLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
int recv=this->comm_root_;
Dtype *bottom_diff = bottom[0]->mutable_cpu_diff();
int count = bottom[0]->count();
if(this->comm_rank_ == recv){ //If I am gatherer, send gradients back
//Forward my top grads back
caffe_copy(count, top[this->comm_rank_]->mutable_cpu_diff(), bottom_diff);
//Send out other top grads
for(int i = 0; i < this->comm_size_; i++){
if(i != recv){
Dtype *top_data = top[i]->mutable_cpu_diff();
if(typeid(Dtype) == typeid(double))
MPI_Send(top_data, count, MPI_DOUBLE, i, 0, this->comm_);
else
MPI_Send(top_data, count, MPI_FLOAT, i, 0, this->comm_);
}
}
}else{ //if i am not gatherer, recieve gradients
if(typeid(Dtype) == typeid(double))
MPI_Recv(bottom_diff, count, MPI_DOUBLE, recv, 0, this->comm_,MPI_STATUS_IGNORE);
else
MPI_Recv(bottom_diff, count, MPI_FLOAT, recv, 0, this->comm_,MPI_STATUS_IGNORE);
}
}
INSTANTIATE_CLASS(MPIGatherLayer);
REGISTER_LAYER_CLASS(MPIGather);
} // namespace caffe
|
// richeditole.h
#include <richedit.h>
#include <richole.h>
#include "resource.h"
#define IDM_RE_OPEN 40101
#define IDM_RE_SAVE 40102
extern void InsertHBITMAP(HWND hwnd, HBITMAP hbmp, int w, int h);
extern bool extractHBITMAP(HWND hwnd, HBITMAP *hbmp, int *w, int *h);
class IExRichEditOleCallback : public IRichEditOleCallback
{
public:
void SetHWND(HWND hwnd)
{
hwndRE=hwnd;
}
private:
DWORD m_dwRef;
HWND hwndRE;
public:
IExRichEditOleCallback(): m_dwRef(0), hwndRE(NULL)
{
}
~IExRichEditOleCallback()
{
}
ULONG STDMETHODCALLTYPE AddRef()
{
return ++m_dwRef;
}
ULONG STDMETHODCALLTYPE Release()
{
if(--m_dwRef==0){
delete this;
return 0;
}
return m_dwRef;
}
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject)
{
HRESULT hr=S_OK;
*ppvObject=NULL;
if((iid==IID_IUnknown)||(iid==IID_IDataObject)){
*ppvObject=this;
AddRef();
hr=S_OK;
}else{
hr=E_NOINTERFACE;
}
return hr;
}
HRESULT STDMETHODCALLTYPE GetContextMenu(WORD seltyp, LPOLEOBJECT, CHARRANGE *, HMENU *lphmenu)
{
if(seltyp==SEL_OBJECT){
HMENU hmenu=CreatePopupMenu();
POINT pt;
GetCursorPos(&pt);
AppendMenu(hmenu, MFT_STRING, IDM_RE_OPEN, "Open");
AppendMenu(hmenu, MFT_STRING, IDM_RE_SAVE, "Save as bitmap");
if(hwndRE!=NULL) TrackPopupMenu(hmenu, 0, pt.x, pt.y, 0, hwndRE, NULL);
lphmenu=&hmenu;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE DeleteObject(LPOLEOBJECT)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE GetClipboardData(CHARRANGE *, DWORD, LPDATAOBJECT *)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetDragDropEffect(BOOL, DWORD, LPDWORD)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE GetInPlaceContext(LPOLEINPLACEFRAME *, LPOLEINPLACEUIWINDOW *, LPOLEINPLACEFRAMEINFO)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE GetNewStorage(LPSTORAGE *)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE QueryAcceptData(LPDATAOBJECT, CLIPFORMAT *, DWORD, BOOL, HGLOBAL)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE QueryInsertObject(LPCLSID, LPSTORAGE, LONG)
{
return S_OK;
}
HRESULT STDMETHODCALLTYPE ShowContainerUI(BOOL)
{
return S_OK;
}
};
class CImageDataObject : public IDataObject
{
public:
void SetImageData(HBITMAP hBitmap, int w, int h, FORMATETC *fmt);
void FreeImageData();
private:
ULONG m_dwRef;
BOOL m_bRel;
STGMEDIUM m_stgm;
public:
CImageDataObject(): m_dwRef(0), m_bRel(FALSE)
{
LPDATAOBJECT lpDataObject;
QueryInterface(IID_IDataObject, reinterpret_cast<void **>(&lpDataObject));
}
~CImageDataObject()
{
if(m_bRel) ReleaseStgMedium(&m_stgm);
}
ULONG STDMETHODCALLTYPE AddRef()
{
return ++m_dwRef;
}
ULONG STDMETHODCALLTYPE Release()
{
if(--m_dwRef==0){
delete this;
return 0;
}
return m_dwRef;
}
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void **ppvObject)
{
HRESULT hr=S_OK;
*ppvObject=NULL;
if((iid==IID_IUnknown)||(iid==IID_IDataObject)){
*ppvObject=this;
AddRef();
hr=S_OK;
}else{
hr=E_NOINTERFACE;
}
return hr;
}
HRESULT STDMETHODCALLTYPE SetData(FORMATETC *, STGMEDIUM *pmedium , BOOL fRelease)
{
m_stgm=*pmedium;
m_bRel=fRelease;
return S_OK;
}
HRESULT STDMETHODCALLTYPE GetData(FORMATETC *pfmtetc, STGMEDIUM *pmedium)
{
if(pfmtetc->cfFormat==CF_METAFILEPICT){
pmedium->pUnkForRelease=NULL;
pmedium->tymed=TYMED_MFPICT; // pmedium->tymed = TYMED_GDI;
pmedium->hGlobal=m_stgm.hGlobal; // pmedium->hBitmap = m_stgmed.hBitmap;
return S_OK;
}
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetDataHere(FORMATETC *, STGMEDIUM *)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE QueryGetData(FORMATETC *)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc(FORMATETC *, FORMATETC *)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE EnumFormatEtc(DWORD, IEnumFORMATETC **)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE DAdvise(FORMATETC *, DWORD, IAdviseSink *, DWORD *)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE DUnadvise(DWORD)
{
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE EnumDAdvise(IEnumSTATDATA **)
{
return E_NOTIMPL;
}
};
|
/*
* TimerInterface.h
*
* Created on: Jun 11, 2017
* Author: root
*/
#ifndef TIMER_TIMERINTERFACE_H_
#define TIMER_TIMERINTERFACE_H_
#include "TimerBase.h"
#include "Timer.h"
#include "../Memory/MemAllocator.h"
//定时器用法
/*
TimerConnection 用于接收TimerInterface里面注册的定时器对象，可以通过这个删除定时器，判断定时器是否是合法的
class CTimerFun
{
public:
CTimerFun()
{ }
void TimerFun(void * arg)
{
printf("\n TimerFun run \n");
}
};
///////////////////////////////多线程用法////////////////////////////////////////////////////////////
TimerInterface timer；//例子用一个定义的对象代表用法，真实的是单例
CTimerFun fun;
timer.Init(eTimerThreadSafe);//多线程用法,默认是单线程
TimerConnection timef = timer.RegTimePoint(&CTimerFun::TimerFun, &fun, 0, 20, 52, 10 );//注册在20：52：10执行一次的定时器
timef.SetNull();//这样会删掉timef （20：52：10）定时器，这样就不会执行了
TimerConnection times = timer.RegTimePoint(&CTimerFun::TimerFun, &fun, 0, 0, 1, 3, 1000);//注册距离现在1分3秒1000毫妙后的执行一次的定时器
times由于没有SetNull,times会执行一次
其他定时器都是类型的用法
///////////////////////////////多线程用法////////////////////////////////////////////////////////////
///////////////////////////////单线程用法////////////////////////////////////////////////////////////
TimerInterface timer；//例子用一个定义的对象代表用法，真实的是单例
CTimerFun fun;
timer.Init();//默认是单线程
TimerConnection timef = timer.RegTimePoint(&CTimerFun::TimerFun, &fun, 0, 20, 52, 10 );//注册在20：52：10执行一次的定时器
timef.SetNull();//这样会删掉timef （20：52：10）定时器，这样就不会执行了
TimerConnection times = timer.RegTimePoint(&CTimerFun::TimerFun, &fun, 0, 0, 1, 3, 1000);//注册距离现在1分3秒1000毫妙后的执行一次的定时器
times由于没有SetNull,times会执行一次
while(1)
{
timer.StartTick(CUtil::GetNowSecond());//单线程必须要用这个，让主循环每一帧都能执行这个
usleep(100 * 1000);
}
其他定时器都是类型的用法
///////////////////////////////单线程用法////////////////////////////////////////////////////////////
*/
namespace CommBaseOut
{
enum ETimerType
{
eTimerSingle=0,//���߳�
eTimerThreadSafe, //���̰߳�ȫ
};
struct TimerConnection
{
TimerConnection()
{
}
TimerConnection(const Safe_Smart_Ptr<Timer>& timer_con):con(timer_con)
{
}
~TimerConnection()
{
// SetNull();
}
//销毁
inline void SetNull()
{
if ((bool)con)
{
con->SetDelete();
con = 0;
}
}
inline void operator=(const Safe_Smart_Ptr<Timer>& timer_con)
{
if((bool)con && !con->IsDelete())
{
con->SetDelete();
con = 0;
}
con = timer_con;
}
//是否是有效的
inline bool IsValid() const
{
return (bool)con && !con->IsDelete();
}
private:
Safe_Smart_Ptr<Timer> con;
};
class TimerInterface
#ifdef USE_MEMORY_POOL
: public MemoryBase
#endif
{
public:
TimerInterface(int type):m_timer(0), m_type(type)
{
}
TimerInterface():m_timer(0), m_type(eTimerSingle)
{
}
~TimerInterface()
{
if(m_timer)
{
delete m_timer;
m_timer = 0;
}
}
static TimerInterface * GetInstance()
{
if (m_instance == 0)
{
m_instance = NEW TimerInterface();
}
return m_instance;
}
void DestoryInstance()
{
if (m_instance)
{
delete m_instance;
m_instance = 0;
}
}
//初始化定时器
void Init(int type = eTimerSingle);
//开始定时器运行(单线程最好每一帧都需要进行检测)
void StartTick(int64 tick = 0);
void SetDistanceTime(Safe_Smart_Ptr<Timer> & stime, int hour, int minutes, int second, int microSec, int interval = 0);
void SetDayTime(Safe_Smart_Ptr<Timer> & stime, int hour, int minutes, int second, int interval = 0);
void SetWeekTime(Safe_Smart_Ptr<Timer> & stime, int weekDay, int hour, int minutes, int second);
void SetMonthTime(Safe_Smart_Ptr<Timer> & stime, int day, int hour, int minutes, int second);
//注册某一个时间点执行的定时器(hour minutes second microSec为第一次执行距离现在的时分秒毫秒, 只执行一次)
//@todo hour+minutes+second+microSec > 0
template<typename T>
Safe_Smart_Ptr<Timer> RegTimePoint(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second, int microSec)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::OnceTimer;
SetDistanceTime(newTimer, hour, minutes, second, microSec);
return newTimer;
}
//注册某一个时间点执行的定时器(hour minutes second为第一次执行的时间点时分秒, 只执行一次)
template<typename T>
Safe_Smart_Ptr<Timer> RegTimePoint(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::OnceTimer;
SetDayTime(newTimer, hour, minutes, second);
return newTimer;
}
//注册循环执行定时器（hour minutes second microSec为第一次执行距离现在的时分秒毫秒, interval 为循环间隔时间，为毫秒）
//@todo hour+minutes+second+microSec > 0
template<typename T>
Safe_Smart_Ptr<Timer> RegRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second, int microSec, int interval)
{
if(interval < SLOT_CHANGE_TIME)
{
interval = SLOT_CHANGE_TIME;
}
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::LoopTimer;
SetDistanceTime(newTimer, hour, minutes, second, microSec, interval);
return newTimer;
}
//注册循环执行定时器（hour minutes second microSec为第一次执行距离现在的时分秒毫秒, interval 为循环间隔时间，为毫秒）
//@todo hour+minutes+second+microSec > 0
template<typename T>
Safe_Smart_Ptr<Timer> RegDayRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second, int microSec)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::LoopTimer;
SetDistanceTime(newTimer, hour, minutes, second, microSec, 24 * 3600 * 1000);
return newTimer;
}
//注册某一个时间点日循环执行定时器（hour minutes second为一天中开始执行的时间点， 23：23：23 每天23点23分23秒执行）
template<typename T>
Safe_Smart_Ptr<Timer> RegDayPointRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::LoopTimer;
SetDayTime(newTimer, hour, minutes, second, 24 * 3600 * 1000);
return newTimer;
}
//周循环（hour minutes second microSec为第一次执行距离现在的时分秒毫秒）
//@todo hour+minutes+second+microSec > 0
template<typename T>
Safe_Smart_Ptr<Timer> RegWeekRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second, int microSec)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::LoopTimer;
SetDistanceTime(newTimer, hour, minutes, second, microSec, 7 * 24 * 3600 * 1000);
return newTimer;
}
//注册某一个时间点周循环执行定时器（ weekDay hour minutes second 为一周中某一天开始执行的时间点）
template<typename T>
Safe_Smart_Ptr<Timer> RegWeekPointRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int weekDay, int hour, int minutes, int second)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::LoopTimer;
SetWeekTime(newTimer, weekDay, hour, minutes, second);
return newTimer;
}
//月循环（hour minutes second microSec为第一次执行距离现在的时分秒毫秒,最好是同一天）
//@todo hour+minutes+second+microSec > 0
template<typename T>
Safe_Smart_Ptr<Timer> RegMonthRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int hour, int minutes, int second, int microSec)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::MonthLoopTimer;
SetDistanceTime(newTimer, hour, minutes, second, microSec);
return newTimer;
}
//注册某一个时间点月循环执行定时器（ day hour minutes second 为一月中某一天开始执行的时间点）
template<typename T>
Safe_Smart_Ptr<Timer> RegMonthPointRepeatedTime(void (T::*fun)(void * arg), T * obj, void * arg, int day, int hour, int minutes, int second)
{
Safe_Smart_Ptr<Timer> newTimer = NEW Timer();
newTimer->SetCallbackFun<T>(fun, obj, arg);
newTimer->m_type = Timer::MonthLoopTimer;
SetMonthTime(newTimer, day, hour, minutes, second);
return newTimer;
}
private:
TimerBase * m_timer;
int m_type;
static TimerInterface * m_instance;
};
}
#endif /* TIMER_TIMERINTERFACE_H_ */
|
/*====================================================================
Copyright(c) 2018 Adam Rankin
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and / or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
====================================================================*/
// Local includes
#include "pch.h"
#include "Common.h"
#include "DeviceResources.h"
#include "DirectXHelper.h"
#include "RenderingCommon.h"
#include "Slice.h"
#include "SliceRenderer.h"
#include "StepTimer.h"
// DirectXTex includes
#include <DirectXTex.h>
// DirectXTK includes
#include <WICTextureLoader.h>
// Direct3D includes
#include <d3d11_4.h>
// Unnecessary, but reduces intellisense errors
#include <WindowsNumerics.h>
using namespace DirectX;
using namespace Windows::Foundation::Numerics;
using namespace Windows::Perception::Spatial;
using namespace Windows::UI::Input::Spatial;
namespace HoloIntervention
{
namespace Rendering
{
const float Slice::LOCKED_SLICE_DISTANCE_OFFSET = 2.1f;
const float Slice::LERP_RATE = 2.5f;
//----------------------------------------------------------------------------
float3 Slice::GetStabilizedPosition(SpatialPointerPose^ pose) const
{
return float3(m_currentPose.m41, m_currentPose.m42, m_currentPose.m43);
}
//----------------------------------------------------------------------------
float3 Slice::GetStabilizedVelocity() const
{
return m_velocity;
}
//----------------------------------------------------------------------------
float Slice::GetStabilizePriority() const
{
// Priority is determined by systems that use this slice entry
return PRIORITY_NOT_ACTIVE;
}
//----------------------------------------------------------------------------
Slice::Slice(const std::shared_ptr<DX::DeviceResources>& deviceResources, DX::StepTimer& timer, Debug& debug)
: m_deviceResources(deviceResources)
, m_timer(timer)
, m_debug(debug)
{
SetBlackMapColour(m_blackMapColour);
SetWhiteMapColour(m_whiteMapColour);
}
//----------------------------------------------------------------------------
Slice::~Slice()
{
ReleaseDeviceDependentResources();
m_vertexBuffer = nullptr;
}
//----------------------------------------------------------------------------
bool Slice::IsInFrustum() const
{
return m_isInFrustum;
}
//----------------------------------------------------------------------------
bool Slice::IsInFrustum(const SpatialBoundingFrustum& frustum) const
{
if (m_timer.GetFrameCount() == m_frustumCheckFrameNumber)
{
return m_isInFrustum;
}
const float bottom = -0.5;
const float left = -0.5;
const float right = 0.5;
const float top = 0.5;
const std::vector<float3> points =
{
transform(float3(left, top, 0.f), m_currentPose),
transform(float3(right, top, 0.f), m_currentPose),
transform(float3(right, bottom, 0.f), m_currentPose),
transform(float3(left, bottom, 0.f), m_currentPose)
};
m_isInFrustum = HoloIntervention::IsInFrustum(frustum, points);
m_frustumCheckFrameNumber = m_timer.GetFrameCount();
return m_isInFrustum;
}
//----------------------------------------------------------------------------
void Slice::Update(SpatialPointerPose^ pose)
{
if (!m_sliceValid)
{
return;
}
const float& deltaTime = static_cast<float>(m_timer.GetElapsedSeconds());
float3 currentTranslation = { m_currentPose.m41, m_currentPose.m42, m_currentPose.m43 };
float3 lastTranslation = { m_lastPose.m41, m_lastPose.m42, m_lastPose.m43 };
const float3 deltaPosition = currentTranslation - lastTranslation; // meters
m_velocity = deltaPosition * (1.f / deltaTime); // meters per second
m_lastPose = m_currentPose;
// Calculate new smoothed currentPose
if (!m_headLocked)
{
if (m_firstFrame)
{
m_currentPose = m_desiredPose;
m_firstFrame = false;
}
else
{
m_currentPose = lerp(m_currentPose, m_desiredPose, deltaTime * LERP_RATE);
}
}
else
{
// Get the gaze direction relative to the given coordinate system.
const float3 offsetFromGaze = pose->Head->Position + (float3(LOCKED_SLICE_DISTANCE_OFFSET) * pose->Head->ForwardDirection);
float4x4 worldTransform;
if (m_useHeadUpDirection)
{
worldTransform = make_float4x4_world(offsetFromGaze, pose->Head->ForwardDirection, pose->Head->UpDirection);
}
else
{
worldTransform = make_float4x4_world(offsetFromGaze, pose->Head->ForwardDirection, float3(0.f, 1.f, 0.f));
}
if (m_firstFrame)
{
m_currentPose = make_float4x4_scale(m_scalingFactor.x, m_scalingFactor.y, 1.f) * worldTransform;
m_firstFrame = false;
}
else
{
m_desiredPose = make_float4x4_scale(m_scalingFactor.x, m_scalingFactor.y, 1.f) * worldTransform;
m_currentPose = lerp(m_currentPose, m_desiredPose, deltaTime * LERP_RATE);
}
}
XMStoreFloat4x4(&m_constantBuffer.worldMatrix, XMLoadFloat4x4(&m_currentPose));
m_deviceResources->GetD3DDeviceContext()->UpdateSubresource(m_sliceConstantBuffer.Get(), 0, nullptr, &m_constantBuffer, 0, 0);
}
//----------------------------------------------------------------------------
void Slice::Render(uint32 indexCount)
{
if (!m_visible || !m_sliceValid)
{
return;
}
const auto context = m_deviceResources->GetD3DDeviceContext();
const UINT stride = sizeof(VertexPositionTexture);
const UINT offset = 0;
context->IASetVertexBuffers(0, 1, m_vertexBuffer.GetAddressOf(), &stride, &offset);
context->VSSetConstantBuffers(0, 1, m_sliceConstantBuffer.GetAddressOf());
context->PSSetConstantBuffers(0, 1, m_sliceConstantBuffer.GetAddressOf());
context->PSSetShaderResources(0, 1, m_shaderResourceView.GetAddressOf());
context->DrawIndexedInstanced(indexCount, 2, 0, 0, 0);
ID3D11ShaderResourceView* ppNullptr[1] = { nullptr };
context->PSSetShaderResources(0, 1, ppNullptr);
}
//----------------------------------------------------------------------------
void Slice::SetFrame(UWPOpenIGTLink::VideoFrame^ frame)
{
std::shared_ptr<byte> image = *(std::shared_ptr<byte>*)(frame->GetImage()->GetImageData());
if (image == nullptr)
{
LOG(LogLevelType::LOG_LEVEL_ERROR, "Unable to access image buffer.");
return;
}
auto frameSize = frame->Dimensions;
auto format = (DXGI_FORMAT)frame->GetPixelFormat(true);
if (frameSize[0] != m_width || frameSize[1] != m_height || format != GetPixelFormat())
{
m_width = frameSize[0];
m_height = frameSize[1];
m_pixelFormat = format;
ReleaseDeviceDependentResources();
CreateDeviceDependentResources();
}
m_frame = frame;
auto context = m_deviceResources->GetD3DDeviceContext();
auto bytesPerPixel = BitsPerPixel(GetPixelFormat()) / 8;
byte* imageRaw = image.get();
D3D11_MAPPED_SUBRESOURCE mappedResource;
context->Map(m_imageStagingTexture.Get(), 0, D3D11_MAP_READ_WRITE, 0, &mappedResource);
byte* mappedData = reinterpret_cast<byte*>(mappedResource.pData);
for (uint32 i = 0; i < m_height; ++i)
{
memcpy(mappedData, imageRaw, m_width * bytesPerPixel);
mappedData += mappedResource.RowPitch;
imageRaw += m_width * bytesPerPixel;
}
context->Unmap(m_imageStagingTexture.Get(), 0);
context->CopyResource(m_imageTexture.Get(), m_imageStagingTexture.Get());
}
//----------------------------------------------------------------------------
void Slice::SetImageData(std::shared_ptr<byte> imageData, uint16 width, uint16 height, DXGI_FORMAT pixelFormat)
{
if (width != m_width || height != m_height || pixelFormat != m_pixelFormat)
{
m_width = width;
m_height = height;
m_pixelFormat = pixelFormat;
ReleaseDeviceDependentResources();
CreateDeviceDependentResources();
}
m_imageData = imageData;
auto context = m_deviceResources->GetD3DDeviceContext();
auto bytesPerPixel = BitsPerPixel(pixelFormat) / 8;
D3D11_MAPPED_SUBRESOURCE mappedResource;
context->Map(m_imageStagingTexture.Get(), 0, D3D11_MAP_READ_WRITE, 0, &mappedResource);
byte* image = m_imageData.get();
byte* mappedData = reinterpret_cast<byte*>(mappedResource.pData);
for (uint32 i = 0; i < m_height; ++i)
{
memcpy(mappedData, image, m_width * bytesPerPixel);
mappedData += mappedResource.RowPitch;
image += m_width * bytesPerPixel;
}
context->Unmap(m_imageStagingTexture.Get(), 0);
context->CopyResource(m_imageTexture.Get(), m_imageStagingTexture.Get());
}
//----------------------------------------------------------------------------
void Slice::SetImageData(const std::wstring& fileName)
{
TexMetadata metadata;
GetMetadataFromWICFile(fileName.c_str(), WIC_FLAGS_NONE, metadata);
if (metadata.width != m_width || metadata.height != m_height || metadata.format != GetPixelFormat())
{
m_width = static_cast<uint16>(metadata.width);
m_height = static_cast<uint16>(metadata.height);
m_pixelFormat = metadata.format;
ReleaseDeviceDependentResources();
CreateDeviceDependentResources();
}
m_imageTexture.Reset();
m_shaderResourceView.Reset();
m_imageData = nullptr;
CreateWICTextureFromFile(m_deviceResources->GetD3DDevice(), m_deviceResources->GetD3DDeviceContext(), fileName.c_str(), (ID3D11Resource**)m_imageTexture.GetAddressOf(), nullptr);
DX::ThrowIfFailed(m_deviceResources->GetD3DDevice()->CreateShaderResourceView(m_imageTexture.Get(), nullptr, &m_shaderResourceView));
#if _DEBUG
m_shaderResourceView->SetPrivateData(WKPDID_D3DDebugObjectName, static_cast<UINT>(strnlen_s("sliceEntrySRVFilename", MAX_PATH)), "sliceEntrySRVFilename");
#endif
}
//----------------------------------------------------------------------------
void Slice::SetImageData(Microsoft::WRL::ComPtr<ID3D11Texture2D> imageTexture)
{
if (imageTexture == nullptr)
{
return;
}
ReleaseDeviceDependentResources();
m_ownTexture = false;
m_imageData = nullptr;
m_imageTexture = imageTexture;
m_imageStagingTexture = nullptr;
D3D11_TEXTURE2D_DESC desc;
imageTexture->GetDesc(&desc);
m_width = desc.Width;
m_height = desc.Height;
m_pixelFormat = desc.Format;
CreateDeviceDependentResources();
}
//----------------------------------------------------------------------------
std::shared_ptr<byte> Slice::GetImageData() const
{
return m_imageData;
}
//-----------------------------------------------------------------------------
void Slice::SetVertexBuffer(Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBuffer)
{
m_vertexBuffer = vertexBuffer;
}
//----------------------------------------------------------------------------
void Slice::SetDesiredPose(const Windows::Foundation::Numerics::float4x4& matrix)
{
m_desiredPose = matrix;
}
//----------------------------------------------------------------------------
void Slice::ForceCurrentPose(const Windows::Foundation::Numerics::float4x4& matrix)
{
m_firstFrame = true;
m_currentPose = m_desiredPose = m_lastPose = matrix;
}
//----------------------------------------------------------------------------
float4x4 Slice::GetCurrentPose() const
{
return m_currentPose;
}
//----------------------------------------------------------------------------
bool Slice::GetVisible() const
{
return m_visible;
}
//----------------------------------------------------------------------------
void Slice::SetVisible(bool visible)
{
m_visible = visible;
}
//----------------------------------------------------------------------------
void Slice::SetHeadlocked(bool headLocked, bool smooth)
{
m_headLocked = headLocked;
if (!smooth)
{
m_firstFrame = true;
}
}
//----------------------------------------------------------------------------
bool Slice::GetHeadlocked() const
{
return m_headLocked;
}
//-----------------------------------------------------------------------------
void Slice::SetUseHeadUpDirection(bool use)
{
m_useHeadUpDirection = use;
}
//-----------------------------------------------------------------------------
bool Slice::GetUseHeadUpDirection() const
{
return m_useHeadUpDirection;
}
//-----------------------------------------------------------------------------
void Slice::SetScalingFactor(float x, float y)
{
m_scalingFactor = float2(x, y);
}
//-----------------------------------------------------------------------------
void Slice::SetScalingFactor(const float2& scale)
{
m_scalingFactor = scale;
}
//-----------------------------------------------------------------------------
void Slice::SetScalingFactor(float uniformScale)
{
m_scalingFactor = float2(uniformScale, uniformScale);
}
//----------------------------------------------------------------------------
void Slice::SetId(uint64 id)
{
m_id = id;
}
//----------------------------------------------------------------------------
uint64 Slice::GetId() const
{
return m_id;
}
//----------------------------------------------------------------------------
bool Slice::IsValid() const
{
return m_sliceValid;
}
//----------------------------------------------------------------------------
void Slice::SetColorizeGreyscale(bool colorize)
{
m_colorizeGreyscale = colorize;
}
//----------------------------------------------------------------------------
bool Slice::GetColorizeGreyscale()
{
return m_colorizeGreyscale;
}
//----------------------------------------------------------------------------
void Slice::SetWhiteMapColour(float4 colour)
{
m_whiteMapColour = colour;
float4 blackMapColour(m_constantBuffer.blackMapColour.x, m_constantBuffer.blackMapColour.y, m_constantBuffer.blackMapColour.z, m_constantBuffer.blackMapColour.w);
XMStoreFloat4(&m_constantBuffer.whiteMinusBlackColour, XMLoadFloat4(&(m_whiteMapColour - blackMapColour)));
}
//----------------------------------------------------------------------------
void Slice::SetBlackMapColour(float4 colour)
{
XMStoreFloat4(&m_constantBuffer.blackMapColour, XMLoadFloat4(&colour));
SetWhiteMapColour(m_whiteMapColour);
}
//----------------------------------------------------------------------------
void Slice::CreateDeviceDependentResources()
{
auto device = m_deviceResources->GetD3DDevice();
const CD3D11_BUFFER_DESC constantBufferDesc(sizeof(SliceConstantBuffer), D3D11_BIND_CONSTANT_BUFFER);
DX::ThrowIfFailed(device->CreateBuffer(&constantBufferDesc, nullptr, &m_sliceConstantBuffer));
if (GetPixelFormat() != DXGI_FORMAT_UNKNOWN && m_width > 0 && m_height > 0)
{
if (m_ownTexture)
{
CD3D11_TEXTURE2D_DESC textureDesc(GetPixelFormat(), m_width, m_height, 1, 0, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ);
DX::ThrowIfFailed(device->CreateTexture2D(&textureDesc, nullptr, &m_imageStagingTexture));
textureDesc = CD3D11_TEXTURE2D_DESC(GetPixelFormat(), m_width, m_height, 1, 0, D3D11_BIND_SHADER_RESOURCE);
DX::ThrowIfFailed(device->CreateTexture2D(&textureDesc, nullptr, &m_imageTexture));
}
DX::ThrowIfFailed(device->CreateShaderResourceView(m_imageTexture.Get(), nullptr, &m_shaderResourceView));
#if _DEBUG
m_shaderResourceView->SetPrivateData(WKPDID_D3DDebugObjectName, static_cast<UINT>(strnlen_s("sliceEntrySRV", MAX_PATH)), "sliceEntrySRV");
#endif
}
m_sliceValid = true;
}
//----------------------------------------------------------------------------
void Slice::ReleaseDeviceDependentResources()
{
m_sliceValid = false;
m_sliceConstantBuffer.Reset();
m_shaderResourceView.Reset();
m_imageTexture.Reset();
m_imageStagingTexture.Reset();
}
//----------------------------------------------------------------------------
DXGI_FORMAT Slice::GetPixelFormat() const
{
return m_pixelFormat;
}
//----------------------------------------------------------------------------
void Slice::SetPixelFormat(DXGI_FORMAT val)
{
m_pixelFormat = val;
}
}
}
|
#include "button.h"
Button::Button(qint8 keyId, QPushButton *parent) : QPushButton(parent), m_keyId(keyId)
{
connect(this, &QPushButton::pressed, this, &Button::slotEventPressed);
}
Button::~Button()
{
}
void Button::slotEventPressed()
{
emit signalEventPressed();
}
qint8 Button::getKeyId() const
{
return m_keyId;
}
void signalEventPressed()
{
qDebug("signal retransmite (in Button)");
}
|
// Fill out your copyright notice in the Description page of Project Settings.
#include "FightWithBlock.h"
#include "MyHUD.h"
AMyHUD::AMyHUD()
{
//ConstructorHelpers::FObjectFinder<SUserWidget> UI(TEXT("WidgetBlueprint'/Game/UMG/UI.UI'"));
}
void AMyHUD::BeginPlay()
{
}
|
#include <bits/stdc++.h>
#define ll long long
#define pf printf
#define sfi(a) scanf("%d",&a);
#define sfii(a,b) scanf("%d %d",&a,&b);
#define INF 100000 //10e9
using namespace std;
int ar[100005];
//SEGMENT TREE
//COPYING BUILD FUNC FOR UPDATE
//CHECK IF YOU ARE CALLING BUILD INSIDE UPDATE
struct node
{
int ovmax,ovmax2;
};
node tree[4*100005];
void build(int root,int b,int e)
{
if(b==e)
{
tree[root].ovmax = ar[b];
tree[root].ovmax2 = 0;
return;
}
int mid = (b+e)/2;
int lc = root*2;
int rc = lc+1;
build(lc,b,mid);
build(rc,mid+1,e);
vector<int>dum;
dum.push_back(tree[lc].ovmax2);
dum.push_back(tree[lc].ovmax);
dum.push_back(tree[rc].ovmax2);
dum.push_back(tree[rc].ovmax);
sort(dum.rbegin(),dum.rend());
tree[root].ovmax = dum[0];
tree[root].ovmax2 = dum[1];
dum.clear();
}
void update(int root,int b,int e,int i,int x)
{
if(b>i || e<i)
{
return;
}
if(b==e && b==i)
{
tree[root].ovmax = x;
tree[root].ovmax2 = 0;
return;
}
int mid = (b+e)/2;
int lc = root*2;
int rc = lc+1;
update(lc,b,mid,i,x);
update(rc,mid+1,e,i,x);
vector<int>dum;
dum.push_back(tree[lc].ovmax2);
dum.push_back(tree[lc].ovmax);
dum.push_back(tree[rc].ovmax2);
dum.push_back(tree[rc].ovmax);
sort(dum.rbegin(),dum.rend());
tree[root].ovmax = dum[0];
tree[root].ovmax2 = dum[1];
dum.clear();
}
node query(int root,int b,int e,int i,int j)
{
if(b>j || e<i)
{
node dummy;
dummy.ovmax2 = 0;
dummy.ovmax = 0;
return dummy;
}
if(b>=i && e<=j)
{
return tree[root];
}
int mid = (b+e)/2;
int lc = root*2;
int rc = lc+1;
node treelc = query(lc,b,mid,i,j);
node treerc = query(rc,mid+1,e,i,j);
node treeroot;
vector<int>dum;
dum.push_back(treelc.ovmax2);
dum.push_back(treelc.ovmax);
dum.push_back(treerc.ovmax2);
dum.push_back(treerc.ovmax);
sort(dum.rbegin(),dum.rend());
treeroot.ovmax = dum[0];
treeroot.ovmax2 = dum[1];
dum.clear();
return treeroot;
}
int main()
{
int n;
sfi(n);
for(int i=1; i<=n; i++)
{
sfi(ar[i]);
}
build(1,1,n);
int q;
sfi(q);
while(q--)
{
char cmd;
cmd = 'g';
while(1)
{
scanf("%c",&cmd);
if(cmd=='U' || cmd=='Q')
break;
}
if(cmd=='Q')
{
int x,y;
sfii(x,y);
node ans = query(1,1,n,x,y);
pf("%d\n",ans.ovmax+ans.ovmax2);
}
else if(cmd=='U')
{
int x,y;
sfii(x,y);
update(1,1,n,x,y);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.